From af77f44ca8635ffdaaec6ca30d1970334f598fd4 Mon Sep 17 00:00:00 2001 From: U000805 Date: Fri, 5 Jun 2026 17:51:39 +0200 Subject: [PATCH] Migrate the Scope generator off classic Xtend onto Xbase + JvmModelInferrer MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Summary The com.avaloq.tools.ddk.xtext.scope plugin compiled the embedded Expression DSL to Java through expression.generator.CodeGenerationX / CompilationContext, whose type system is the legacy classic Xtend runtime (org.eclipse.xtend.expression.*, org.eclipse.xtend.typesystem.emf.*). That was the only reason the plugin required those bundles. This PR replaces the IGenerator2-based ScopeGenerator with an Xbase JvmModelInferrer, introduces a self-contained (Xtend-free) expression-translation layer, deletes the classic-Xtend execution context, and removes org.eclipse.xtend and org.eclipse.xtend.typesystem.emf from the scope plugin. Key decisions Decision Rationale Scope generation moves to a JvmModelInferrer + Xbase JvmModelGenerator Same pattern as Format/Check; lets the standard XbaseCompiler emit the provider classes. The *ScopeProvider/*ScopeNameProvider are now inferred JVM types rather than hand-templated .java. Hybrid expression backend: an Xbase translator + a string compiler fallback String + concatenation (very common in .scope) has no operator_plus in xbase.lib — Xbase special-cases it in its compiler — so it can't be pre-linked as an XExpression tree. We translate to Xbase what maps cleanly and fall back to a faithful port of the legacy string output for +, arithmetic and relational operators. Model-type names resolve via imported EPackages, not the classpath In real sources, (Cast)x / typeSelect(T) / T.isInstance(x) name EMF model types (FormDef, ILogicalTable, intfdef::AlternatingGroup), not Java FQNs. javaType resolves them through the model's imported EPackages → GenModelUtilX.instanceClassName, exactly as the legacy EmfRegistryMetaModel did. findDeclaredType would fail on these. .ext (JAVA extension) support dropped Scope sources no longer reference Xtend extension files; removed the .ext-reading validation and the isJavaExtensionCall/isExtension generator branches. factory becomes a direct Xbase static call Must be written Type.method(args); the generator resolves the type to a JvmDeclaredType.qualifiedName and emits the static call. Bare factory foo() is no longer supported. dsl-devkit only; output need not be byte-identical Downstream ASMD .scope/.ext sources and their committed generated providers are regenerated by the author separately. Implementation New (scope plugin): jvmmodel/ScopeJvmModelInferrer.java — infers the provider + name-provider JVM types; attaches method bodies as strings; framework types emitted fully-qualified so the unit needs no imports. jvmmodel/ScopeExpressionTranslator.xtend — translates the Expression AST → XExpression (literals, if/list, variable & this calls, boolean/equality/relational ops linked to xbase.lib, getter navigations, extension calls, casts/typeSelect/isInstance, method calls). jvmmodel/ScopeExpressionCompiler.xtend — Xtend-free Java-string fallback; ports CodeGenerationX/ExpressionExtensionsX output branch-for-branch, minus the .ext paths. jvmmodel/ScopeTranslationContext.xtend — variables, implicit parameter (type resolution) vs implicit-var name (emitted this binding), model-type resolver; newCompilationContext(...) replaces the legacy CompilationContext.clone(...). generator/ScopeModelTypeResolver.java — model-name → EClassifier over imported EPackages (alias-aware). expression/jvmmodel/ExpressionJvmModelInferrer.xtend + Expression/Scope grammar updates to embed Xbase (with src-gen regeneration). Removed: generator/ScopeGenerator.xtend (IGenerator2). ScopingGeneratorUtil.getCompilationContext and its classic-Xtend inner classes (ScopeExecutionContext, ScopeResource) + orphaned helpers/imports. ScopeValidator.checkExtensions + its message key. org.eclipse.xtend, org.eclipse.xtend.typesystem.emf from META-INF/MANIFEST.MF. Verification mvn clean verify of the expression + scope plugins: BUILD SUCCESS with the Xtend bundles removed. A grep of the plugin confirms no classic-Xtend imports remain (only a doc-comment mention of EmfRegistryMetaModel). Caveats / follow-ups dsl-devkit has no .scope input files, so the inferrer never runs during verify — only compilation is checked. Generated-Java output fidelity must be validated by regenerating ASMD in Eclipse. The expression plugin itself still requires Xtend while CompilationContext.java exists (separate increment). Next: apply the same playbook to the export plugin. --- .../skills/asmd-scope-ext-migration/SKILL.md | 190 + .../skills/expression-dsl-to-xbase/SKILL.md | 193 + com.avaloq.tools.ddk.workflow/.classpath | 2 + .../antlr-generator-3.2.0-patch.jar | Bin 0 -> 1484649 bytes .../tools/ddk/workflow/GenerateExport.mwe2 | 7 + .../ddk/workflow/GenerateExpression.mwe2 | 7 + .../tools/ddk/workflow/GenerateScope.mwe2 | 7 + .../META-INF/MANIFEST.MF | 3 +- .../export/ide/AbstractExportIdeModule.java | 4 +- .../ide/contentassist/antlr/ExportParser.java | 362 + .../antlr/internal/InternalExport.g | 22255 +++- .../antlr/internal/InternalExport.tokens | 226 +- .../antlr/internal/InternalExportLexer.java | 3556 +- .../antlr/internal/InternalExportParser.java | 84028 ++++++++++++--- .../META-INF/MANIFEST.MF | 8 +- .../plugin.xml_gen | 159 + .../export/ui/AbstractExportUiModule.java | 133 +- .../xtext/export/ui/editor/ExportEditor.java | 13 + .../export/ui/internal/ExportActivator.java | 4 +- .../META-INF/MANIFEST.MF | 12 +- .../export/AbstractExportRuntimeModule.java | 361 +- .../tools/ddk/xtext/export/Export.xtextbin | Bin 9828 -> 24147 bytes .../parser/antlr/internal/InternalExport.g | 6302 +- .../antlr/internal/InternalExport.tokens | 222 +- .../antlr/internal/InternalExportLexer.java | 3504 +- .../antlr/internal/InternalExportParser.java | 23154 +++- .../AbstractExportSemanticSequencer.java | 284 + .../AbstractExportSyntacticSequencer.java | 222 + .../export/services/ExportGrammarAccess.java | 988 +- .../validation/AbstractExportValidator.java | 3 + .../ddk/xtext/export/ExportRuntimeModule.java | 4 +- .../ExportFeatureExtensionGenerator.xtend | 77 - .../export/generator/ExportGenerator.xtend | 136 - .../generator/ExportGeneratorSupport.java | 175 - .../generator/ExportModelTypeResolver.java | 117 + .../ExportedNamesProviderGenerator.xtend | 96 - .../FingerprintComputerGenerator.xtend | 134 - .../generator/FragmentProviderGenerator.xtend | 94 - ...esourceDescriptionConstantsGenerator.xtend | 55 - .../ResourceDescriptionManagerGenerator.xtend | 60 - ...ResourceDescriptionStrategyGenerator.xtend | 190 - .../jvmmodel/ExportExpressionCompiler.xtend | 481 + .../jvmmodel/ExportExpressionTranslator.xtend | 870 + .../jvmmodel/ExportJvmModelInferrer.xtend | 733 + .../jvmmodel/ExportTranslationContext.xtend | 190 + .../export/scoping/ExportScopeProvider.java | 40 +- .../export/validation/ExportValidator.java | 31 - .../META-INF/MANIFEST.MF | 3 +- .../ide/AbstractExpressionIdeModule.java | 4 +- .../contentassist/antlr/ExpressionParser.java | 362 + .../antlr/internal/InternalExpression.g | 20411 +++- .../antlr/internal/InternalExpression.tokens | 202 +- .../internal/InternalExpressionLexer.java | 3232 +- .../internal/InternalExpressionParser.java | 75847 ++++++++++++-- .../META-INF/MANIFEST.MF | 8 +- .../plugin.xml_gen | 159 + .../ui/AbstractExpressionUiModule.java | 133 +- .../AbstractExpressionProposalProvider.java | 6 +- .../ui/editor/ExpressionEditor.java | 13 + .../ui/internal/ExpressionActivator.java | 4 +- .../META-INF/MANIFEST.MF | 13 +- .../AbstractExpressionRuntimeModule.java | 73 +- .../ddk/xtext/expression/Expression.xtextbin | Bin 6926 -> 21273 bytes .../ExpressionStandaloneSetupGenerated.java | 4 +- .../antlr/internal/InternalExpression.g | 6296 +- .../antlr/internal/InternalExpression.tokens | 196 +- .../internal/InternalExpressionLexer.java | 3306 +- .../internal/InternalExpressionParser.java | 22949 +++- .../AbstractExpressionScopeProvider.java | 4 +- .../AbstractExpressionSemanticSequencer.java | 288 +- .../AbstractExpressionSyntacticSequencer.java | 222 + .../services/ExpressionGrammarAccess.java | 988 +- .../AbstractExpressionValidator.java | 9 +- .../ddk/xtext/expression/Expression.xtext | 2 +- .../generator/CodeGenerationX.xtend | 373 - .../generator/CompilationContext.java | 429 - .../xtext/expression/generator/CompilerX.java | 45 - .../generator/ExpressionExtensionsX.xtend | 88 - .../jvmmodel/ExpressionJvmModelInferrer.xtend | 62 + .../scoping/ExpressionScopeProvider.java | 4 +- .../META-INF/MANIFEST.MF | 2 - .../expression/CodeGenerationXTest.java | 207 - .../expression/CompilationContextTest.java | 61 - .../generator/expression/TestExtensions.ext | 5 - .../test/generator/GeneratorTestSuite.java | 4 - .../META-INF/MANIFEST.MF | 3 +- .../scope/ide/AbstractScopeIdeModule.java | 4 +- .../ide/contentassist/antlr/ScopeParser.java | 362 + .../antlr/internal/InternalScope.g | 23097 +++- .../antlr/internal/InternalScope.tokens | 236 +- .../antlr/internal/InternalScopeLexer.java | 3574 +- .../antlr/internal/InternalScopeParser.java | 87009 +++++++++++++--- .../META-INF/MANIFEST.MF | 8 +- .../plugin.xml_gen | 159 + .../xtext/scope/ui/AbstractScopeUiModule.java | 133 +- .../xtext/scope/ui/editor/ScopeEditor.java | 13 + .../scope/ui/internal/ScopeActivator.java | 4 +- .../META-INF/MANIFEST.MF | 13 +- .../scope/AbstractScopeRuntimeModule.java | 76 +- .../tools/ddk/xtext/scope/Scope.xtextbin | Bin 11236 -> 25555 bytes .../parser/antlr/internal/InternalScope.g | 6296 +- .../antlr/internal/InternalScope.tokens | 232 +- .../antlr/internal/InternalScopeLexer.java | 3710 +- .../antlr/internal/InternalScopeParser.java | 23519 ++++- .../AbstractScopeSemanticSequencer.java | 284 + .../AbstractScopeSyntacticSequencer.java | 222 + .../scope/services/ScopeGrammarAccess.java | 988 +- .../validation/AbstractScopeValidator.java | 3 + .../ddk/xtext/scope/ScopeRuntimeModule.java | 2 + .../scope/generator/ScopeGenerator.xtend | 83 - .../generator/ScopeModelTypeResolver.java | 117 + .../ScopeNameProviderGenerator.xtend | 137 +- .../generator/ScopeProviderGenerator.xtend | 531 +- .../scope/generator/ScopeProviderX.xtend | 12 +- .../scope/generator/ScopingGeneratorUtil.java | 192 - .../jvmmodel/ScopeExpressionCompiler.xtend | 483 + .../ScopeExpressionMethodRequest.xtend | 173 + .../jvmmodel/ScopeExpressionTranslator.xtend | 881 + .../jvmmodel/ScopeJvmModelInferrer.xtend | 292 + .../jvmmodel/ScopeTranslationContext.xtend | 190 + .../scope/scoping/ScopeScopeProvider.java | 34 +- .../ddk/xtext/scope/validation/Messages.java | 1 - .../scope/validation/ScopeValidator.java | 30 - .../scope/validation/messages.properties | 1 - ddk-target/ddk.target | 6 - 125 files changed, 384532 insertions(+), 54284 deletions(-) create mode 100644 .agents/skills/asmd-scope-ext-migration/SKILL.md create mode 100644 .agents/skills/expression-dsl-to-xbase/SKILL.md create mode 100644 com.avaloq.tools.ddk.workflow/antlr-generator-3.2.0-patch.jar create mode 100644 com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/editor/ExportEditor.java delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportFeatureExtensionGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGeneratorSupport.java create mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportModelTypeResolver.java delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportedNamesProviderGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FingerprintComputerGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FragmentProviderGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionConstantsGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionManagerGenerator.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionStrategyGenerator.xtend create mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionCompiler.xtend create mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionTranslator.xtend create mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportJvmModelInferrer.xtend create mode 100644 com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportTranslationContext.xtend create mode 100644 com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/editor/ExpressionEditor.java delete mode 100644 com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CodeGenerationX.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilationContext.java delete mode 100644 com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilerX.java delete mode 100644 com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/ExpressionExtensionsX.xtend create mode 100644 com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/jvmmodel/ExpressionJvmModelInferrer.xtend delete mode 100644 com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CodeGenerationXTest.java delete mode 100644 com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CompilationContextTest.java delete mode 100644 com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/TestExtensions.ext create mode 100644 com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/editor/ScopeEditor.java delete mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeGenerator.xtend create mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeModelTypeResolver.java create mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionCompiler.xtend create mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionMethodRequest.xtend create mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionTranslator.xtend create mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeJvmModelInferrer.xtend create mode 100644 com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeTranslationContext.xtend diff --git a/.agents/skills/asmd-scope-ext-migration/SKILL.md b/.agents/skills/asmd-scope-ext-migration/SKILL.md new file mode 100644 index 0000000000..e6a3ccbd4e --- /dev/null +++ b/.agents/skills/asmd-scope-ext-migration/SKILL.md @@ -0,0 +1,190 @@ +--- +name: asmd-scope-ext-migration +description: > + Adapts ASMD downstream source files (.scope and .export) to the Xbase-rebased DDK Expression grammar and + removes the legacy classic-Xtend extension files (.ext). Use this skill whenever the user wants to: migrate + ASMD .scope/.export sources after the dsl-devkit scope/export generator was ported to Xbase, delete the .ext + files, rewire `extension a::b::C` declarations to Java helper classes, fix unresolved extension-function + calls, convert `factory` expressions to the `Type.method(...)` form, or regenerate a DSL's scope/export + providers in ASMD. Triggers on phrases like "remove the ext files", "migrate the scope files", "adapt the + export files", "fix the extension calls in .scope", "port ASMD scoping off .ext". This is the DOWNSTREAM + counterpart of the `expression-dsl-to-xbase` skill (which does the dsl-devkit generator side). +globs: + - "**/*.scope" + - "**/*.export" + - "**/*.ext" +--- + +# ASMD `.scope` / `.export` Adaptation + `.ext` Removal Skill + +> Companion to **`expression-dsl-to-xbase`** (the dsl-devkit generator-side migration). That skill makes the +> Scope/Export *generators* Xbase-based and drops `org.eclipse.xtend`. **This** skill fixes the ASMD *source* +> files so they compile against the new generator and removes the `.ext` files. Run the generator-side first +> (or consume a build of the new dsl-devkit scope/export plugins) before applying this skill. +> +> For ASMD coding standards, build commands, and module layout, see `AGENTS.md` at the ASMD repo root. + +## The one fact that determines everything + +The DDK **Expression grammar change was minimal**: only the base grammar moved +`with org.eclipse.xtext.common.Terminals` → `with org.eclipse.xtext.xbase.Xbase`. **The embedded expression +syntax is unchanged.** So the bodies of scope rules, `naming`, `find(...)`, `scopeof(...)`, the collection +operators (`select`/`collect`/`selectFirst`/`reject`/`exists`/`notExists`/`sortBy`/`forAll`), `typeSelect`, +the `->` chain, the `?:` / `if…then…else` conditionals, casts `(Type)x`, and `::`-qualified type names **all +stay exactly the same**. + +**What changes is ONLY the extension mechanism**: the legacy `.ext` files (classic-Xtend `JAVA` delegation +stubs) are gone, and `extension a::b::C` now binds directly to a **Java class with `public static` methods**. + +> ⚠️ Do **not** rewrite scope-rule bodies, naming sections, or collection operators. If you find yourself +> changing `select`/`typeSelect`/`find`/`scopeof` syntax, stop — that is not part of this migration. + +## What a `.ext` file actually is + +Every ASMD `.ext` file is a list of **pure delegation stubs** to `public static` Java methods: + +```text +// AvqScriptScoping.ext (file at .../avqscript/AvqScriptScoping.ext) +import avqscript; +import ecore; + +ecore::EObject innermostDeclaringContainer(EObject this) : + JAVA com.avaloq.tools.dsl.avqscript.scoping.AvqScriptScoping.innermostDeclaringContainer(org.eclipse.emf.ecore.EObject); + +List[avqscript::Declaration] getTypeDeclarations(avqscript::ScriptPackage this) : + JAVA com.avaloq.tools.dsl.avqscript.scoping.AvqScriptScoping.getTypeDeclarations(com.avaloq.tools.dsl.avqscript.avqscript.ScriptPackage); +``` + +So the `.ext` is an **indirection layer** between the source `extension X::Y::N` declaration and the real Java +helper class named in each `JAVA …` target. **The Java helper class already exists and already has the +`public static` methods** — the `.ext` adds nothing but the (now obsolete) classic-Xtend binding. + +Note the package shift: the `.ext` is at `…dsl.avqscript.AvqScriptScoping` but its `JAVA` target lives in +`…dsl.avqscript.scoping.AvqScriptScoping` (a `scoping`/`export` sub-package). The repoint must use the **Java +class** package. + +## How `extension` resolves in the new (Xbase) world + +`extension a::b::C` is resolved by the translator as the **Java class** `a.b.C` (`findDeclaredType`). A call +`name(args)` or `target.name(args)` links to the **first `public static` `JvmOperation`** on that class where: + +- `simpleName == name` (the source call name), and +- `parameters.size == argumentCount`, where **the receiver/target counts as the first argument** + (`x.foo(a)` → 2 args; `foo(a)` → 1 arg; `foo()` → 0 args). + +Consequences (the four mismatch classes to reconcile — see below): the Java method name must equal the source +call name; the first parameter must accept the receiver's type; and receiver-dropped stubs change the arg count. + +## Migration procedure (per DSL `.core` module) + +### 1. Inventory + +For the DSL, list its `.scope` and `.export` files and every `extension …` line they declare, and the matching +`*.ext` files. A typical scope header: + +```text +extension com::avaloq::tools::dsl::avqscript::AvqScriptScoping // → AvqScriptScoping.ext +extension com::avaloq::tools::dsl::codetabdata::CodeTabDataScoping +extension com::avaloq::tools::dsl::common::^scoping::MetaModelScoping // foundation .ext +``` + +(`^scoping` just escapes the `scoping` keyword segment; the Java package segment is plain `scoping`.) + +### 2. Find each `.ext`'s real Java helper class + +Open the `.ext` and read the `JAVA .(…)` targets. They almost always point at a single helper +class in a `.scoping` / `.export` sub-package, e.g. `com.avaloq.tools.dsl.avqscript.scoping.AvqScriptScoping`. + +### 3. Repoint the `extension` declaration to the Java class + +Change the `::`-qualified name from the `.ext` path to the **Java helper class**: + +```diff +-extension com::avaloq::tools::dsl::avqscript::AvqScriptScoping ++extension com::avaloq::tools::dsl::avqscript::scoping::AvqScriptScoping +``` + +If one `.ext` delegated to **several** Java classes, add one `extension` line per class. + +### 4. Delete the `.ext` file + +Remove `*.ext` once nothing references it. Also remove any build/MWE2 wiring that registered it (older +`*.mwe2` / generator setup that listed extension files), and drop `org.eclipse.xtend*` / +`org.eclipse.internal.xtend` entries from the DSL's `META-INF/MANIFEST.MF` if present. + +### 5. Reconcile the four mismatch classes the `.ext` was hiding + +The `.ext` could silently rename/retype/re-arity a call. With it gone, the source call must match the Java +static method exactly. For each extension call that no longer resolves: + +| Mismatch | Symptom in the `.ext` | Fix (prefer call-site; else add a `public static` overload to the helper) | +|---|---|---| +| **Name** | ext fn name ≠ `JAVA` method name | rename the call site to the Java method name, or add an alias `public static` method | +| **Receiver/param type** | `getExtendableScriptPackage(EObject this)` → `JAVA …(SuperCall)` | the Java first param must accept the call-site receiver type; add an overload if the actual receiver is broader | +| **Dropped receiver** | `getQualifiedNameFunction(EObject this)` → `JAVA …getQualifiedNameFunction()` (0-arg) | the new resolver counts the target as an arg, so `x.getQualifiedNameFunction()` (1 arg) won't match the 0-arg method — **drop the receiver**: `getQualifiedNameFunction()`; or add a 1-arg overload that ignores its arg | +| **No-receiver helpers** | `getPredefinedTypes()` / `getNumberType()` / `lastSegment()` (already 0-arg) | already written receiver-free in source (`context * = getPredefinedTypes();`) — these just need the repoint, no call-site change | + +> **Do NOT add a Java helper for EMF-native getters.** A call like `this.getName()` that resolves to a real +> `EStructuralFeature` getter links through the normal getter-navigation path and needs no `extension`. Only +> functions that were *genuinely defined in the `.ext`* require the Java helper class. Check the model `.ecore` +> before assuming a call is an extension. + +### 6. Convert `factory` expressions to the `Type.method(...)` form + +`factory` now requires the **Java factory class named explicitly**: + +```diff +-factory makeFooScope(args) ++factory com::avaloq::tools::dsl::foo::scoping::FooScoping.makeFooScope(args) +``` + +The generator emits `.(scope, ctx, , originalResource, )`. The factory method +must be a `public static` method with that leading framework-parameter signature. Bare `factory foo()` (no +type) no longer resolves. + +### 7. Ensure helper visibility + +The repointed Java helper class must be **on the DSL `.core` classpath** (its bundle exported and required in +`META-INF/MANIFEST.MF`) and its methods **`public static`**. Foundation helpers +(`com.avaloq.tools.foundation.xtext.core.…scoping.MetaModelScoping`, etc.) get the identical treatment. + +### 8. Regenerate + build + iterate + +Regenerate the DSL's scope/export providers via its MWE2 workflow (the DDK `GenerateScope`/`GenerateExport` +flow), then build the `.core` module and fix any remaining unresolved extension calls: + +```bash +mvn clean install -pl :com.avaloq.tools.dsl..core -am +``` + +Re-run after each batch of fixes. The new dsl-devkit scope/export plugins must be installed/available first. + +## Worked example (AvqScript) + +```diff + scoping com.avaloq.tools.dsl.avqscript.AvqScript with com.avaloq.tools.dsl.avqbase.AvqBase + … +-extension com::avaloq::tools::dsl::avqscript::AvqScriptScoping // native helper operations +-extension com::avaloq::tools::dsl::codetabdata::CodeTabDataScoping // global code table access +-extension com::avaloq::tools::dsl::common::^scoping::MetaModelScoping // pre-defined types and operations ++extension com::avaloq::tools::dsl::avqscript::scoping::AvqScriptScoping ++extension com::avaloq::tools::dsl::codetabdata::scoping::CodeTabDataScoping ++extension com::avaloq::tools::foundation::xtext::core::metamodel::scoping::MetaModelScoping +``` + +- `this.getTypeDeclarations()`, `this.innermostDeclaringContainer()`, `this.isClientAll()` resolve to the + `public static` methods on `…avqscript.scoping.AvqScriptScoping` — repoint only. +- `getPredefinedTypes()` (already receiver-free) resolves to + `…foundation.xtext.core.metamodel.scoping.MetaModelScoping.getPredefinedTypes()` — repoint only. +- `getQualifiedNameFunction()` was a receiver-dropped stub → keep it written **without** a receiver. +- Delete `AvqScriptScoping.ext`, `AvqScriptExport.ext`, `CodeTabDataScoping.ext`, foundation `MetaModelScoping.ext`. + +## Scope & constraints + +- **ASMD only.** This is the downstream rewrite the dsl-devkit migration deliberately left to ASMD. +- **Do not change expression/scope-rule syntax** — only the extension wiring, `.ext` removal, and `factory` form. +- Keep the EPL/Avaloq copyright headers on any Java helper you add or modify (see ASMD `AGENTS.md`). +- Migrate and verify **one DSL at a time**; build its `.core` module green before moving on. +- If an `.ext` ever contained real Xtend expression logic (not a plain `JAVA` stub), that logic must be **ported + into a `public static` method** on the helper class — the source can only bind to compiled Java now. (All + surveyed ASMD `.ext` files are pure `JAVA` stubs, but verify each before deleting.) diff --git a/.agents/skills/expression-dsl-to-xbase/SKILL.md b/.agents/skills/expression-dsl-to-xbase/SKILL.md new file mode 100644 index 0000000000..88006052b4 --- /dev/null +++ b/.agents/skills/expression-dsl-to-xbase/SKILL.md @@ -0,0 +1,193 @@ +--- +name: expression-dsl-to-xbase +description: > + Migrates an Xtext DSL that embeds the custom DDK "Expression" language (com.avaloq.tools.ddk.xtext.expression) + off the legacy classic-Xtend (Xpand/Xtend1) expression compiler — CodeGenerationX / CompilationContext / + ScopingGeneratorUtil execution context — and onto Xbase + a JvmModelInferrer, then removes the + org.eclipse.xtend and org.eclipse.xtend.typesystem.emf Require-Bundle dependencies from the plugin. + Use this skill whenever the user wants to: make a generator plugin "Xtend-free" / drop org.eclipse.xtend, + convert a *Generator (IGenerator2) to extend JvmModelGenerator, replace CompilationContext / CodeGenerationX, + port the scope or export generator to Xbase, or repeat the scope-plugin migration on another consumer of the + Expression DSL. Triggers on phrases like "remove the xtend dependency", "make it use Xbase", "convert the + generator to a JvmModelInferrer", "drop CompilationContext", "port export generator like we did scope". +globs: + - "**/com.avaloq.tools.ddk.xtext.scope/**" + - "**/com.avaloq.tools.ddk.xtext.export/**" + - "**/com.avaloq.tools.ddk.xtext.expression/**" + - "**/*.xtend" + - "**/*.xtext" + - "**/MANIFEST.MF" +--- + +# Expression-DSL → Xbase Migration Skill + +> For general coding standards (copyright headers, Javadoc, import rules, naming), see `AGENTS.md` at the +> repository root. The EPL header used by these files is the 10-line +> `Copyright (c) 2016 Avaloq Group AG and others.` … `Avaloq Group AG - initial API and implementation` block. + +## What this skill is for + +The DDK ships a custom embedded expression language (`com.avaloq.tools.ddk.xtext.expression`, the **Expression +DSL** — a port of the old Xtend1/Xpand expression syntax). Grammars such as **Scope** (`Scope with +com.avaloq.tools.ddk.xtext.expression.Expression`) and **Export** inherit its rules. Their generators historically +compiled embedded expressions to Java **strings** through `expression.generator.CodeGenerationX` + +`CompilationContext`, whose type system is the **classic Xtend** runtime +(`org.eclipse.xtend.expression.*`, `org.eclipse.xtend.typesystem.emf.*`). That is the *only* reason those plugins +`Require-Bundle: org.eclipse.xtend, org.eclipse.xtend.typesystem.emf`. + +This skill removes that legacy coupling by: + +1. Making the embedded expression bodies **Xbase** (`XExpression`) so they can be compiled by the standard + `XbaseCompiler` via a `JvmModelInferrer`, and +2. Providing an **Xtend-free Java-string fallback compiler** for the handful of Expression-DSL constructs that + have no clean Xbase representation (string `+` concatenation, the arithmetic/relational operator overloads). + +## Binding decisions (carried over from the scope migration — confirm they still hold) + +These were agreed with the user during the scope plugin migration. Re-confirm before applying to a new plugin: + +- **dsl-devkit ONLY.** Do **not** migrate the downstream `.scope` / `.export` / `.ext` source files — the + user rewrites those (and regenerates) separately. The migration only has to keep *dsl-devkit* green. +- **Output need NOT be byte-identical.** The committed generated `*ScopeProvider.java` etc. may change shape + (they become inferred JVM types emitted by `JvmModelGenerator`). Generator/golden tests are regenerated. +- **`.ext` (JAVA extension) support is dropped.** Scope/export sources no longer reference Xtend extension + files. Remove the `.ext`-reading validation and the `isJavaExtensionCall` / `isExtension` / + `getCalledJavaMethod` generator branches. Do **not** build an `.ext` reader. +- **Factory expressions become direct Xbase static calls.** `factory` must be written `Type.method(args)` in + source (the FQN type is named explicitly); the generator resolves the type identifier to a + `JvmDeclaredType.qualifiedName` and emits `.(scope, ctx, , originalResource, )`. + Bare `factory foo()` (no type) is no longer supported. +- **No runtime validation in the loop.** dsl-devkit has **no `.scope`/`.export` input files**, so the + inferrer never actually runs during `mvn verify` — only **compilation** of the generators is checked. Runtime + and generated-Java *import* fidelity are therefore **unverifiable** inside dsl-devkit. Treat "build is green" + as "compiles", not "correct". The user validates real output by regenerating in Eclipse. + +> ⚠️ **"Green but broken" trap.** Because the inferrer never runs in CI, a faithful port still needs careful +> by-hand comparison against the legacy generator output. Always diff your emitted-string logic against the +> legacy `CodeGenerationX` / `ExpressionExtensionsX` branch-for-branch. + +## Target architecture (what "done" looks like) + +Mirror the scope plugin's final shape: + +| Concern | Legacy | New | +|---|---|---| +| Generator entry point | `*Generator` implements `IGenerator2` | `*JvmModelInferrer extends AbstractModelInferrer`; `*Generator` extends Xbase `JvmModelGenerator` (wired via the `.mwe2` fragment) | +| Provider classes | hand-templated `.java` strings | **inferred JVM types** (`toClass`/`toMethod`/`toField`); bodies attached as strings via `body = [append(text)]` | +| Embedded expression → Xbase | n/a | `*ExpressionTranslator` builds `XExpression` trees where the construct maps cleanly to Xbase + `xbase.lib` operators | +| Expression → Java string (fallback) | `CodeGenerationX` + `CompilationContext` (classic Xtend) | `*ExpressionCompiler` (Xtend-2, **no** classic-Xtend deps) — ports the string output of `CodeGenerationX`/`ExpressionExtensionsX` *exactly*, minus the `.ext` branches | +| Type/variable/`this` resolution | `CompilationContext` over classic-Xtend `TypeSystem` | `*TranslationContext` (variables, implicit param, implicit-var name) + the translator's JVM type resolution | +| Model-type name → Java class | `EmfRegistryMetaModel` over imported EPackages | `*ModelTypeResolver` (plain Java/EMF) over the model's imported `EPackage`s → `GenModelUtilX.instanceClassName` | +| Legacy execution context | `ScopingGeneratorUtil.getCompilationContext` + inner `ExecutionContextImpl`/`Resource` | **deleted** | +| Plugin deps | `org.eclipse.xtend`, `org.eclipse.xtend.typesystem.emf` | **removed from MANIFEST** | + +### Why a *translator* AND a *string compiler* + +String `+` concatenation is extremely common in these sources and has **no `operator_plus` in `xbase.lib`** +(Xbase special-cases `String +` inside its own compiler), so it **cannot** be pre-linked as an `XExpression` +tree. The relational-operator overload selection is similarly hard to do blind. So: translate to Xbase what +maps cleanly; fall back to the ported string compiler for `+`, unary/binary arithmetic, and the relational +operators. The fallback emits Java text directly (`a + b + c`, `(x) ? y : z`, `Iterables.filter(...)`, …). + +### Model-type resolution — the critical correctness point + +In real `.scope`/`.export` sources the type names in `(Cast)x`, `x.typeSelect(T)` and `T.isInstance(x)` are +**EMF model types** (e.g. `FormDef`, `ILogicalTable`, `intfdef::AlternatingGroup`), **not** dotted Java FQNs. +So `javaType(...)` MUST resolve them through the model's **imported EPackages** → +`GenModelUtilX.instanceClassName(classifier)`, exactly as the legacy `ScopingGeneratorUtil.registerMetaModels` +did. Resolving via `findDeclaredType` against the classpath would **fail** on `Entity`/`FormDef`/etc. + +- Build the EPackage list from + `EObjectUtil.getScopeProviderByEObject(model).getScope(model, IMPORT__PACKAGE).getAllElements()` resolved to + `EPackage[]`. +- Handle import **aliases**: `alias::Type` → `model.getImports()` match on `imp.getName()` → + `imp.getPackage().getEClassifier(Type)`. +- A single-segment name searches every imported package's `getEClassifier(name)`. + +## Step sequence (add new files alongside old, wire last, then delete) + +Keep the build green at every increment. Build only the two plugins with `-am` (see recipe below). + +1. **Survey** the target plugin: list every use of `CodeGenerationX`, `CompilationContext`, + `ScopingGeneratorUtil`, and the `org.eclipse.xtend*` imports. Note each generator fallback site. +2. **Translator** — `*ExpressionTranslator.xtend`: dispatch over the Expression AST → `XExpression`. Cover + literals, list/if, variable & `this` feature calls, boolean/equality/relational ops (link to `xbase.lib`), + getter navigations, extension calls (`extension a::b::C` static method), casts/`typeSelect`/`isInstance`, + receiver/implicit method calls. Return `null` for anything not yet handled. +3. **Translation context** — `*TranslationContext.xtend`: variables map, `implicitVariable` + (`JvmFormalParameter`, drives type resolution) **and** `implicitVariableName` (`String`, the emitted `this` + binding, e.g. `obj`/`ctx`/`UNEXPECTED_THIS`), `modelTypeResolver`. Add a + `newCompilationContext(implicitVarName, implicitType, extraVars(name→FQN), sourceElement)` factory on the + translator to replace the legacy `CompilationContext.clone(...)`/`cloneWithVariable(...)` calls. +4. **Model-type resolver** — `*ModelTypeResolver.java`: as above. `static forElement(EObject)` → + `EcoreUtil2.getContainerOfType(element, .class)`. +5. **String compiler** — `*ExpressionCompiler.xtend`: port `CodeGenerationX` + `ExpressionExtensionsX` string + output **exactly**, dropping the `.ext` branches. Inject `GenModelUtilX` as a **plain field** (not + `extension`) and call `genModelUtil.instanceClassName(classifier)` explicitly. Resolve `javaType` via the + model-type resolver first, else `ctx.resolveDslType` (strip a leading `java.lang.` for un-nested names). + **Preserve the legacy `FeatureCall` 3-way tail**: `isSimpleFeatureCall`→getter, `isSimpleNavigation`→ + `notCompilable()`, else→getter (do NOT collapse these — the middle branch must stay `notCompilable()`). +6. **Wire the generators**: replace `@Inject extension CodeGenerationX` + `CompilationContext` field with + `@Inject *ExpressionCompiler compiler` + `@Inject *ExpressionTranslator translator`; rewrite every fallback + `compilationContext.clone(...).javaExpression(...)` to + `compiler.javaExpression(expr, translator.newCompilationContext(...))`. Drop the `CompilationContext` + `configure(...)` parameter. +7. **Inferrer + grammar**: replace the `IGenerator2` `*Generator` with `*JvmModelInferrer` (infer the provider + types, attach string bodies; emit framework types **fully qualified** so the unit needs no imports). Make the + embedded expression bodies Xbase in the grammar (`Expression.xtext` embeds Xbase; add an + `ExpressionJvmModelInferrer`), switch the `.mwe2` generator fragment so the runtime module binds the inferrer + + `JvmModelGenerator`, and **regenerate `src-gen`** via the MWE2 workflow. +8. **Delete legacy**: remove `ScopingGeneratorUtil.getCompilationContext` + its classic-Xtend inner classes + (`*ExecutionContext`, `*Resource`) and any now-orphaned private helpers + imports; keep the still-used utility + methods. Remove the `.ext` validation (`checkExtensions`) + its message key/field. +9. **Drop deps**: remove `org.eclipse.xtend` and `org.eclipse.xtend.typesystem.emf` from the plugin + `META-INF/MANIFEST.MF`. (The `expression` plugin itself may keep them while `CompilationContext.java` still + exists — that is a separate, later increment.) +10. **Build green** after each step; grep the whole plugin `src/**` for + `org\.eclipse\.xtend\.(expression|typesystem)|org\.eclipse\.internal\.xtend|CompilationContext|EmfRegistryMetaModel|ExecutionContextImpl` + to confirm only doc-comment mentions remain. + +## Build / verify recipe (Windows / PowerShell) + +Always prefix (the cwd drifts and multiple dotted `-D` props need the stop-parsing token `--%`): + +```powershell +Set-Location D:\git\dsl-devkit +$env:JAVA_HOME = "D:\Java\jdk-21.0.10" +$env:Path = "D:\Programs\apache-maven-3.9.16\bin;$env:JAVA_HOME\bin;$env:Path" +mvn --% clean verify -f ./ddk-parent/pom.xml -pl :com.avaloq.tools.ddk.xtext.expression,:com.avaloq.tools.ddk.xtext.scope -am -DskipTests "-Dcheckstyle.skip=true" "-Dpmd.skip=true" "-Dspotbugs.skip=true" --batch-mode +``` + +- Pipe to a log + `Select-String` for `BUILD SUCCESS|BUILD FAILURE`; on failure grep + `ERROR:|undefined|Type mismatch|ambiguous|incompatible`. +- Run the build **async** and wait for the completion notification (exit code is reported automatically). + **Do not poll or `Start-Sleep`.** Builds take ~50–90 s. +- Swap the `-pl` list for the export plugin when migrating it. +- The build only checks **compilation**, not runtime/output (no `.scope` inputs). See the "green but broken" + warning above. + +## Xtend gotchas confirmed during this migration + +- **Reserved words**: `val` → use `getVal()`/`^val`; also `^if`/`^else`/`^var`. +- **Lambda `it` shadowing**: inside `.exists[…]` / `.filter[…]` the implicit `it` rebinds. Hoist outer fields + you need (e.g. `val operationName = name`, `val parameterCount = params.size`) **before** the lambda. +- **Leading-paren statement ambiguity**: a statement that starts with `(` right after another expression is + parsed as a call on the previous line (`params.size(receiver…)`). Bind a `val` first, e.g. + `val declaredType = receiverType as JvmDeclaredType` then `declaredType.allFeatures…`. +- **`@Inject extension` member shadowing**: an extension method can be shadowed by a same-named native member + (e.g. `GenModelUtilX.instanceClassName(EClassifier)` lost to EMF's native `EClassifier.getInstanceClassName()` + which returns `null` for generated EClasses). Inject as a **plain field** and call the method explicitly. +- `#[…]` is a `List`, `a -> b` is a `Pair`. `create_file` fails on existing files (edit instead). Same-package + classes need no import. +- `vscode_listCodeUsages` can resolve relative paths against the **wrong root** in a multi-root workspace, and + the Java reference provider may be unregistered ("No reference provider available"). Use `grep_search` + instead to find callers. + +## Reference: the scope migration (already landed) + +Files added: `jvmmodel/ScopeJvmModelInferrer.xtend`, `jvmmodel/ScopeExpressionTranslator.xtend`, +`jvmmodel/ScopeExpressionCompiler.xtend`, `jvmmodel/ScopeTranslationContext.xtend`, +`jvmmodel/ScopeExpressionMethodRequest.xtend`, `generator/ScopeModelTypeResolver.java`, plus +`expression/jvmmodel/ExpressionJvmModelInferrer.xtend`. Deleted: `generator/ScopeGenerator.xtend` and +`ScopingGeneratorUtil.getCompilationContext` + its inner classes. MANIFEST dropped `org.eclipse.xtend` + +`org.eclipse.xtend.typesystem.emf`. The **export** plugin is the next target — same playbook. diff --git a/com.avaloq.tools.ddk.workflow/.classpath b/com.avaloq.tools.ddk.workflow/.classpath index 97bf0dc637..772ba5e859 100644 --- a/com.avaloq.tools.ddk.workflow/.classpath +++ b/com.avaloq.tools.ddk.workflow/.classpath @@ -4,4 +4,6 @@ + + diff --git a/com.avaloq.tools.ddk.workflow/antlr-generator-3.2.0-patch.jar b/com.avaloq.tools.ddk.workflow/antlr-generator-3.2.0-patch.jar new file mode 100644 index 0000000000000000000000000000000000000000..90516fd7ac76a3ec685e046f91eb762e68e20586 GIT binary patch literal 1484649 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%0AaAH?nu0NxCVyl& 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

0o!{G>?pE44LUKy|#M%y*oR=c!hc*7_{If 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%0DU}=hy#Jq^`TKJB5lbk_T^f`R<=qC!pt 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

kDx#JEXxXY5fwD%JuFeuD@(=>Tp`Q&% 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�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%0DXL{~qe7JA{hcxu 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

I8_nWQmla%we@Iji{1SQ?m*~ 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 QGin|_fqUSNv#iel1NWwaUjP6A literal 0 HcmV?d00001 diff --git a/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExport.mwe2 b/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExport.mwe2 index 0af1514f8e..1fd82c083b 100644 --- a/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExport.mwe2 +++ b/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExport.mwe2 @@ -53,6 +53,8 @@ Workflow { uriMap = {from = "platform:/plugin/" to = "platform:/resource/"} registerGenModelFile = "platform:/resource/org.eclipse.xtext/org/eclipse/xtext/Xtext.genmodel" registerGenModelFile = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" + registerGenModelFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel" + registerGenModelFile = "platform:/resource/org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel" registerGenModelFile = "platform:/resource/com.avaloq.tools.ddk.xtext.expression/metamodel/com/avaloq/tools/ddk/xtext/expression/Expression.genmodel" registerEcoreFile = "${metamodelBase}/${modelDirectory}/${baseName}.ecore" registerGenModelFile = "${metamodelBase}/${modelDirectory}/${baseName}.genmodel" @@ -153,6 +155,11 @@ Workflow { // rename refactoring // fragment = refactoring.RefactorElementNameFragment {} + // Xbase support + fragment = org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 {} + fragment = org.eclipse.xtext.xtext.generator.xbase.XtypeGeneratorFragment2 {} + fragment = org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 {} + // Code generator fragment = org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 { generateJavaMain = false diff --git a/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExpression.mwe2 b/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExpression.mwe2 index 12c0773446..82f305fee2 100644 --- a/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExpression.mwe2 +++ b/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateExpression.mwe2 @@ -42,6 +42,8 @@ Workflow { uriMap = {from = "platform:/plugin/" to = "platform:/resource/"} registerGenModelFile = "platform:/resource/org.eclipse.xtext/org/eclipse/xtext/Xtext.genmodel" registerGenModelFile = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" + registerGenModelFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel" + registerGenModelFile = "platform:/resource/org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel" registerEcoreFile = "${metamodelBase}/${modelDirectory}/${baseName}.ecore" registerGenModelFile = "${metamodelBase}/${modelDirectory}/${baseName}.genmodel" } @@ -126,6 +128,11 @@ Workflow { // content assist API fragment = org.eclipse.xtext.xtext.generator.ui.contentAssist.ContentAssistFragment2 {} + // Xbase support + fragment = org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 {} + fragment = org.eclipse.xtext.xtext.generator.xbase.XtypeGeneratorFragment2 {} + fragment = org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 {} + fragment = BundleVersionStripperFragment { bundle = "org.antlr.runtime" bundle = "org.eclipse.xtext.xbase.lib" diff --git a/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateScope.mwe2 b/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateScope.mwe2 index 04d8f70a56..e4de47d938 100644 --- a/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateScope.mwe2 +++ b/com.avaloq.tools.ddk.workflow/src/com/avaloq/tools/ddk/workflow/GenerateScope.mwe2 @@ -53,6 +53,8 @@ Workflow { uriMap = {from = "platform:/plugin/" to = "platform:/resource/"} registerGenModelFile = "platform:/resource/org.eclipse.xtext/org/eclipse/xtext/Xtext.genmodel" registerGenModelFile = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" + registerGenModelFile = "platform:/resource/org.eclipse.xtext.xbase/model/Xbase.genmodel" + registerGenModelFile = "platform:/resource/org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel" registerGenModelFile = "platform:/resource/com.avaloq.tools.ddk.xtext.expression/metamodel/com/avaloq/tools/ddk/xtext/expression/Expression.genmodel" registerEcoreFile = "${metamodelBase}/${modelDirectory}/${baseName}.ecore" registerGenModelFile = "${metamodelBase}/${modelDirectory}/${baseName}.genmodel" @@ -152,6 +154,11 @@ Workflow { // rename refactoring // fragment = refactoring.RefactorElementNameFragment {} + // Xbase support + fragment = org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 {} + fragment = org.eclipse.xtext.xtext.generator.xbase.XtypeGeneratorFragment2 {} + fragment = org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 {} + // Code generator fragment = org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 { generateJavaMain = false diff --git a/com.avaloq.tools.ddk.xtext.export.ide/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.export.ide/META-INF/MANIFEST.MF index 1ca0773013..61a3b46542 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.export.ide/META-INF/MANIFEST.MF @@ -10,5 +10,6 @@ Export-Package: com.avaloq.tools.ddk.xtext.export.ide.contentassist.antlr, com.avaloq.tools.ddk.xtext.export.ide.contentassist.antlr.internal Require-Bundle: org.antlr.runtime, org.eclipse.xtext.ide, - com.avaloq.tools.ddk.xtext.export + com.avaloq.tools.ddk.xtext.export, + org.eclipse.xtext.xbase.ide Automatic-Module-Name: com.avaloq.tools.ddk.xtext.export.ide diff --git a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/AbstractExportIdeModule.java b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/AbstractExportIdeModule.java index 9a4ba6f8d0..aaafe9228c 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/AbstractExportIdeModule.java +++ b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/AbstractExportIdeModule.java @@ -7,18 +7,18 @@ import com.avaloq.tools.ddk.xtext.export.ide.contentassist.antlr.internal.InternalExportLexer; import com.google.inject.Binder; import com.google.inject.name.Names; -import org.eclipse.xtext.ide.DefaultIdeModule; import org.eclipse.xtext.ide.LexerIdeBindings; import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +import org.eclipse.xtext.xbase.ide.DefaultXbaseIdeModule; /** * Manual modifications go to {@link ExportIdeModule}. */ @SuppressWarnings("all") -public abstract class AbstractExportIdeModule extends DefaultIdeModule { +public abstract class AbstractExportIdeModule extends DefaultXbaseIdeModule { // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 public void configureContentAssistLexer(Binder binder) { diff --git a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/ExportParser.java b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/ExportParser.java index f12baad0f8..db31df96a4 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/ExportParser.java +++ b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/ExportParser.java @@ -52,6 +52,45 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0(), "rule__CollectionExpression__NameAlternatives_0_0"); builder.put(grammarAccess.getTypeAccess().getAlternatives(), "rule__Type__Alternatives"); builder.put(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0(), "rule__CollectionType__ClAlternatives_0_0"); + builder.put(grammarAccess.getXAssignmentAccess().getAlternatives(), "rule__XAssignment__Alternatives"); + builder.put(grammarAccess.getOpMultiAssignAccess().getAlternatives(), "rule__OpMultiAssign__Alternatives"); + builder.put(grammarAccess.getOpEqualityAccess().getAlternatives(), "rule__OpEquality__Alternatives"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1(), "rule__XRelationalExpression__Alternatives_1"); + builder.put(grammarAccess.getOpCompareAccess().getAlternatives(), "rule__OpCompare__Alternatives"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives(), "rule__OpOther__Alternatives"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives_5_1(), "rule__OpOther__Alternatives_5_1"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives_6_1(), "rule__OpOther__Alternatives_6_1"); + builder.put(grammarAccess.getOpAddAccess().getAlternatives(), "rule__OpAdd__Alternatives"); + builder.put(grammarAccess.getOpMultiAccess().getAlternatives(), "rule__OpMulti__Alternatives"); + builder.put(grammarAccess.getXUnaryOperationAccess().getAlternatives(), "rule__XUnaryOperation__Alternatives"); + builder.put(grammarAccess.getOpUnaryAccess().getAlternatives(), "rule__OpUnary__Alternatives"); + builder.put(grammarAccess.getOpPostfixAccess().getAlternatives(), "rule__OpPostfix__Alternatives"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1(), "rule__XMemberFeatureCall__Alternatives_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1(), "rule__XMemberFeatureCall__Alternatives_1_1_3_1"); + builder.put(grammarAccess.getXPrimaryExpressionAccess().getAlternatives(), "rule__XPrimaryExpression__Alternatives"); + builder.put(grammarAccess.getXLiteralAccess().getAlternatives(), "rule__XLiteral__Alternatives"); + builder.put(grammarAccess.getXCollectionLiteralAccess().getAlternatives(), "rule__XCollectionLiteral__Alternatives"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2(), "rule__XSwitchExpression__Alternatives_2"); + builder.put(grammarAccess.getXCasePartAccess().getAlternatives_3(), "rule__XCasePart__Alternatives_3"); + builder.put(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives(), "rule__XExpressionOrVarDeclaration__Alternatives"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1(), "rule__XVariableDeclaration__Alternatives_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2(), "rule__XVariableDeclaration__Alternatives_2"); + builder.put(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1(), "rule__XFeatureCall__Alternatives_3_1"); + builder.put(grammarAccess.getFeatureCallIDAccess().getAlternatives(), "rule__FeatureCallID__Alternatives"); + builder.put(grammarAccess.getIdOrSuperAccess().getAlternatives(), "rule__IdOrSuper__Alternatives"); + builder.put(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1(), "rule__XConstructorCall__Alternatives_4_1"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1(), "rule__XBooleanLiteral__Alternatives_1"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3(), "rule__XTryCatchFinallyExpression__Alternatives_3"); + builder.put(grammarAccess.getNumberAccess().getAlternatives(), "rule__Number__Alternatives"); + builder.put(grammarAccess.getNumberAccess().getAlternatives_1_0(), "rule__Number__Alternatives_1_0"); + builder.put(grammarAccess.getNumberAccess().getAlternatives_1_1_1(), "rule__Number__Alternatives_1_1_1"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getAlternatives(), "rule__JvmTypeReference__Alternatives"); + builder.put(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives(), "rule__JvmArgumentTypeReference__Alternatives"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2(), "rule__JvmWildcardTypeReference__Alternatives_2"); + builder.put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1(), "rule__XImportDeclaration__Alternatives_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3(), "rule__XImportDeclaration__Alternatives_1_0_3"); builder.put(grammarAccess.getExportModelAccess().getGroup(), "rule__ExportModel__Group__0"); builder.put(grammarAccess.getExportModelAccess().getGroup_0(), "rule__ExportModel__Group_0__0"); builder.put(grammarAccess.getExportModelAccess().getGroup_3(), "rule__ExportModel__Group_3__0"); @@ -127,6 +166,185 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionTypeAccess().getGroup(), "rule__CollectionType__Group__0"); builder.put(grammarAccess.getSimpleTypeAccess().getGroup(), "rule__SimpleType__Group__0"); builder.put(grammarAccess.getSimpleTypeAccess().getGroup_1(), "rule__SimpleType__Group_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_0(), "rule__XAssignment__Group_0__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1(), "rule__XAssignment__Group_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1(), "rule__XAssignment__Group_1_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0(), "rule__XAssignment__Group_1_1_0__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0(), "rule__XAssignment__Group_1_1_0_0__0"); + builder.put(grammarAccess.getOpMultiAssignAccess().getGroup_5(), "rule__OpMultiAssign__Group_5__0"); + builder.put(grammarAccess.getOpMultiAssignAccess().getGroup_6(), "rule__OpMultiAssign__Group_6__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup(), "rule__XOrExpression__Group__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1(), "rule__XOrExpression__Group_1__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1_0(), "rule__XOrExpression__Group_1_0__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0(), "rule__XOrExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup(), "rule__XAndExpression__Group__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1(), "rule__XAndExpression__Group_1__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1_0(), "rule__XAndExpression__Group_1_0__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0(), "rule__XAndExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup(), "rule__XEqualityExpression__Group__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1(), "rule__XEqualityExpression__Group_1__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0(), "rule__XEqualityExpression__Group_1_0__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0(), "rule__XEqualityExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup(), "rule__XRelationalExpression__Group__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0(), "rule__XRelationalExpression__Group_1_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0(), "rule__XRelationalExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0(), "rule__XRelationalExpression__Group_1_0_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1(), "rule__XRelationalExpression__Group_1_1__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0(), "rule__XRelationalExpression__Group_1_1_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0(), "rule__XRelationalExpression__Group_1_1_0_0__0"); + builder.put(grammarAccess.getOpCompareAccess().getGroup_1(), "rule__OpCompare__Group_1__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup(), "rule__XOtherOperatorExpression__Group__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1(), "rule__XOtherOperatorExpression__Group_1__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0(), "rule__XOtherOperatorExpression__Group_1_0__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0(), "rule__XOtherOperatorExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_2(), "rule__OpOther__Group_2__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5(), "rule__OpOther__Group_5__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5_1_0(), "rule__OpOther__Group_5_1_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0(), "rule__OpOther__Group_5_1_0_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6(), "rule__OpOther__Group_6__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6_1_0(), "rule__OpOther__Group_6_1_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0(), "rule__OpOther__Group_6_1_0_0__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup(), "rule__XAdditiveExpression__Group__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1(), "rule__XAdditiveExpression__Group_1__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0(), "rule__XAdditiveExpression__Group_1_0__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0(), "rule__XAdditiveExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup(), "rule__XMultiplicativeExpression__Group__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1(), "rule__XMultiplicativeExpression__Group_1__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0(), "rule__XMultiplicativeExpression__Group_1_0__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0(), "rule__XMultiplicativeExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXUnaryOperationAccess().getGroup_0(), "rule__XUnaryOperation__Group_0__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup(), "rule__XCastedExpression__Group__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1(), "rule__XCastedExpression__Group_1__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0(), "rule__XCastedExpression__Group_1_0__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0(), "rule__XCastedExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup(), "rule__XPostfixOperation__Group__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup_1(), "rule__XPostfixOperation__Group_1__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup_1_0(), "rule__XPostfixOperation__Group_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup(), "rule__XMemberFeatureCall__Group__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0(), "rule__XMemberFeatureCall__Group_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0(), "rule__XMemberFeatureCall__Group_1_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0(), "rule__XMemberFeatureCall__Group_1_0_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1(), "rule__XMemberFeatureCall__Group_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0(), "rule__XMemberFeatureCall__Group_1_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0(), "rule__XMemberFeatureCall__Group_1_1_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2(), "rule__XMemberFeatureCall__Group_1_1_1_2__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3(), "rule__XMemberFeatureCall__Group_1_1_3__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup(), "rule__XSetLiteral__Group__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup_3(), "rule__XSetLiteral__Group_3__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup_3_1(), "rule__XSetLiteral__Group_3_1__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup(), "rule__XListLiteral__Group__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup_3(), "rule__XListLiteral__Group_3__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup_3_1(), "rule__XListLiteral__Group_3_1__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup(), "rule__XClosure__Group__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_0(), "rule__XClosure__Group_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_0_0(), "rule__XClosure__Group_0_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1(), "rule__XClosure__Group_1__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0(), "rule__XClosure__Group_1_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0_0(), "rule__XClosure__Group_1_0_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0_0_1(), "rule__XClosure__Group_1_0_0_1__0"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getGroup(), "rule__XExpressionInClosure__Group__0"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getGroup_1(), "rule__XExpressionInClosure__Group_1__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup(), "rule__XShortClosure__Group__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0(), "rule__XShortClosure__Group_0__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0(), "rule__XShortClosure__Group_0_0__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1(), "rule__XShortClosure__Group_0_0_1__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1(), "rule__XShortClosure__Group_0_0_1_1__0"); + builder.put(grammarAccess.getXParenthesizedExpressionAccess().getGroup(), "rule__XParenthesizedExpression__Group__0"); + builder.put(grammarAccess.getXIfExpressionAccess().getGroup(), "rule__XIfExpression__Group__0"); + builder.put(grammarAccess.getXIfExpressionAccess().getGroup_6(), "rule__XIfExpression__Group_6__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup(), "rule__XSwitchExpression__Group__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0(), "rule__XSwitchExpression__Group_2_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0(), "rule__XSwitchExpression__Group_2_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0(), "rule__XSwitchExpression__Group_2_0_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1(), "rule__XSwitchExpression__Group_2_1__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0(), "rule__XSwitchExpression__Group_2_1_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0(), "rule__XSwitchExpression__Group_2_1_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_5(), "rule__XSwitchExpression__Group_5__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup(), "rule__XCasePart__Group__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup_2(), "rule__XCasePart__Group_2__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup_3_0(), "rule__XCasePart__Group_3_0__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup(), "rule__XForLoopExpression__Group__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup_0(), "rule__XForLoopExpression__Group_0__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0(), "rule__XForLoopExpression__Group_0_0__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup(), "rule__XBasicForLoopExpression__Group__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3(), "rule__XBasicForLoopExpression__Group_3__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1(), "rule__XBasicForLoopExpression__Group_3_1__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7(), "rule__XBasicForLoopExpression__Group_7__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1(), "rule__XBasicForLoopExpression__Group_7_1__0"); + builder.put(grammarAccess.getXWhileExpressionAccess().getGroup(), "rule__XWhileExpression__Group__0"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getGroup(), "rule__XDoWhileExpression__Group__0"); + builder.put(grammarAccess.getXBlockExpressionAccess().getGroup(), "rule__XBlockExpression__Group__0"); + builder.put(grammarAccess.getXBlockExpressionAccess().getGroup_2(), "rule__XBlockExpression__Group_2__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup(), "rule__XVariableDeclaration__Group__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0(), "rule__XVariableDeclaration__Group_2_0__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0(), "rule__XVariableDeclaration__Group_2_0_0__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_3(), "rule__XVariableDeclaration__Group_3__0"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getGroup(), "rule__JvmFormalParameter__Group__0"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getGroup(), "rule__FullJvmFormalParameter__Group__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup(), "rule__XFeatureCall__Group__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_1(), "rule__XFeatureCall__Group_1__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_1_2(), "rule__XFeatureCall__Group_1_2__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3(), "rule__XFeatureCall__Group_3__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1(), "rule__XFeatureCall__Group_3_1_1__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1(), "rule__XFeatureCall__Group_3_1_1_1__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup(), "rule__XConstructorCall__Group__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_3(), "rule__XConstructorCall__Group_3__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_3_2(), "rule__XConstructorCall__Group_3_2__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4(), "rule__XConstructorCall__Group_4__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1(), "rule__XConstructorCall__Group_4_1_1__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1(), "rule__XConstructorCall__Group_4_1_1_1__0"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getGroup(), "rule__XBooleanLiteral__Group__0"); + builder.put(grammarAccess.getXNullLiteralAccess().getGroup(), "rule__XNullLiteral__Group__0"); + builder.put(grammarAccess.getXNumberLiteralAccess().getGroup(), "rule__XNumberLiteral__Group__0"); + builder.put(grammarAccess.getXStringLiteralAccess().getGroup(), "rule__XStringLiteral__Group__0"); + builder.put(grammarAccess.getXTypeLiteralAccess().getGroup(), "rule__XTypeLiteral__Group__0"); + builder.put(grammarAccess.getXThrowExpressionAccess().getGroup(), "rule__XThrowExpression__Group__0"); + builder.put(grammarAccess.getXReturnExpressionAccess().getGroup(), "rule__XReturnExpression__Group__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup(), "rule__XTryCatchFinallyExpression__Group__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0(), "rule__XTryCatchFinallyExpression__Group_3_0__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1(), "rule__XTryCatchFinallyExpression__Group_3_0_1__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1(), "rule__XTryCatchFinallyExpression__Group_3_1__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup(), "rule__XSynchronizedExpression__Group__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0(), "rule__XSynchronizedExpression__Group_0__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0(), "rule__XSynchronizedExpression__Group_0_0__0"); + builder.put(grammarAccess.getXCatchClauseAccess().getGroup(), "rule__XCatchClause__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup(), "rule__QualifiedName__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0"); + builder.put(grammarAccess.getNumberAccess().getGroup_1(), "rule__Number__Group_1__0"); + builder.put(grammarAccess.getNumberAccess().getGroup_1_1(), "rule__Number__Group_1_1__0"); + builder.put(grammarAccess.getStaticQualifierAccess().getGroup(), "rule__StaticQualifier__Group__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0(), "rule__JvmTypeReference__Group_0__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1(), "rule__JvmTypeReference__Group_0_1__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0(), "rule__JvmTypeReference__Group_0_1_0__0"); + builder.put(grammarAccess.getArrayBracketsAccess().getGroup(), "rule__ArrayBrackets__Group__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup(), "rule__XFunctionTypeRef__Group__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0(), "rule__XFunctionTypeRef__Group_0__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1(), "rule__XFunctionTypeRef__Group_0_1__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1(), "rule__XFunctionTypeRef__Group_0_1_1__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup(), "rule__JvmParameterizedTypeReference__Group__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1(), "rule__JvmParameterizedTypeReference__Group_1__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2(), "rule__JvmParameterizedTypeReference__Group_1_2__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4(), "rule__JvmParameterizedTypeReference__Group_1_4__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup(), "rule__JvmWildcardTypeReference__Group__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0(), "rule__JvmWildcardTypeReference__Group_2_0__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1(), "rule__JvmWildcardTypeReference__Group_2_1__0"); + builder.put(grammarAccess.getJvmUpperBoundAccess().getGroup(), "rule__JvmUpperBound__Group__0"); + builder.put(grammarAccess.getJvmUpperBoundAndedAccess().getGroup(), "rule__JvmUpperBoundAnded__Group__0"); + builder.put(grammarAccess.getJvmLowerBoundAccess().getGroup(), "rule__JvmLowerBound__Group__0"); + builder.put(grammarAccess.getJvmLowerBoundAndedAccess().getGroup(), "rule__JvmLowerBoundAnded__Group__0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getGroup(), "rule__JvmTypeParameter__Group__0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getGroup_1(), "rule__JvmTypeParameter__Group_1__0"); + builder.put(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup(), "rule__QualifiedNameWithWildcard__Group__0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getGroup(), "rule__XImportDeclaration__Group__0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getGroup_1_0(), "rule__XImportDeclaration__Group_1_0__0"); + builder.put(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup(), "rule__QualifiedNameInStaticImport__Group__0"); builder.put(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1(), "rule__ExportModel__ExtensionAssignment_0_1"); builder.put(grammarAccess.getExportModelAccess().getNameAssignment_0_2(), "rule__ExportModel__NameAssignment_0_2"); builder.put(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4(), "rule__ExportModel__TargetGrammarAssignment_0_4"); @@ -226,6 +444,150 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionTypeAccess().getId1Assignment_2(), "rule__CollectionType__Id1Assignment_2"); builder.put(grammarAccess.getSimpleTypeAccess().getIdAssignment_0(), "rule__SimpleType__IdAssignment_0"); builder.put(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1(), "rule__SimpleType__IdAssignment_1_1"); + builder.put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1(), "rule__XAssignment__FeatureAssignment_0_1"); + builder.put(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3(), "rule__XAssignment__ValueAssignment_0_3"); + builder.put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XAssignment__FeatureAssignment_1_1_0_0_1"); + builder.put(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1(), "rule__XAssignment__RightOperandAssignment_1_1_1"); + builder.put(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOrExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOrExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAndExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAndExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1(), "rule__XEqualityExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1(), "rule__XRelationalExpression__TypeAssignment_1_0_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1(), "rule__XRelationalExpression__RightOperandAssignment_1_1_1"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAdditiveExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1(), "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1(), "rule__XUnaryOperation__FeatureAssignment_0_1"); + builder.put(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2(), "rule__XUnaryOperation__OperandAssignment_0_2"); + builder.put(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1(), "rule__XCastedExpression__TypeAssignment_1_1"); + builder.put(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1(), "rule__XPostfixOperation__FeatureAssignment_1_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1(), "rule__XMemberFeatureCall__ValueAssignment_1_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1(), "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0(), "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"); + builder.put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0(), "rule__XSetLiteral__ElementsAssignment_3_0"); + builder.put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1(), "rule__XSetLiteral__ElementsAssignment_3_1_1"); + builder.put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0(), "rule__XListLiteral__ElementsAssignment_3_0"); + builder.put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1(), "rule__XListLiteral__ElementsAssignment_3_1_1"); + builder.put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"); + builder.put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"); + builder.put(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1(), "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"); + builder.put(grammarAccess.getXClosureAccess().getExpressionAssignment_2(), "rule__XClosure__ExpressionAssignment_2"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0(), "rule__XExpressionInClosure__ExpressionsAssignment_1_0"); + builder.put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"); + builder.put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"); + builder.put(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2(), "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"); + builder.put(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1(), "rule__XShortClosure__ExpressionAssignment_1"); + builder.put(grammarAccess.getXIfExpressionAccess().getIfAssignment_3(), "rule__XIfExpression__IfAssignment_3"); + builder.put(grammarAccess.getXIfExpressionAccess().getThenAssignment_5(), "rule__XIfExpression__ThenAssignment_5"); + builder.put(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1(), "rule__XIfExpression__ElseAssignment_6_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1(), "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1(), "rule__XSwitchExpression__SwitchAssignment_2_0_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0(), "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1(), "rule__XSwitchExpression__SwitchAssignment_2_1_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4(), "rule__XSwitchExpression__CasesAssignment_4"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2(), "rule__XSwitchExpression__DefaultAssignment_5_2"); + builder.put(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1(), "rule__XCasePart__TypeGuardAssignment_1"); + builder.put(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1(), "rule__XCasePart__CaseAssignment_2_1"); + builder.put(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1(), "rule__XCasePart__ThenAssignment_3_0_1"); + builder.put(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1(), "rule__XCasePart__FallThroughAssignment_3_1"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3(), "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1(), "rule__XForLoopExpression__ForExpressionAssignment_1"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3(), "rule__XForLoopExpression__EachExpressionAssignment_3"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5(), "rule__XBasicForLoopExpression__ExpressionAssignment_5"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9(), "rule__XBasicForLoopExpression__EachExpressionAssignment_9"); + builder.put(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3(), "rule__XWhileExpression__PredicateAssignment_3"); + builder.put(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5(), "rule__XWhileExpression__BodyAssignment_5"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2(), "rule__XDoWhileExpression__BodyAssignment_2"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5(), "rule__XDoWhileExpression__PredicateAssignment_5"); + builder.put(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0(), "rule__XBlockExpression__ExpressionsAssignment_2_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0(), "rule__XVariableDeclaration__WriteableAssignment_1_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0(), "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1(), "rule__XVariableDeclaration__NameAssignment_2_0_0_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1(), "rule__XVariableDeclaration__NameAssignment_2_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1(), "rule__XVariableDeclaration__RightAssignment_3_1"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__JvmFormalParameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1(), "rule__JvmFormalParameter__NameAssignment_1"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1(), "rule__FullJvmFormalParameter__NameAssignment_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2(), "rule__XFeatureCall__FeatureAssignment_2"); + builder.put(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0(), "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"); + builder.put(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2(), "rule__XConstructorCall__ConstructorAssignment_2"); + builder.put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0(), "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5(), "rule__XConstructorCall__ArgumentsAssignment_5"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1(), "rule__XBooleanLiteral__IsTrueAssignment_1_1"); + builder.put(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1(), "rule__XNumberLiteral__ValueAssignment_1"); + builder.put(grammarAccess.getXStringLiteralAccess().getValueAssignment_1(), "rule__XStringLiteral__ValueAssignment_1"); + builder.put(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3(), "rule__XTypeLiteral__TypeAssignment_3"); + builder.put(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4(), "rule__XTypeLiteral__ArrayDimensionsAssignment_4"); + builder.put(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2(), "rule__XThrowExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2(), "rule__XReturnExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2(), "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0(), "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1(), "rule__XSynchronizedExpression__ParamAssignment_1"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3(), "rule__XSynchronizedExpression__ExpressionAssignment_3"); + builder.put(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2(), "rule__XCatchClause__DeclaredParamAssignment_2"); + builder.put(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4(), "rule__XCatchClause__ExpressionAssignment_4"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2(), "rule__XFunctionTypeRef__ReturnTypeAssignment_2"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0(), "rule__JvmParameterizedTypeReference__TypeAssignment_0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1(), "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"); + builder.put(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBound__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBound__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getNameAssignment_0(), "rule__JvmTypeParameter__NameAssignment_0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_0(), "rule__JvmTypeParameter__ConstraintsAssignment_1_0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_1(), "rule__JvmTypeParameter__ConstraintsAssignment_1_1"); + builder.put(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment(), "rule__XImportSection__ImportDeclarationsAssignment"); + builder.put(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0(), "rule__XImportDeclaration__StaticAssignment_1_0_0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1(), "rule__XImportDeclaration__ExtensionAssignment_1_0_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2(), "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2"); + builder.put(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0(), "rule__XImportDeclaration__WildcardAssignment_1_0_3_0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1(), "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1(), "rule__XImportDeclaration__ImportedTypeAssignment_1_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2(), "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2"); } } diff --git a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.g b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.g index e2e6228455..23e309ae8c 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.g +++ b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.g @@ -1275,1064 +1275,17531 @@ finally { restoreStackSize(stackSize); } -rule__InterfaceItem__Alternatives +// Entry rule entryRuleXExpression +entryRuleXExpression +: +{ before(grammarAccess.getXExpressionRule()); } + ruleXExpression +{ after(grammarAccess.getXExpressionRule()); } + EOF +; + +// Rule XExpression +ruleXExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); } - ruleInterfaceField - { after(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); } - ruleInterfaceNavigation - { after(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); } - ruleInterfaceExpression - { after(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); } + { before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } + ruleXAssignment + { after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Alternatives_7_0 +// Entry rule entryRuleXAssignment +entryRuleXAssignment +: +{ before(grammarAccess.getXAssignmentRule()); } + ruleXAssignment +{ after(grammarAccess.getXAssignmentRule()); } + EOF +; + +// Rule XAssignment +ruleXAssignment @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); } - (rule__Export__FingerprintAssignment_7_0_0) - { after(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); } - ) - | + : ( - { before(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); } - (rule__Export__ResourceFingerprintAssignment_7_0_1) - { after(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); } + { before(grammarAccess.getXAssignmentAccess().getAlternatives()); } + (rule__XAssignment__Alternatives) + { after(grammarAccess.getXAssignmentAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Alternatives_8 +// Entry rule entryRuleOpSingleAssign +entryRuleOpSingleAssign +: +{ before(grammarAccess.getOpSingleAssignRule()); } + ruleOpSingleAssign +{ after(grammarAccess.getOpSingleAssignRule()); } + EOF +; + +// Rule OpSingleAssign +ruleOpSingleAssign @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getExportAccess().getGroup_8_0()); } - (rule__Export__Group_8_0__0) - { after(grammarAccess.getExportAccess().getGroup_8_0()); } - ) - | + : ( - { before(grammarAccess.getExportAccess().getGroup_8_1()); } - (rule__Export__Group_8_1__0) - { after(grammarAccess.getExportAccess().getGroup_8_1()); } + { before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } + '=' + { after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__Expression__Alternatives +// Entry rule entryRuleOpMultiAssign +entryRuleOpMultiAssign +: +{ before(grammarAccess.getOpMultiAssignRule()); } + ruleOpMultiAssign +{ after(grammarAccess.getOpMultiAssignRule()); } + EOF +; + +// Rule OpMultiAssign +ruleOpMultiAssign @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } - ruleLetExpression - { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } - (ruleCastedExpression) - { after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } - ruleChainExpression - { after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + { before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } + (rule__OpMultiAssign__Alternatives) + { after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainedExpression__Alternatives +// Entry rule entryRuleXOrExpression +entryRuleXOrExpression +: +{ before(grammarAccess.getXOrExpressionRule()); } + ruleXOrExpression +{ after(grammarAccess.getXOrExpressionRule()); } + EOF +; + +// Rule XOrExpression +ruleXOrExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } - ruleIfExpressionKw - { after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } - ruleIfExpressionTri - { after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } - ruleSwitchExpression - { after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + { before(grammarAccess.getXOrExpressionAccess().getGroup()); } + (rule__XOrExpression__Group__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAlternatives_1_1_0 +// Entry rule entryRuleOpOr +entryRuleOpOr +: +{ before(grammarAccess.getOpOrRule()); } + ruleOpOr +{ after(grammarAccess.getOpOrRule()); } + EOF +; + +// Rule OpOr +ruleOpOr @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } - '==' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } - '!=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } - '>=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } - '<=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } - '>' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } - ) - | + : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } - '<' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + { before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } + '||' + { after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__NameAlternatives_1_1_0 +// Entry rule entryRuleXAndExpression +entryRuleXAndExpression +: +{ before(grammarAccess.getXAndExpressionRule()); } + ruleXAndExpression +{ after(grammarAccess.getXAndExpressionRule()); } + EOF +; + +// Rule XAndExpression +ruleXAndExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } - '+' - { after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } - ) - | + : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } - '-' - { after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + { before(grammarAccess.getXAndExpressionAccess().getGroup()); } + (rule__XAndExpression__Group__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__NameAlternatives_1_1_0 +// Entry rule entryRuleOpAnd +entryRuleOpAnd +: +{ before(grammarAccess.getOpAndRule()); } + ruleOpAnd +{ after(grammarAccess.getOpAndRule()); } + EOF +; + +// Rule OpAnd +ruleOpAnd @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } - '*' - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } - ) - | + : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } - '/' - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + { before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } + '&&' + { after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryOrInfixExpression__Alternatives +// Entry rule entryRuleXEqualityExpression +entryRuleXEqualityExpression +: +{ before(grammarAccess.getXEqualityExpressionRule()); } + ruleXEqualityExpression +{ after(grammarAccess.getXEqualityExpressionRule()); } + EOF +; + +// Rule XEqualityExpression +ruleXEqualityExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } - ruleUnaryExpression - { after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } - ) - | + : ( - { before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } - ruleInfixExpression - { after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + { before(grammarAccess.getXEqualityExpressionAccess().getGroup()); } + (rule__XEqualityExpression__Group__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__NameAlternatives_0_0 +// Entry rule entryRuleOpEquality +entryRuleOpEquality +: +{ before(grammarAccess.getOpEqualityRule()); } + ruleOpEquality +{ after(grammarAccess.getOpEqualityRule()); } + EOF +; + +// Rule OpEquality +ruleOpEquality @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } - '!' - { after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } - ) - | + : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } - '-' - { after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + { before(grammarAccess.getOpEqualityAccess().getAlternatives()); } + (rule__OpEquality__Alternatives) + { after(grammarAccess.getOpEqualityAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Alternatives_1 +// Entry rule entryRuleXRelationalExpression +entryRuleXRelationalExpression +: +{ before(grammarAccess.getXRelationalExpressionRule()); } + ruleXRelationalExpression +{ after(grammarAccess.getXRelationalExpressionRule()); } + EOF +; + +// Rule XRelationalExpression +ruleXRelationalExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } - (rule__InfixExpression__Group_1_0__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } - (rule__InfixExpression__Group_1_1__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } - ) - | + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } - (rule__InfixExpression__Group_1_2__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + { before(grammarAccess.getXRelationalExpressionAccess().getGroup()); } + (rule__XRelationalExpression__Group__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpCompare +entryRuleOpCompare +: +{ before(grammarAccess.getOpCompareRule()); } + ruleOpCompare +{ after(grammarAccess.getOpCompareRule()); } + EOF +; + +// Rule OpCompare +ruleOpCompare + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } - (rule__InfixExpression__Group_1_3__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + { before(grammarAccess.getOpCompareAccess().getAlternatives()); } + (rule__OpCompare__Alternatives) + { after(grammarAccess.getOpCompareAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAlternatives_1_3_2_0 +// Entry rule entryRuleXOtherOperatorExpression +entryRuleXOtherOperatorExpression +: +{ before(grammarAccess.getXOtherOperatorExpressionRule()); } + ruleXOtherOperatorExpression +{ after(grammarAccess.getXOtherOperatorExpressionRule()); } + EOF +; + +// Rule XOtherOperatorExpression +ruleXOtherOperatorExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } - 'collect' - { after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } - 'select' - { after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } - 'selectFirst' - { after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } - 'reject' - { after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } - 'exists' - { after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } - 'notExists' - { after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } - 'sortBy' - { after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } - 'forAll' - { after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); } + (rule__XOtherOperatorExpression__Group__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Alternatives +// Entry rule entryRuleOpOther +entryRuleOpOther +: +{ before(grammarAccess.getOpOtherRule()); } + ruleOpOther +{ after(grammarAccess.getOpOtherRule()); } + EOF +; + +// Rule OpOther +ruleOpOther @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } - ruleLiteral - { after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } - ruleFeatureCall - { after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } - ruleListLiteral - { after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } - ruleConstructorCallExpression - { after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } - ruleGlobalVarExpression - { after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } - ) - | + : ( - { before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } - ruleParanthesizedExpression - { after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + { before(grammarAccess.getOpOtherAccess().getAlternatives()); } + (rule__OpOther__Alternatives) + { after(grammarAccess.getOpOtherAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__Literal__Alternatives +// Entry rule entryRuleXAdditiveExpression +entryRuleXAdditiveExpression +: +{ before(grammarAccess.getXAdditiveExpressionRule()); } + ruleXAdditiveExpression +{ after(grammarAccess.getXAdditiveExpressionRule()); } + EOF +; + +// Rule XAdditiveExpression +ruleXAdditiveExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } - ruleBooleanLiteral - { after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } + (rule__XAdditiveExpression__Group__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpAdd +entryRuleOpAdd +: +{ before(grammarAccess.getOpAddRule()); } + ruleOpAdd +{ after(grammarAccess.getOpAddRule()); } + EOF +; + +// Rule OpAdd +ruleOpAdd + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } - ruleIntegerLiteral - { after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + { before(grammarAccess.getOpAddAccess().getAlternatives()); } + (rule__OpAdd__Alternatives) + { after(grammarAccess.getOpAddAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXMultiplicativeExpression +entryRuleXMultiplicativeExpression +: +{ before(grammarAccess.getXMultiplicativeExpressionRule()); } + ruleXMultiplicativeExpression +{ after(grammarAccess.getXMultiplicativeExpressionRule()); } + EOF +; + +// Rule XMultiplicativeExpression +ruleXMultiplicativeExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } - ruleNullLiteral - { after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } + (rule__XMultiplicativeExpression__Group__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpMulti +entryRuleOpMulti +: +{ before(grammarAccess.getOpMultiRule()); } + ruleOpMulti +{ after(grammarAccess.getOpMultiRule()); } + EOF +; + +// Rule OpMulti +ruleOpMulti + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } - ruleRealLiteral - { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + { before(grammarAccess.getOpMultiAccess().getAlternatives()); } + (rule__OpMulti__Alternatives) + { after(grammarAccess.getOpMultiAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXUnaryOperation +entryRuleXUnaryOperation +: +{ before(grammarAccess.getXUnaryOperationRule()); } + ruleXUnaryOperation +{ after(grammarAccess.getXUnaryOperationRule()); } + EOF +; + +// Rule XUnaryOperation +ruleXUnaryOperation + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } - ruleStringLiteral - { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + { before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } + (rule__XUnaryOperation__Alternatives) + { after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__BooleanLiteral__ValAlternatives_0 +// Entry rule entryRuleOpUnary +entryRuleOpUnary +: +{ before(grammarAccess.getOpUnaryRule()); } + ruleOpUnary +{ after(grammarAccess.getOpUnaryRule()); } + EOF +; + +// Rule OpUnary +ruleOpUnary @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } - 'true' - { after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + { before(grammarAccess.getOpUnaryAccess().getAlternatives()); } + (rule__OpUnary__Alternatives) + { after(grammarAccess.getOpUnaryAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCastedExpression +entryRuleXCastedExpression +: +{ before(grammarAccess.getXCastedExpressionRule()); } + ruleXCastedExpression +{ after(grammarAccess.getXCastedExpressionRule()); } + EOF +; + +// Rule XCastedExpression +ruleXCastedExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } - 'false' - { after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + { before(grammarAccess.getXCastedExpressionAccess().getGroup()); } + (rule__XCastedExpression__Group__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__FeatureCall__Alternatives +// Entry rule entryRuleXPostfixOperation +entryRuleXPostfixOperation +: +{ before(grammarAccess.getXPostfixOperationRule()); } + ruleXPostfixOperation +{ after(grammarAccess.getXPostfixOperationRule()); } + EOF +; + +// Rule XPostfixOperation +ruleXPostfixOperation @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } - ruleOperationCall - { after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + { before(grammarAccess.getXPostfixOperationAccess().getGroup()); } + (rule__XPostfixOperation__Group__0) + { after(grammarAccess.getXPostfixOperationAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpPostfix +entryRuleOpPostfix +: +{ before(grammarAccess.getOpPostfixRule()); } + ruleOpPostfix +{ after(grammarAccess.getOpPostfixRule()); } + EOF +; + +// Rule OpPostfix +ruleOpPostfix + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } - (rule__FeatureCall__TypeAssignment_1) - { after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + { before(grammarAccess.getOpPostfixAccess().getAlternatives()); } + (rule__OpPostfix__Alternatives) + { after(grammarAccess.getOpPostfixAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXMemberFeatureCall +entryRuleXMemberFeatureCall +: +{ before(grammarAccess.getXMemberFeatureCallRule()); } + ruleXMemberFeatureCall +{ after(grammarAccess.getXMemberFeatureCallRule()); } + EOF +; + +// Rule XMemberFeatureCall +ruleXMemberFeatureCall + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } - ruleCollectionExpression - { after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } + (rule__XMemberFeatureCall__Group__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXPrimaryExpression +entryRuleXPrimaryExpression +: +{ before(grammarAccess.getXPrimaryExpressionRule()); } + ruleXPrimaryExpression +{ after(grammarAccess.getXPrimaryExpressionRule()); } + EOF +; + +// Rule XPrimaryExpression +ruleXPrimaryExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } - ruleTypeSelectExpression - { after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + { before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } + (rule__XPrimaryExpression__Alternatives) + { after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__NameAlternatives_0_0 +// Entry rule entryRuleXLiteral +entryRuleXLiteral +: +{ before(grammarAccess.getXLiteralRule()); } + ruleXLiteral +{ after(grammarAccess.getXLiteralRule()); } + EOF +; + +// Rule XLiteral +ruleXLiteral @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } - 'collect' - { after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + { before(grammarAccess.getXLiteralAccess().getAlternatives()); } + (rule__XLiteral__Alternatives) + { after(grammarAccess.getXLiteralAccess().getAlternatives()); } ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } - 'select' - { after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCollectionLiteral +entryRuleXCollectionLiteral +: +{ before(grammarAccess.getXCollectionLiteralRule()); } + ruleXCollectionLiteral +{ after(grammarAccess.getXCollectionLiteralRule()); } + EOF +; + +// Rule XCollectionLiteral +ruleXCollectionLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } + (rule__XCollectionLiteral__Alternatives) + { after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSetLiteral +entryRuleXSetLiteral +: +{ before(grammarAccess.getXSetLiteralRule()); } + ruleXSetLiteral +{ after(grammarAccess.getXSetLiteralRule()); } + EOF +; + +// Rule XSetLiteral +ruleXSetLiteral + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } - 'selectFirst' - { after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + { before(grammarAccess.getXSetLiteralAccess().getGroup()); } + (rule__XSetLiteral__Group__0) + { after(grammarAccess.getXSetLiteralAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXListLiteral +entryRuleXListLiteral +: +{ before(grammarAccess.getXListLiteralRule()); } + ruleXListLiteral +{ after(grammarAccess.getXListLiteralRule()); } + EOF +; + +// Rule XListLiteral +ruleXListLiteral + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } - 'reject' - { after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + { before(grammarAccess.getXListLiteralAccess().getGroup()); } + (rule__XListLiteral__Group__0) + { after(grammarAccess.getXListLiteralAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXClosure +entryRuleXClosure +: +{ before(grammarAccess.getXClosureRule()); } + ruleXClosure +{ after(grammarAccess.getXClosureRule()); } + EOF +; + +// Rule XClosure +ruleXClosure + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } - 'exists' - { after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + { before(grammarAccess.getXClosureAccess().getGroup()); } + (rule__XClosure__Group__0) + { after(grammarAccess.getXClosureAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXExpressionInClosure +entryRuleXExpressionInClosure +: +{ before(grammarAccess.getXExpressionInClosureRule()); } + ruleXExpressionInClosure +{ after(grammarAccess.getXExpressionInClosureRule()); } + EOF +; + +// Rule XExpressionInClosure +ruleXExpressionInClosure + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } - 'notExists' - { after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + { before(grammarAccess.getXExpressionInClosureAccess().getGroup()); } + (rule__XExpressionInClosure__Group__0) + { after(grammarAccess.getXExpressionInClosureAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXShortClosure +entryRuleXShortClosure +: +{ before(grammarAccess.getXShortClosureRule()); } + ruleXShortClosure +{ after(grammarAccess.getXShortClosureRule()); } + EOF +; + +// Rule XShortClosure +ruleXShortClosure + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } - 'sortBy' - { after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + { before(grammarAccess.getXShortClosureAccess().getGroup()); } + (rule__XShortClosure__Group__0) + { after(grammarAccess.getXShortClosureAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXParenthesizedExpression +entryRuleXParenthesizedExpression +: +{ before(grammarAccess.getXParenthesizedExpressionRule()); } + ruleXParenthesizedExpression +{ after(grammarAccess.getXParenthesizedExpressionRule()); } + EOF +; + +// Rule XParenthesizedExpression +ruleXParenthesizedExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } - 'forAll' - { after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + { before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } + (rule__XParenthesizedExpression__Group__0) + { after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXIfExpression +entryRuleXIfExpression +: +{ before(grammarAccess.getXIfExpressionRule()); } + ruleXIfExpression +{ after(grammarAccess.getXIfExpressionRule()); } + EOF +; + +// Rule XIfExpression +ruleXIfExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXIfExpressionAccess().getGroup()); } + (rule__XIfExpression__Group__0) + { after(grammarAccess.getXIfExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSwitchExpression +entryRuleXSwitchExpression +: +{ before(grammarAccess.getXSwitchExpressionRule()); } + ruleXSwitchExpression +{ after(grammarAccess.getXSwitchExpressionRule()); } + EOF +; + +// Rule XSwitchExpression +ruleXSwitchExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup()); } + (rule__XSwitchExpression__Group__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCasePart +entryRuleXCasePart +: +{ before(grammarAccess.getXCasePartRule()); } + ruleXCasePart +{ after(grammarAccess.getXCasePartRule()); } + EOF +; + +// Rule XCasePart +ruleXCasePart + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCasePartAccess().getGroup()); } + (rule__XCasePart__Group__0) + { after(grammarAccess.getXCasePartAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXForLoopExpression +entryRuleXForLoopExpression +: +{ before(grammarAccess.getXForLoopExpressionRule()); } + ruleXForLoopExpression +{ after(grammarAccess.getXForLoopExpressionRule()); } + EOF +; + +// Rule XForLoopExpression +ruleXForLoopExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup()); } + (rule__XForLoopExpression__Group__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBasicForLoopExpression +entryRuleXBasicForLoopExpression +: +{ before(grammarAccess.getXBasicForLoopExpressionRule()); } + ruleXBasicForLoopExpression +{ after(grammarAccess.getXBasicForLoopExpressionRule()); } + EOF +; + +// Rule XBasicForLoopExpression +ruleXBasicForLoopExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + (rule__XBasicForLoopExpression__Group__0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXWhileExpression +entryRuleXWhileExpression +: +{ before(grammarAccess.getXWhileExpressionRule()); } + ruleXWhileExpression +{ after(grammarAccess.getXWhileExpressionRule()); } + EOF +; + +// Rule XWhileExpression +ruleXWhileExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXWhileExpressionAccess().getGroup()); } + (rule__XWhileExpression__Group__0) + { after(grammarAccess.getXWhileExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXDoWhileExpression +entryRuleXDoWhileExpression +: +{ before(grammarAccess.getXDoWhileExpressionRule()); } + ruleXDoWhileExpression +{ after(grammarAccess.getXDoWhileExpressionRule()); } + EOF +; + +// Rule XDoWhileExpression +ruleXDoWhileExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } + (rule__XDoWhileExpression__Group__0) + { after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBlockExpression +entryRuleXBlockExpression +: +{ before(grammarAccess.getXBlockExpressionRule()); } + ruleXBlockExpression +{ after(grammarAccess.getXBlockExpressionRule()); } + EOF +; + +// Rule XBlockExpression +ruleXBlockExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBlockExpressionAccess().getGroup()); } + (rule__XBlockExpression__Group__0) + { after(grammarAccess.getXBlockExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXExpressionOrVarDeclaration +entryRuleXExpressionOrVarDeclaration +: +{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); } + ruleXExpressionOrVarDeclaration +{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); } + EOF +; + +// Rule XExpressionOrVarDeclaration +ruleXExpressionOrVarDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } + (rule__XExpressionOrVarDeclaration__Alternatives) + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__Type__Alternatives +// Entry rule entryRuleXVariableDeclaration +entryRuleXVariableDeclaration +: +{ before(grammarAccess.getXVariableDeclarationRule()); } + ruleXVariableDeclaration +{ after(grammarAccess.getXVariableDeclarationRule()); } + EOF +; + +// Rule XVariableDeclaration +ruleXVariableDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup()); } + (rule__XVariableDeclaration__Group__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmFormalParameter +entryRuleJvmFormalParameter +: +{ before(grammarAccess.getJvmFormalParameterRule()); } + ruleJvmFormalParameter +{ after(grammarAccess.getJvmFormalParameterRule()); } + EOF +; + +// Rule JvmFormalParameter +ruleJvmFormalParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmFormalParameterAccess().getGroup()); } + (rule__JvmFormalParameter__Group__0) + { after(grammarAccess.getJvmFormalParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleFullJvmFormalParameter +entryRuleFullJvmFormalParameter +: +{ before(grammarAccess.getFullJvmFormalParameterRule()); } + ruleFullJvmFormalParameter +{ after(grammarAccess.getFullJvmFormalParameterRule()); } + EOF +; + +// Rule FullJvmFormalParameter +ruleFullJvmFormalParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } + (rule__FullJvmFormalParameter__Group__0) + { after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXFeatureCall +entryRuleXFeatureCall +: +{ before(grammarAccess.getXFeatureCallRule()); } + ruleXFeatureCall +{ after(grammarAccess.getXFeatureCallRule()); } + EOF +; + +// Rule XFeatureCall +ruleXFeatureCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXFeatureCallAccess().getGroup()); } + (rule__XFeatureCall__Group__0) + { after(grammarAccess.getXFeatureCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleFeatureCallID +entryRuleFeatureCallID +: +{ before(grammarAccess.getFeatureCallIDRule()); } + ruleFeatureCallID +{ after(grammarAccess.getFeatureCallIDRule()); } + EOF +; + +// Rule FeatureCallID +ruleFeatureCallID + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } + (rule__FeatureCallID__Alternatives) + { after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleIdOrSuper +entryRuleIdOrSuper +: +{ before(grammarAccess.getIdOrSuperRule()); } + ruleIdOrSuper +{ after(grammarAccess.getIdOrSuperRule()); } + EOF +; + +// Rule IdOrSuper +ruleIdOrSuper + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getIdOrSuperAccess().getAlternatives()); } + (rule__IdOrSuper__Alternatives) + { after(grammarAccess.getIdOrSuperAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXConstructorCall +entryRuleXConstructorCall +: +{ before(grammarAccess.getXConstructorCallRule()); } + ruleXConstructorCall +{ after(grammarAccess.getXConstructorCallRule()); } + EOF +; + +// Rule XConstructorCall +ruleXConstructorCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXConstructorCallAccess().getGroup()); } + (rule__XConstructorCall__Group__0) + { after(grammarAccess.getXConstructorCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBooleanLiteral +entryRuleXBooleanLiteral +: +{ before(grammarAccess.getXBooleanLiteralRule()); } + ruleXBooleanLiteral +{ after(grammarAccess.getXBooleanLiteralRule()); } + EOF +; + +// Rule XBooleanLiteral +ruleXBooleanLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBooleanLiteralAccess().getGroup()); } + (rule__XBooleanLiteral__Group__0) + { after(grammarAccess.getXBooleanLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXNullLiteral +entryRuleXNullLiteral +: +{ before(grammarAccess.getXNullLiteralRule()); } + ruleXNullLiteral +{ after(grammarAccess.getXNullLiteralRule()); } + EOF +; + +// Rule XNullLiteral +ruleXNullLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXNullLiteralAccess().getGroup()); } + (rule__XNullLiteral__Group__0) + { after(grammarAccess.getXNullLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXNumberLiteral +entryRuleXNumberLiteral +: +{ before(grammarAccess.getXNumberLiteralRule()); } + ruleXNumberLiteral +{ after(grammarAccess.getXNumberLiteralRule()); } + EOF +; + +// Rule XNumberLiteral +ruleXNumberLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXNumberLiteralAccess().getGroup()); } + (rule__XNumberLiteral__Group__0) + { after(grammarAccess.getXNumberLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXStringLiteral +entryRuleXStringLiteral +: +{ before(grammarAccess.getXStringLiteralRule()); } + ruleXStringLiteral +{ after(grammarAccess.getXStringLiteralRule()); } + EOF +; + +// Rule XStringLiteral +ruleXStringLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXStringLiteralAccess().getGroup()); } + (rule__XStringLiteral__Group__0) + { after(grammarAccess.getXStringLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXTypeLiteral +entryRuleXTypeLiteral +: +{ before(grammarAccess.getXTypeLiteralRule()); } + ruleXTypeLiteral +{ after(grammarAccess.getXTypeLiteralRule()); } + EOF +; + +// Rule XTypeLiteral +ruleXTypeLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXTypeLiteralAccess().getGroup()); } + (rule__XTypeLiteral__Group__0) + { after(grammarAccess.getXTypeLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXThrowExpression +entryRuleXThrowExpression +: +{ before(grammarAccess.getXThrowExpressionRule()); } + ruleXThrowExpression +{ after(grammarAccess.getXThrowExpressionRule()); } + EOF +; + +// Rule XThrowExpression +ruleXThrowExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXThrowExpressionAccess().getGroup()); } + (rule__XThrowExpression__Group__0) + { after(grammarAccess.getXThrowExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXReturnExpression +entryRuleXReturnExpression +: +{ before(grammarAccess.getXReturnExpressionRule()); } + ruleXReturnExpression +{ after(grammarAccess.getXReturnExpressionRule()); } + EOF +; + +// Rule XReturnExpression +ruleXReturnExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXReturnExpressionAccess().getGroup()); } + (rule__XReturnExpression__Group__0) + { after(grammarAccess.getXReturnExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXTryCatchFinallyExpression +entryRuleXTryCatchFinallyExpression +: +{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); } + ruleXTryCatchFinallyExpression +{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); } + EOF +; + +// Rule XTryCatchFinallyExpression +ruleXTryCatchFinallyExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } + (rule__XTryCatchFinallyExpression__Group__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSynchronizedExpression +entryRuleXSynchronizedExpression +: +{ before(grammarAccess.getXSynchronizedExpressionRule()); } + ruleXSynchronizedExpression +{ after(grammarAccess.getXSynchronizedExpressionRule()); } + EOF +; + +// Rule XSynchronizedExpression +ruleXSynchronizedExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } + (rule__XSynchronizedExpression__Group__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCatchClause +entryRuleXCatchClause +: +{ before(grammarAccess.getXCatchClauseRule()); } + ruleXCatchClause +{ after(grammarAccess.getXCatchClauseRule()); } + EOF +; + +// Rule XCatchClause +ruleXCatchClause + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCatchClauseAccess().getGroup()); } + (rule__XCatchClause__Group__0) + { after(grammarAccess.getXCatchClauseAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName +: +{ before(grammarAccess.getQualifiedNameRule()); } + ruleQualifiedName +{ after(grammarAccess.getQualifiedNameRule()); } + EOF +; + +// Rule QualifiedName +ruleQualifiedName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameAccess().getGroup()); } + (rule__QualifiedName__Group__0) + { after(grammarAccess.getQualifiedNameAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleNumber +entryRuleNumber +@init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +} +: +{ before(grammarAccess.getNumberRule()); } + ruleNumber +{ after(grammarAccess.getNumberRule()); } + EOF +; +finally { + myHiddenTokenState.restore(); +} + +// Rule Number +ruleNumber + @init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNumberAccess().getAlternatives()); } + (rule__Number__Alternatives) + { after(grammarAccess.getNumberAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); + myHiddenTokenState.restore(); +} + +// Entry rule entryRuleJvmTypeReference +entryRuleJvmTypeReference +: +{ before(grammarAccess.getJvmTypeReferenceRule()); } + ruleJvmTypeReference +{ after(grammarAccess.getJvmTypeReferenceRule()); } + EOF +; + +// Rule JvmTypeReference +ruleJvmTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } + (rule__JvmTypeReference__Alternatives) + { after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets +: +{ before(grammarAccess.getArrayBracketsRule()); } + ruleArrayBrackets +{ after(grammarAccess.getArrayBracketsRule()); } + EOF +; + +// Rule ArrayBrackets +ruleArrayBrackets + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArrayBracketsAccess().getGroup()); } + (rule__ArrayBrackets__Group__0) + { after(grammarAccess.getArrayBracketsAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef +: +{ before(grammarAccess.getXFunctionTypeRefRule()); } + ruleXFunctionTypeRef +{ after(grammarAccess.getXFunctionTypeRefRule()); } + EOF +; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } + (rule__XFunctionTypeRef__Group__0) + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference +: +{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + ruleJvmParameterizedTypeReference +{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + EOF +; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } + (rule__JvmParameterizedTypeReference__Group__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference +: +{ before(grammarAccess.getJvmArgumentTypeReferenceRule()); } + ruleJvmArgumentTypeReference +{ after(grammarAccess.getJvmArgumentTypeReferenceRule()); } + EOF +; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } + (rule__JvmArgumentTypeReference__Alternatives) + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference +: +{ before(grammarAccess.getJvmWildcardTypeReferenceRule()); } + ruleJvmWildcardTypeReference +{ after(grammarAccess.getJvmWildcardTypeReferenceRule()); } + EOF +; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } + (rule__JvmWildcardTypeReference__Group__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound +: +{ before(grammarAccess.getJvmUpperBoundRule()); } + ruleJvmUpperBound +{ after(grammarAccess.getJvmUpperBoundRule()); } + EOF +; + +// Rule JvmUpperBound +ruleJvmUpperBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + (rule__JvmUpperBound__Group__0) + { after(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded +: +{ before(grammarAccess.getJvmUpperBoundAndedRule()); } + ruleJvmUpperBoundAnded +{ after(grammarAccess.getJvmUpperBoundAndedRule()); } + EOF +; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } + (rule__JvmUpperBoundAnded__Group__0) + { after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound +: +{ before(grammarAccess.getJvmLowerBoundRule()); } + ruleJvmLowerBound +{ after(grammarAccess.getJvmLowerBoundRule()); } + EOF +; + +// Rule JvmLowerBound +ruleJvmLowerBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmLowerBoundAccess().getGroup()); } + (rule__JvmLowerBound__Group__0) + { after(grammarAccess.getJvmLowerBoundAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded +: +{ before(grammarAccess.getJvmLowerBoundAndedRule()); } + ruleJvmLowerBoundAnded +{ after(grammarAccess.getJvmLowerBoundAndedRule()); } + EOF +; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } + (rule__JvmLowerBoundAnded__Group__0) + { after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard +: +{ before(grammarAccess.getQualifiedNameWithWildcardRule()); } + ruleQualifiedNameWithWildcard +{ after(grammarAccess.getQualifiedNameWithWildcardRule()); } + EOF +; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } + (rule__QualifiedNameWithWildcard__Group__0) + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleValidID +entryRuleValidID +: +{ before(grammarAccess.getValidIDRule()); } + ruleValidID +{ after(grammarAccess.getValidIDRule()); } + EOF +; + +// Rule ValidID +ruleValidID + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } + RULE_ID + { after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration +: +{ before(grammarAccess.getXImportDeclarationRule()); } + ruleXImportDeclaration +{ after(grammarAccess.getXImportDeclarationRule()); } + EOF +; + +// Rule XImportDeclaration +ruleXImportDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXImportDeclarationAccess().getGroup()); } + (rule__XImportDeclaration__Group__0) + { after(grammarAccess.getXImportDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport +: +{ before(grammarAccess.getQualifiedNameInStaticImportRule()); } + ruleQualifiedNameInStaticImport +{ after(grammarAccess.getQualifiedNameInStaticImportRule()); } + EOF +; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport + @init { + int stackSize = keepStackSize(); + } + : + ( + ( + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + (rule__QualifiedNameInStaticImport__Group__0) + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + ) + ( + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + (rule__QualifiedNameInStaticImport__Group__0)* + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + ) + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceItem__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); } + ruleInterfaceField + { after(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); } + ruleInterfaceNavigation + { after(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); } + ruleInterfaceExpression + { after(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Alternatives_7_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); } + (rule__Export__FingerprintAssignment_7_0_0) + { after(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); } + ) + | + ( + { before(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); } + (rule__Export__ResourceFingerprintAssignment_7_0_1) + { after(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Alternatives_8 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExportAccess().getGroup_8_0()); } + (rule__Export__Group_8_0__0) + { after(grammarAccess.getExportAccess().getGroup_8_0()); } + ) + | + ( + { before(grammarAccess.getExportAccess().getGroup_8_1()); } + (rule__Export__Group_8_1__0) + { after(grammarAccess.getExportAccess().getGroup_8_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Expression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } + ruleLetExpression + { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } + (ruleCastedExpression) + { after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + ruleChainExpression + { after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainedExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + ruleIfExpressionKw + { after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + ruleIfExpressionTri + { after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + ruleSwitchExpression + { after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__OperatorAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } + '==' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + '!=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } + '>=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + '<=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + '>' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + '<' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__NameAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } + '+' + { after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + '-' + { after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__NameAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + '*' + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + '/' + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryOrInfixExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + ruleUnaryExpression + { after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + ruleInfixExpression + { after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__NameAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + '!' + { after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + '-' + { after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + (rule__InfixExpression__Group_1_0__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + (rule__InfixExpression__Group_1_1__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + (rule__InfixExpression__Group_1_2__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + (rule__InfixExpression__Group_1_3__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__NameAlternatives_1_3_2_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + 'collect' + { after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + 'select' + { after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + 'selectFirst' + { after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + 'reject' + { after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + 'exists' + { after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + 'notExists' + { after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + 'sortBy' + { after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + 'forAll' + { after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrimaryExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + ruleLiteral + { after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } + ruleFeatureCall + { after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + ruleListLiteral + { after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + ruleConstructorCallExpression + { after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + ruleGlobalVarExpression + { after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + ruleParanthesizedExpression + { after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Literal__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + ruleBooleanLiteral + { after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + ruleIntegerLiteral + { after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + ruleNullLiteral + { after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + ruleRealLiteral + { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + ruleStringLiteral + { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__BooleanLiteral__ValAlternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + 'true' + { after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + ) + | + ( + { before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + 'false' + { after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__FeatureCall__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + ruleOperationCall + { after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + (rule__FeatureCall__TypeAssignment_1) + { after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + ruleCollectionExpression + { after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + ruleTypeSelectExpression + { after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__NameAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + 'collect' + { after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } + 'select' + { after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + 'selectFirst' + { after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + 'reject' + { after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + 'exists' + { after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + 'notExists' + { after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + 'sortBy' + { after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + 'forAll' + { after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Type__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } + ruleCollectionType + { after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } + ruleSimpleType + { after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__ClAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } + 'Collection' + { after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } + 'List' + { after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } + ) + | + ( + { before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } + 'Set' + { after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXAssignmentAccess().getGroup_0()); } + (rule__XAssignment__Group_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getXAssignmentAccess().getGroup_1()); } + (rule__XAssignment__Group_1__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); } + '+=' + { after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); } + '-=' + { after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); } + '*=' + { after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); } + '/=' + { after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); } + '%=' + { after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); } + (rule__OpMultiAssign__Group_5__0) + { after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); } + (rule__OpMultiAssign__Group_6__0) + { after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpEquality__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); } + '==' + { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); } + '!=' + { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); } + '===' + { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); } + '!==' + { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); } + (rule__XRelationalExpression__Group_1_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); } + (rule__XRelationalExpression__Group_1_1__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); } + '>=' + { after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getGroup_1()); } + (rule__OpCompare__Group_1__0) + { after(grammarAccess.getOpCompareAccess().getGroup_1()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); } + '>' + { after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); } + '<' + { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); } + '->' + { after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); } + '..<' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_2()); } + (rule__OpOther__Group_2__0) + { after(grammarAccess.getOpOtherAccess().getGroup_2()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); } + '..' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); } + '=>' + { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_5()); } + (rule__OpOther__Group_5__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_6()); } + (rule__OpOther__Group_6__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); } + '<>' + { after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); } + '?:' + { after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); } + (rule__OpOther__Group_5_1_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); } + (rule__OpOther__Group_6_1_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); } + '=>' + { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpAdd__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); } + '+' + { after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); } + '-' + { after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMulti__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); } + '*' + { after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); } + '**' + { after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); } + '/' + { after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); } + '%' + { after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); } + (rule__XUnaryOperation__Group_0__0) + { after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); } + ruleXCastedExpression + { after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpUnary__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); } + '!' + { after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); } + '-' + { after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); } + '+' + { after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpPostfix__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); } + '++' + { after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); } + '--' + { after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); } + (rule__XMemberFeatureCall__Group_1_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); } + (rule__XMemberFeatureCall__Group_1_1__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); } + '.' + { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); } + (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); } + '.' + { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); } + (rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); } + (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_1_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_3_1_1__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPrimaryExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); } + ruleXConstructorCall + { after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); } + ruleXBlockExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); } + ruleXSwitchExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); } + (ruleXSynchronizedExpression) + { after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); } + ruleXFeatureCall + { after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); } + ruleXLiteral + { after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); } + ruleXIfExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); } + (ruleXForLoopExpression) + { after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); } + ruleXBasicForLoopExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); } + ruleXWhileExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); } + ruleXDoWhileExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); } + ruleXThrowExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); } + ruleXReturnExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); } + ruleXTryCatchFinallyExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); } + ruleXParenthesizedExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XLiteral__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); } + ruleXCollectionLiteral + { after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); } + (ruleXClosure) + { after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); } + ruleXBooleanLiteral + { after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); } + ruleXNumberLiteral + { after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); } + ruleXNullLiteral + { after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); } + ruleXStringLiteral + { after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); } + ruleXTypeLiteral + { after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCollectionLiteral__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); } + ruleXSetLiteral + { after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); } + ruleXListLiteral + { after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); } + (rule__XSwitchExpression__Group_2_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); } + (rule__XSwitchExpression__Group_2_1__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXCasePartAccess().getGroup_3_0()); } + (rule__XCasePart__Group_3_0__0) + { after(grammarAccess.getXCasePartAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); } + (rule__XCasePart__FallThroughAssignment_3_1) + { after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionOrVarDeclaration__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); } + ruleXVariableDeclaration + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); } + ruleXExpression + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); } + (rule__XVariableDeclaration__WriteableAssignment_1_0) + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); } + ) + | + ( + { before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); } + 'val' + { after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); } + (rule__XVariableDeclaration__Group_2_0__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); } + (rule__XVariableDeclaration__NameAssignment_2_1) + { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Alternatives_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); } + ) + | + ( + { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); } + (rule__XFeatureCall__Group_3_1_1__0) + { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__FeatureCallID__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); } + 'extends' + { after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); } + 'static' + { after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); } + 'import' + { after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); } + 'extension' + { after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__IdOrSuper__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); } + ruleFeatureCallID + { after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); } + 'super' + { after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Alternatives_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_0) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); } + ) + | + ( + { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); } + (rule__XConstructorCall__Group_4_1_1__0) + { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBooleanLiteral__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); } + 'false' + { after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); } + ) + | + ( + { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); } + (rule__XBooleanLiteral__IsTrueAssignment_1_1) + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); } + (rule__XTryCatchFinallyExpression__Group_3_0__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); } + (rule__XTryCatchFinallyExpression__Group_3_1__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); } + RULE_HEX + { after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getGroup_1()); } + (rule__Number__Group_1__0) + { after(grammarAccess.getNumberAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); } + RULE_INT + { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); } + RULE_DECIMAL + { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives_1_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); } + RULE_INT + { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); } + RULE_DECIMAL + { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmTypeReference__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); } + (rule__JvmTypeReference__Group_0__0) + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); } + ruleXFunctionTypeRef + { after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmArgumentTypeReference__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); } + ruleJvmWildcardTypeReference + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmWildcardTypeReference__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); } + (rule__JvmWildcardTypeReference__Group_2_0__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); } + (rule__JvmWildcardTypeReference__Group_2_1__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } + (rule__XImportDeclaration__Group_1_0__0) + { after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } + (rule__XImportDeclaration__ImportedTypeAssignment_1_1) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } + (rule__XImportDeclaration__ImportedNamespaceAssignment_1_2) + { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1_0_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } + (rule__XImportDeclaration__WildcardAssignment_1_0_3_0) + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } + (rule__XImportDeclaration__MemberNameAssignment_1_0_3_1) + { after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group__0__Impl + rule__ExportModel__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getGroup_0()); } + (rule__ExportModel__Group_0__0)? + { after(grammarAccess.getExportModelAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group__1__Impl + rule__ExportModel__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + ( + { before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } + (rule__ExportModel__ImportsAssignment_1) + { after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } + ) + ( + { before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } + (rule__ExportModel__ImportsAssignment_1)* + { after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } + ) +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group__2__Impl + rule__ExportModel__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); } + (rule__ExportModel__ExtensionsAssignment_2)* + { after(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group__3__Impl + rule__ExportModel__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getGroup_3()); } + (rule__ExportModel__Group_3__0)? + { after(grammarAccess.getExportModelAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + ( + { before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } + (rule__ExportModel__ExportsAssignment_4) + { after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } + ) + ( + { before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } + (rule__ExportModel__ExportsAssignment_4)* + { after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } + ) +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ExportModel__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_0__0__Impl + rule__ExportModel__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); } + 'export' + { after(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_0__1__Impl + rule__ExportModel__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); } + (rule__ExportModel__ExtensionAssignment_0_1)? + { after(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_0__2__Impl + rule__ExportModel__Group_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); } + (rule__ExportModel__NameAssignment_0_2) + { after(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_0__3__Impl + rule__ExportModel__Group_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getForKeyword_0_3()); } + 'for' + { after(grammarAccess.getExportModelAccess().getForKeyword_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_0__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); } + (rule__ExportModel__TargetGrammarAssignment_0_4) + { after(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ExportModel__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_3__0__Impl + rule__ExportModel__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } + 'interface' + { after(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_3__1__Impl + rule__ExportModel__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); } + '{' + { after(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_3__2__Impl + rule__ExportModel__Group_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + ( + { before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } + (rule__ExportModel__InterfacesAssignment_3_2) + { after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } + ) + ( + { before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } + (rule__ExportModel__InterfacesAssignment_3_2)* + { after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } + ) +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ExportModel__Group_3__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ExportModel__Group_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); } + '}' + { after(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Import__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group__0__Impl + rule__Import__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getImportKeyword_0()); } + 'import' + { after(grammarAccess.getImportAccess().getImportKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group__1__Impl + rule__Import__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getPackageAssignment_1()); } + (rule__Import__PackageAssignment_1) + { after(grammarAccess.getImportAccess().getPackageAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getGroup_2()); } + (rule__Import__Group_2__0)? + { after(grammarAccess.getImportAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Import__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group_2__0__Impl + rule__Import__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getAsKeyword_2_0()); } + 'as' + { after(grammarAccess.getImportAccess().getAsKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getNameAssignment_2_1()); } + (rule__Import__NameAssignment_2_1) + { after(grammarAccess.getImportAccess().getNameAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Extension__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Extension__Group__0__Impl + rule__Extension__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Extension__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } + 'extension' + { after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Extension__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Extension__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Extension__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } + (rule__Extension__ExtensionAssignment_1) + { after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Interface__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group__0__Impl + rule__Interface__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); } + (rule__Interface__TypeAssignment_0) + { after(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group__1__Impl + rule__Interface__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getGroup_1()); } + (rule__Interface__Group_1__0)? + { after(grammarAccess.getInterfaceAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group__2__Impl + rule__Interface__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getGroup_2()); } + (rule__Interface__Group_2__0)* + { after(grammarAccess.getInterfaceAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); } + ';' + { after(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Interface__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_1__0__Impl + rule__Interface__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); } + '[' + { after(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_1__1__Impl + rule__Interface__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); } + (rule__Interface__GuardAssignment_1_1) + { after(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); } + ']' + { after(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Interface__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_2__0__Impl + rule__Interface__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); } + '=' + { after(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_2__1__Impl + rule__Interface__Group_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); } + (rule__Interface__ItemsAssignment_2_1) + { after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_2__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getGroup_2_2()); } + (rule__Interface__Group_2_2__0)* + { after(grammarAccess.getInterfaceAccess().getGroup_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Interface__Group_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_2_2__0__Impl + rule__Interface__Group_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); } + ',' + { after(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Interface__Group_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Interface__Group_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); } + (rule__Interface__ItemsAssignment_2_2_1) + { after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InterfaceField__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceField__Group__0__Impl + rule__InterfaceField__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceField__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); } + (rule__InterfaceField__UnorderedAssignment_0)? + { after(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceField__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceField__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceField__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); } + (rule__InterfaceField__FieldAssignment_1) + { after(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InterfaceNavigation__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceNavigation__Group__0__Impl + rule__InterfaceNavigation__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceNavigation__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); } + '@' + { after(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceNavigation__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceNavigation__Group__1__Impl + rule__InterfaceNavigation__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceNavigation__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); } + (rule__InterfaceNavigation__UnorderedAssignment_1)? + { after(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceNavigation__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceNavigation__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceNavigation__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); } + (rule__InterfaceNavigation__RefAssignment_2) + { after(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InterfaceExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceExpression__Group__0__Impl + rule__InterfaceExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); } + 'eval' + { after(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceExpression__Group__1__Impl + rule__InterfaceExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); } + (rule__InterfaceExpression__RefAssignment_1)? + { after(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceExpression__Group__2__Impl + rule__InterfaceExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); } + (rule__InterfaceExpression__UnorderedAssignment_2)? + { after(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceExpression__Group__3__Impl + rule__InterfaceExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); } + '(' + { after(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceExpression__Group__4__Impl + rule__InterfaceExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); } + (rule__InterfaceExpression__ExprAssignment_4) + { after(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InterfaceExpression__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InterfaceExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); } + ')' + { after(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__0__Impl + rule__Export__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getExportKeyword_0()); } + 'export' + { after(grammarAccess.getExportAccess().getExportKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__1__Impl + rule__Export__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_1()); } + (rule__Export__Group_1__0)? + { after(grammarAccess.getExportAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__2__Impl + rule__Export__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getTypeAssignment_2()); } + (rule__Export__TypeAssignment_2) + { after(grammarAccess.getExportAccess().getTypeAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__3__Impl + rule__Export__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_3()); } + (rule__Export__Group_3__0)? + { after(grammarAccess.getExportAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__4__Impl + rule__Export__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_4()); } + (rule__Export__Group_4__0)? + { after(grammarAccess.getExportAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__5__Impl + rule__Export__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); } + '{' + { after(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__6__Impl + rule__Export__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_6()); } + (rule__Export__Group_6__0)? + { after(grammarAccess.getExportAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__7__Impl + rule__Export__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_7()); } + (rule__Export__Group_7__0)? + { after(grammarAccess.getExportAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__8__Impl + rule__Export__Group__9 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getAlternatives_8()); } + (rule__Export__Alternatives_8)* + { after(grammarAccess.getExportAccess().getAlternatives_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__9 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group__9__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group__9__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); } + '}' + { after(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_1__0__Impl + rule__Export__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getLookupAssignment_1_0()); } + (rule__Export__LookupAssignment_1_0) + { after(grammarAccess.getExportAccess().getLookupAssignment_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_1_1()); } + (rule__Export__Group_1_1__0)? + { after(grammarAccess.getExportAccess().getGroup_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_1_1__0__Impl + rule__Export__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); } + '[' + { after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_1_1__1__Impl + rule__Export__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); } + (rule__Export__LookupPredicateAssignment_1_1_1) + { after(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_1_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); } + ']' + { after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_3__0__Impl + rule__Export__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getAsKeyword_3_0()); } + 'as' + { after(grammarAccess.getExportAccess().getAsKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_3__1__Impl + rule__Export__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); } + (rule__Export__QualifiedNameAssignment_3_1)? + { after(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_3__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } + (rule__Export__NamingAssignment_3_2) + { after(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_4__0__Impl + rule__Export__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); } + '[' + { after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_4__1__Impl + rule__Export__Group_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGuardAssignment_4_1()); } + (rule__Export__GuardAssignment_4_1) + { after(grammarAccess.getExportAccess().getGuardAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_4__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); } + ']' + { after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__0__Impl + rule__Export__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } + 'uri-fragment' + { after(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__1__Impl + rule__Export__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); } + '=' + { after(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__2__Impl + rule__Export__Group_6__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); } + (rule__Export__FragmentUniqueAssignment_6_2)? + { after(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__3__Impl + rule__Export__Group_6__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } + 'attribute' + { after(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__4__Impl + rule__Export__Group_6__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); } + '(' + { after(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__5__Impl + rule__Export__Group_6__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); } + (rule__Export__FragmentAttributeAssignment_6_5) + { after(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__6__Impl + rule__Export__Group_6__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } + ')' + { after(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_6__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_6__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); } + ';' + { after(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_7__0__Impl + rule__Export__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getAlternatives_7_0()); } + (rule__Export__Alternatives_7_0) + { after(grammarAccess.getExportAccess().getAlternatives_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_7__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); } + ';' + { after(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_8_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_0__0__Impl + rule__Export__Group_8_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); } + 'field' + { after(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_0__1__Impl + rule__Export__Group_8_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); } + (rule__Export__AttributesAssignment_8_0_1) + { after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_0__2__Impl + rule__Export__Group_8_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_8_0_2()); } + (rule__Export__Group_8_0_2__0)* + { after(grammarAccess.getExportAccess().getGroup_8_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); } + ';' + { after(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_8_0_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_0_2__0__Impl + rule__Export__Group_8_0_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); } + ',' + { after(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_0_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_0_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); } + (rule__Export__AttributesAssignment_8_0_2_1) + { after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_8_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_1__0__Impl + rule__Export__Group_8_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); } + 'data' + { after(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_1__1__Impl + rule__Export__Group_8_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); } + (rule__Export__UserDataAssignment_8_1_1) + { after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_1__2__Impl + rule__Export__Group_8_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getGroup_8_1_2()); } + (rule__Export__Group_8_1_2__0)* + { after(grammarAccess.getExportAccess().getGroup_8_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); } + ';' + { after(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Export__Group_8_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_1_2__0__Impl + rule__Export__Group_8_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); } + ',' + { after(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Export__Group_8_1_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Export__Group_8_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); } + (rule__Export__UserDataAssignment_8_1_2_1) + { after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__UserData__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__UserData__Group__0__Impl + rule__UserData__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__UserData__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUserDataAccess().getNameAssignment_0()); } + (rule__UserData__NameAssignment_0) + { after(grammarAccess.getUserDataAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__UserData__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__UserData__Group__1__Impl + rule__UserData__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__UserData__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); } + '=' + { after(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__UserData__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__UserData__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__UserData__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUserDataAccess().getExprAssignment_2()); } + (rule__UserData__ExprAssignment_2) + { after(grammarAccess.getUserDataAccess().getExprAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedID__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group__0__Impl + rule__QualifiedID__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); } + RULE_ID + { after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getGroup_1()); } + (rule__QualifiedID__Group_1__0)* + { after(grammarAccess.getQualifiedIDAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedID__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group_1__0__Impl + rule__QualifiedID__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } + '::' + { after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); } + RULE_ID + { after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__LetExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__0__Impl + rule__LetExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } + 'let' + { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__1__Impl + rule__LetExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + (rule__LetExpression__IdentifierAssignment_1) + { after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__2__Impl + rule__LetExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } + '=' + { after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__3__Impl + rule__LetExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } + (rule__LetExpression__VarExprAssignment_3) + { after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__4__Impl + rule__LetExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } + ':' + { after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } + (rule__LetExpression__TargetAssignment_5) + { after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CastedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__0__Impl + rule__CastedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__1__Impl + rule__CastedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } + (rule__CastedExpression__TypeAssignment_1) + { after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__2__Impl + rule__CastedExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } + (rule__CastedExpression__TargetAssignment_3) + { after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ChainExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group__0__Impl + rule__ChainExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } + ruleChainedExpression + { after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getGroup_1()); } + (rule__ChainExpression__Group_1__0)* + { after(grammarAccess.getChainExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ChainExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__0__Impl + rule__ChainExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } + () + { after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__1__Impl + rule__ChainExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } + '->' + { after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } + (rule__ChainExpression__NextAssignment_1_2) + { after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionTri__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group__0__Impl + rule__IfExpressionTri__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } + ruleOrExpression + { after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } + (rule__IfExpressionTri__Group_1__0)? + { after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionTri__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__0__Impl + rule__IfExpressionTri__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + () + { after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__1__Impl + rule__IfExpressionTri__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } + '?' + { after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__2__Impl + rule__IfExpressionTri__Group_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } + (rule__IfExpressionTri__ThenPartAssignment_1_2) + { after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__3__Impl + rule__IfExpressionTri__Group_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } + ':' + { after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } + (rule__IfExpressionTri__ElsePartAssignment_1_4) + { after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__0__Impl + rule__IfExpressionKw__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } + 'if' + { after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__1__Impl + rule__IfExpressionKw__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } + (rule__IfExpressionKw__ConditionAssignment_1) + { after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__2__Impl + rule__IfExpressionKw__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } + 'then' + { after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__3__Impl + rule__IfExpressionKw__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } + (rule__IfExpressionKw__ThenPartAssignment_3) + { after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } + (rule__IfExpressionKw__Group_4__0)? + { after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } + (rule__IfExpressionKw__Group_4_0__0) + { after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group_4_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4_0__0__Impl + rule__IfExpressionKw__Group_4_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } + 'else' + { after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } + (rule__IfExpressionKw__ElsePartAssignment_4_0_1) + { after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SwitchExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__0__Impl + rule__SwitchExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } + 'switch' + { after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__1__Impl + rule__SwitchExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } + (rule__SwitchExpression__Group_1__0)? + { after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__2__Impl + rule__SwitchExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } + '{' + { after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__3__Impl + rule__SwitchExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } + (rule__SwitchExpression__CaseAssignment_3)* + { after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__4__Impl + rule__SwitchExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } + 'default' + { after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__5__Impl + rule__SwitchExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } + ':' + { after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__6__Impl + rule__SwitchExpression__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + (rule__SwitchExpression__DefaultExprAssignment_6) + { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } + '}' + { after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SwitchExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__0__Impl + rule__SwitchExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } + '(' + { after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__1__Impl + rule__SwitchExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + (rule__SwitchExpression__SwitchExprAssignment_1_1) + { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } + ')' + { after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Case__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__0__Impl + rule__Case__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } + 'case' + { after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__1__Impl + rule__Case__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } + (rule__Case__ConditionAssignment_1) + { after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__2__Impl + rule__Case__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getColonKeyword_2()); } + ':' + { after(grammarAccess.getCaseAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + (rule__Case__ThenParAssignment_3) + { after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OrExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group__0__Impl + rule__OrExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + ruleAndExpression + { after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getGroup_1()); } + (rule__OrExpression__Group_1__0)* + { after(grammarAccess.getOrExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OrExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__0__Impl + rule__OrExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__1__Impl + rule__OrExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + (rule__OrExpression__OperatorAssignment_1_1) + { after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + (rule__OrExpression__RightAssignment_1_2) + { after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__AndExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group__0__Impl + rule__AndExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + ruleImpliesExpression + { after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getGroup_1()); } + (rule__AndExpression__Group_1__0)* + { after(grammarAccess.getAndExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__AndExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__0__Impl + rule__AndExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__1__Impl + rule__AndExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + (rule__AndExpression__OperatorAssignment_1_1) + { after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + (rule__AndExpression__RightAssignment_1_2) + { after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ImpliesExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group__0__Impl + rule__ImpliesExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + ruleRelationalExpression + { after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + (rule__ImpliesExpression__Group_1__0)* + { after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ImpliesExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__0__Impl + rule__ImpliesExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__1__Impl + rule__ImpliesExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + (rule__ImpliesExpression__OperatorAssignment_1_1) + { after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + (rule__ImpliesExpression__RightAssignment_1_2) + { after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelationalExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group__0__Impl + rule__RelationalExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + ruleAdditiveExpression + { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + (rule__RelationalExpression__Group_1__0)* + { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelationalExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__0__Impl + rule__RelationalExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__1__Impl + rule__RelationalExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } + (rule__RelationalExpression__OperatorAssignment_1_1) + { after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + (rule__RelationalExpression__RightAssignment_1_2) + { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +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 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group__1__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().getOperationCallParamsAction_1_0()); } + () + { after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group_1__1__Impl + rule__AdditiveExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + (rule__AdditiveExpression__NameAssignment_1_1) + { after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + (rule__AdditiveExpression__ParamsAssignment_1_2) + { after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MultiplicativeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group__0__Impl + rule__MultiplicativeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + ruleUnaryOrInfixExpression + { after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + (rule__MultiplicativeExpression__Group_1__0)* + { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MultiplicativeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__0__Impl + rule__MultiplicativeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } + () + { after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__1__Impl + rule__MultiplicativeExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } + (rule__MultiplicativeExpression__NameAssignment_1_1) + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + (rule__MultiplicativeExpression__ParamsAssignment_1_2) + { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__UnaryExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__UnaryExpression__Group__0__Impl + rule__UnaryExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + (rule__UnaryExpression__NameAssignment_0) + { after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__UnaryExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + (rule__UnaryExpression__ParamsAssignment_1) + { after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group__0__Impl + rule__InfixExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } + rulePrimaryExpression + { after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + (rule__InfixExpression__Alternatives_1)* + { after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__0__Impl + rule__InfixExpression__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__1__Impl + rule__InfixExpression__Group_1_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__2__Impl + rule__InfixExpression__Group_1_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } + (rule__InfixExpression__NameAssignment_1_0_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__3__Impl + rule__InfixExpression__Group_1_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__4__Impl + rule__InfixExpression__Group_1_0__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } + (rule__InfixExpression__Group_1_0_4__0)? + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4__0__Impl + rule__InfixExpression__Group_1_0_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } + (rule__InfixExpression__ParamsAssignment_1_0_4_0) + { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } + (rule__InfixExpression__Group_1_0_4_1__0)* + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0_4_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4_1__0__Impl + rule__InfixExpression__Group_1_0_4_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } + ',' + { after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } + (rule__InfixExpression__ParamsAssignment_1_0_4_1_1) + { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__0__Impl + rule__InfixExpression__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__1__Impl + rule__InfixExpression__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } + (rule__InfixExpression__TypeAssignment_1_1_2) + { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__0__Impl + rule__InfixExpression__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__1__Impl + rule__InfixExpression__Group_1_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__2__Impl + rule__InfixExpression__Group_1_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } + (rule__InfixExpression__NameAssignment_1_2_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__3__Impl + rule__InfixExpression__Group_1_2__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__4__Impl + rule__InfixExpression__Group_1_2__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } + (rule__InfixExpression__TypeAssignment_1_2_4) + { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__0__Impl + rule__InfixExpression__Group_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__1__Impl + rule__InfixExpression__Group_1_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__2__Impl + rule__InfixExpression__Group_1_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } + (rule__InfixExpression__NameAssignment_1_3_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__3__Impl + rule__InfixExpression__Group_1_3__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__4__Impl + rule__InfixExpression__Group_1_3__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } + (rule__InfixExpression__Group_1_3_4__0)? + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__5__Impl + rule__InfixExpression__Group_1_3__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } + (rule__InfixExpression__ExpAssignment_1_3_5) + { after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_3_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3_4__0__Impl + rule__InfixExpression__Group_1_3_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } + (rule__InfixExpression__VarAssignment_1_3_4_0) + { after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } + '|' + { after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParanthesizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__0__Impl + rule__ParanthesizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__1__Impl + rule__ParanthesizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } + ruleExpression + { after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalVarExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalVarExpression__Group__0__Impl + rule__GlobalVarExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } + 'GLOBALVAR' + { after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalVarExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } + (rule__GlobalVarExpression__NameAssignment_1) + { after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__0__Impl + rule__OperationCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } + (rule__OperationCall__NameAssignment_0) + { after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__1__Impl + rule__OperationCall__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__2__Impl + rule__OperationCall__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getGroup_2()); } + (rule__OperationCall__Group_2__0)? + { after(grammarAccess.getOperationCallAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2__0__Impl + rule__OperationCall__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } + (rule__OperationCall__ParamsAssignment_2_0) + { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getGroup_2_1()); } + (rule__OperationCall__Group_2_1__0)* + { after(grammarAccess.getOperationCallAccess().getGroup_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2_1__0__Impl + rule__OperationCall__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } + ',' + { after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } + (rule__OperationCall__ParamsAssignment_2_1_1) + { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__0__Impl + rule__ListLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } + () + { after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__1__Impl + rule__ListLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } + '{' + { after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__2__Impl + rule__ListLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getGroup_2()); } + (rule__ListLiteral__Group_2__0)? + { after(grammarAccess.getListLiteralAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } + '}' + { after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2__0__Impl + rule__ListLiteral__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } + (rule__ListLiteral__ElementsAssignment_2_0) + { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getGroup_2_1()); } + (rule__ListLiteral__Group_2_1__0)* + { after(grammarAccess.getListLiteralAccess().getGroup_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2_1__0__Impl + rule__ListLiteral__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } + ',' + { after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } + (rule__ListLiteral__ElementsAssignment_2_1_1) + { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ConstructorCallExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ConstructorCallExpression__Group__0__Impl + rule__ConstructorCallExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } + 'new' + { after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ConstructorCallExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } + (rule__ConstructorCallExpression__TypeAssignment_1) + { after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TypeSelectExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__0__Impl + rule__TypeSelectExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } + (rule__TypeSelectExpression__NameAssignment_0) + { after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__1__Impl + rule__TypeSelectExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__2__Impl + rule__TypeSelectExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } + (rule__TypeSelectExpression__TypeAssignment_2) + { after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__0__Impl + rule__CollectionExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } + (rule__CollectionExpression__NameAssignment_0) + { after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__1__Impl + rule__CollectionExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__2__Impl + rule__CollectionExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } + (rule__CollectionExpression__Group_2__0)? + { after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__3__Impl + rule__CollectionExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } + (rule__CollectionExpression__ExpAssignment_3) + { after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionExpression__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group_2__0__Impl + rule__CollectionExpression__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } + (rule__CollectionExpression__VarAssignment_2_0) + { after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } + '|' + { after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__0__Impl + rule__CollectionType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } + (rule__CollectionType__ClAssignment_0) + { after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__1__Impl + rule__CollectionType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } + '[' + { after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__2__Impl + rule__CollectionType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } + (rule__CollectionType__Id1Assignment_2) + { after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } + ']' + { after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SimpleType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group__0__Impl + rule__SimpleType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } + (rule__SimpleType__IdAssignment_0) + { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getGroup_1()); } + (rule__SimpleType__Group_1__0)* + { after(grammarAccess.getSimpleTypeAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SimpleType__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group_1__0__Impl + rule__SimpleType__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } + '::' + { after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } + (rule__SimpleType__IdAssignment_1_1) + { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__0__Impl + rule__XAssignment__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); } + () + { after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__1__Impl + rule__XAssignment__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); } + (rule__XAssignment__FeatureAssignment_0_1) + { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__2__Impl + rule__XAssignment__Group_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); } + ruleOpSingleAssign + { after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); } + (rule__XAssignment__ValueAssignment_0_3) + { after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1__0__Impl + rule__XAssignment__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); } + ruleXOrExpression + { after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); } + (rule__XAssignment__Group_1_1__0)? + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1__0__Impl + rule__XAssignment__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); } + (rule__XAssignment__Group_1_1_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); } + (rule__XAssignment__RightOperandAssignment_1_1_1) + { after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); } + (rule__XAssignment__Group_1_1_0_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0_0__0__Impl + rule__XAssignment__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); } + (rule__XAssignment__FeatureAssignment_1_1_0_0_1) + { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpMultiAssign__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__0__Impl + rule__OpMultiAssign__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); } + '<' + { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__1__Impl + rule__OpMultiAssign__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); } + '<' + { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); } + '=' + { after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpMultiAssign__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__0__Impl + rule__OpMultiAssign__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); } + '>' + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__1__Impl + rule__OpMultiAssign__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); } + ('>')? + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); } + '>=' + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group__0__Impl + rule__XOrExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); } + ruleXAndExpression + { after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1()); } + (rule__XOrExpression__Group_1__0)* + { after(grammarAccess.getXOrExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1__0__Impl + rule__XOrExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); } + (rule__XOrExpression__Group_1_0__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XOrExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); } + (rule__XOrExpression__Group_1_0_0__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0_0__0__Impl + rule__XOrExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XOrExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group__0__Impl + rule__XAndExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); } + ruleXEqualityExpression + { after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1()); } + (rule__XAndExpression__Group_1__0)* + { after(grammarAccess.getXAndExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1__0__Impl + rule__XAndExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); } + (rule__XAndExpression__Group_1_0__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XAndExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); } + (rule__XAndExpression__Group_1_0_0__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0_0__0__Impl + rule__XAndExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XAndExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group__0__Impl + rule__XEqualityExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); } + ruleXRelationalExpression + { after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); } + (rule__XEqualityExpression__Group_1__0)* + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1__0__Impl + rule__XEqualityExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); } + (rule__XEqualityExpression__Group_1_0__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XEqualityExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); } + (rule__XEqualityExpression__Group_1_0_0__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0_0__0__Impl + rule__XEqualityExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XEqualityExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group__0__Impl + rule__XRelationalExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); } + ruleXOtherOperatorExpression + { after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); } + (rule__XRelationalExpression__Alternatives_1)* + { after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0__0__Impl + rule__XRelationalExpression__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); } + (rule__XRelationalExpression__Group_1_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); } + (rule__XRelationalExpression__TypeAssignment_1_0_1) + { after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); } + (rule__XRelationalExpression__Group_1_0_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0_0__0__Impl + rule__XRelationalExpression__Group_1_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); } + () + { after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); } + 'instanceof' + { after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1__0__Impl + rule__XRelationalExpression__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); } + (rule__XRelationalExpression__Group_1_1_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); } + (rule__XRelationalExpression__RightOperandAssignment_1_1_1) + { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); } + (rule__XRelationalExpression__Group_1_1_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0_0__0__Impl + rule__XRelationalExpression__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); } + (rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1) + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpCompare__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpCompare__Group_1__0__Impl + rule__OpCompare__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); } + '<' + { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpCompare__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); } + '=' + { after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group__0__Impl + rule__XOtherOperatorExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); } + ruleXAdditiveExpression + { after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); } + (rule__XOtherOperatorExpression__Group_1__0)* + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1__0__Impl + rule__XOtherOperatorExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); } + (rule__XOtherOperatorExpression__Group_1_0__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XOtherOperatorExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); } + (rule__XOtherOperatorExpression__Group_1_0_0__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0_0__0__Impl + rule__XOtherOperatorExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_2__0__Impl + rule__OpOther__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); } + '..' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5__0__Impl + rule__OpOther__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); } + (rule__OpOther__Alternatives_5_1) + { after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); } + (rule__OpOther__Group_5_1_0_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0_0__0__Impl + rule__OpOther__Group_5_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6__0__Impl + rule__OpOther__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); } + (rule__OpOther__Alternatives_6_1) + { after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); } + (rule__OpOther__Group_6_1_0_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0_0__0__Impl + rule__OpOther__Group_6_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group__0__Impl + rule__XAdditiveExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); } + ruleXMultiplicativeExpression + { after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); } + (rule__XAdditiveExpression__Group_1__0)* + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1__0__Impl + rule__XAdditiveExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); } + (rule__XAdditiveExpression__Group_1_0__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XAdditiveExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); } + (rule__XAdditiveExpression__Group_1_0_0__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0_0__0__Impl + rule__XAdditiveExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XAdditiveExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group__0__Impl + rule__XMultiplicativeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); } + (rule__XMultiplicativeExpression__Group_1__0)* + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1__0__Impl + rule__XMultiplicativeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); } + (rule__XMultiplicativeExpression__Group_1_0__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XMultiplicativeExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); } + (rule__XMultiplicativeExpression__Group_1_0_0__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0_0__0__Impl + rule__XMultiplicativeExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XUnaryOperation__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__0__Impl + rule__XUnaryOperation__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); } + () + { after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__1__Impl + rule__XUnaryOperation__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); } + (rule__XUnaryOperation__FeatureAssignment_0_1) + { after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); } + (rule__XUnaryOperation__OperandAssignment_0_2) + { after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group__0__Impl + rule__XCastedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); } + ruleXPostfixOperation + { after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); } + (rule__XCastedExpression__Group_1__0)* + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1__0__Impl + rule__XCastedExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); } + (rule__XCastedExpression__Group_1_0__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); } + (rule__XCastedExpression__TypeAssignment_1_1) + { after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); } + (rule__XCastedExpression__Group_1_0_0__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0_0__0__Impl + rule__XCastedExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); } + () + { after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); } + 'as' + { after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group__0__Impl + rule__XPostfixOperation__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); } + ruleXMemberFeatureCall + { after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); } + (rule__XPostfixOperation__Group_1__0)? + { after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); } + (rule__XPostfixOperation__Group_1_0__0) + { after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1_0__0__Impl + rule__XPostfixOperation__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); } + () + { after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); } + (rule__XPostfixOperation__FeatureAssignment_1_0_1) + { after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group__0__Impl + rule__XMemberFeatureCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); } + ruleXPrimaryExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); } + (rule__XMemberFeatureCall__Alternatives_1)* + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0__0__Impl + rule__XMemberFeatureCall__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); } + (rule__XMemberFeatureCall__Group_1_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); } + (rule__XMemberFeatureCall__ValueAssignment_1_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); } + (rule__XMemberFeatureCall__Group_1_0_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); } + () + { after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); } + (rule__XMemberFeatureCall__Alternatives_1_0_0_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); } + (rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); } + ruleOpSingleAssign + { after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); } + (rule__XMemberFeatureCall__Group_1_1_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__1__Impl + rule__XMemberFeatureCall__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_1__0)? + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__2__Impl + rule__XMemberFeatureCall__Group_1_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); } + (rule__XMemberFeatureCall__FeatureAssignment_1_1_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__3__Impl + rule__XMemberFeatureCall__Group_1_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); } + (rule__XMemberFeatureCall__Group_1_1_3__0)? + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4)? + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); } + (rule__XMemberFeatureCall__Group_1_1_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl + rule__XMemberFeatureCall__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); } + (rule__XMemberFeatureCall__Alternatives_1_1_0_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); } + '<' + { after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__1__Impl + rule__XMemberFeatureCall__Group_1_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); } + (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__2__Impl + rule__XMemberFeatureCall__Group_1_1_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); } + (rule__XMemberFeatureCall__Group_1_1_1_2__0)* + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); } + '>' + { after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl + rule__XMemberFeatureCall__Group_1_1_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); } + ',' + { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); } + (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__0__Impl + rule__XMemberFeatureCall__Group_1_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); } + (rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__1__Impl + rule__XMemberFeatureCall__Group_1_1_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); } + (rule__XMemberFeatureCall__Alternatives_1_1_3_1)? + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); } + ')' + { after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_3_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0)* + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); } + ',' + { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__0__Impl + rule__XSetLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); } + () + { after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__1__Impl + rule__XSetLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); } + '#' + { after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__2__Impl + rule__XSetLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); } + '{' + { after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__3__Impl + rule__XSetLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getGroup_3()); } + (rule__XSetLiteral__Group_3__0)? + { after(grammarAccess.getXSetLiteralAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); } + '}' + { after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3__0__Impl + rule__XSetLiteral__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); } + (rule__XSetLiteral__ElementsAssignment_3_0) + { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); } + (rule__XSetLiteral__Group_3_1__0)* + { after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3_1__0__Impl + rule__XSetLiteral__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); } + (rule__XSetLiteral__ElementsAssignment_3_1_1) + { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__0__Impl + rule__XListLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); } + () + { after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__1__Impl + rule__XListLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); } + '#' + { after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__2__Impl + rule__XListLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); } + '[' + { after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__3__Impl + rule__XListLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getGroup_3()); } + (rule__XListLiteral__Group_3__0)? + { after(grammarAccess.getXListLiteralAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); } + ']' + { after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3__0__Impl + rule__XListLiteral__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); } + (rule__XListLiteral__ElementsAssignment_3_0) + { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); } + (rule__XListLiteral__Group_3_1__0)* + { after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3_1__0__Impl + rule__XListLiteral__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); } + (rule__XListLiteral__ElementsAssignment_3_1_1) + { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__0__Impl + rule__XClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_0()); } + (rule__XClosure__Group_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__1__Impl + rule__XClosure__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1()); } + (rule__XClosure__Group_1__0)? + { after(grammarAccess.getXClosureAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__2__Impl + rule__XClosure__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); } + (rule__XClosure__ExpressionAssignment_2) + { after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); } + ']' + { after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_0_0()); } + (rule__XClosure__Group_0_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0_0__0__Impl + rule__XClosure__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); } + () + { after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); } + '[' + { after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0()); } + (rule__XClosure__Group_1_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0__0__Impl + rule__XClosure__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); } + (rule__XClosure__Group_1_0_0__0)? + { after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); } + (rule__XClosure__ExplicitSyntaxAssignment_1_0_1) + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0__0__Impl + rule__XClosure__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); } + (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0) + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); } + (rule__XClosure__Group_1_0_0_1__0)* + { after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0_1__0__Impl + rule__XClosure__Group_1_0_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); } + ',' + { after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); } + (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1) + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XExpressionInClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group__0__Impl + rule__XExpressionInClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); } + () + { after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); } + (rule__XExpressionInClosure__Group_1__0)* + { after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XExpressionInClosure__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group_1__0__Impl + rule__XExpressionInClosure__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); } + (rule__XExpressionInClosure__ExpressionsAssignment_1_0) + { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); } + (';')? + { after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group__0__Impl + rule__XShortClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0()); } + (rule__XShortClosure__Group_0__0) + { after(grammarAccess.getXShortClosureAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); } + (rule__XShortClosure__ExpressionAssignment_1) + { after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); } + (rule__XShortClosure__Group_0_0__0) + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__0__Impl + rule__XShortClosure__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); } + () + { after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__1__Impl + rule__XShortClosure__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); } + (rule__XShortClosure__Group_0_0_1__0)? + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); } + (rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2) + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1__0__Impl + rule__XShortClosure__Group_0_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); } + (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0) + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); } + (rule__XShortClosure__Group_0_0_1_1__0)* + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1_1__0__Impl + rule__XShortClosure__Group_0_0_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); } + ',' + { after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); } + (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1) + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XParenthesizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__0__Impl + rule__XParenthesizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__1__Impl + rule__XParenthesizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); } + ruleXExpression + { after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XIfExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__0__Impl + rule__XIfExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); } + () + { after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__1__Impl + rule__XIfExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); } + 'if' + { after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__2__Impl + rule__XIfExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__3__Impl + rule__XIfExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); } + (rule__XIfExpression__IfAssignment_3) + { after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__4__Impl + rule__XIfExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__5__Impl + rule__XIfExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); } + (rule__XIfExpression__ThenAssignment_5) + { after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getGroup_6()); } + (rule__XIfExpression__Group_6__0)? + { after(grammarAccess.getXIfExpressionAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XIfExpression__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group_6__0__Impl + rule__XIfExpression__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); } + ('else') + { after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); } + (rule__XIfExpression__ElseAssignment_6_1) + { after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__0__Impl + rule__XSwitchExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); } + () + { after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__1__Impl + rule__XSwitchExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); } + 'switch' + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__2__Impl + rule__XSwitchExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); } + (rule__XSwitchExpression__Alternatives_2) + { after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__3__Impl + rule__XSwitchExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); } + '{' + { after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__4__Impl + rule__XSwitchExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); } + (rule__XSwitchExpression__CasesAssignment_4)* + { after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__5__Impl + rule__XSwitchExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); } + (rule__XSwitchExpression__Group_5__0)? + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); } + '}' + { after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__0__Impl + rule__XSwitchExpression__Group_2_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); } + (rule__XSwitchExpression__Group_2_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__1__Impl + rule__XSwitchExpression__Group_2_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); } + (rule__XSwitchExpression__SwitchAssignment_2_0_1) + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); } + ')' + { after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); } + (rule__XSwitchExpression__Group_2_0_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__0__Impl + rule__XSwitchExpression__Group_2_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); } + '(' + { after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__1__Impl + rule__XSwitchExpression__Group_2_0_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); } + (rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1) + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1__0__Impl + rule__XSwitchExpression__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); } + (rule__XSwitchExpression__Group_2_1_0__0)? + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); } + (rule__XSwitchExpression__SwitchAssignment_2_1_1) + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); } + (rule__XSwitchExpression__Group_2_1_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0_0__0__Impl + rule__XSwitchExpression__Group_2_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); } + (rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0) + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__0__Impl + rule__XSwitchExpression__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); } + 'default' + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__1__Impl + rule__XSwitchExpression__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); } + (rule__XSwitchExpression__DefaultAssignment_5_2) + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__0__Impl + rule__XCasePart__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); } + () + { after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__1__Impl + rule__XCasePart__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); } + (rule__XCasePart__TypeGuardAssignment_1)? + { after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__2__Impl + rule__XCasePart__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getGroup_2()); } + (rule__XCasePart__Group_2__0)? + { after(grammarAccess.getXCasePartAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getAlternatives_3()); } + (rule__XCasePart__Alternatives_3) + { after(grammarAccess.getXCasePartAccess().getAlternatives_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_2__0__Impl + rule__XCasePart__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); } + 'case' + { after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); } + (rule__XCasePart__CaseAssignment_2_1) + { after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group_3_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_3_0__0__Impl + rule__XCasePart__Group_3_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_3_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); } + ':' + { after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_3_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_3_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_3_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); } + (rule__XCasePart__ThenAssignment_3_0_1) + { after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XForLoopExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__0__Impl + rule__XForLoopExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); } + (rule__XForLoopExpression__Group_0__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__1__Impl + rule__XForLoopExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); } + (rule__XForLoopExpression__ForExpressionAssignment_1) + { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__2__Impl + rule__XForLoopExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); } + (rule__XForLoopExpression__EachExpressionAssignment_3) + { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XForLoopExpression__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); } + (rule__XForLoopExpression__Group_0_0__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XForLoopExpression__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__0__Impl + rule__XForLoopExpression__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); } + () + { after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__1__Impl + rule__XForLoopExpression__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); } + 'for' + { after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__2__Impl + rule__XForLoopExpression__Group_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } + '(' + { after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__3__Impl + rule__XForLoopExpression__Group_0_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); } + (rule__XForLoopExpression__DeclaredParamAssignment_0_0_3) + { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); } + ':' + { after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__0__Impl + rule__XBasicForLoopExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); } + () + { after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__1__Impl + rule__XBasicForLoopExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); } + 'for' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__2__Impl + rule__XBasicForLoopExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__3__Impl + rule__XBasicForLoopExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); } + (rule__XBasicForLoopExpression__Group_3__0)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__4__Impl + rule__XBasicForLoopExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); } + ';' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__5__Impl + rule__XBasicForLoopExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); } + (rule__XBasicForLoopExpression__ExpressionAssignment_5)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__6__Impl + rule__XBasicForLoopExpression__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); } + ';' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__7__Impl + rule__XBasicForLoopExpression__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); } + (rule__XBasicForLoopExpression__Group_7__0)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__8__Impl + rule__XBasicForLoopExpression__Group__9 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); } + ')' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__9 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__9__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__9__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); } + (rule__XBasicForLoopExpression__EachExpressionAssignment_9) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3__0__Impl + rule__XBasicForLoopExpression__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); } + (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); } + (rule__XBasicForLoopExpression__Group_3_1__0)* + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3_1__0__Impl + rule__XBasicForLoopExpression__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); } + (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7__0__Impl + rule__XBasicForLoopExpression__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); } + (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); } + (rule__XBasicForLoopExpression__Group_7_1__0)* + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_7_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7_1__0__Impl + rule__XBasicForLoopExpression__Group_7_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); } + ',' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); } + (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XWhileExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__0__Impl + rule__XWhileExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); } + () + { after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__1__Impl + rule__XWhileExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); } + 'while' + { after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__2__Impl + rule__XWhileExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__3__Impl + rule__XWhileExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); } + (rule__XWhileExpression__PredicateAssignment_3) + { after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__4__Impl + rule__XWhileExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); } + (rule__XWhileExpression__BodyAssignment_5) + { after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XDoWhileExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__0__Impl + rule__XDoWhileExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); } + () + { after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__1__Impl + rule__XDoWhileExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); } + 'do' + { after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__2__Impl + rule__XDoWhileExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); } + (rule__XDoWhileExpression__BodyAssignment_2) + { after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__3__Impl + rule__XDoWhileExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); } + 'while' + { after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__4 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } - ruleCollectionType - { after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } - ruleSimpleType - { after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } - ) + rule__XDoWhileExpression__Group__4__Impl + rule__XDoWhileExpression__Group__5 ; finally { restoreStackSize(stackSize); } -rule__CollectionType__ClAlternatives_0_0 +rule__XDoWhileExpression__Group__4__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } - 'Collection' - { after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } - ) - | - ( - { before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } - 'List' - { after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } - ) - | - ( - { before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } - 'Set' - { after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } - ) +( + { before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); } + '(' + { after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); } +) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__0 +rule__XDoWhileExpression__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group__0__Impl - rule__ExportModel__Group__1 + rule__XDoWhileExpression__Group__5__Impl + rule__XDoWhileExpression__Group__6 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__0__Impl +rule__XDoWhileExpression__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getGroup_0()); } - (rule__ExportModel__Group_0__0)? - { after(grammarAccess.getExportModelAccess().getGroup_0()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); } + (rule__XDoWhileExpression__PredicateAssignment_5) + { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__1 +rule__XDoWhileExpression__Group__6 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group__1__Impl - rule__ExportModel__Group__2 + rule__XDoWhileExpression__Group__6__Impl ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__1__Impl +rule__XDoWhileExpression__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - ( - { before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } - (rule__ExportModel__ImportsAssignment_1) - { after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } - ) - ( - { before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } - (rule__ExportModel__ImportsAssignment_1)* - { after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } - ) + { before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); } + ')' + { after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__2 + +rule__XBlockExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group__2__Impl - rule__ExportModel__Group__3 + rule__XBlockExpression__Group__0__Impl + rule__XBlockExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__2__Impl +rule__XBlockExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); } - (rule__ExportModel__ExtensionsAssignment_2)* - { after(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); } + { before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); } + () + { after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__3 +rule__XBlockExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group__3__Impl - rule__ExportModel__Group__4 + rule__XBlockExpression__Group__1__Impl + rule__XBlockExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__3__Impl +rule__XBlockExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getGroup_3()); } - (rule__ExportModel__Group_3__0)? - { after(grammarAccess.getExportModelAccess().getGroup_3()); } + { before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); } + '{' + { after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__4 +rule__XBlockExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group__4__Impl + rule__XBlockExpression__Group__2__Impl + rule__XBlockExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group__4__Impl +rule__XBlockExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - ( - { before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } - (rule__ExportModel__ExportsAssignment_4) - { after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } - ) - ( - { before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } - (rule__ExportModel__ExportsAssignment_4)* - { after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } - ) + { before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); } + (rule__XBlockExpression__Group_2__0)* + { after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ExportModel__Group_0__0 +rule__XBlockExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_0__0__Impl - rule__ExportModel__Group_0__1 + rule__XBlockExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__0__Impl +rule__XBlockExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); } - 'export' - { after(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); } + { before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); } + '}' + { after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__1 + +rule__XBlockExpression__Group_2__0 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_0__1__Impl - rule__ExportModel__Group_0__2 + rule__XBlockExpression__Group_2__0__Impl + rule__XBlockExpression__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__1__Impl +rule__XBlockExpression__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); } - (rule__ExportModel__ExtensionAssignment_0_1)? - { after(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); } + { before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); } + (rule__XBlockExpression__ExpressionsAssignment_2_0) + { after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__2 +rule__XBlockExpression__Group_2__1 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_0__2__Impl - rule__ExportModel__Group_0__3 + rule__XBlockExpression__Group_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__2__Impl +rule__XBlockExpression__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); } - (rule__ExportModel__NameAssignment_0_2) - { after(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); } + { before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); } + (';')? + { after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__3 + +rule__XVariableDeclaration__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_0__3__Impl - rule__ExportModel__Group_0__4 + rule__XVariableDeclaration__Group__0__Impl + rule__XVariableDeclaration__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__3__Impl +rule__XVariableDeclaration__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getForKeyword_0_3()); } - 'for' - { after(grammarAccess.getExportModelAccess().getForKeyword_0_3()); } + { before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); } + () + { after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__4 +rule__XVariableDeclaration__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_0__4__Impl + rule__XVariableDeclaration__Group__1__Impl + rule__XVariableDeclaration__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_0__4__Impl +rule__XVariableDeclaration__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); } - (rule__ExportModel__TargetGrammarAssignment_0_4) - { after(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); } + { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); } + (rule__XVariableDeclaration__Alternatives_1) + { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ExportModel__Group_3__0 +rule__XVariableDeclaration__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_3__0__Impl - rule__ExportModel__Group_3__1 + rule__XVariableDeclaration__Group__2__Impl + rule__XVariableDeclaration__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__0__Impl +rule__XVariableDeclaration__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } - 'interface' - { after(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); } + (rule__XVariableDeclaration__Alternatives_2) + { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__1 +rule__XVariableDeclaration__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_3__1__Impl - rule__ExportModel__Group_3__2 + rule__XVariableDeclaration__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__1__Impl +rule__XVariableDeclaration__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); } - '{' - { after(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); } + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); } + (rule__XVariableDeclaration__Group_3__0)? + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__2 + +rule__XVariableDeclaration__Group_2_0__0 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_3__2__Impl - rule__ExportModel__Group_3__3 + rule__XVariableDeclaration__Group_2_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__2__Impl +rule__XVariableDeclaration__Group_2_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - ( - { before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } - (rule__ExportModel__InterfacesAssignment_3_2) - { after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } - ) - ( - { before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } - (rule__ExportModel__InterfacesAssignment_3_2)* - { after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } - ) + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); } + (rule__XVariableDeclaration__Group_2_0_0__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__3 + +rule__XVariableDeclaration__Group_2_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__ExportModel__Group_3__3__Impl + rule__XVariableDeclaration__Group_2_0_0__0__Impl + rule__XVariableDeclaration__Group_2_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__ExportModel__Group_3__3__Impl +rule__XVariableDeclaration__Group_2_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); } - '}' - { after(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); } + { before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); } + (rule__XVariableDeclaration__TypeAssignment_2_0_0_0) + { after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Import__Group__0 +rule__XVariableDeclaration__Group_2_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__Import__Group__0__Impl - rule__Import__Group__1 + rule__XVariableDeclaration__Group_2_0_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Import__Group__0__Impl +rule__XVariableDeclaration__Group_2_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getImportKeyword_0()); } - 'import' - { after(grammarAccess.getImportAccess().getImportKeyword_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); } + (rule__XVariableDeclaration__NameAssignment_2_0_0_1) + { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__Group__1 + +rule__XVariableDeclaration__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__Import__Group__1__Impl - rule__Import__Group__2 + rule__XVariableDeclaration__Group_3__0__Impl + rule__XVariableDeclaration__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__Import__Group__1__Impl +rule__XVariableDeclaration__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getPackageAssignment_1()); } - (rule__Import__PackageAssignment_1) - { after(grammarAccess.getImportAccess().getPackageAssignment_1()); } + { before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); } + '=' + { after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__Group__2 +rule__XVariableDeclaration__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__Import__Group__2__Impl + rule__XVariableDeclaration__Group_3__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Import__Group__2__Impl +rule__XVariableDeclaration__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getGroup_2()); } - (rule__Import__Group_2__0)? - { after(grammarAccess.getImportAccess().getGroup_2()); } + { before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); } + (rule__XVariableDeclaration__RightAssignment_3_1) + { after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); } ) ; finally { @@ -2340,53 +18807,53 @@ finally { } -rule__Import__Group_2__0 +rule__JvmFormalParameter__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Import__Group_2__0__Impl - rule__Import__Group_2__1 + rule__JvmFormalParameter__Group__0__Impl + rule__JvmFormalParameter__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Import__Group_2__0__Impl +rule__JvmFormalParameter__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getAsKeyword_2_0()); } - 'as' - { after(grammarAccess.getImportAccess().getAsKeyword_2_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); } + (rule__JvmFormalParameter__ParameterTypeAssignment_0)? + { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__Group_2__1 +rule__JvmFormalParameter__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Import__Group_2__1__Impl + rule__JvmFormalParameter__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Import__Group_2__1__Impl +rule__JvmFormalParameter__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getNameAssignment_2_1()); } - (rule__Import__NameAssignment_2_1) - { after(grammarAccess.getImportAccess().getNameAssignment_2_1()); } + { before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); } + (rule__JvmFormalParameter__NameAssignment_1) + { after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); } ) ; finally { @@ -2394,53 +18861,53 @@ finally { } -rule__Extension__Group__0 +rule__FullJvmFormalParameter__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Extension__Group__0__Impl - rule__Extension__Group__1 + rule__FullJvmFormalParameter__Group__0__Impl + rule__FullJvmFormalParameter__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Extension__Group__0__Impl +rule__FullJvmFormalParameter__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } - 'extension' - { after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); } + (rule__FullJvmFormalParameter__ParameterTypeAssignment_0) + { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Extension__Group__1 +rule__FullJvmFormalParameter__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Extension__Group__1__Impl + rule__FullJvmFormalParameter__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Extension__Group__1__Impl +rule__FullJvmFormalParameter__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } - (rule__Extension__ExtensionAssignment_1) - { after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); } + (rule__FullJvmFormalParameter__NameAssignment_1) + { after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); } ) ; finally { @@ -2448,377 +18915,377 @@ finally { } -rule__Interface__Group__0 +rule__XFeatureCall__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group__0__Impl - rule__Interface__Group__1 + rule__XFeatureCall__Group__0__Impl + rule__XFeatureCall__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__0__Impl +rule__XFeatureCall__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); } - (rule__Interface__TypeAssignment_0) - { after(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); } + { before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); } + () + { after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__1 +rule__XFeatureCall__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group__1__Impl - rule__Interface__Group__2 + rule__XFeatureCall__Group__1__Impl + rule__XFeatureCall__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__1__Impl +rule__XFeatureCall__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getGroup_1()); } - (rule__Interface__Group_1__0)? - { after(grammarAccess.getInterfaceAccess().getGroup_1()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_1()); } + (rule__XFeatureCall__Group_1__0)? + { after(grammarAccess.getXFeatureCallAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__2 +rule__XFeatureCall__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group__2__Impl - rule__Interface__Group__3 + rule__XFeatureCall__Group__2__Impl + rule__XFeatureCall__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__2__Impl +rule__XFeatureCall__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getGroup_2()); } - (rule__Interface__Group_2__0)* - { after(grammarAccess.getInterfaceAccess().getGroup_2()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); } + (rule__XFeatureCall__FeatureAssignment_2) + { after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__3 +rule__XFeatureCall__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group__3__Impl + rule__XFeatureCall__Group__3__Impl + rule__XFeatureCall__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group__3__Impl +rule__XFeatureCall__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); } - ';' - { after(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_3()); } + (rule__XFeatureCall__Group_3__0)? + { after(grammarAccess.getXFeatureCallAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Interface__Group_1__0 +rule__XFeatureCall__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_1__0__Impl - rule__Interface__Group_1__1 + rule__XFeatureCall__Group__4__Impl ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_1__0__Impl +rule__XFeatureCall__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); } - '[' - { after(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_4)? + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_1__1 + +rule__XFeatureCall__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_1__1__Impl - rule__Interface__Group_1__2 + rule__XFeatureCall__Group_1__0__Impl + rule__XFeatureCall__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_1__1__Impl +rule__XFeatureCall__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); } - (rule__Interface__GuardAssignment_1_1) - { after(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); } + { before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); } + '<' + { after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_1__2 +rule__XFeatureCall__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_1__2__Impl + rule__XFeatureCall__Group_1__1__Impl + rule__XFeatureCall__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_1__2__Impl +rule__XFeatureCall__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); } - ']' - { after(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); } + (rule__XFeatureCall__TypeArgumentsAssignment_1_1) + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Interface__Group_2__0 +rule__XFeatureCall__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_2__0__Impl - rule__Interface__Group_2__1 + rule__XFeatureCall__Group_1__2__Impl + rule__XFeatureCall__Group_1__3 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2__0__Impl +rule__XFeatureCall__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); } - '=' - { after(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); } + (rule__XFeatureCall__Group_1_2__0)* + { after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2__1 +rule__XFeatureCall__Group_1__3 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_2__1__Impl - rule__Interface__Group_2__2 + rule__XFeatureCall__Group_1__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2__1__Impl +rule__XFeatureCall__Group_1__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); } - (rule__Interface__ItemsAssignment_2_1) - { after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); } + { before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); } + '>' + { after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2__2 + +rule__XFeatureCall__Group_1_2__0 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_2__2__Impl + rule__XFeatureCall__Group_1_2__0__Impl + rule__XFeatureCall__Group_1_2__1 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2__2__Impl +rule__XFeatureCall__Group_1_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getGroup_2_2()); } - (rule__Interface__Group_2_2__0)* - { after(grammarAccess.getInterfaceAccess().getGroup_2_2()); } + { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); } + ',' + { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Interface__Group_2_2__0 +rule__XFeatureCall__Group_1_2__1 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_2_2__0__Impl - rule__Interface__Group_2_2__1 + rule__XFeatureCall__Group_1_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2_2__0__Impl +rule__XFeatureCall__Group_1_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); } - ',' - { after(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); } + (rule__XFeatureCall__TypeArgumentsAssignment_1_2_1) + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2_2__1 + +rule__XFeatureCall__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__Interface__Group_2_2__1__Impl + rule__XFeatureCall__Group_3__0__Impl + rule__XFeatureCall__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__Interface__Group_2_2__1__Impl +rule__XFeatureCall__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); } - (rule__Interface__ItemsAssignment_2_2_1) - { after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); } + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); } + (rule__XFeatureCall__ExplicitOperationCallAssignment_3_0) + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__InterfaceField__Group__0 +rule__XFeatureCall__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__InterfaceField__Group__0__Impl - rule__InterfaceField__Group__1 + rule__XFeatureCall__Group_3__1__Impl + rule__XFeatureCall__Group_3__2 ; finally { restoreStackSize(stackSize); } -rule__InterfaceField__Group__0__Impl +rule__XFeatureCall__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); } - (rule__InterfaceField__UnorderedAssignment_0)? - { after(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); } + { before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); } + (rule__XFeatureCall__Alternatives_3_1)? + { after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceField__Group__1 +rule__XFeatureCall__Group_3__2 @init { int stackSize = keepStackSize(); } : - rule__InterfaceField__Group__1__Impl + rule__XFeatureCall__Group_3__2__Impl ; finally { restoreStackSize(stackSize); } -rule__InterfaceField__Group__1__Impl +rule__XFeatureCall__Group_3__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); } - (rule__InterfaceField__FieldAssignment_1) - { after(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); } + { before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); } + ')' + { after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); } ) ; finally { @@ -2826,512 +19293,512 @@ finally { } -rule__InterfaceNavigation__Group__0 +rule__XFeatureCall__Group_3_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__InterfaceNavigation__Group__0__Impl - rule__InterfaceNavigation__Group__1 + rule__XFeatureCall__Group_3_1_1__0__Impl + rule__XFeatureCall__Group_3_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__Group__0__Impl +rule__XFeatureCall__Group_3_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); } - '@' - { after(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__Group__1 +rule__XFeatureCall__Group_3_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__InterfaceNavigation__Group__1__Impl - rule__InterfaceNavigation__Group__2 + rule__XFeatureCall__Group_3_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__Group__1__Impl +rule__XFeatureCall__Group_3_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); } - (rule__InterfaceNavigation__UnorderedAssignment_1)? - { after(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); } + (rule__XFeatureCall__Group_3_1_1_1__0)* + { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__Group__2 + +rule__XFeatureCall__Group_3_1_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__InterfaceNavigation__Group__2__Impl + rule__XFeatureCall__Group_3_1_1_1__0__Impl + rule__XFeatureCall__Group_3_1_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__Group__2__Impl +rule__XFeatureCall__Group_3_1_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); } - (rule__InterfaceNavigation__RefAssignment_2) - { after(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); } + { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); } + ',' + { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__InterfaceExpression__Group__0 +rule__XFeatureCall__Group_3_1_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__InterfaceExpression__Group__0__Impl - rule__InterfaceExpression__Group__1 + rule__XFeatureCall__Group_3_1_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__0__Impl +rule__XFeatureCall__Group_3_1_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); } - 'eval' - { after(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__1 + +rule__XConstructorCall__Group__0 @init { int stackSize = keepStackSize(); } : - rule__InterfaceExpression__Group__1__Impl - rule__InterfaceExpression__Group__2 + rule__XConstructorCall__Group__0__Impl + rule__XConstructorCall__Group__1 ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__1__Impl +rule__XConstructorCall__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); } - (rule__InterfaceExpression__RefAssignment_1)? - { after(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); } + { before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); } + () + { after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__2 +rule__XConstructorCall__Group__1 @init { int stackSize = keepStackSize(); } : - rule__InterfaceExpression__Group__2__Impl - rule__InterfaceExpression__Group__3 + rule__XConstructorCall__Group__1__Impl + rule__XConstructorCall__Group__2 ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__2__Impl +rule__XConstructorCall__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); } - (rule__InterfaceExpression__UnorderedAssignment_2)? - { after(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); } + { before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); } + 'new' + { after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__3 +rule__XConstructorCall__Group__2 @init { int stackSize = keepStackSize(); } : - rule__InterfaceExpression__Group__3__Impl - rule__InterfaceExpression__Group__4 + rule__XConstructorCall__Group__2__Impl + rule__XConstructorCall__Group__3 ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__3__Impl +rule__XConstructorCall__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); } - '(' - { after(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); } + { before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); } + (rule__XConstructorCall__ConstructorAssignment_2) + { after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__4 +rule__XConstructorCall__Group__3 @init { int stackSize = keepStackSize(); } : - rule__InterfaceExpression__Group__4__Impl - rule__InterfaceExpression__Group__5 + rule__XConstructorCall__Group__3__Impl + rule__XConstructorCall__Group__4 ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__4__Impl +rule__XConstructorCall__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); } - (rule__InterfaceExpression__ExprAssignment_4) - { after(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_3()); } + (rule__XConstructorCall__Group_3__0)? + { after(grammarAccess.getXConstructorCallAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__5 +rule__XConstructorCall__Group__4 @init { int stackSize = keepStackSize(); } : - rule__InterfaceExpression__Group__5__Impl + rule__XConstructorCall__Group__4__Impl + rule__XConstructorCall__Group__5 ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__Group__5__Impl +rule__XConstructorCall__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); } - ')' - { after(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_4()); } + (rule__XConstructorCall__Group_4__0)? + { after(grammarAccess.getXConstructorCallAccess().getGroup_4()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group__0 +rule__XConstructorCall__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__0__Impl - rule__Export__Group__1 + rule__XConstructorCall__Group__5__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group__0__Impl +rule__XConstructorCall__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getExportKeyword_0()); } - 'export' - { after(grammarAccess.getExportAccess().getExportKeyword_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); } + (rule__XConstructorCall__ArgumentsAssignment_5)? + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__1 + +rule__XConstructorCall__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__1__Impl - rule__Export__Group__2 + rule__XConstructorCall__Group_3__0__Impl + rule__XConstructorCall__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group__1__Impl +rule__XConstructorCall__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_1()); } - (rule__Export__Group_1__0)? - { after(grammarAccess.getExportAccess().getGroup_1()); } + { before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); } + ('<') + { after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__2 +rule__XConstructorCall__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__2__Impl - rule__Export__Group__3 + rule__XConstructorCall__Group_3__1__Impl + rule__XConstructorCall__Group_3__2 ; finally { restoreStackSize(stackSize); } -rule__Export__Group__2__Impl +rule__XConstructorCall__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getTypeAssignment_2()); } - (rule__Export__TypeAssignment_2) - { after(grammarAccess.getExportAccess().getTypeAssignment_2()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); } + (rule__XConstructorCall__TypeArgumentsAssignment_3_1) + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__3 +rule__XConstructorCall__Group_3__2 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__3__Impl - rule__Export__Group__4 + rule__XConstructorCall__Group_3__2__Impl + rule__XConstructorCall__Group_3__3 ; finally { restoreStackSize(stackSize); } -rule__Export__Group__3__Impl +rule__XConstructorCall__Group_3__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_3()); } - (rule__Export__Group_3__0)? - { after(grammarAccess.getExportAccess().getGroup_3()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); } + (rule__XConstructorCall__Group_3_2__0)* + { after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__4 +rule__XConstructorCall__Group_3__3 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__4__Impl - rule__Export__Group__5 + rule__XConstructorCall__Group_3__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group__4__Impl +rule__XConstructorCall__Group_3__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_4()); } - (rule__Export__Group_4__0)? - { after(grammarAccess.getExportAccess().getGroup_4()); } + { before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); } + '>' + { after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__5 + +rule__XConstructorCall__Group_3_2__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__5__Impl - rule__Export__Group__6 + rule__XConstructorCall__Group_3_2__0__Impl + rule__XConstructorCall__Group_3_2__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group__5__Impl +rule__XConstructorCall__Group_3_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); } - '{' - { after(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); } + { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); } + ',' + { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__6 +rule__XConstructorCall__Group_3_2__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__6__Impl - rule__Export__Group__7 + rule__XConstructorCall__Group_3_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group__6__Impl +rule__XConstructorCall__Group_3_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_6()); } - (rule__Export__Group_6__0)? - { after(grammarAccess.getExportAccess().getGroup_6()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); } + (rule__XConstructorCall__TypeArgumentsAssignment_3_2_1) + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__7 + +rule__XConstructorCall__Group_4__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__7__Impl - rule__Export__Group__8 + rule__XConstructorCall__Group_4__0__Impl + rule__XConstructorCall__Group_4__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group__7__Impl +rule__XConstructorCall__Group_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_7()); } - (rule__Export__Group_7__0)? - { after(grammarAccess.getExportAccess().getGroup_7()); } + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); } + (rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0) + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__8 +rule__XConstructorCall__Group_4__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__8__Impl - rule__Export__Group__9 + rule__XConstructorCall__Group_4__1__Impl + rule__XConstructorCall__Group_4__2 ; finally { restoreStackSize(stackSize); } -rule__Export__Group__8__Impl +rule__XConstructorCall__Group_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAlternatives_8()); } - (rule__Export__Alternatives_8)* - { after(grammarAccess.getExportAccess().getAlternatives_8()); } + { before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); } + (rule__XConstructorCall__Alternatives_4_1)? + { after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group__9 +rule__XConstructorCall__Group_4__2 @init { int stackSize = keepStackSize(); } : - rule__Export__Group__9__Impl + rule__XConstructorCall__Group_4__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group__9__Impl +rule__XConstructorCall__Group_4__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); } - '}' - { after(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); } + { before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); } + ')' + { after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); } ) ; finally { @@ -3339,53 +19806,53 @@ finally { } -rule__Export__Group_1__0 +rule__XConstructorCall__Group_4_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_1__0__Impl - rule__Export__Group_1__1 + rule__XConstructorCall__Group_4_1_1__0__Impl + rule__XConstructorCall__Group_4_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1__0__Impl +rule__XConstructorCall__Group_4_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLookupAssignment_1_0()); } - (rule__Export__LookupAssignment_1_0) - { after(grammarAccess.getExportAccess().getLookupAssignment_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_1_0) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1__1 +rule__XConstructorCall__Group_4_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_1__1__Impl + rule__XConstructorCall__Group_4_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1__1__Impl +rule__XConstructorCall__Group_4_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_1_1()); } - (rule__Export__Group_1_1__0)? - { after(grammarAccess.getExportAccess().getGroup_1_1()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); } + (rule__XConstructorCall__Group_4_1_1_1__0)* + { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); } ) ; finally { @@ -3393,161 +19860,161 @@ finally { } -rule__Export__Group_1_1__0 +rule__XConstructorCall__Group_4_1_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_1_1__0__Impl - rule__Export__Group_1_1__1 + rule__XConstructorCall__Group_4_1_1_1__0__Impl + rule__XConstructorCall__Group_4_1_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1_1__0__Impl +rule__XConstructorCall__Group_4_1_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); } - '[' - { after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); } + ',' + { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1_1__1 +rule__XConstructorCall__Group_4_1_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_1_1__1__Impl - rule__Export__Group_1_1__2 + rule__XConstructorCall__Group_4_1_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1_1__1__Impl +rule__XConstructorCall__Group_4_1_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); } - (rule__Export__LookupPredicateAssignment_1_1_1) - { after(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1_1__2 + +rule__XBooleanLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_1_1__2__Impl + rule__XBooleanLiteral__Group__0__Impl + rule__XBooleanLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_1_1__2__Impl +rule__XBooleanLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); } - ']' - { after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); } + { before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); } + () + { after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group_3__0 +rule__XBooleanLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_3__0__Impl - rule__Export__Group_3__1 + rule__XBooleanLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_3__0__Impl +rule__XBooleanLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAsKeyword_3_0()); } - 'as' - { after(grammarAccess.getExportAccess().getAsKeyword_3_0()); } + { before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); } + (rule__XBooleanLiteral__Alternatives_1) + { after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_3__1 + +rule__XNullLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_3__1__Impl - rule__Export__Group_3__2 + rule__XNullLiteral__Group__0__Impl + rule__XNullLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_3__1__Impl +rule__XNullLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); } - (rule__Export__QualifiedNameAssignment_3_1)? - { after(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); } + { before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); } + () + { after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_3__2 +rule__XNullLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_3__2__Impl + rule__XNullLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_3__2__Impl +rule__XNullLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } - (rule__Export__NamingAssignment_3_2) - { after(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } + { before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); } + 'null' + { after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); } ) ; finally { @@ -3555,350 +20022,350 @@ finally { } -rule__Export__Group_4__0 +rule__XNumberLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_4__0__Impl - rule__Export__Group_4__1 + rule__XNumberLiteral__Group__0__Impl + rule__XNumberLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_4__0__Impl +rule__XNumberLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); } - '[' - { after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); } + { before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); } + () + { after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_4__1 +rule__XNumberLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_4__1__Impl - rule__Export__Group_4__2 + rule__XNumberLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_4__1__Impl +rule__XNumberLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGuardAssignment_4_1()); } - (rule__Export__GuardAssignment_4_1) - { after(grammarAccess.getExportAccess().getGuardAssignment_4_1()); } + { before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); } + (rule__XNumberLiteral__ValueAssignment_1) + { after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_4__2 + +rule__XStringLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_4__2__Impl + rule__XStringLiteral__Group__0__Impl + rule__XStringLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_4__2__Impl +rule__XStringLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); } - ']' - { after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); } + { before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); } + () + { after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group_6__0 +rule__XStringLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__0__Impl - rule__Export__Group_6__1 + rule__XStringLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__0__Impl +rule__XStringLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } - 'uri-fragment' - { after(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } + { before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); } + (rule__XStringLiteral__ValueAssignment_1) + { after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__1 + +rule__XTypeLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__1__Impl - rule__Export__Group_6__2 + rule__XTypeLiteral__Group__0__Impl + rule__XTypeLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__1__Impl +rule__XTypeLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); } - '=' - { after(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); } + { before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); } + () + { after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__2 +rule__XTypeLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__2__Impl - rule__Export__Group_6__3 + rule__XTypeLiteral__Group__1__Impl + rule__XTypeLiteral__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__2__Impl +rule__XTypeLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); } - (rule__Export__FragmentUniqueAssignment_6_2)? - { after(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); } + 'typeof' + { after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__3 +rule__XTypeLiteral__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__3__Impl - rule__Export__Group_6__4 + rule__XTypeLiteral__Group__2__Impl + rule__XTypeLiteral__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__3__Impl +rule__XTypeLiteral__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } - 'attribute' - { after(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } + { before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__4 +rule__XTypeLiteral__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__4__Impl - rule__Export__Group_6__5 + rule__XTypeLiteral__Group__3__Impl + rule__XTypeLiteral__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__4__Impl +rule__XTypeLiteral__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); } - '(' - { after(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); } + (rule__XTypeLiteral__TypeAssignment_3) + { after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__5 +rule__XTypeLiteral__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__5__Impl - rule__Export__Group_6__6 + rule__XTypeLiteral__Group__4__Impl + rule__XTypeLiteral__Group__5 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__5__Impl +rule__XTypeLiteral__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); } - (rule__Export__FragmentAttributeAssignment_6_5) - { after(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); } + { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); } + (rule__XTypeLiteral__ArrayDimensionsAssignment_4)* + { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__6 +rule__XTypeLiteral__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__6__Impl - rule__Export__Group_6__7 + rule__XTypeLiteral__Group__5__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__6__Impl +rule__XTypeLiteral__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } + { before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); } ')' - { after(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } + { after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__7 + +rule__XThrowExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_6__7__Impl + rule__XThrowExpression__Group__0__Impl + rule__XThrowExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_6__7__Impl +rule__XThrowExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); } - ';' - { after(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); } + { before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); } + () + { after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group_7__0 +rule__XThrowExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_7__0__Impl - rule__Export__Group_7__1 + rule__XThrowExpression__Group__1__Impl + rule__XThrowExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_7__0__Impl +rule__XThrowExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAlternatives_7_0()); } - (rule__Export__Alternatives_7_0) - { after(grammarAccess.getExportAccess().getAlternatives_7_0()); } + { before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); } + 'throw' + { after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_7__1 +rule__XThrowExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_7__1__Impl + rule__XThrowExpression__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_7__1__Impl +rule__XThrowExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); } - ';' - { after(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); } + { before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); } + (rule__XThrowExpression__ExpressionAssignment_2) + { after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); } ) ; finally { @@ -3906,458 +20373,465 @@ finally { } -rule__Export__Group_8_0__0 +rule__XReturnExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_0__0__Impl - rule__Export__Group_8_0__1 + rule__XReturnExpression__Group__0__Impl + rule__XReturnExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__0__Impl +rule__XReturnExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); } - 'field' - { after(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); } + { before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); } + () + { after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__1 +rule__XReturnExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_0__1__Impl - rule__Export__Group_8_0__2 + rule__XReturnExpression__Group__1__Impl + rule__XReturnExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__1__Impl +rule__XReturnExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); } - (rule__Export__AttributesAssignment_8_0_1) - { after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); } + { before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); } + 'return' + { after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__2 +rule__XReturnExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_0__2__Impl - rule__Export__Group_8_0__3 + rule__XReturnExpression__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__2__Impl +rule__XReturnExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_8_0_2()); } - (rule__Export__Group_8_0_2__0)* - { after(grammarAccess.getExportAccess().getGroup_8_0_2()); } + { before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); } + (rule__XReturnExpression__ExpressionAssignment_2)? + { after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__3 + +rule__XTryCatchFinallyExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_0__3__Impl + rule__XTryCatchFinallyExpression__Group__0__Impl + rule__XTryCatchFinallyExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0__3__Impl +rule__XTryCatchFinallyExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); } - ';' - { after(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); } + () + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group_8_0_2__0 +rule__XTryCatchFinallyExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_0_2__0__Impl - rule__Export__Group_8_0_2__1 + rule__XTryCatchFinallyExpression__Group__1__Impl + rule__XTryCatchFinallyExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0_2__0__Impl +rule__XTryCatchFinallyExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); } - ',' - { after(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); } + 'try' + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0_2__1 +rule__XTryCatchFinallyExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_0_2__1__Impl + rule__XTryCatchFinallyExpression__Group__2__Impl + rule__XTryCatchFinallyExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_0_2__1__Impl +rule__XTryCatchFinallyExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); } - (rule__Export__AttributesAssignment_8_0_2_1) - { after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); } + (rule__XTryCatchFinallyExpression__ExpressionAssignment_2) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group_8_1__0 +rule__XTryCatchFinallyExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_1__0__Impl - rule__Export__Group_8_1__1 + rule__XTryCatchFinallyExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__0__Impl +rule__XTryCatchFinallyExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); } - 'data' - { after(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); } + (rule__XTryCatchFinallyExpression__Alternatives_3) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__1 + +rule__XTryCatchFinallyExpression__Group_3_0__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_1__1__Impl - rule__Export__Group_8_1__2 + rule__XTryCatchFinallyExpression__Group_3_0__0__Impl + rule__XTryCatchFinallyExpression__Group_3_0__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__1__Impl +rule__XTryCatchFinallyExpression__Group_3_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); } - (rule__Export__UserDataAssignment_8_1_1) - { after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); } + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + ) + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)* + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + ) ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__2 +rule__XTryCatchFinallyExpression__Group_3_0__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_1__2__Impl - rule__Export__Group_8_1__3 + rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__2__Impl +rule__XTryCatchFinallyExpression__Group_3_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGroup_8_1_2()); } - (rule__Export__Group_8_1_2__0)* - { after(grammarAccess.getExportAccess().getGroup_8_1_2()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); } + (rule__XTryCatchFinallyExpression__Group_3_0_1__0)? + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__3 + +rule__XTryCatchFinallyExpression__Group_3_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_1__3__Impl + rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl + rule__XTryCatchFinallyExpression__Group_3_0_1__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1__3__Impl +rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); } - ';' - { after(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); } + ('finally') + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Export__Group_8_1_2__0 +rule__XTryCatchFinallyExpression__Group_3_0_1__1 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_1_2__0__Impl - rule__Export__Group_8_1_2__1 + rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1_2__0__Impl +rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); } - ',' - { after(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); } + (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1_2__1 + +rule__XTryCatchFinallyExpression__Group_3_1__0 @init { int stackSize = keepStackSize(); } : - rule__Export__Group_8_1_2__1__Impl + rule__XTryCatchFinallyExpression__Group_3_1__0__Impl + rule__XTryCatchFinallyExpression__Group_3_1__1 ; finally { restoreStackSize(stackSize); } -rule__Export__Group_8_1_2__1__Impl +rule__XTryCatchFinallyExpression__Group_3_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); } - (rule__Export__UserDataAssignment_8_1_2_1) - { after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); } + 'finally' + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__UserData__Group__0 +rule__XTryCatchFinallyExpression__Group_3_1__1 @init { int stackSize = keepStackSize(); } : - rule__UserData__Group__0__Impl - rule__UserData__Group__1 + rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__UserData__Group__0__Impl +rule__XTryCatchFinallyExpression__Group_3_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUserDataAccess().getNameAssignment_0()); } - (rule__UserData__NameAssignment_0) - { after(grammarAccess.getUserDataAccess().getNameAssignment_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); } + (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__UserData__Group__1 + +rule__XSynchronizedExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__UserData__Group__1__Impl - rule__UserData__Group__2 + rule__XSynchronizedExpression__Group__0__Impl + rule__XSynchronizedExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__UserData__Group__1__Impl +rule__XSynchronizedExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); } - '=' - { after(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); } + (rule__XSynchronizedExpression__Group_0__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UserData__Group__2 +rule__XSynchronizedExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__UserData__Group__2__Impl + rule__XSynchronizedExpression__Group__1__Impl + rule__XSynchronizedExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__UserData__Group__2__Impl +rule__XSynchronizedExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUserDataAccess().getExprAssignment_2()); } - (rule__UserData__ExprAssignment_2) - { after(grammarAccess.getUserDataAccess().getExprAssignment_2()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); } + (rule__XSynchronizedExpression__ParamAssignment_1) + { after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__QualifiedID__Group__0 +rule__XSynchronizedExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group__0__Impl - rule__QualifiedID__Group__1 + rule__XSynchronizedExpression__Group__2__Impl + rule__XSynchronizedExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group__0__Impl +rule__XSynchronizedExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); } - RULE_ID - { after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group__1 +rule__XSynchronizedExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group__1__Impl + rule__XSynchronizedExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group__1__Impl +rule__XSynchronizedExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getGroup_1()); } - (rule__QualifiedID__Group_1__0)* - { after(grammarAccess.getQualifiedIDAccess().getGroup_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); } + (rule__XSynchronizedExpression__ExpressionAssignment_3) + { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); } ) ; finally { @@ -4365,458 +20839,458 @@ finally { } -rule__QualifiedID__Group_1__0 +rule__XSynchronizedExpression__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group_1__0__Impl - rule__QualifiedID__Group_1__1 + rule__XSynchronizedExpression__Group_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group_1__0__Impl +rule__XSynchronizedExpression__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } - '::' - { after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); } + (rule__XSynchronizedExpression__Group_0_0__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group_1__1 + +rule__XSynchronizedExpression__Group_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group_1__1__Impl + rule__XSynchronizedExpression__Group_0_0__0__Impl + rule__XSynchronizedExpression__Group_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group_1__1__Impl +rule__XSynchronizedExpression__Group_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); } - RULE_ID - { after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); } + () + { after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__LetExpression__Group__0 +rule__XSynchronizedExpression__Group_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__0__Impl - rule__LetExpression__Group__1 + rule__XSynchronizedExpression__Group_0_0__1__Impl + rule__XSynchronizedExpression__Group_0_0__2 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__0__Impl +rule__XSynchronizedExpression__Group_0_0__1__Impl @init { int stackSize = keepStackSize(); } -: -( - { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } - 'let' - { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } +: +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); } + 'synchronized' + { after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__1 +rule__XSynchronizedExpression__Group_0_0__2 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__1__Impl - rule__LetExpression__Group__2 + rule__XSynchronizedExpression__Group_0_0__2__Impl ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__1__Impl +rule__XSynchronizedExpression__Group_0_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } - (rule__LetExpression__IdentifierAssignment_1) - { after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } + '(' + { after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__2 + +rule__XCatchClause__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__2__Impl - rule__LetExpression__Group__3 + rule__XCatchClause__Group__0__Impl + rule__XCatchClause__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__2__Impl +rule__XCatchClause__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } - '=' - { after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } + { before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); } + ('catch') + { after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__3 +rule__XCatchClause__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__3__Impl - rule__LetExpression__Group__4 + rule__XCatchClause__Group__1__Impl + rule__XCatchClause__Group__2 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__3__Impl +rule__XCatchClause__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } - (rule__LetExpression__VarExprAssignment_3) - { after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } + { before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__4 +rule__XCatchClause__Group__2 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__4__Impl - rule__LetExpression__Group__5 + rule__XCatchClause__Group__2__Impl + rule__XCatchClause__Group__3 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__4__Impl +rule__XCatchClause__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } - ':' - { after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } + { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); } + (rule__XCatchClause__DeclaredParamAssignment_2) + { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__5 +rule__XCatchClause__Group__3 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__5__Impl + rule__XCatchClause__Group__3__Impl + rule__XCatchClause__Group__4 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__5__Impl +rule__XCatchClause__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } - (rule__LetExpression__TargetAssignment_5) - { after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } + { before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__CastedExpression__Group__0 +rule__XCatchClause__Group__4 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__0__Impl - rule__CastedExpression__Group__1 + rule__XCatchClause__Group__4__Impl ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__0__Impl +rule__XCatchClause__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } - '(' - { after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } + { before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); } + (rule__XCatchClause__ExpressionAssignment_4) + { after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__1 + +rule__QualifiedName__Group__0 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__1__Impl - rule__CastedExpression__Group__2 + rule__QualifiedName__Group__0__Impl + rule__QualifiedName__Group__1 ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__1__Impl +rule__QualifiedName__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } - (rule__CastedExpression__TypeAssignment_1) - { after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } + { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__2 +rule__QualifiedName__Group__1 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__2__Impl - rule__CastedExpression__Group__3 + rule__QualifiedName__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__2__Impl +rule__QualifiedName__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } - ')' - { after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } + { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } + (rule__QualifiedName__Group_1__0)* + { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__3 + +rule__QualifiedName__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__3__Impl + rule__QualifiedName__Group_1__0__Impl + rule__QualifiedName__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__3__Impl +rule__QualifiedName__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } - (rule__CastedExpression__TargetAssignment_3) - { after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } + { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } + ('.') + { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ChainExpression__Group__0 +rule__QualifiedName__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group__0__Impl - rule__ChainExpression__Group__1 + rule__QualifiedName__Group_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__0__Impl +rule__QualifiedName__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } - ruleChainedExpression - { after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } + { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); } + ruleValidID + { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__1 + +rule__Number__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group__1__Impl + rule__Number__Group_1__0__Impl + rule__Number__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__1__Impl +rule__Number__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getGroup_1()); } - (rule__ChainExpression__Group_1__0)* - { after(grammarAccess.getChainExpressionAccess().getGroup_1()); } + { before(grammarAccess.getNumberAccess().getAlternatives_1_0()); } + (rule__Number__Alternatives_1_0) + { after(grammarAccess.getNumberAccess().getAlternatives_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ChainExpression__Group_1__0 +rule__Number__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__0__Impl - rule__ChainExpression__Group_1__1 + rule__Number__Group_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__0__Impl +rule__Number__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } - () - { after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } + { before(grammarAccess.getNumberAccess().getGroup_1_1()); } + (rule__Number__Group_1_1__0)? + { after(grammarAccess.getNumberAccess().getGroup_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__1 + +rule__Number__Group_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__1__Impl - rule__ChainExpression__Group_1__2 + rule__Number__Group_1_1__0__Impl + rule__Number__Group_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__1__Impl +rule__Number__Group_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } - '->' - { after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } + { before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); } + '.' + { after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__2 +rule__Number__Group_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__2__Impl + rule__Number__Group_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__2__Impl +rule__Number__Group_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } - (rule__ChainExpression__NextAssignment_1_2) - { after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } + { before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); } + (rule__Number__Alternatives_1_1_1) + { after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); } ) ; finally { @@ -4824,53 +21298,53 @@ finally { } -rule__IfExpressionTri__Group__0 +rule__JvmTypeReference__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group__0__Impl - rule__IfExpressionTri__Group__1 + rule__JvmTypeReference__Group_0__0__Impl + rule__JvmTypeReference__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__0__Impl +rule__JvmTypeReference__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } - ruleOrExpression - { after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); } + ruleJvmParameterizedTypeReference + { after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__1 +rule__JvmTypeReference__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group__1__Impl + rule__JvmTypeReference__Group_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__1__Impl +rule__JvmTypeReference__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } - (rule__IfExpressionTri__Group_1__0)? - { after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); } + (rule__JvmTypeReference__Group_0_1__0)* + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); } ) ; finally { @@ -4878,134 +21352,134 @@ finally { } -rule__IfExpressionTri__Group_1__0 +rule__JvmTypeReference__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__0__Impl - rule__IfExpressionTri__Group_1__1 + rule__JvmTypeReference__Group_0_1__0__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__0__Impl +rule__JvmTypeReference__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } - () - { after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); } + (rule__JvmTypeReference__Group_0_1_0__0) + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__1 + +rule__JvmTypeReference__Group_0_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__1__Impl - rule__IfExpressionTri__Group_1__2 + rule__JvmTypeReference__Group_0_1_0__0__Impl + rule__JvmTypeReference__Group_0_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__1__Impl +rule__JvmTypeReference__Group_0_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } - '?' - { after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); } + () + { after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__2 +rule__JvmTypeReference__Group_0_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__2__Impl - rule__IfExpressionTri__Group_1__3 + rule__JvmTypeReference__Group_0_1_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__2__Impl +rule__JvmTypeReference__Group_0_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } - (rule__IfExpressionTri__ThenPartAssignment_1_2) - { after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); } + ruleArrayBrackets + { after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__3 + +rule__ArrayBrackets__Group__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__3__Impl - rule__IfExpressionTri__Group_1__4 + rule__ArrayBrackets__Group__0__Impl + rule__ArrayBrackets__Group__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__3__Impl +rule__ArrayBrackets__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } - ':' - { after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } + { before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); } + '[' + { after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__4 +rule__ArrayBrackets__Group__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__4__Impl + rule__ArrayBrackets__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__4__Impl +rule__ArrayBrackets__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } - (rule__IfExpressionTri__ElsePartAssignment_1_4) - { after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } + { before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); } + ']' + { after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); } ) ; finally { @@ -5013,161 +21487,161 @@ finally { } -rule__IfExpressionKw__Group__0 +rule__XFunctionTypeRef__Group__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__0__Impl - rule__IfExpressionKw__Group__1 + rule__XFunctionTypeRef__Group__0__Impl + rule__XFunctionTypeRef__Group__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__0__Impl +rule__XFunctionTypeRef__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } - 'if' - { after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); } + (rule__XFunctionTypeRef__Group_0__0)? + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__1 +rule__XFunctionTypeRef__Group__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__1__Impl - rule__IfExpressionKw__Group__2 + rule__XFunctionTypeRef__Group__1__Impl + rule__XFunctionTypeRef__Group__2 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__1__Impl +rule__XFunctionTypeRef__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } - (rule__IfExpressionKw__ConditionAssignment_1) - { after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); } + '=>' + { after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__2 +rule__XFunctionTypeRef__Group__2 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__2__Impl - rule__IfExpressionKw__Group__3 + rule__XFunctionTypeRef__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__2__Impl +rule__XFunctionTypeRef__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } - 'then' - { after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); } + (rule__XFunctionTypeRef__ReturnTypeAssignment_2) + { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__3 + +rule__XFunctionTypeRef__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__3__Impl - rule__IfExpressionKw__Group__4 + rule__XFunctionTypeRef__Group_0__0__Impl + rule__XFunctionTypeRef__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__3__Impl +rule__XFunctionTypeRef__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } - (rule__IfExpressionKw__ThenPartAssignment_3) - { after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); } + '(' + { after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__4 +rule__XFunctionTypeRef__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__4__Impl + rule__XFunctionTypeRef__Group_0__1__Impl + rule__XFunctionTypeRef__Group_0__2 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__4__Impl +rule__XFunctionTypeRef__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } - (rule__IfExpressionKw__Group_4__0)? - { after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); } + (rule__XFunctionTypeRef__Group_0_1__0)? + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__IfExpressionKw__Group_4__0 +rule__XFunctionTypeRef__Group_0__2 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4__0__Impl + rule__XFunctionTypeRef__Group_0__2__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4__0__Impl +rule__XFunctionTypeRef__Group_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } - (rule__IfExpressionKw__Group_4_0__0) - { after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); } + ')' + { after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); } ) ; finally { @@ -5175,53 +21649,53 @@ finally { } -rule__IfExpressionKw__Group_4_0__0 +rule__XFunctionTypeRef__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4_0__0__Impl - rule__IfExpressionKw__Group_4_0__1 + rule__XFunctionTypeRef__Group_0_1__0__Impl + rule__XFunctionTypeRef__Group_0_1__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__0__Impl +rule__XFunctionTypeRef__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } - 'else' - { after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); } + (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0) + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__1 +rule__XFunctionTypeRef__Group_0_1__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4_0__1__Impl + rule__XFunctionTypeRef__Group_0_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__1__Impl +rule__XFunctionTypeRef__Group_0_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } - (rule__IfExpressionKw__ElsePartAssignment_4_0_1) - { after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); } + (rule__XFunctionTypeRef__Group_0_1_1__0)* + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); } ) ; finally { @@ -5229,296 +21703,296 @@ finally { } -rule__SwitchExpression__Group__0 +rule__XFunctionTypeRef__Group_0_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__0__Impl - rule__SwitchExpression__Group__1 + rule__XFunctionTypeRef__Group_0_1_1__0__Impl + rule__XFunctionTypeRef__Group_0_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__0__Impl +rule__XFunctionTypeRef__Group_0_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } - 'switch' - { after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); } + ',' + { after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__1 +rule__XFunctionTypeRef__Group_0_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__1__Impl - rule__SwitchExpression__Group__2 + rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__1__Impl +rule__XFunctionTypeRef__Group_0_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } - (rule__SwitchExpression__Group_1__0)? - { after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); } + (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1) + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__2 + +rule__JvmParameterizedTypeReference__Group__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__2__Impl - rule__SwitchExpression__Group__3 + rule__JvmParameterizedTypeReference__Group__0__Impl + rule__JvmParameterizedTypeReference__Group__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__2__Impl +rule__JvmParameterizedTypeReference__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); } + (rule__JvmParameterizedTypeReference__TypeAssignment_0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__3 +rule__JvmParameterizedTypeReference__Group__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__3__Impl - rule__SwitchExpression__Group__4 + rule__JvmParameterizedTypeReference__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__3__Impl +rule__JvmParameterizedTypeReference__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } - (rule__SwitchExpression__CaseAssignment_3)* - { after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); } + (rule__JvmParameterizedTypeReference__Group_1__0)? + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__4 + +rule__JvmParameterizedTypeReference__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__4__Impl - rule__SwitchExpression__Group__5 + rule__JvmParameterizedTypeReference__Group_1__0__Impl + rule__JvmParameterizedTypeReference__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__4__Impl +rule__JvmParameterizedTypeReference__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - 'default' - { after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } +( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); } + ('<') + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__5 +rule__JvmParameterizedTypeReference__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__5__Impl - rule__SwitchExpression__Group__6 + rule__JvmParameterizedTypeReference__Group_1__1__Impl + rule__JvmParameterizedTypeReference__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__5__Impl +rule__JvmParameterizedTypeReference__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } - ':' - { after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__6 +rule__JvmParameterizedTypeReference__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__6__Impl - rule__SwitchExpression__Group__7 + rule__JvmParameterizedTypeReference__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1__3 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__6__Impl +rule__JvmParameterizedTypeReference__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } - (rule__SwitchExpression__DefaultExprAssignment_6) - { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); } + (rule__JvmParameterizedTypeReference__Group_1_2__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__7 +rule__JvmParameterizedTypeReference__Group_1__3 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__7__Impl + rule__JvmParameterizedTypeReference__Group_1__3__Impl + rule__JvmParameterizedTypeReference__Group_1__4 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__7__Impl +rule__JvmParameterizedTypeReference__Group_1__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); } + '>' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__SwitchExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1__4 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__0__Impl - rule__SwitchExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1__4__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } - '(' - { after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); } + (rule__JvmParameterizedTypeReference__Group_1_4__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__1 + +rule__JvmParameterizedTypeReference__Group_1_2__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__1__Impl - rule__SwitchExpression__Group_1__2 + rule__JvmParameterizedTypeReference__Group_1_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_2__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__1__Impl +rule__JvmParameterizedTypeReference__Group_1_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } - (rule__SwitchExpression__SwitchExprAssignment_1_1) - { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); } + ',' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__2 +rule__JvmParameterizedTypeReference__Group_1_2__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__2__Impl +rule__JvmParameterizedTypeReference__Group_1_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } - ')' - { after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); } ) ; finally { @@ -5526,107 +22000,107 @@ finally { } -rule__Case__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4__0 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__0__Impl - rule__Case__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4__1 ; finally { restoreStackSize(stackSize); } -rule__Case__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } - 'case' - { after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); } + (rule__JvmParameterizedTypeReference__Group_1_4_0__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__1 +rule__JvmParameterizedTypeReference__Group_1_4__1 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__1__Impl - rule__Case__Group__2 + rule__JvmParameterizedTypeReference__Group_1_4__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4__2 ; finally { restoreStackSize(stackSize); } -rule__Case__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } - (rule__Case__ConditionAssignment_1) - { after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); } + (rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__2 +rule__JvmParameterizedTypeReference__Group_1_4__2 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__2__Impl - rule__Case__Group__3 + rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Case__Group__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getColonKeyword_2()); } - ':' - { after(grammarAccess.getCaseAccess().getColonKeyword_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); } + (rule__JvmParameterizedTypeReference__Group_1_4_2__0)? + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__3 + +rule__JvmParameterizedTypeReference__Group_1_4_0__0 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__3__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__Case__Group__3__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } - (rule__Case__ThenParAssignment_3) - { after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); } + (rule__JvmParameterizedTypeReference__Group_1_4_0_0__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); } ) ; finally { @@ -5634,53 +22108,53 @@ finally { } -rule__OrExpression__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group__0__Impl - rule__OrExpression__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } - ruleAndExpression - { after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); } + () + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__1 +rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getGroup_1()); } - (rule__OrExpression__Group_1__0)* - { after(grammarAccess.getOrExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); } + '.' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); } ) ; finally { @@ -5688,350 +22162,350 @@ finally { } -rule__OrExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1_4_2__0 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__0__Impl - rule__OrExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); } + ('<') + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__1 +rule__JvmParameterizedTypeReference__Group_1_4_2__1 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__1__Impl - rule__OrExpression__Group_1__2 + rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } - (rule__OrExpression__OperatorAssignment_1_1) - { after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__2 +rule__JvmParameterizedTypeReference__Group_1_4_2__2 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } - (rule__OrExpression__RightAssignment_1_2) - { after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); } + (rule__JvmParameterizedTypeReference__Group_1_4_2_2__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AndExpression__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4_2__3 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group__0__Impl - rule__AndExpression__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } - ruleImpliesExpression - { after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); } + '>' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__1 + +rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getGroup_1()); } - (rule__AndExpression__Group_1__0)* - { after(grammarAccess.getAndExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); } + ',' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AndExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__0__Impl - rule__AndExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__1 + +rule__JvmWildcardTypeReference__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__1__Impl - rule__AndExpression__Group_1__2 + rule__JvmWildcardTypeReference__Group__0__Impl + rule__JvmWildcardTypeReference__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__1__Impl +rule__JvmWildcardTypeReference__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } - (rule__AndExpression__OperatorAssignment_1_1) - { after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); } + () + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__2 +rule__JvmWildcardTypeReference__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__2__Impl + rule__JvmWildcardTypeReference__Group__1__Impl + rule__JvmWildcardTypeReference__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__2__Impl +rule__JvmWildcardTypeReference__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } - (rule__AndExpression__RightAssignment_1_2) - { after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); } + '?' + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ImpliesExpression__Group__0 +rule__JvmWildcardTypeReference__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group__0__Impl - rule__ImpliesExpression__Group__1 + rule__JvmWildcardTypeReference__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__0__Impl +rule__JvmWildcardTypeReference__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } - ruleRelationalExpression - { after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); } + (rule__JvmWildcardTypeReference__Alternatives_2)? + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__1 + +rule__JvmWildcardTypeReference__Group_2_0__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group__1__Impl + rule__JvmWildcardTypeReference__Group_2_0__0__Impl + rule__JvmWildcardTypeReference__Group_2_0__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__1__Impl +rule__JvmWildcardTypeReference__Group_2_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } - (rule__ImpliesExpression__Group_1__0)* - { after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ImpliesExpression__Group_1__0 +rule__JvmWildcardTypeReference__Group_2_0__1 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__0__Impl - rule__ImpliesExpression__Group_1__1 + rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__0__Impl +rule__JvmWildcardTypeReference__Group_2_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1)* + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__1 + +rule__JvmWildcardTypeReference__Group_2_1__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__1__Impl - rule__ImpliesExpression__Group_1__2 + rule__JvmWildcardTypeReference__Group_2_1__0__Impl + rule__JvmWildcardTypeReference__Group_2_1__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__1__Impl +rule__JvmWildcardTypeReference__Group_2_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } - (rule__ImpliesExpression__OperatorAssignment_1_1) - { after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__2 +rule__JvmWildcardTypeReference__Group_2_1__1 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__2__Impl + rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__2__Impl +rule__JvmWildcardTypeReference__Group_2_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } - (rule__ImpliesExpression__RightAssignment_1_2) - { after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1)* + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); } ) ; finally { @@ -6039,53 +22513,53 @@ finally { } -rule__RelationalExpression__Group__0 +rule__JvmUpperBound__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__0__Impl - rule__RelationalExpression__Group__1 + rule__JvmUpperBound__Group__0__Impl + rule__JvmUpperBound__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__0__Impl +rule__JvmUpperBound__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); } + 'extends' + { after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1 +rule__JvmUpperBound__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__1__Impl + rule__JvmUpperBound__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1__Impl +rule__JvmUpperBound__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } - (rule__RelationalExpression__Group_1__0)* - { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); } + (rule__JvmUpperBound__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); } ) ; finally { @@ -6093,3930 +22567,4303 @@ finally { } -rule__RelationalExpression__Group_1__0 +rule__JvmUpperBoundAnded__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__0__Impl - rule__RelationalExpression__Group_1__1 + rule__JvmUpperBoundAnded__Group__0__Impl + rule__JvmUpperBoundAnded__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__0__Impl +rule__JvmUpperBoundAnded__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); } + '&' + { after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1 +rule__JvmUpperBoundAnded__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__1__Impl - rule__RelationalExpression__Group_1__2 + rule__JvmUpperBoundAnded__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1__Impl +rule__JvmUpperBoundAnded__Group__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.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); } + (rule__JvmUpperBoundAnded__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2 + +rule__JvmLowerBound__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__2__Impl + rule__JvmLowerBound__Group__0__Impl + rule__JvmLowerBound__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2__Impl +rule__JvmLowerBound__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - (rule__RelationalExpression__RightAssignment_1_2) - { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); } + 'super' + { after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AdditiveExpression__Group__0 +rule__JvmLowerBound__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__0__Impl - rule__AdditiveExpression__Group__1 + rule__JvmLowerBound__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__0__Impl +rule__JvmLowerBound__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); } + (rule__JvmLowerBound__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1 + +rule__JvmLowerBoundAnded__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__1__Impl + rule__JvmLowerBoundAnded__Group__0__Impl + rule__JvmLowerBoundAnded__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1__Impl +rule__JvmLowerBoundAnded__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - (rule__AdditiveExpression__Group_1__0)* - { after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); } + '&' + { after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AdditiveExpression__Group_1__0 +rule__JvmLowerBoundAnded__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__0__Impl - rule__AdditiveExpression__Group_1__1 + rule__JvmLowerBoundAnded__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__0__Impl +rule__JvmLowerBoundAnded__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } - () - { after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); } + (rule__JvmLowerBoundAnded__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1 + +rule__QualifiedNameWithWildcard__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__1__Impl - rule__AdditiveExpression__Group_1__2 + rule__QualifiedNameWithWildcard__Group__0__Impl + rule__QualifiedNameWithWildcard__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1__Impl +rule__QualifiedNameWithWildcard__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } - (rule__AdditiveExpression__NameAssignment_1_1) - { after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); } + ruleQualifiedName + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2 +rule__QualifiedNameWithWildcard__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__2__Impl + rule__QualifiedNameWithWildcard__Group__1__Impl + rule__QualifiedNameWithWildcard__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2__Impl +rule__QualifiedNameWithWildcard__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } - (rule__AdditiveExpression__ParamsAssignment_1_2) - { after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MultiplicativeExpression__Group__0 +rule__QualifiedNameWithWildcard__Group__2 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__0__Impl - rule__MultiplicativeExpression__Group__1 + rule__QualifiedNameWithWildcard__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__0__Impl +rule__QualifiedNameWithWildcard__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } - ruleUnaryOrInfixExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); } + '*' + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1 + +rule__XImportDeclaration__Group__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__1__Impl + rule__XImportDeclaration__Group__0__Impl + rule__XImportDeclaration__Group__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1__Impl +rule__XImportDeclaration__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - (rule__MultiplicativeExpression__Group_1__0)* - { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); } + 'import' + { after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MultiplicativeExpression__Group_1__0 +rule__XImportDeclaration__Group__1 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__0__Impl - rule__MultiplicativeExpression__Group_1__1 + rule__XImportDeclaration__Group__1__Impl + rule__XImportDeclaration__Group__2 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__0__Impl +rule__XImportDeclaration__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } - () - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); } + (rule__XImportDeclaration__Alternatives_1) + { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1 +rule__XImportDeclaration__Group__2 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__1__Impl - rule__MultiplicativeExpression__Group_1__2 + rule__XImportDeclaration__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1__Impl +rule__XImportDeclaration__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } - (rule__MultiplicativeExpression__NameAssignment_1_1) - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); } + (';')? + { after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2 + +rule__XImportDeclaration__Group_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__2__Impl + rule__XImportDeclaration__Group_1_0__0__Impl + rule__XImportDeclaration__Group_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2__Impl +rule__XImportDeclaration__Group_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } - (rule__MultiplicativeExpression__ParamsAssignment_1_2) - { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + { before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); } + (rule__XImportDeclaration__StaticAssignment_1_0_0) + { after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__UnaryExpression__Group__0 +rule__XImportDeclaration__Group_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group__0__Impl - rule__UnaryExpression__Group__1 + rule__XImportDeclaration__Group_1_0__1__Impl + rule__XImportDeclaration__Group_1_0__2 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__0__Impl +rule__XImportDeclaration__Group_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } - (rule__UnaryExpression__NameAssignment_0) - { after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); } + (rule__XImportDeclaration__ExtensionAssignment_1_0_1)? + { after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__1 +rule__XImportDeclaration__Group_1_0__2 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group__1__Impl + rule__XImportDeclaration__Group_1_0__2__Impl + rule__XImportDeclaration__Group_1_0__3 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__1__Impl +rule__XImportDeclaration__Group_1_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } - (rule__UnaryExpression__ParamsAssignment_1) - { after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); } + (rule__XImportDeclaration__ImportedTypeAssignment_1_0_2) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group__0 +rule__XImportDeclaration__Group_1_0__3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group__0__Impl - rule__InfixExpression__Group__1 + rule__XImportDeclaration__Group_1_0__3__Impl ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__0__Impl +rule__XImportDeclaration__Group_1_0__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } - rulePrimaryExpression - { after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); } + (rule__XImportDeclaration__Alternatives_1_0_3) + { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__1 + +rule__QualifiedNameInStaticImport__Group__0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group__1__Impl + rule__QualifiedNameInStaticImport__Group__0__Impl + rule__QualifiedNameInStaticImport__Group__1 ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__1__Impl +rule__QualifiedNameInStaticImport__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } - (rule__InfixExpression__Alternatives_1)* - { after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0__0 +rule__QualifiedNameInStaticImport__Group__1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__0__Impl - rule__InfixExpression__Group_1_0__1 + rule__QualifiedNameInStaticImport__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__0__Impl +rule__QualifiedNameInStaticImport__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__1 + +rule__ExportModel__ExtensionAssignment_0_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__1__Impl - rule__InfixExpression__Group_1_0__2 + ( + { before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } + ( + { before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } + 'extension' + { after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } + ) + { after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__1__Impl +rule__ExportModel__NameAssignment_0_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } -) + ( + { before(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); } + RULE_ID + { after(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__2 +rule__ExportModel__TargetGrammarAssignment_0_4 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__2__Impl - rule__InfixExpression__Group_1_0__3 + ( + { before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); } + ( + { before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); } + ruleQualifiedID + { after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); } + ) + { after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__2__Impl +rule__ExportModel__ImportsAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } - (rule__InfixExpression__NameAssignment_1_0_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } -) + ( + { before(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); } + ruleImport + { after(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__3 +rule__ExportModel__ExtensionsAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__3__Impl - rule__InfixExpression__Group_1_0__4 + ( + { before(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); } + ruleExtension + { after(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__3__Impl +rule__ExportModel__InterfacesAssignment_3_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } -) + ( + { before(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); } + ruleInterface + { after(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__4 +rule__ExportModel__ExportsAssignment_4 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__4__Impl - rule__InfixExpression__Group_1_0__5 + ( + { before(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); } + ruleExport + { after(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__4__Impl +rule__Import__PackageAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } - (rule__InfixExpression__Group_1_0_4__0)? - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } -) + ( + { before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + ( + { before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } + RULE_STRING + { after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } + ) + { after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__5 +rule__Import__NameAssignment_2_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__5__Impl + ( + { before(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); } + RULE_ID + { after(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__5__Impl +rule__Extension__ExtensionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } -) + ( + { before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } + ruleQualifiedID + { after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } +rule__Interface__TypeAssignment_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); } + ( + { before(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } + ruleQualifiedID + { after(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} -rule__InfixExpression__Group_1_0_4__0 +rule__Interface__GuardAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4__0__Impl - rule__InfixExpression__Group_1_0_4__1 + ( + { before(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); } + ruleExpression + { after(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__0__Impl +rule__Interface__ItemsAssignment_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } - (rule__InfixExpression__ParamsAssignment_1_0_4_0) - { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } -) + ( + { before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); } + ruleInterfaceItem + { after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__1 +rule__Interface__ItemsAssignment_2_2_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4__1__Impl + ( + { before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); } + ruleInterfaceItem + { after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__1__Impl +rule__InterfaceField__UnorderedAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } - (rule__InfixExpression__Group_1_0_4_1__0)* - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } -) + ( + { before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } + ( + { before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } + '+' + { after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } + ) + { after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0_4_1__0 +rule__InterfaceField__FieldAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4_1__0__Impl - rule__InfixExpression__Group_1_0_4_1__1 + ( + { before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); } + ( + { before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); } + RULE_ID + { after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); } + ) + { after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__0__Impl +rule__InterfaceNavigation__UnorderedAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } - ',' - { after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } -) + ( + { before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } + ( + { before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } + '+' + { after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } + ) + { after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__1 +rule__InterfaceNavigation__RefAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4_1__1__Impl + ( + { before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); } + ( + { before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); } + RULE_ID + { after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); } + ) + { after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__1__Impl +rule__InterfaceExpression__RefAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } - (rule__InfixExpression__ParamsAssignment_1_0_4_1_1) - { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } -) + ( + { before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } + ( + { before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } + '@' + { after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } + ) + { after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_1__0 +rule__InterfaceExpression__UnorderedAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__0__Impl - rule__InfixExpression__Group_1_1__1 + ( + { before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } + ( + { before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } + '+' + { after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } + ) + { after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__0__Impl +rule__InterfaceExpression__ExprAssignment_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } -) + ( + { before(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); } + ruleExpression + { after(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__1 +rule__Export__LookupAssignment_1_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__1__Impl - rule__InfixExpression__Group_1_1__2 + ( + { before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + ( + { before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + 'lookup' + { after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + ) + { after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__1__Impl +rule__Export__LookupPredicateAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } -) + ( + { before(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); } + ruleExpression + { after(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__2 +rule__Export__TypeAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__2__Impl + ( + { before(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); } + ( + { before(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } + ruleQualifiedID + { after(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__2__Impl +rule__Export__QualifiedNameAssignment_3_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } - (rule__InfixExpression__TypeAssignment_1_1_2) - { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } -) + ( + { before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } + ( + { before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } + 'qualified' + { after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } + ) + { after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_2__0 +rule__Export__NamingAssignment_3_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__0__Impl - rule__InfixExpression__Group_1_2__1 + ( + { before(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); } + ruleExpression + { after(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__0__Impl +rule__Export__GuardAssignment_4_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } -) + ( + { before(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); } + ruleExpression + { after(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__1 +rule__Export__FragmentUniqueAssignment_6_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__1__Impl - rule__InfixExpression__Group_1_2__2 + ( + { before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } + ( + { before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } + 'unique' + { after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } + ) + { after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__1__Impl +rule__Export__FragmentAttributeAssignment_6_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } -) + ( + { before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); } + ( + { before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); } + RULE_ID + { after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); } + ) + { after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__2 +rule__Export__FingerprintAssignment_7_0_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__2__Impl - rule__InfixExpression__Group_1_2__3 + ( + { before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } + ( + { before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } + 'object-fingerprint' + { after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } + ) + { after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__2__Impl +rule__Export__ResourceFingerprintAssignment_7_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } - (rule__InfixExpression__NameAssignment_1_2_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } -) + ( + { before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } + ( + { before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } + 'resource-fingerprint' + { after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } + ) + { after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__3 +rule__Export__AttributesAssignment_8_0_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__3__Impl - rule__InfixExpression__Group_1_2__4 + ( + { before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); } + ruleAttribute + { after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__3__Impl +rule__Export__AttributesAssignment_8_0_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } -) + ( + { before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); } + ruleAttribute + { after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__4 +rule__Export__UserDataAssignment_8_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__4__Impl - rule__InfixExpression__Group_1_2__5 + ( + { before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); } + ruleUserData + { after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__4__Impl +rule__Export__UserDataAssignment_8_1_2_1 @init { int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } - (rule__InfixExpression__TypeAssignment_1_2_4) - { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } -) + } +: + ( + { before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); } + ruleUserData + { after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__5 +rule__UserData__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__5__Impl + ( + { before(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); } + RULE_ID + { after(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__5__Impl +rule__UserData__ExprAssignment_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } -) + ( + { before(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); } + ruleExpression + { after(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_3__0 +rule__Attribute__AttributeAssignment @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__0__Impl - rule__InfixExpression__Group_1_3__1 + ( + { before(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); } + ( + { before(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); } + RULE_ID + { after(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); } + ) + { after(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__0__Impl +rule__LetExpression__IdentifierAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } -) + ( + { before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__1 +rule__LetExpression__VarExprAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__1__Impl - rule__InfixExpression__Group_1_3__2 + ( + { before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__1__Impl +rule__LetExpression__TargetAssignment_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } -) + ( + { before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + ruleExpression + { after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__2 +rule__CastedExpression__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__2__Impl - rule__InfixExpression__Group_1_3__3 + ( + { before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + ruleType + { after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__2__Impl +rule__CastedExpression__TargetAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } - (rule__InfixExpression__NameAssignment_1_3_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } -) + ( + { before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__3 +rule__ChainExpression__NextAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__3__Impl - rule__InfixExpression__Group_1_3__4 + ( + { before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + ruleChainedExpression + { after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__3__Impl +rule__IfExpressionTri__ThenPartAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } -) + ( + { before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__4 +rule__IfExpressionTri__ElsePartAssignment_1_4 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__4__Impl - rule__InfixExpression__Group_1_3__5 + ( + { before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__4__Impl +rule__IfExpressionKw__ConditionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } - (rule__InfixExpression__Group_1_3_4__0)? - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } -) + ( + { before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__5 +rule__IfExpressionKw__ThenPartAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__5__Impl - rule__InfixExpression__Group_1_3__6 + ( + { before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__5__Impl +rule__IfExpressionKw__ElsePartAssignment_4_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } - (rule__InfixExpression__ExpAssignment_1_3_5) - { after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } -) + ( + { before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__6 +rule__SwitchExpression__SwitchExprAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__6__Impl + ( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + ruleOrExpression + { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__6__Impl +rule__SwitchExpression__CaseAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } -) + ( + { before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + ruleCase + { after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_3_4__0 +rule__SwitchExpression__DefaultExprAssignment_6 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3_4__0__Impl - rule__InfixExpression__Group_1_3_4__1 + ( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + ruleOrExpression + { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__0__Impl +rule__Case__ConditionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } - (rule__InfixExpression__VarAssignment_1_3_4_0) - { after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } -) + ( + { before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + ruleOrExpression + { after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__1 +rule__Case__ThenParAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3_4__1__Impl + ( + { before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + ruleOrExpression + { after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__1__Impl +rule__OrExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } - '|' - { after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } -) + ( + { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ( + { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + '||' + { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ) + { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ParanthesizedExpression__Group__0 +rule__OrExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__0__Impl - rule__ParanthesizedExpression__Group__1 + ( + { before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + ruleAndExpression + { after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__0__Impl +rule__AndExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } - '(' - { after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } -) + ( + { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ( + { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + '&&' + { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ) + { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__1 +rule__AndExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__1__Impl - rule__ParanthesizedExpression__Group__2 + ( + { before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + ruleImpliesExpression + { after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__1__Impl +rule__ImpliesExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } - ruleExpression - { after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } -) + ( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + 'implies' + { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ) + { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__2 +rule__ImpliesExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__2__Impl + ( + { before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + ruleRelationalExpression + { after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__2__Impl +rule__RelationalExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } - ')' - { after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } -) + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + (rule__RelationalExpression__OperatorAlternatives_1_1_0) + { after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalVarExpression__Group__0 +rule__RelationalExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__GlobalVarExpression__Group__0__Impl - rule__GlobalVarExpression__Group__1 + ( + { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + ruleAdditiveExpression + { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__0__Impl +rule__AdditiveExpression__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } - 'GLOBALVAR' - { after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } -) + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + (rule__AdditiveExpression__NameAlternatives_1_1_0) + { after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__1 +rule__AdditiveExpression__ParamsAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__GlobalVarExpression__Group__1__Impl + ( + { before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + ruleMultiplicativeExpression + { after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__1__Impl +rule__MultiplicativeExpression__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } - (rule__GlobalVarExpression__NameAssignment_1) - { after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } -) + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + (rule__MultiplicativeExpression__NameAlternatives_1_1_0) + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group__0 +rule__MultiplicativeExpression__ParamsAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__0__Impl - rule__OperationCall__Group__1 + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + ruleUnaryOrInfixExpression + { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__0__Impl +rule__UnaryExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } - (rule__OperationCall__NameAssignment_0) - { after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + (rule__UnaryExpression__NameAlternatives_0_0) + { after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__1 +rule__UnaryExpression__ParamsAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__1__Impl - rule__OperationCall__Group__2 + ( + { before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + ruleInfixExpression + { after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__1__Impl +rule__InfixExpression__NameAssignment_1_0_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + ruleIdentifier + { after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__2 +rule__InfixExpression__ParamsAssignment_1_0_4_0 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__2__Impl - rule__OperationCall__Group__3 + ( + { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__2__Impl +rule__InfixExpression__ParamsAssignment_1_0_4_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getGroup_2()); } - (rule__OperationCall__Group_2__0)? - { after(grammarAccess.getOperationCallAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__3 +rule__InfixExpression__TypeAssignment_1_1_2 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__3__Impl + ( + { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + ruleType + { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__3__Impl +rule__InfixExpression__NameAssignment_1_2_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } - ')' - { after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ( + { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + 'typeSelect' + { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ) + { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group_2__0 +rule__InfixExpression__TypeAssignment_1_2_4 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2__0__Impl - rule__OperationCall__Group_2__1 + ( + { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + ruleType + { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__0__Impl +rule__InfixExpression__NameAssignment_1_3_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } - (rule__OperationCall__ParamsAssignment_2_0) - { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + (rule__InfixExpression__NameAlternatives_1_3_2_0) + { after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__1 +rule__InfixExpression__VarAssignment_1_3_4_0 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2__1__Impl + ( + { before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + ruleIdentifier + { after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__1__Impl +rule__InfixExpression__ExpAssignment_1_3_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getGroup_2_1()); } - (rule__OperationCall__Group_2_1__0)* - { after(grammarAccess.getOperationCallAccess().getGroup_2_1()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group_2_1__0 +rule__BooleanLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2_1__0__Impl - rule__OperationCall__Group_2_1__1 + ( + { before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + (rule__BooleanLiteral__ValAlternatives_0) + { after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__0__Impl +rule__IntegerLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } - ',' - { after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } -) + ( + { before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + RULE_INT + { after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__1 +rule__NullLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2_1__1__Impl + ( + { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ( + { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + 'null' + { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ) + { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__1__Impl +rule__RealLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } - (rule__OperationCall__ParamsAssignment_2_1_1) - { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } -) + ( + { before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + RULE_REAL + { after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group__0 +rule__StringLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__0__Impl - rule__ListLiteral__Group__1 + ( + { before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + RULE_STRING + { after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__0__Impl +rule__GlobalVarExpression__NameAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } - () - { after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } -) + ( + { before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__1 +rule__FeatureCall__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__1__Impl - rule__ListLiteral__Group__2 + ( + { before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + ruleType + { after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__1__Impl +rule__OperationCall__NameAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } -) + ( + { before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__2 +rule__OperationCall__ParamsAssignment_2_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__2__Impl - rule__ListLiteral__Group__3 + ( + { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__2__Impl +rule__OperationCall__ParamsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getGroup_2()); } - (rule__ListLiteral__Group_2__0)? - { after(grammarAccess.getListLiteralAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + ruleExpression + { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__3 +rule__ListLiteral__ElementsAssignment_2_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__3__Impl + ( + { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__3__Impl +rule__ListLiteral__ElementsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } - '}' - { after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } -) + ( + { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + ruleExpression + { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group_2__0 +rule__ConstructorCallExpression__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2__0__Impl - rule__ListLiteral__Group_2__1 + ( + { before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + ruleSimpleType + { after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__0__Impl +rule__TypeSelectExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } - (rule__ListLiteral__ElementsAssignment_2_0) - { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } -) + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + 'typeSelect' + { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ) + { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__1 +rule__TypeSelectExpression__TypeAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2__1__Impl + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + ruleType + { after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__1__Impl +rule__CollectionExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getGroup_2_1()); } - (rule__ListLiteral__Group_2_1__0)* - { after(grammarAccess.getListLiteralAccess().getGroup_2_1()); } -) + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + (rule__CollectionExpression__NameAlternatives_0_0) + { after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group_2_1__0 +rule__CollectionExpression__VarAssignment_2_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2_1__0__Impl - rule__ListLiteral__Group_2_1__1 + ( + { before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + ruleIdentifier + { after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__0__Impl +rule__CollectionExpression__ExpAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } - ',' - { after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } -) + ( + { before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__1 +rule__CollectionType__ClAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2_1__1__Impl + ( + { before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + (rule__CollectionType__ClAlternatives_0_0) + { after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__1__Impl +rule__CollectionType__Id1Assignment_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } - (rule__ListLiteral__ElementsAssignment_2_1_1) - { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } -) + ( + { before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + ruleSimpleType + { after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ConstructorCallExpression__Group__0 +rule__SimpleType__IdAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__ConstructorCallExpression__Group__0__Impl - rule__ConstructorCallExpression__Group__1 + ( + { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__0__Impl +rule__SimpleType__IdAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } - 'new' - { after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } -) + ( + { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + ruleIdentifier + { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__1 +rule__XAssignment__FeatureAssignment_0_1 @init { int stackSize = keepStackSize(); } : - rule__ConstructorCallExpression__Group__1__Impl + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); } + ruleFeatureCallID + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__1__Impl +rule__XAssignment__ValueAssignment_0_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } - (rule__ConstructorCallExpression__TypeAssignment_1) - { after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } -) + ( + { before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); } + ruleXAssignment + { after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__TypeSelectExpression__Group__0 +rule__XAssignment__FeatureAssignment_1_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__0__Impl - rule__TypeSelectExpression__Group__1 + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); } + ruleOpMultiAssign + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__0__Impl +rule__XAssignment__RightOperandAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } - (rule__TypeSelectExpression__NameAssignment_0) - { after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); } + ruleXAssignment + { after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__1 +rule__XOrExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__1__Impl - rule__TypeSelectExpression__Group__2 + ( + { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); } + ruleOpOr + { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__1__Impl +rule__XOrExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); } + ruleXAndExpression + { after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__2 +rule__XAndExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__2__Impl - rule__TypeSelectExpression__Group__3 + ( + { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); } + ruleOpAnd + { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__2__Impl +rule__XAndExpression__RightOperandAssignment_1_1 @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } - (rule__TypeSelectExpression__TypeAssignment_2) - { after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } -) + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); } + ruleXEqualityExpression + { after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__3 +rule__XEqualityExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__3__Impl + ( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); } + ruleOpEquality + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__3__Impl +rule__XEqualityExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } - ')' - { after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } -) + ( + { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); } + ruleXRelationalExpression + { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionExpression__Group__0 +rule__XRelationalExpression__TypeAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__0__Impl - rule__CollectionExpression__Group__1 + ( + { before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__0__Impl +rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } - (rule__CollectionExpression__NameAssignment_0) - { after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); } + ruleOpCompare + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__1 +rule__XRelationalExpression__RightOperandAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__1__Impl - rule__CollectionExpression__Group__2 + ( + { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); } + ruleXOtherOperatorExpression + { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__1__Impl +rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); } + ruleOpOther + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__2 +rule__XOtherOperatorExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__2__Impl - rule__CollectionExpression__Group__3 + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); } + ruleXAdditiveExpression + { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__2__Impl +rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } - (rule__CollectionExpression__Group_2__0)? - { after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); } + ruleOpAdd + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__3 +rule__XAdditiveExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__3__Impl - rule__CollectionExpression__Group__4 + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); } + ruleXMultiplicativeExpression + { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__3__Impl +rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } - (rule__CollectionExpression__ExpAssignment_3) - { after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } -) + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); } + ruleOpMulti + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__4 +rule__XMultiplicativeExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__4__Impl + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__4__Impl +rule__XUnaryOperation__FeatureAssignment_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } - ')' - { after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } -) + ( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); } + ruleOpUnary + { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionExpression__Group_2__0 +rule__XUnaryOperation__OperandAssignment_0_2 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group_2__0__Impl - rule__CollectionExpression__Group_2__1 + ( + { before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__0__Impl +rule__XCastedExpression__TypeAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } - (rule__CollectionExpression__VarAssignment_2_0) - { after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } -) + ( + { before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__1 +rule__XPostfixOperation__FeatureAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group_2__1__Impl + ( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); } + ( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); } + ruleOpPostfix + { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); } + ) + { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__1__Impl +rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } - '|' - { after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + '::' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionType__Group__0 +rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__0__Impl - rule__CollectionType__Group__1 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); } + ruleFeatureCallID + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__0__Impl +rule__XMemberFeatureCall__ValueAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } - (rule__CollectionType__ClAssignment_0) - { after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); } + ruleXAssignment + { after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__1 +rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__1__Impl - rule__CollectionType__Group__2 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + '?.' + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__1__Impl +rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } - '[' - { after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + '::' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__2 +rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__2__Impl - rule__CollectionType__Group__3 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__2__Impl +rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } - (rule__CollectionType__Id1Assignment_2) - { after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__3 +rule__XMemberFeatureCall__FeatureAssignment_1_1_2 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__3__Impl + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); } + ruleIdOrSuper + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__3__Impl +rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } - ']' - { after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + '(' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__SimpleType__Group__0 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group__0__Impl - rule__SimpleType__Group__1 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__0__Impl +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } - (rule__SimpleType__IdAssignment_0) - { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__1 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group__1__Impl + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__1__Impl +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getGroup_1()); } - (rule__SimpleType__Group_1__0)* - { after(grammarAccess.getSimpleTypeAccess().getGroup_1()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); } + ruleXClosure + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__SimpleType__Group_1__0 +rule__XSetLiteral__ElementsAssignment_3_0 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group_1__0__Impl - rule__SimpleType__Group_1__1 + ( + { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ruleXExpression + { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__0__Impl +rule__XSetLiteral__ElementsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } - '::' - { after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } -) + ( + { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__1 +rule__XListLiteral__ElementsAssignment_3_0 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group_1__1__Impl + ( + { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ruleXExpression + { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__1__Impl +rule__XListLiteral__ElementsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } - (rule__SimpleType__IdAssignment_1_1) - { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } -) + ( + { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ExportModel__ExtensionAssignment_0_1 +rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } - ( - { before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } - 'extension' - { after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } - ) - { after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); } + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__NameAssignment_0_2 +rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); } - RULE_ID - { after(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); } + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__TargetGrammarAssignment_0_4 +rule__XClosure__ExplicitSyntaxAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); } + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } ( - { before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); } - ruleQualifiedID - { after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); } + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } + '|' + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } ) - { after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); } + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__ImportsAssignment_1 +rule__XClosure__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); } - ruleImport - { after(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); } + { before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); } + ruleXExpressionInClosure + { after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__ExtensionsAssignment_2 +rule__XExpressionInClosure__ExpressionsAssignment_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); } - ruleExtension - { after(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); } + { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__InterfacesAssignment_3_2 +rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); } - ruleInterface - { after(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); } + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ExportModel__ExportsAssignment_4 +rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); } - ruleExport - { after(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); } + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__PackageAssignment_1 +rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } ( - { before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } - RULE_STRING - { after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + '|' + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } ) - { after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__NameAssignment_2_1 +rule__XShortClosure__ExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); } - RULE_ID - { after(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); } + { before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Extension__ExtensionAssignment_1 +rule__XIfExpression__IfAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } - ruleQualifiedID - { after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } + { before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__TypeAssignment_0 +rule__XIfExpression__ThenAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); } - ( - { before(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } - ruleQualifiedID - { after(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } - ) - { after(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); } + { before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__GuardAssignment_1_1 +rule__XIfExpression__ElseAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); } - ruleExpression - { after(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); } + { before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__ItemsAssignment_2_1 +rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); } - ruleInterfaceItem - { after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Interface__ItemsAssignment_2_2_1 +rule__XSwitchExpression__SwitchAssignment_2_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); } - ruleInterfaceItem - { after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceField__UnorderedAssignment_0 +rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } - ( - { before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } - '+' - { after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } - ) - { after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceField__FieldAssignment_1 +rule__XSwitchExpression__SwitchAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); } - ( - { before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); } - RULE_ID - { after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); } - ) - { after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__UnorderedAssignment_1 +rule__XSwitchExpression__CasesAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } - ( - { before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } - '+' - { after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } - ) - { after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); } + ruleXCasePart + { after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceNavigation__RefAssignment_2 +rule__XSwitchExpression__DefaultAssignment_5_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); } - ( - { before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); } - RULE_ID - { after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); } - ) - { after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__RefAssignment_1 +rule__XCasePart__TypeGuardAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } - ( - { before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } - '@' - { after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } - ) - { after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); } + { before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__UnorderedAssignment_2 +rule__XCasePart__CaseAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } - ( - { before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } - '+' - { after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } - ) - { after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); } + { before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); } + ruleXExpression + { after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InterfaceExpression__ExprAssignment_4 +rule__XCasePart__ThenAssignment_3_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); } - ruleExpression - { after(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); } + { before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); } + ruleXExpression + { after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__LookupAssignment_1_0 +rule__XCasePart__FallThroughAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } ( - { before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } - 'lookup' - { after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } ) - { after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); } + { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__LookupPredicateAssignment_1_1_1 +rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); } - ruleExpression - { after(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__TypeAssignment_2 +rule__XForLoopExpression__ForExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); } - ( - { before(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } - ruleQualifiedID - { after(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } - ) - { after(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__QualifiedNameAssignment_3_1 +rule__XForLoopExpression__EachExpressionAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } - ( - { before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } - 'qualified' - { after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } - ) - { after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__NamingAssignment_3_2 +rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); } - ruleExpression - { after(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__GuardAssignment_4_1 +rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); } - ruleExpression - { after(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__FragmentUniqueAssignment_6_2 +rule__XBasicForLoopExpression__ExpressionAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } - ( - { before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } - 'unique' - { after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } - ) - { after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__FragmentAttributeAssignment_6_5 +rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); } - ( - { before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); } - RULE_ID - { after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); } - ) - { after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__FingerprintAssignment_7_0_0 +rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } - ( - { before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } - 'object-fingerprint' - { after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } - ) - { after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__ResourceFingerprintAssignment_7_0_1 +rule__XBasicForLoopExpression__EachExpressionAssignment_9 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } - ( - { before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } - 'resource-fingerprint' - { after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } - ) - { after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__AttributesAssignment_8_0_1 +rule__XWhileExpression__PredicateAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); } - ruleAttribute - { after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); } + { before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__AttributesAssignment_8_0_2_1 +rule__XWhileExpression__BodyAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); } - ruleAttribute - { after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); } + { before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__UserDataAssignment_8_1_1 +rule__XDoWhileExpression__BodyAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); } - ruleUserData - { after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Export__UserDataAssignment_8_1_2_1 +rule__XDoWhileExpression__PredicateAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); } - ruleUserData - { after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UserData__NameAssignment_0 +rule__XBlockExpression__ExpressionsAssignment_2_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); } - RULE_ID - { after(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); } + { before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UserData__ExprAssignment_2 +rule__XVariableDeclaration__WriteableAssignment_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); } - ruleExpression - { after(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + ( + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + 'var' + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + ) + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Attribute__AttributeAssignment +rule__XVariableDeclaration__TypeAssignment_2_0_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); } - ( - { before(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); } - RULE_ID - { after(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); } - ) - { after(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__IdentifierAssignment_1 +rule__XVariableDeclaration__NameAssignment_2_0_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); } + ruleValidID + { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__VarExprAssignment_3 +rule__XVariableDeclaration__NameAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); } + ruleValidID + { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__TargetAssignment_5 +rule__XVariableDeclaration__RightAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } - ruleExpression - { after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); } + ruleXExpression + { after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__TypeAssignment_1 +rule__JvmFormalParameter__ParameterTypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } - ruleType - { after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__TargetAssignment_3 +rule__JvmFormalParameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } + ruleValidID + { after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__NextAssignment_1_2 +rule__FullJvmFormalParameter__ParameterTypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } - ruleChainedExpression - { after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__ThenPartAssignment_1_2 +rule__FullJvmFormalParameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } + ruleValidID + { after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__ElsePartAssignment_1_4 +rule__XFeatureCall__TypeArgumentsAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ConditionAssignment_1 +rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ThenPartAssignment_3 +rule__XFeatureCall__FeatureAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); } + ruleIdOrSuper + { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + '(' + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + ) + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ElsePartAssignment_4_0_1 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__SwitchExprAssignment_1_1 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } - ruleOrExpression - { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__CaseAssignment_3 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } - ruleCase - { after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__DefaultExprAssignment_6 +rule__XFeatureCall__FeatureCallArgumentsAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } - ruleOrExpression - { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); } + ruleXClosure + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__ConditionAssignment_1 +rule__XConstructorCall__ConstructorAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } - ruleOrExpression - { after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); } + ( + { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__ThenParAssignment_3 +rule__XConstructorCall__TypeArgumentsAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } - ruleOrExpression - { after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__OperatorAssignment_1_1 +rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - ( - { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - '||' - { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - ) - { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__RightAssignment_1_2 +rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } - ruleAndExpression - { after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + ( + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + '(' + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + ) + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__OperatorAssignment_1_1 +rule__XConstructorCall__ArgumentsAssignment_4_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - '&&' - { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - ) - { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__RightAssignment_1_2 +rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } - ruleImpliesExpression - { after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__OperatorAssignment_1_1 +rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - 'implies' - { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - ) - { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__RightAssignment_1_2 +rule__XConstructorCall__ArgumentsAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } - ruleRelationalExpression - { after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); } + ruleXClosure + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAssignment_1_1 +rule__XBooleanLiteral__IsTrueAssignment_1_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.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + ( + { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + 'true' + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + ) + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__RightAssignment_1_2 +rule__XNumberLiteral__ValueAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); } + ruleNumber + { after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__NameAssignment_1_1 +rule__XStringLiteral__ValueAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } - (rule__AdditiveExpression__NameAlternatives_1_1_0) - { after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + { before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); } + RULE_STRING + { after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__ParamsAssignment_1_2 +rule__XTypeLiteral__TypeAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); } + ( + { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); } + ) + { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__NameAssignment_1_1 +rule__XTypeLiteral__ArrayDimensionsAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } - (rule__MultiplicativeExpression__NameAlternatives_1_1_0) - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); } + ruleArrayBrackets + { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__ParamsAssignment_1_2 +rule__XThrowExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } - ruleUnaryOrInfixExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__NameAssignment_0 +rule__XReturnExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } - (rule__UnaryExpression__NameAlternatives_0_0) - { after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + { before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__ParamsAssignment_1 +rule__XTryCatchFinallyExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } - ruleInfixExpression - { after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_0_2 +rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } - ruleIdentifier - { after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); } + ruleXCatchClause + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ParamsAssignment_1_0_4_0 +rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ParamsAssignment_1_0_4_1_1 +rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__TypeAssignment_1_1_2 +rule__XSynchronizedExpression__ParamAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } - ruleType - { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_2_2 +rule__XSynchronizedExpression__ExpressionAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - ( - { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - 'typeSelect' - { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - ) - { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__TypeAssignment_1_2_4 +rule__XCatchClause__DeclaredParamAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } - ruleType - { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); } + ruleFullJvmFormalParameter + { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_3_2 +rule__XCatchClause__ExpressionAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } - (rule__InfixExpression__NameAlternatives_1_3_2_0) - { after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + { before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); } + ruleXExpression + { after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__VarAssignment_1_3_4_0 +rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } - ruleIdentifier - { after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ExpAssignment_1_3_5 +rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__BooleanLiteral__ValAssignment +rule__XFunctionTypeRef__ReturnTypeAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } - (rule__BooleanLiteral__ValAlternatives_0) - { after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IntegerLiteral__ValAssignment +rule__JvmParameterizedTypeReference__TypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } - RULE_INT - { after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); } + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NullLiteral__ValAssignment +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - ( - { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - 'null' - { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - ) - { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RealLiteral__ValAssignment +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } - RULE_REAL - { after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__StringLiteral__ValAssignment +rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } - RULE_STRING - { after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); } + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); } + ruleValidID + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); } + ) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__NameAssignment_1 +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__FeatureCall__TypeAssignment_1 +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } - ruleType - { after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__NameAssignment_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); } + ruleJvmUpperBound + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__ParamsAssignment_2_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); } + ruleJvmUpperBoundAnded + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__ParamsAssignment_2_1_1 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } - ruleExpression - { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); } + ruleJvmLowerBound + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__ElementsAssignment_2_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); } + ruleJvmLowerBoundAnded + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__ElementsAssignment_2_1_1 +rule__JvmUpperBound__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } - ruleExpression - { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__TypeAssignment_1 +rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } - ruleSimpleType - { after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__NameAssignment_0 +rule__JvmLowerBound__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - ( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - 'typeSelect' - { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - ) - { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__TypeAssignment_2 +rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } - ruleType - { after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__NameAssignment_0 +rule__XImportDeclaration__StaticAssignment_1_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } - (rule__CollectionExpression__NameAlternatives_0_0) - { after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + 'static' + { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__VarAssignment_2_0 +rule__XImportDeclaration__ExtensionAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } - ruleIdentifier - { after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + 'extension' + { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__ExpAssignment_3 +rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); } + ruleQualifiedNameInStaticImport + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__ClAssignment_0 +rule__XImportDeclaration__WildcardAssignment_1_0_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } - (rule__CollectionType__ClAlternatives_0_0) - { after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + '*' + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Id1Assignment_2 +rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } - ruleSimpleType - { after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); } + ruleValidID + { after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__IdAssignment_0 +rule__XImportDeclaration__ImportedTypeAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__IdAssignment_1_1 +rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } - ruleIdentifier - { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); } + ruleQualifiedNameWithWildcard + { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); } ) ; finally { @@ -10025,11 +26872,15 @@ finally { RULE_REAL : ('0'..'9')* '.' ('0'..'9')*; -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; +RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?; + +RULE_INT : '0'..'9' ('0'..'9'|'_')*; + +RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?; -RULE_INT : ('0'..'9')+; +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; diff --git a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.tokens b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.tokens index 9fa2ec9d9b..3512ca877f 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.tokens +++ b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExport.tokens @@ -1,83 +1,135 @@ -'!'=22 -'!='=13 -'&&'=78 -'('=51 -')'=52 -'*'=20 -'+'=18 -','=48 -'-'=19 -'->'=60 -'.'=68 -'/'=21 -':'=59 -'::'=57 -';'=44 -'<'=17 -'<='=15 -'='=47 -'=='=12 -'>'=16 -'>='=14 -'?'=61 -'@'=49 -'Collection'=33 -'GLOBALVAR'=70 -'List'=34 -'Set'=35 -'['=45 -']'=46 -'as'=42 -'attribute'=54 -'case'=67 -'collect'=23 -'data'=56 -'default'=66 -'else'=64 -'eval'=50 -'exists'=27 -'export'=36 -'extension'=43 -'false'=32 -'field'=55 -'for'=37 -'forAll'=30 -'if'=62 -'implies'=79 -'import'=41 -'interface'=38 -'let'=58 -'lookup'=72 -'new'=71 -'notExists'=28 -'null'=81 -'object-fingerprint'=75 -'qualified'=73 -'reject'=26 -'resource-fingerprint'=76 -'select'=24 -'selectFirst'=25 -'sortBy'=29 -'switch'=65 -'then'=63 -'true'=31 -'typeSelect'=80 -'unique'=74 -'uri-fragment'=53 -'{'=39 -'|'=69 -'||'=77 -'}'=40 -RULE_ANY_OTHER=11 +'!'=27 +'!='=18 +'!=='=47 +'#'=97 +'%'=55 +'%='=45 +'&&'=16 +'&'=108 +'('=77 +')'=78 +'*'=25 +'**'=54 +'*='=43 +'+'=23 +'++'=56 +'+='=41 +','=74 +'-'=24 +'--'=57 +'-='=42 +'->'=48 +'.'=58 +'..'=50 +'..<'=49 +'/'=26 +'/='=44 +':'=85 +'::'=83 +';'=71 +'<'=22 +'<='=20 +'<>'=52 +'='=14 +'=='=17 +'==='=46 +'=>'=51 +'>'=21 +'>='=19 +'?'=86 +'?.'=116 +'?:'=53 +'@'=75 +'Collection'=38 +'GLOBALVAR'=94 +'List'=39 +'Set'=40 +'['=72 +']'=73 +'as'=70 +'attribute'=80 +'case'=92 +'catch'=107 +'collect'=28 +'data'=82 +'default'=91 +'do'=99 +'else'=89 +'eval'=76 +'exists'=32 +'export'=65 +'extends'=60 +'extension'=63 +'false'=37 +'field'=81 +'finally'=105 +'for'=66 +'forAll'=35 +'if'=87 +'implies'=114 +'import'=62 +'instanceof'=96 +'interface'=67 +'let'=84 +'lookup'=109 +'new'=95 +'notExists'=33 +'null'=100 +'object-fingerprint'=112 +'qualified'=110 +'reject'=31 +'resource-fingerprint'=113 +'return'=103 +'select'=29 +'selectFirst'=30 +'sortBy'=34 +'static'=61 +'super'=64 +'switch'=90 +'synchronized'=106 +'then'=88 +'throw'=102 +'true'=36 +'try'=104 +'typeSelect'=115 +'typeof'=101 +'unique'=111 +'uri-fragment'=79 +'val'=59 +'var'=117 +'while'=98 +'{'=68 +'|'=93 +'||'=15 +'}'=69 +RULE_ANY_OTHER=13 +RULE_DECIMAL=7 +RULE_HEX=5 RULE_ID=4 RULE_INT=6 -RULE_ML_COMMENT=8 -RULE_REAL=7 -RULE_SL_COMMENT=9 -RULE_STRING=5 -RULE_WS=10 -T__12=12 -T__13=13 +RULE_ML_COMMENT=10 +RULE_REAL=9 +RULE_SL_COMMENT=11 +RULE_STRING=8 +RULE_WS=12 +T__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 +T__105=105 +T__106=106 +T__107=107 +T__108=108 +T__109=109 +T__110=110 +T__111=111 +T__112=112 +T__113=113 +T__114=114 +T__115=115 +T__116=116 +T__117=117 T__14=14 T__15=15 T__16=16 @@ -146,3 +198,21 @@ T__78=78 T__79=79 T__80=80 T__81=81 +T__82=82 +T__83=83 +T__84=84 +T__85=85 +T__86=86 +T__87=87 +T__88=88 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportLexer.java b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportLexer.java index 289bb2f5fc..4f9ba5f886 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportLexer.java +++ b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportLexer.java @@ -12,19 +12,12 @@ @SuppressWarnings("all") public class InternalExportLexer extends Lexer { + public static final int RULE_HEX=5; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -33,54 +26,27 @@ public class InternalExportLexer extends Lexer { public static final int T__60=60; public static final int T__61=61; public static final int RULE_ID=4; - public static final int RULE_REAL=7; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; + public static final int RULE_REAL=9; public static final int RULE_INT=6; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=5; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -91,6 +57,76 @@ public class InternalExportLexer extends Lexer { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=8; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -105,58 +141,15 @@ public InternalExportLexer(CharStream input, RecognizerSharedState state) { } public String getGrammarFileName() { return "InternalExport.g"; } - // $ANTLR start "T__12" - public final void mT__12() throws RecognitionException { - try { - int _type = T__12; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:11:7: ( '==' ) - // InternalExport.g:11:9: '==' - { - match("=="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__12" - - // $ANTLR start "T__13" - public final void mT__13() throws RecognitionException { - try { - int _type = T__13; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:12:7: ( '!=' ) - // InternalExport.g:12:9: '!=' - { - match("!="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__13" - // $ANTLR start "T__14" public final void mT__14() throws RecognitionException { try { int _type = T__14; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:13:7: ( '>=' ) - // InternalExport.g:13:9: '>=' + // InternalExport.g:11:7: ( '=' ) + // InternalExport.g:11:9: '=' { - match(">="); - + match('='); } @@ -173,10 +166,10 @@ public final void mT__15() throws RecognitionException { try { int _type = T__15; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:14:7: ( '<=' ) - // InternalExport.g:14:9: '<=' + // InternalExport.g:12:7: ( '||' ) + // InternalExport.g:12:9: '||' { - match("<="); + match("||"); } @@ -194,10 +187,11 @@ public final void mT__16() throws RecognitionException { try { int _type = T__16; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:15:7: ( '>' ) - // InternalExport.g:15:9: '>' + // InternalExport.g:13:7: ( '&&' ) + // InternalExport.g:13:9: '&&' { - match('>'); + match("&&"); + } @@ -214,10 +208,11 @@ public final void mT__17() throws RecognitionException { try { int _type = T__17; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:16:7: ( '<' ) - // InternalExport.g:16:9: '<' + // InternalExport.g:14:7: ( '==' ) + // InternalExport.g:14:9: '==' { - match('<'); + match("=="); + } @@ -234,10 +229,11 @@ public final void mT__18() throws RecognitionException { try { int _type = T__18; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:17:7: ( '+' ) - // InternalExport.g:17:9: '+' + // InternalExport.g:15:7: ( '!=' ) + // InternalExport.g:15:9: '!=' { - match('+'); + match("!="); + } @@ -254,10 +250,11 @@ public final void mT__19() throws RecognitionException { try { int _type = T__19; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:18:7: ( '-' ) - // InternalExport.g:18:9: '-' + // InternalExport.g:16:7: ( '>=' ) + // InternalExport.g:16:9: '>=' { - match('-'); + match(">="); + } @@ -274,10 +271,11 @@ public final void mT__20() throws RecognitionException { try { int _type = T__20; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:19:7: ( '*' ) - // InternalExport.g:19:9: '*' + // InternalExport.g:17:7: ( '<=' ) + // InternalExport.g:17:9: '<=' { - match('*'); + match("<="); + } @@ -294,10 +292,10 @@ public final void mT__21() throws RecognitionException { try { int _type = T__21; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:20:7: ( '/' ) - // InternalExport.g:20:9: '/' + // InternalExport.g:18:7: ( '>' ) + // InternalExport.g:18:9: '>' { - match('/'); + match('>'); } @@ -314,10 +312,10 @@ public final void mT__22() throws RecognitionException { try { int _type = T__22; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:21:7: ( '!' ) - // InternalExport.g:21:9: '!' + // InternalExport.g:19:7: ( '<' ) + // InternalExport.g:19:9: '<' { - match('!'); + match('<'); } @@ -334,11 +332,10 @@ public final void mT__23() throws RecognitionException { try { int _type = T__23; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:22:7: ( 'collect' ) - // InternalExport.g:22:9: 'collect' + // InternalExport.g:20:7: ( '+' ) + // InternalExport.g:20:9: '+' { - match("collect"); - + match('+'); } @@ -355,11 +352,10 @@ public final void mT__24() throws RecognitionException { try { int _type = T__24; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:23:7: ( 'select' ) - // InternalExport.g:23:9: 'select' + // InternalExport.g:21:7: ( '-' ) + // InternalExport.g:21:9: '-' { - match("select"); - + match('-'); } @@ -376,11 +372,10 @@ public final void mT__25() throws RecognitionException { try { int _type = T__25; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:24:7: ( 'selectFirst' ) - // InternalExport.g:24:9: 'selectFirst' + // InternalExport.g:22:7: ( '*' ) + // InternalExport.g:22:9: '*' { - match("selectFirst"); - + match('*'); } @@ -397,11 +392,10 @@ public final void mT__26() throws RecognitionException { try { int _type = T__26; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:25:7: ( 'reject' ) - // InternalExport.g:25:9: 'reject' + // InternalExport.g:23:7: ( '/' ) + // InternalExport.g:23:9: '/' { - match("reject"); - + match('/'); } @@ -418,11 +412,10 @@ public final void mT__27() throws RecognitionException { try { int _type = T__27; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:26:7: ( 'exists' ) - // InternalExport.g:26:9: 'exists' + // InternalExport.g:24:7: ( '!' ) + // InternalExport.g:24:9: '!' { - match("exists"); - + match('!'); } @@ -439,10 +432,10 @@ public final void mT__28() throws RecognitionException { try { int _type = T__28; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:27:7: ( 'notExists' ) - // InternalExport.g:27:9: 'notExists' + // InternalExport.g:25:7: ( 'collect' ) + // InternalExport.g:25:9: 'collect' { - match("notExists"); + match("collect"); } @@ -460,10 +453,10 @@ public final void mT__29() throws RecognitionException { try { int _type = T__29; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:28:7: ( 'sortBy' ) - // InternalExport.g:28:9: 'sortBy' + // InternalExport.g:26:7: ( 'select' ) + // InternalExport.g:26:9: 'select' { - match("sortBy"); + match("select"); } @@ -481,10 +474,10 @@ public final void mT__30() throws RecognitionException { try { int _type = T__30; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:29:7: ( 'forAll' ) - // InternalExport.g:29:9: 'forAll' + // InternalExport.g:27:7: ( 'selectFirst' ) + // InternalExport.g:27:9: 'selectFirst' { - match("forAll"); + match("selectFirst"); } @@ -502,10 +495,10 @@ public final void mT__31() throws RecognitionException { try { int _type = T__31; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:30:7: ( 'true' ) - // InternalExport.g:30:9: 'true' + // InternalExport.g:28:7: ( 'reject' ) + // InternalExport.g:28:9: 'reject' { - match("true"); + match("reject"); } @@ -523,10 +516,10 @@ public final void mT__32() throws RecognitionException { try { int _type = T__32; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:31:7: ( 'false' ) - // InternalExport.g:31:9: 'false' + // InternalExport.g:29:7: ( 'exists' ) + // InternalExport.g:29:9: 'exists' { - match("false"); + match("exists"); } @@ -544,10 +537,10 @@ public final void mT__33() throws RecognitionException { try { int _type = T__33; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:32:7: ( 'Collection' ) - // InternalExport.g:32:9: 'Collection' + // InternalExport.g:30:7: ( 'notExists' ) + // InternalExport.g:30:9: 'notExists' { - match("Collection"); + match("notExists"); } @@ -565,10 +558,10 @@ public final void mT__34() throws RecognitionException { try { int _type = T__34; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:33:7: ( 'List' ) - // InternalExport.g:33:9: 'List' + // InternalExport.g:31:7: ( 'sortBy' ) + // InternalExport.g:31:9: 'sortBy' { - match("List"); + match("sortBy"); } @@ -586,10 +579,10 @@ public final void mT__35() throws RecognitionException { try { int _type = T__35; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:34:7: ( 'Set' ) - // InternalExport.g:34:9: 'Set' + // InternalExport.g:32:7: ( 'forAll' ) + // InternalExport.g:32:9: 'forAll' { - match("Set"); + match("forAll"); } @@ -607,10 +600,10 @@ public final void mT__36() throws RecognitionException { try { int _type = T__36; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:35:7: ( 'export' ) - // InternalExport.g:35:9: 'export' + // InternalExport.g:33:7: ( 'true' ) + // InternalExport.g:33:9: 'true' { - match("export"); + match("true"); } @@ -628,10 +621,10 @@ public final void mT__37() throws RecognitionException { try { int _type = T__37; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:36:7: ( 'for' ) - // InternalExport.g:36:9: 'for' + // InternalExport.g:34:7: ( 'false' ) + // InternalExport.g:34:9: 'false' { - match("for"); + match("false"); } @@ -649,10 +642,10 @@ public final void mT__38() throws RecognitionException { try { int _type = T__38; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:37:7: ( 'interface' ) - // InternalExport.g:37:9: 'interface' + // InternalExport.g:35:7: ( 'Collection' ) + // InternalExport.g:35:9: 'Collection' { - match("interface"); + match("Collection"); } @@ -670,10 +663,11 @@ public final void mT__39() throws RecognitionException { try { int _type = T__39; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:38:7: ( '{' ) - // InternalExport.g:38:9: '{' + // InternalExport.g:36:7: ( 'List' ) + // InternalExport.g:36:9: 'List' { - match('{'); + match("List"); + } @@ -690,10 +684,11 @@ public final void mT__40() throws RecognitionException { try { int _type = T__40; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:39:7: ( '}' ) - // InternalExport.g:39:9: '}' + // InternalExport.g:37:7: ( 'Set' ) + // InternalExport.g:37:9: 'Set' { - match('}'); + match("Set"); + } @@ -710,10 +705,10 @@ public final void mT__41() throws RecognitionException { try { int _type = T__41; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:40:7: ( 'import' ) - // InternalExport.g:40:9: 'import' + // InternalExport.g:38:7: ( '+=' ) + // InternalExport.g:38:9: '+=' { - match("import"); + match("+="); } @@ -731,10 +726,10 @@ public final void mT__42() throws RecognitionException { try { int _type = T__42; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:41:7: ( 'as' ) - // InternalExport.g:41:9: 'as' + // InternalExport.g:39:7: ( '-=' ) + // InternalExport.g:39:9: '-=' { - match("as"); + match("-="); } @@ -752,10 +747,10 @@ public final void mT__43() throws RecognitionException { try { int _type = T__43; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:42:7: ( 'extension' ) - // InternalExport.g:42:9: 'extension' + // InternalExport.g:40:7: ( '*=' ) + // InternalExport.g:40:9: '*=' { - match("extension"); + match("*="); } @@ -773,10 +768,11 @@ public final void mT__44() throws RecognitionException { try { int _type = T__44; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:43:7: ( ';' ) - // InternalExport.g:43:9: ';' + // InternalExport.g:41:7: ( '/=' ) + // InternalExport.g:41:9: '/=' { - match(';'); + match("/="); + } @@ -793,10 +789,11 @@ public final void mT__45() throws RecognitionException { try { int _type = T__45; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:44:7: ( '[' ) - // InternalExport.g:44:9: '[' + // InternalExport.g:42:7: ( '%=' ) + // InternalExport.g:42:9: '%=' { - match('['); + match("%="); + } @@ -813,10 +810,11 @@ public final void mT__46() throws RecognitionException { try { int _type = T__46; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:45:7: ( ']' ) - // InternalExport.g:45:9: ']' + // InternalExport.g:43:7: ( '===' ) + // InternalExport.g:43:9: '===' { - match(']'); + match("==="); + } @@ -833,10 +831,11 @@ public final void mT__47() throws RecognitionException { try { int _type = T__47; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:46:7: ( '=' ) - // InternalExport.g:46:9: '=' + // InternalExport.g:44:7: ( '!==' ) + // InternalExport.g:44:9: '!==' { - match('='); + match("!=="); + } @@ -853,10 +852,11 @@ public final void mT__48() throws RecognitionException { try { int _type = T__48; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:47:7: ( ',' ) - // InternalExport.g:47:9: ',' + // InternalExport.g:45:7: ( '->' ) + // InternalExport.g:45:9: '->' { - match(','); + match("->"); + } @@ -873,10 +873,11 @@ public final void mT__49() throws RecognitionException { try { int _type = T__49; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:48:7: ( '@' ) - // InternalExport.g:48:9: '@' + // InternalExport.g:46:7: ( '..<' ) + // InternalExport.g:46:9: '..<' { - match('@'); + match("..<"); + } @@ -893,10 +894,10 @@ public final void mT__50() throws RecognitionException { try { int _type = T__50; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:49:7: ( 'eval' ) - // InternalExport.g:49:9: 'eval' + // InternalExport.g:47:7: ( '..' ) + // InternalExport.g:47:9: '..' { - match("eval"); + match(".."); } @@ -914,10 +915,11 @@ public final void mT__51() throws RecognitionException { try { int _type = T__51; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:50:7: ( '(' ) - // InternalExport.g:50:9: '(' + // InternalExport.g:48:7: ( '=>' ) + // InternalExport.g:48:9: '=>' { - match('('); + match("=>"); + } @@ -934,10 +936,11 @@ public final void mT__52() throws RecognitionException { try { int _type = T__52; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:51:7: ( ')' ) - // InternalExport.g:51:9: ')' + // InternalExport.g:49:7: ( '<>' ) + // InternalExport.g:49:9: '<>' { - match(')'); + match("<>"); + } @@ -954,10 +957,10 @@ public final void mT__53() throws RecognitionException { try { int _type = T__53; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:52:7: ( 'uri-fragment' ) - // InternalExport.g:52:9: 'uri-fragment' + // InternalExport.g:50:7: ( '?:' ) + // InternalExport.g:50:9: '?:' { - match("uri-fragment"); + match("?:"); } @@ -975,10 +978,10 @@ public final void mT__54() throws RecognitionException { try { int _type = T__54; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:53:7: ( 'attribute' ) - // InternalExport.g:53:9: 'attribute' + // InternalExport.g:51:7: ( '**' ) + // InternalExport.g:51:9: '**' { - match("attribute"); + match("**"); } @@ -996,11 +999,10 @@ public final void mT__55() throws RecognitionException { try { int _type = T__55; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:54:7: ( 'field' ) - // InternalExport.g:54:9: 'field' + // InternalExport.g:52:7: ( '%' ) + // InternalExport.g:52:9: '%' { - match("field"); - + match('%'); } @@ -1017,10 +1019,10 @@ public final void mT__56() throws RecognitionException { try { int _type = T__56; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:55:7: ( 'data' ) - // InternalExport.g:55:9: 'data' + // InternalExport.g:53:7: ( '++' ) + // InternalExport.g:53:9: '++' { - match("data"); + match("++"); } @@ -1038,10 +1040,10 @@ public final void mT__57() throws RecognitionException { try { int _type = T__57; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:56:7: ( '::' ) - // InternalExport.g:56:9: '::' + // InternalExport.g:54:7: ( '--' ) + // InternalExport.g:54:9: '--' { - match("::"); + match("--"); } @@ -1059,11 +1061,10 @@ public final void mT__58() throws RecognitionException { try { int _type = T__58; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:57:7: ( 'let' ) - // InternalExport.g:57:9: 'let' + // InternalExport.g:55:7: ( '.' ) + // InternalExport.g:55:9: '.' { - match("let"); - + match('.'); } @@ -1080,10 +1081,11 @@ public final void mT__59() throws RecognitionException { try { int _type = T__59; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:58:7: ( ':' ) - // InternalExport.g:58:9: ':' + // InternalExport.g:56:7: ( 'val' ) + // InternalExport.g:56:9: 'val' { - match(':'); + match("val"); + } @@ -1100,10 +1102,10 @@ public final void mT__60() throws RecognitionException { try { int _type = T__60; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:59:7: ( '->' ) - // InternalExport.g:59:9: '->' + // InternalExport.g:57:7: ( 'extends' ) + // InternalExport.g:57:9: 'extends' { - match("->"); + match("extends"); } @@ -1121,10 +1123,11 @@ public final void mT__61() throws RecognitionException { try { int _type = T__61; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:60:7: ( '?' ) - // InternalExport.g:60:9: '?' + // InternalExport.g:58:7: ( 'static' ) + // InternalExport.g:58:9: 'static' { - match('?'); + match("static"); + } @@ -1141,10 +1144,10 @@ public final void mT__62() throws RecognitionException { try { int _type = T__62; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:61:7: ( 'if' ) - // InternalExport.g:61:9: 'if' + // InternalExport.g:59:7: ( 'import' ) + // InternalExport.g:59:9: 'import' { - match("if"); + match("import"); } @@ -1162,10 +1165,10 @@ public final void mT__63() throws RecognitionException { try { int _type = T__63; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:62:7: ( 'then' ) - // InternalExport.g:62:9: 'then' + // InternalExport.g:60:7: ( 'extension' ) + // InternalExport.g:60:9: 'extension' { - match("then"); + match("extension"); } @@ -1183,10 +1186,10 @@ public final void mT__64() throws RecognitionException { try { int _type = T__64; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:63:7: ( 'else' ) - // InternalExport.g:63:9: 'else' + // InternalExport.g:61:7: ( 'super' ) + // InternalExport.g:61:9: 'super' { - match("else"); + match("super"); } @@ -1204,10 +1207,10 @@ public final void mT__65() throws RecognitionException { try { int _type = T__65; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:64:7: ( 'switch' ) - // InternalExport.g:64:9: 'switch' + // InternalExport.g:62:7: ( 'export' ) + // InternalExport.g:62:9: 'export' { - match("switch"); + match("export"); } @@ -1225,10 +1228,10 @@ public final void mT__66() throws RecognitionException { try { int _type = T__66; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:65:7: ( 'default' ) - // InternalExport.g:65:9: 'default' + // InternalExport.g:63:7: ( 'for' ) + // InternalExport.g:63:9: 'for' { - match("default"); + match("for"); } @@ -1246,10 +1249,10 @@ public final void mT__67() throws RecognitionException { try { int _type = T__67; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:66:7: ( 'case' ) - // InternalExport.g:66:9: 'case' + // InternalExport.g:64:7: ( 'interface' ) + // InternalExport.g:64:9: 'interface' { - match("case"); + match("interface"); } @@ -1267,10 +1270,10 @@ public final void mT__68() throws RecognitionException { try { int _type = T__68; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:67:7: ( '.' ) - // InternalExport.g:67:9: '.' + // InternalExport.g:65:7: ( '{' ) + // InternalExport.g:65:9: '{' { - match('.'); + match('{'); } @@ -1287,10 +1290,10 @@ public final void mT__69() throws RecognitionException { try { int _type = T__69; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:68:7: ( '|' ) - // InternalExport.g:68:9: '|' + // InternalExport.g:66:7: ( '}' ) + // InternalExport.g:66:9: '}' { - match('|'); + match('}'); } @@ -1307,10 +1310,10 @@ public final void mT__70() throws RecognitionException { try { int _type = T__70; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:69:7: ( 'GLOBALVAR' ) - // InternalExport.g:69:9: 'GLOBALVAR' + // InternalExport.g:67:7: ( 'as' ) + // InternalExport.g:67:9: 'as' { - match("GLOBALVAR"); + match("as"); } @@ -1328,11 +1331,10 @@ public final void mT__71() throws RecognitionException { try { int _type = T__71; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:70:7: ( 'new' ) - // InternalExport.g:70:9: 'new' + // InternalExport.g:68:7: ( ';' ) + // InternalExport.g:68:9: ';' { - match("new"); - + match(';'); } @@ -1349,11 +1351,10 @@ public final void mT__72() throws RecognitionException { try { int _type = T__72; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:71:7: ( 'lookup' ) - // InternalExport.g:71:9: 'lookup' + // InternalExport.g:69:7: ( '[' ) + // InternalExport.g:69:9: '[' { - match("lookup"); - + match('['); } @@ -1370,11 +1371,10 @@ public final void mT__73() throws RecognitionException { try { int _type = T__73; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:72:7: ( 'qualified' ) - // InternalExport.g:72:9: 'qualified' + // InternalExport.g:70:7: ( ']' ) + // InternalExport.g:70:9: ']' { - match("qualified"); - + match(']'); } @@ -1391,11 +1391,10 @@ public final void mT__74() throws RecognitionException { try { int _type = T__74; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:73:7: ( 'unique' ) - // InternalExport.g:73:9: 'unique' + // InternalExport.g:71:7: ( ',' ) + // InternalExport.g:71:9: ',' { - match("unique"); - + match(','); } @@ -1412,11 +1411,10 @@ public final void mT__75() throws RecognitionException { try { int _type = T__75; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:74:7: ( 'object-fingerprint' ) - // InternalExport.g:74:9: 'object-fingerprint' + // InternalExport.g:72:7: ( '@' ) + // InternalExport.g:72:9: '@' { - match("object-fingerprint"); - + match('@'); } @@ -1433,10 +1431,10 @@ public final void mT__76() throws RecognitionException { try { int _type = T__76; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:75:7: ( 'resource-fingerprint' ) - // InternalExport.g:75:9: 'resource-fingerprint' + // InternalExport.g:73:7: ( 'eval' ) + // InternalExport.g:73:9: 'eval' { - match("resource-fingerprint"); + match("eval"); } @@ -1454,11 +1452,10 @@ public final void mT__77() throws RecognitionException { try { int _type = T__77; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:76:7: ( '||' ) - // InternalExport.g:76:9: '||' + // InternalExport.g:74:7: ( '(' ) + // InternalExport.g:74:9: '(' { - match("||"); - + match('('); } @@ -1475,11 +1472,10 @@ public final void mT__78() throws RecognitionException { try { int _type = T__78; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:77:7: ( '&&' ) - // InternalExport.g:77:9: '&&' + // InternalExport.g:75:7: ( ')' ) + // InternalExport.g:75:9: ')' { - match("&&"); - + match(')'); } @@ -1496,10 +1492,10 @@ public final void mT__79() throws RecognitionException { try { int _type = T__79; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:78:7: ( 'implies' ) - // InternalExport.g:78:9: 'implies' + // InternalExport.g:76:7: ( 'uri-fragment' ) + // InternalExport.g:76:9: 'uri-fragment' { - match("implies"); + match("uri-fragment"); } @@ -1517,10 +1513,10 @@ public final void mT__80() throws RecognitionException { try { int _type = T__80; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:79:7: ( 'typeSelect' ) - // InternalExport.g:79:9: 'typeSelect' + // InternalExport.g:77:7: ( 'attribute' ) + // InternalExport.g:77:9: 'attribute' { - match("typeSelect"); + match("attribute"); } @@ -1538,10 +1534,10 @@ public final void mT__81() throws RecognitionException { try { int _type = T__81; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:80:7: ( 'null' ) - // InternalExport.g:80:9: 'null' + // InternalExport.g:78:7: ( 'field' ) + // InternalExport.g:78:9: 'field' { - match("null"); + match("field"); } @@ -1554,33 +1550,784 @@ public final void mT__81() throws RecognitionException { } // $ANTLR end "T__81" - // $ANTLR start "RULE_REAL" - public final void mRULE_REAL() throws RecognitionException { + // $ANTLR start "T__82" + public final void mT__82() throws RecognitionException { try { - int _type = RULE_REAL; + int _type = T__82; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10026:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) - // InternalExport.g:10026:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + // InternalExport.g:79:7: ( 'data' ) + // InternalExport.g:79:9: 'data' { - // InternalExport.g:10026:13: ( '0' .. '9' )* - loop1: - do { - int alt1=2; - int LA1_0 = input.LA(1); - - if ( ((LA1_0>='0' && LA1_0<='9')) ) { - alt1=1; - } - + match("data"); - switch (alt1) { - case 1 : - // InternalExport.g:10026:14: '0' .. '9' - { - matchRange('0','9'); - } - break; + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__82" + + // $ANTLR start "T__83" + public final void mT__83() throws RecognitionException { + try { + int _type = T__83; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:80:7: ( '::' ) + // InternalExport.g:80:9: '::' + { + match("::"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__83" + + // $ANTLR start "T__84" + public final void mT__84() throws RecognitionException { + try { + int _type = T__84; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:81:7: ( 'let' ) + // InternalExport.g:81:9: 'let' + { + match("let"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__84" + + // $ANTLR start "T__85" + public final void mT__85() throws RecognitionException { + try { + int _type = T__85; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:82:7: ( ':' ) + // InternalExport.g:82:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__85" + + // $ANTLR start "T__86" + public final void mT__86() throws RecognitionException { + try { + int _type = T__86; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:83:7: ( '?' ) + // InternalExport.g:83:9: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__86" + + // $ANTLR start "T__87" + public final void mT__87() throws RecognitionException { + try { + int _type = T__87; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:84:7: ( 'if' ) + // InternalExport.g:84:9: 'if' + { + match("if"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__87" + + // $ANTLR start "T__88" + public final void mT__88() throws RecognitionException { + try { + int _type = T__88; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:85:7: ( 'then' ) + // InternalExport.g:85:9: 'then' + { + match("then"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:86:7: ( 'else' ) + // InternalExport.g:86:9: 'else' + { + match("else"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" + + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:87:7: ( 'switch' ) + // InternalExport.g:87:9: 'switch' + { + match("switch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__90" + + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { + try { + int _type = T__91; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:88:7: ( 'default' ) + // InternalExport.g:88:9: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" + + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:89:7: ( 'case' ) + // InternalExport.g:89:9: 'case' + { + match("case"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" + + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:90:7: ( '|' ) + // InternalExport.g:90:9: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:91:7: ( 'GLOBALVAR' ) + // InternalExport.g:91:9: 'GLOBALVAR' + { + match("GLOBALVAR"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:92:7: ( 'new' ) + // InternalExport.g:92:9: 'new' + { + match("new"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__95" + + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { + try { + int _type = T__96; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:93:7: ( 'instanceof' ) + // InternalExport.g:93:9: 'instanceof' + { + match("instanceof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" + + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:94:7: ( '#' ) + // InternalExport.g:94:9: '#' + { + match('#'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__97" + + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { + try { + int _type = T__98; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:95:7: ( 'while' ) + // InternalExport.g:95:9: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:96:7: ( 'do' ) + // InternalExport.g:96:9: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:97:8: ( 'null' ) + // InternalExport.g:97:10: 'null' + { + match("null"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:98:8: ( 'typeof' ) + // InternalExport.g:98:10: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:99:8: ( 'throw' ) + // InternalExport.g:99:10: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:100:8: ( 'return' ) + // InternalExport.g:100:10: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:101:8: ( 'try' ) + // InternalExport.g:101:10: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "T__105" + public final void mT__105() throws RecognitionException { + try { + int _type = T__105; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:102:8: ( 'finally' ) + // InternalExport.g:102:10: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__105" + + // $ANTLR start "T__106" + public final void mT__106() throws RecognitionException { + try { + int _type = T__106; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:103:8: ( 'synchronized' ) + // InternalExport.g:103:10: 'synchronized' + { + match("synchronized"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__106" + + // $ANTLR start "T__107" + public final void mT__107() throws RecognitionException { + try { + int _type = T__107; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:104:8: ( 'catch' ) + // InternalExport.g:104:10: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__107" + + // $ANTLR start "T__108" + public final void mT__108() throws RecognitionException { + try { + int _type = T__108; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:105:8: ( '&' ) + // InternalExport.g:105:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__108" + + // $ANTLR start "T__109" + public final void mT__109() throws RecognitionException { + try { + int _type = T__109; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:106:8: ( 'lookup' ) + // InternalExport.g:106:10: 'lookup' + { + match("lookup"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__109" + + // $ANTLR start "T__110" + public final void mT__110() throws RecognitionException { + try { + int _type = T__110; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:107:8: ( 'qualified' ) + // InternalExport.g:107:10: 'qualified' + { + match("qualified"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__110" + + // $ANTLR start "T__111" + public final void mT__111() throws RecognitionException { + try { + int _type = T__111; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:108:8: ( 'unique' ) + // InternalExport.g:108:10: 'unique' + { + match("unique"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__111" + + // $ANTLR start "T__112" + public final void mT__112() throws RecognitionException { + try { + int _type = T__112; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:109:8: ( 'object-fingerprint' ) + // InternalExport.g:109:10: 'object-fingerprint' + { + match("object-fingerprint"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__112" + + // $ANTLR start "T__113" + public final void mT__113() throws RecognitionException { + try { + int _type = T__113; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:110:8: ( 'resource-fingerprint' ) + // InternalExport.g:110:10: 'resource-fingerprint' + { + match("resource-fingerprint"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__113" + + // $ANTLR start "T__114" + public final void mT__114() throws RecognitionException { + try { + int _type = T__114; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:111:8: ( 'implies' ) + // InternalExport.g:111:10: 'implies' + { + match("implies"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__114" + + // $ANTLR start "T__115" + public final void mT__115() throws RecognitionException { + try { + int _type = T__115; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:112:8: ( 'typeSelect' ) + // InternalExport.g:112:10: 'typeSelect' + { + match("typeSelect"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__115" + + // $ANTLR start "T__116" + public final void mT__116() throws RecognitionException { + try { + int _type = T__116; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:113:8: ( '?.' ) + // InternalExport.g:113:10: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__116" + + // $ANTLR start "T__117" + public final void mT__117() throws RecognitionException { + try { + int _type = T__117; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:114:8: ( 'var' ) + // InternalExport.g:114:10: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__117" + + // $ANTLR start "RULE_REAL" + public final void mRULE_REAL() throws RecognitionException { + try { + int _type = RULE_REAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:26873:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) + // InternalExport.g:26873:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + { + // InternalExport.g:26873:13: ( '0' .. '9' )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( ((LA1_0>='0' && LA1_0<='9')) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalExport.g:26873:14: '0' .. '9' + { + matchRange('0','9'); + + } + break; default : break loop1; @@ -1588,7 +2335,7 @@ public final void mRULE_REAL() throws RecognitionException { } while (true); match('.'); - // InternalExport.g:10026:29: ( '0' .. '9' )* + // InternalExport.g:26873:29: ( '0' .. '9' )* loop2: do { int alt2=2; @@ -1599,19 +2346,378 @@ public final void mRULE_REAL() throws RecognitionException { } - switch (alt2) { - case 1 : - // InternalExport.g:10026:30: '0' .. '9' - { - matchRange('0','9'); + switch (alt2) { + case 1 : + // InternalExport.g:26873:30: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_REAL" + + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:26875:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // InternalExport.g:26875:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // InternalExport.g:26875:12: ( '0x' | '0X' ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='0') ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1=='x') ) { + alt3=1; + } + else if ( (LA3_1=='X') ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalExport.g:26875:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // InternalExport.g:26875:18: '0X' + { + match("0X"); + + + } + break; + + } + + // InternalExport.g:26875:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ + int cnt4=0; + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='f')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalExport.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt4 >= 1 ) break loop4; + EarlyExitException eee = + new EarlyExitException(4, input); + throw eee; + } + cnt4++; + } while (true); + + // InternalExport.g:26875:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='#') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalExport.g:26875:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // InternalExport.g:26875:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='B'||LA5_0=='b') ) { + alt5=1; + } + else if ( (LA5_0=='L'||LA5_0=='l') ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalExport.g:26875:64: ( 'b' | 'B' ) ( 'i' | 'I' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='I'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExport.g:26875:84: ( 'l' | 'L' ) + { + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_HEX" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:26877:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // InternalExport.g:26877:12: '0' .. '9' ( '0' .. '9' | '_' )* + { + matchRange('0','9'); + // InternalExport.g:26877:21: ( '0' .. '9' | '_' )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||LA7_0=='_') ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalExport.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_DECIMAL" + public final void mRULE_DECIMAL() throws RecognitionException { + try { + int _type = RULE_DECIMAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:26879:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // InternalExport.g:26879:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // InternalExport.g:26879:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='E'||LA9_0=='e') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalExport.g:26879:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalExport.g:26879:36: ( '+' | '-' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='+'||LA8_0=='-') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalExport.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_INT(); + + } + break; + + } + + // InternalExport.g:26879:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='B'||LA10_0=='b') ) { + alt10=1; + } + else if ( (LA10_0=='D'||LA10_0=='F'||LA10_0=='L'||LA10_0=='d'||LA10_0=='f'||LA10_0=='l') ) { + alt10=2; + } + switch (alt10) { + case 1 : + // InternalExport.g:26879:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExport.g:26879:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) + { + if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + - } - break; + } + break; - default : - break loop2; - } - } while (true); + } } @@ -1622,26 +2728,26 @@ public final void mRULE_REAL() throws RecognitionException { finally { } } - // $ANTLR end "RULE_REAL" + // $ANTLR end "RULE_DECIMAL" // $ANTLR start "RULE_ID" public final void mRULE_ID() throws RecognitionException { try { int _type = RULE_ID; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10028:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalExport.g:10028:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalExport.g:26881:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalExport.g:26881:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* { - // InternalExport.g:10028:11: ( '^' )? - int alt3=2; - int LA3_0 = input.LA(1); + // InternalExport.g:26881:11: ( '^' )? + int alt11=2; + int LA11_0 = input.LA(1); - if ( (LA3_0=='^') ) { - alt3=1; + if ( (LA11_0=='^') ) { + alt11=1; } - switch (alt3) { + switch (alt11) { case 1 : - // InternalExport.g:10028:11: '^' + // InternalExport.g:26881:11: '^' { match('^'); @@ -1650,7 +2756,7 @@ public final void mRULE_ID() throws RecognitionException { } - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { input.consume(); } @@ -1659,22 +2765,22 @@ public final void mRULE_ID() throws RecognitionException { recover(mse); throw mse;} - // InternalExport.g:10028:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop4: + // InternalExport.g:26881:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop12: do { - int alt4=2; - int LA4_0 = input.LA(1); + int alt12=2; + int LA12_0 = input.LA(1); - if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { - alt4=1; + if ( (LA12_0=='$'||(LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) { + alt12=1; } - switch (alt4) { + switch (alt12) { case 1 : // InternalExport.g: { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { input.consume(); } @@ -1688,7 +2794,7 @@ public final void mRULE_ID() throws RecognitionException { break; default : - break loop4; + break loop12; } } while (true); @@ -1703,101 +2809,52 @@ public final void mRULE_ID() throws RecognitionException { } // $ANTLR end "RULE_ID" - // $ANTLR start "RULE_INT" - public final void mRULE_INT() throws RecognitionException { - try { - int _type = RULE_INT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10030:10: ( ( '0' .. '9' )+ ) - // InternalExport.g:10030:12: ( '0' .. '9' )+ - { - // InternalExport.g:10030:12: ( '0' .. '9' )+ - int cnt5=0; - loop5: - do { - int alt5=2; - int LA5_0 = input.LA(1); - - if ( ((LA5_0>='0' && LA5_0<='9')) ) { - alt5=1; - } - - - switch (alt5) { - case 1 : - // InternalExport.g:10030:13: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - if ( cnt5 >= 1 ) break loop5; - EarlyExitException eee = - new EarlyExitException(5, input); - throw eee; - } - cnt5++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_INT" - // $ANTLR start "RULE_STRING" public final void mRULE_STRING() throws RecognitionException { try { int _type = RULE_STRING; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10032:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalExport.g:10032:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalExport.g:26883:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalExport.g:26883:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) { - // InternalExport.g:10032:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt8=2; - int LA8_0 = input.LA(1); + // InternalExport.g:26883:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA8_0=='\"') ) { - alt8=1; + if ( (LA17_0=='\"') ) { + alt17=1; } - else if ( (LA8_0=='\'') ) { - alt8=2; + else if ( (LA17_0=='\'') ) { + alt17=2; } else { NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + new NoViableAltException("", 17, 0, input); throw nvae; } - switch (alt8) { + switch (alt17) { case 1 : - // InternalExport.g:10032:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + // InternalExport.g:26883:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? { match('\"'); - // InternalExport.g:10032:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop6: + // InternalExport.g:26883:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop13: do { - int alt6=3; - int LA6_0 = input.LA(1); + int alt13=3; + int LA13_0 = input.LA(1); - if ( (LA6_0=='\\') ) { - alt6=1; + if ( (LA13_0=='\\') ) { + alt13=1; } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; + else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) { + alt13=2; } - switch (alt6) { + switch (alt13) { case 1 : - // InternalExport.g:10032:21: '\\\\' . + // InternalExport.g:26883:21: '\\\\' . { match('\\'); matchAny(); @@ -1805,7 +2862,7 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= } break; case 2 : - // InternalExport.g:10032:28: ~ ( ( '\\\\' | '\"' ) ) + // InternalExport.g:26883:28: ~ ( ( '\\\\' | '\"' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1821,35 +2878,52 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= break; default : - break loop6; + break loop13; } } while (true); - match('\"'); + // InternalExport.g:26883:44: ( '\"' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\"') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalExport.g:26883:44: '\"' + { + match('\"'); + + } + break; + + } + } break; case 2 : - // InternalExport.g:10032:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + // InternalExport.g:26883:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? { match('\''); - // InternalExport.g:10032:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop7: + // InternalExport.g:26883:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop15: do { - int alt7=3; - int LA7_0 = input.LA(1); + int alt15=3; + int LA15_0 = input.LA(1); - if ( (LA7_0=='\\') ) { - alt7=1; + if ( (LA15_0=='\\') ) { + alt15=1; } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; + else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) { + alt15=2; } - switch (alt7) { + switch (alt15) { case 1 : - // InternalExport.g:10032:54: '\\\\' . + // InternalExport.g:26883:55: '\\\\' . { match('\\'); matchAny(); @@ -1857,7 +2931,7 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= } break; case 2 : - // InternalExport.g:10032:61: ~ ( ( '\\\\' | '\\'' ) ) + // InternalExport.g:26883:62: ~ ( ( '\\\\' | '\\'' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1873,11 +2947,28 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= break; default : - break loop7; + break loop15; } } while (true); - match('\''); + // InternalExport.g:26883:79: ( '\\'' )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalExport.g:26883:79: '\\'' + { + match('\''); + + } + break; + + } + } break; @@ -1900,37 +2991,37 @@ public final void mRULE_ML_COMMENT() throws RecognitionException { try { int _type = RULE_ML_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10034:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalExport.g:10034:19: '/*' ( options {greedy=false; } : . )* '*/' + // InternalExport.g:26885:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalExport.g:26885:19: '/*' ( options {greedy=false; } : . )* '*/' { match("/*"); - // InternalExport.g:10034:24: ( options {greedy=false; } : . )* - loop9: + // InternalExport.g:26885:24: ( options {greedy=false; } : . )* + loop18: do { - int alt9=2; - int LA9_0 = input.LA(1); + int alt18=2; + int LA18_0 = input.LA(1); - if ( (LA9_0=='*') ) { - int LA9_1 = input.LA(2); + if ( (LA18_0=='*') ) { + int LA18_1 = input.LA(2); - if ( (LA9_1=='/') ) { - alt9=2; + if ( (LA18_1=='/') ) { + alt18=2; } - else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) { + alt18=1; } } - else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) { + alt18=1; } - switch (alt9) { + switch (alt18) { case 1 : - // InternalExport.g:10034:52: . + // InternalExport.g:26885:52: . { matchAny(); @@ -1938,7 +3029,7 @@ else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { break; default : - break loop9; + break loop18; } } while (true); @@ -1960,25 +3051,25 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { try { int _type = RULE_SL_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10036:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalExport.g:10036:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + // InternalExport.g:26887:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalExport.g:26887:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? { match("//"); - // InternalExport.g:10036:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop10: + // InternalExport.g:26887:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop19: do { - int alt10=2; - int LA10_0 = input.LA(1); + int alt19=2; + int LA19_0 = input.LA(1); - if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\uFFFF')) ) { - alt10=1; + if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { + alt19=1; } - switch (alt10) { + switch (alt19) { case 1 : - // InternalExport.g:10036:24: ~ ( ( '\\n' | '\\r' ) ) + // InternalExport.g:26887:24: ~ ( ( '\\n' | '\\r' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1994,31 +3085,31 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { break; default : - break loop10; + break loop19; } } while (true); - // InternalExport.g:10036:40: ( ( '\\r' )? '\\n' )? - int alt12=2; - int LA12_0 = input.LA(1); + // InternalExport.g:26887:40: ( ( '\\r' )? '\\n' )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA12_0=='\n'||LA12_0=='\r') ) { - alt12=1; + if ( (LA21_0=='\n'||LA21_0=='\r') ) { + alt21=1; } - switch (alt12) { + switch (alt21) { case 1 : - // InternalExport.g:10036:41: ( '\\r' )? '\\n' + // InternalExport.g:26887:41: ( '\\r' )? '\\n' { - // InternalExport.g:10036:41: ( '\\r' )? - int alt11=2; - int LA11_0 = input.LA(1); + // InternalExport.g:26887:41: ( '\\r' )? + int alt20=2; + int LA20_0 = input.LA(1); - if ( (LA11_0=='\r') ) { - alt11=1; + if ( (LA20_0=='\r') ) { + alt20=1; } - switch (alt11) { + switch (alt20) { case 1 : - // InternalExport.g:10036:41: '\\r' + // InternalExport.g:26887:41: '\\r' { match('\r'); @@ -2027,647 +3118,899 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { } - match('\n'); + match('\n'); + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:26889:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalExport.g:26889:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalExport.g:26889:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='\t' && LA22_0<='\n')||LA22_0=='\r'||LA22_0==' ') ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalExport.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:26891:16: ( . ) + // InternalExport.g:26891:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalExport.g:1:8: ( T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | T__115 | T__116 | T__117 | RULE_REAL | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt23=114; + alt23 = dfa23.predict(input); + switch (alt23) { + case 1 : + // InternalExport.g:1:10: T__14 + { + mT__14(); + + } + break; + case 2 : + // InternalExport.g:1:16: T__15 + { + mT__15(); + + } + break; + case 3 : + // InternalExport.g:1:22: T__16 + { + mT__16(); + + } + break; + case 4 : + // InternalExport.g:1:28: T__17 + { + mT__17(); + + } + break; + case 5 : + // InternalExport.g:1:34: T__18 + { + mT__18(); + + } + break; + case 6 : + // InternalExport.g:1:40: T__19 + { + mT__19(); + + } + break; + case 7 : + // InternalExport.g:1:46: T__20 + { + mT__20(); + + } + break; + case 8 : + // InternalExport.g:1:52: T__21 + { + mT__21(); + + } + break; + case 9 : + // InternalExport.g:1:58: T__22 + { + mT__22(); + + } + break; + case 10 : + // InternalExport.g:1:64: T__23 + { + mT__23(); + + } + break; + case 11 : + // InternalExport.g:1:70: T__24 + { + mT__24(); + + } + break; + case 12 : + // InternalExport.g:1:76: T__25 + { + mT__25(); + + } + break; + case 13 : + // InternalExport.g:1:82: T__26 + { + mT__26(); + + } + break; + case 14 : + // InternalExport.g:1:88: T__27 + { + mT__27(); + + } + break; + case 15 : + // InternalExport.g:1:94: T__28 + { + mT__28(); + + } + break; + case 16 : + // InternalExport.g:1:100: T__29 + { + mT__29(); + + } + break; + case 17 : + // InternalExport.g:1:106: T__30 + { + mT__30(); - } - break; + } + break; + case 18 : + // InternalExport.g:1:112: T__31 + { + mT__31(); - } + } + break; + case 19 : + // InternalExport.g:1:118: T__32 + { + mT__32(); + } + break; + case 20 : + // InternalExport.g:1:124: T__33 + { + mT__33(); - } + } + break; + case 21 : + // InternalExport.g:1:130: T__34 + { + mT__34(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_SL_COMMENT" + } + break; + case 22 : + // InternalExport.g:1:136: T__35 + { + mT__35(); - // $ANTLR start "RULE_WS" - public final void mRULE_WS() throws RecognitionException { - try { - int _type = RULE_WS; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10038:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalExport.g:10038:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - { - // InternalExport.g:10038:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt13=0; - loop13: - do { - int alt13=2; - int LA13_0 = input.LA(1); + } + break; + case 23 : + // InternalExport.g:1:142: T__36 + { + mT__36(); - if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) { - alt13=1; } + break; + case 24 : + // InternalExport.g:1:148: T__37 + { + mT__37(); + } + break; + case 25 : + // InternalExport.g:1:154: T__38 + { + mT__38(); - switch (alt13) { - case 1 : - // InternalExport.g: - { - if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { - input.consume(); + } + break; + case 26 : + // InternalExport.g:1:160: T__39 + { + mT__39(); - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + } + break; + case 27 : + // InternalExport.g:1:166: T__40 + { + mT__40(); + } + break; + case 28 : + // InternalExport.g:1:172: T__41 + { + mT__41(); - } - break; + } + break; + case 29 : + // InternalExport.g:1:178: T__42 + { + mT__42(); - default : - if ( cnt13 >= 1 ) break loop13; - EarlyExitException eee = - new EarlyExitException(13, input); - throw eee; } - cnt13++; - } while (true); + break; + case 30 : + // InternalExport.g:1:184: T__43 + { + mT__43(); + } + break; + case 31 : + // InternalExport.g:1:190: T__44 + { + mT__44(); - } + } + break; + case 32 : + // InternalExport.g:1:196: T__45 + { + mT__45(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_WS" + } + break; + case 33 : + // InternalExport.g:1:202: T__46 + { + mT__46(); - // $ANTLR start "RULE_ANY_OTHER" - public final void mRULE_ANY_OTHER() throws RecognitionException { - try { - int _type = RULE_ANY_OTHER; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:10040:16: ( . ) - // InternalExport.g:10040:18: . - { - matchAny(); + } + break; + case 34 : + // InternalExport.g:1:208: T__47 + { + mT__47(); - } + } + break; + case 35 : + // InternalExport.g:1:214: T__48 + { + mT__48(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ANY_OTHER" + } + break; + case 36 : + // InternalExport.g:1:220: T__49 + { + mT__49(); - public void mTokens() throws RecognitionException { - // InternalExport.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | RULE_REAL | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt14=78; - alt14 = dfa14.predict(input); - switch (alt14) { - case 1 : - // InternalExport.g:1:10: T__12 + } + break; + case 37 : + // InternalExport.g:1:226: T__50 { - mT__12(); + mT__50(); } break; - case 2 : - // InternalExport.g:1:16: T__13 + case 38 : + // InternalExport.g:1:232: T__51 { - mT__13(); + mT__51(); } break; - case 3 : - // InternalExport.g:1:22: T__14 + case 39 : + // InternalExport.g:1:238: T__52 { - mT__14(); + mT__52(); } break; - case 4 : - // InternalExport.g:1:28: T__15 + case 40 : + // InternalExport.g:1:244: T__53 { - mT__15(); + mT__53(); } break; - case 5 : - // InternalExport.g:1:34: T__16 + case 41 : + // InternalExport.g:1:250: T__54 { - mT__16(); + mT__54(); } break; - case 6 : - // InternalExport.g:1:40: T__17 + case 42 : + // InternalExport.g:1:256: T__55 { - mT__17(); + mT__55(); } break; - case 7 : - // InternalExport.g:1:46: T__18 + case 43 : + // InternalExport.g:1:262: T__56 { - mT__18(); + mT__56(); } break; - case 8 : - // InternalExport.g:1:52: T__19 + case 44 : + // InternalExport.g:1:268: T__57 { - mT__19(); + mT__57(); } break; - case 9 : - // InternalExport.g:1:58: T__20 + case 45 : + // InternalExport.g:1:274: T__58 { - mT__20(); + mT__58(); } break; - case 10 : - // InternalExport.g:1:64: T__21 + case 46 : + // InternalExport.g:1:280: T__59 { - mT__21(); + mT__59(); } break; - case 11 : - // InternalExport.g:1:70: T__22 + case 47 : + // InternalExport.g:1:286: T__60 { - mT__22(); + mT__60(); } break; - case 12 : - // InternalExport.g:1:76: T__23 + case 48 : + // InternalExport.g:1:292: T__61 { - mT__23(); + mT__61(); } break; - case 13 : - // InternalExport.g:1:82: T__24 + case 49 : + // InternalExport.g:1:298: T__62 { - mT__24(); + mT__62(); } break; - case 14 : - // InternalExport.g:1:88: T__25 + case 50 : + // InternalExport.g:1:304: T__63 { - mT__25(); + mT__63(); } break; - case 15 : - // InternalExport.g:1:94: T__26 + case 51 : + // InternalExport.g:1:310: T__64 { - mT__26(); + mT__64(); } break; - case 16 : - // InternalExport.g:1:100: T__27 + case 52 : + // InternalExport.g:1:316: T__65 { - mT__27(); + mT__65(); } break; - case 17 : - // InternalExport.g:1:106: T__28 + case 53 : + // InternalExport.g:1:322: T__66 { - mT__28(); + mT__66(); } break; - case 18 : - // InternalExport.g:1:112: T__29 + case 54 : + // InternalExport.g:1:328: T__67 { - mT__29(); + mT__67(); } break; - case 19 : - // InternalExport.g:1:118: T__30 + case 55 : + // InternalExport.g:1:334: T__68 { - mT__30(); + mT__68(); } break; - case 20 : - // InternalExport.g:1:124: T__31 + case 56 : + // InternalExport.g:1:340: T__69 { - mT__31(); + mT__69(); } break; - case 21 : - // InternalExport.g:1:130: T__32 + case 57 : + // InternalExport.g:1:346: T__70 { - mT__32(); + mT__70(); } break; - case 22 : - // InternalExport.g:1:136: T__33 + case 58 : + // InternalExport.g:1:352: T__71 { - mT__33(); + mT__71(); } break; - case 23 : - // InternalExport.g:1:142: T__34 + case 59 : + // InternalExport.g:1:358: T__72 { - mT__34(); + mT__72(); } break; - case 24 : - // InternalExport.g:1:148: T__35 + case 60 : + // InternalExport.g:1:364: T__73 { - mT__35(); + mT__73(); } break; - case 25 : - // InternalExport.g:1:154: T__36 + case 61 : + // InternalExport.g:1:370: T__74 { - mT__36(); + mT__74(); } break; - case 26 : - // InternalExport.g:1:160: T__37 + case 62 : + // InternalExport.g:1:376: T__75 { - mT__37(); + mT__75(); } break; - case 27 : - // InternalExport.g:1:166: T__38 + case 63 : + // InternalExport.g:1:382: T__76 { - mT__38(); + mT__76(); } break; - case 28 : - // InternalExport.g:1:172: T__39 + case 64 : + // InternalExport.g:1:388: T__77 { - mT__39(); + mT__77(); } break; - case 29 : - // InternalExport.g:1:178: T__40 + case 65 : + // InternalExport.g:1:394: T__78 { - mT__40(); + mT__78(); } break; - case 30 : - // InternalExport.g:1:184: T__41 + case 66 : + // InternalExport.g:1:400: T__79 { - mT__41(); + mT__79(); } break; - case 31 : - // InternalExport.g:1:190: T__42 + case 67 : + // InternalExport.g:1:406: T__80 { - mT__42(); + mT__80(); } break; - case 32 : - // InternalExport.g:1:196: T__43 + case 68 : + // InternalExport.g:1:412: T__81 { - mT__43(); + mT__81(); } break; - case 33 : - // InternalExport.g:1:202: T__44 + case 69 : + // InternalExport.g:1:418: T__82 { - mT__44(); + mT__82(); } break; - case 34 : - // InternalExport.g:1:208: T__45 + case 70 : + // InternalExport.g:1:424: T__83 { - mT__45(); + mT__83(); } break; - case 35 : - // InternalExport.g:1:214: T__46 + case 71 : + // InternalExport.g:1:430: T__84 { - mT__46(); + mT__84(); } break; - case 36 : - // InternalExport.g:1:220: T__47 + case 72 : + // InternalExport.g:1:436: T__85 { - mT__47(); + mT__85(); } break; - case 37 : - // InternalExport.g:1:226: T__48 + case 73 : + // InternalExport.g:1:442: T__86 { - mT__48(); + mT__86(); } break; - case 38 : - // InternalExport.g:1:232: T__49 + case 74 : + // InternalExport.g:1:448: T__87 { - mT__49(); + mT__87(); } break; - case 39 : - // InternalExport.g:1:238: T__50 + case 75 : + // InternalExport.g:1:454: T__88 { - mT__50(); + mT__88(); } break; - case 40 : - // InternalExport.g:1:244: T__51 + case 76 : + // InternalExport.g:1:460: T__89 { - mT__51(); + mT__89(); } break; - case 41 : - // InternalExport.g:1:250: T__52 + case 77 : + // InternalExport.g:1:466: T__90 { - mT__52(); + mT__90(); } break; - case 42 : - // InternalExport.g:1:256: T__53 + case 78 : + // InternalExport.g:1:472: T__91 { - mT__53(); + mT__91(); } break; - case 43 : - // InternalExport.g:1:262: T__54 + case 79 : + // InternalExport.g:1:478: T__92 { - mT__54(); + mT__92(); } break; - case 44 : - // InternalExport.g:1:268: T__55 + case 80 : + // InternalExport.g:1:484: T__93 { - mT__55(); + mT__93(); } break; - case 45 : - // InternalExport.g:1:274: T__56 + case 81 : + // InternalExport.g:1:490: T__94 { - mT__56(); + mT__94(); } break; - case 46 : - // InternalExport.g:1:280: T__57 + case 82 : + // InternalExport.g:1:496: T__95 { - mT__57(); + mT__95(); } break; - case 47 : - // InternalExport.g:1:286: T__58 + case 83 : + // InternalExport.g:1:502: T__96 { - mT__58(); + mT__96(); } break; - case 48 : - // InternalExport.g:1:292: T__59 + case 84 : + // InternalExport.g:1:508: T__97 { - mT__59(); + mT__97(); } break; - case 49 : - // InternalExport.g:1:298: T__60 + case 85 : + // InternalExport.g:1:514: T__98 { - mT__60(); + mT__98(); } break; - case 50 : - // InternalExport.g:1:304: T__61 + case 86 : + // InternalExport.g:1:520: T__99 { - mT__61(); + mT__99(); } break; - case 51 : - // InternalExport.g:1:310: T__62 + case 87 : + // InternalExport.g:1:526: T__100 { - mT__62(); + mT__100(); } break; - case 52 : - // InternalExport.g:1:316: T__63 + case 88 : + // InternalExport.g:1:533: T__101 { - mT__63(); + mT__101(); } break; - case 53 : - // InternalExport.g:1:322: T__64 + case 89 : + // InternalExport.g:1:540: T__102 { - mT__64(); + mT__102(); } break; - case 54 : - // InternalExport.g:1:328: T__65 + case 90 : + // InternalExport.g:1:547: T__103 { - mT__65(); + mT__103(); } break; - case 55 : - // InternalExport.g:1:334: T__66 + case 91 : + // InternalExport.g:1:554: T__104 { - mT__66(); + mT__104(); } break; - case 56 : - // InternalExport.g:1:340: T__67 + case 92 : + // InternalExport.g:1:561: T__105 { - mT__67(); + mT__105(); } break; - case 57 : - // InternalExport.g:1:346: T__68 + case 93 : + // InternalExport.g:1:568: T__106 { - mT__68(); + mT__106(); } break; - case 58 : - // InternalExport.g:1:352: T__69 + case 94 : + // InternalExport.g:1:575: T__107 { - mT__69(); + mT__107(); } break; - case 59 : - // InternalExport.g:1:358: T__70 + case 95 : + // InternalExport.g:1:582: T__108 { - mT__70(); + mT__108(); } break; - case 60 : - // InternalExport.g:1:364: T__71 + case 96 : + // InternalExport.g:1:589: T__109 { - mT__71(); + mT__109(); } break; - case 61 : - // InternalExport.g:1:370: T__72 + case 97 : + // InternalExport.g:1:596: T__110 { - mT__72(); + mT__110(); } break; - case 62 : - // InternalExport.g:1:376: T__73 + case 98 : + // InternalExport.g:1:603: T__111 { - mT__73(); + mT__111(); } break; - case 63 : - // InternalExport.g:1:382: T__74 + case 99 : + // InternalExport.g:1:610: T__112 { - mT__74(); + mT__112(); } break; - case 64 : - // InternalExport.g:1:388: T__75 + case 100 : + // InternalExport.g:1:617: T__113 { - mT__75(); + mT__113(); } break; - case 65 : - // InternalExport.g:1:394: T__76 + case 101 : + // InternalExport.g:1:624: T__114 { - mT__76(); + mT__114(); } break; - case 66 : - // InternalExport.g:1:400: T__77 + case 102 : + // InternalExport.g:1:631: T__115 { - mT__77(); + mT__115(); } break; - case 67 : - // InternalExport.g:1:406: T__78 + case 103 : + // InternalExport.g:1:638: T__116 { - mT__78(); + mT__116(); } break; - case 68 : - // InternalExport.g:1:412: T__79 + case 104 : + // InternalExport.g:1:645: T__117 { - mT__79(); + mT__117(); } break; - case 69 : - // InternalExport.g:1:418: T__80 + case 105 : + // InternalExport.g:1:652: RULE_REAL { - mT__80(); + mRULE_REAL(); } break; - case 70 : - // InternalExport.g:1:424: T__81 + case 106 : + // InternalExport.g:1:662: RULE_HEX { - mT__81(); + mRULE_HEX(); } break; - case 71 : - // InternalExport.g:1:430: RULE_REAL + case 107 : + // InternalExport.g:1:671: RULE_INT { - mRULE_REAL(); + mRULE_INT(); } break; - case 72 : - // InternalExport.g:1:440: RULE_ID + case 108 : + // InternalExport.g:1:680: RULE_DECIMAL { - mRULE_ID(); + mRULE_DECIMAL(); } break; - case 73 : - // InternalExport.g:1:448: RULE_INT + case 109 : + // InternalExport.g:1:693: RULE_ID { - mRULE_INT(); + mRULE_ID(); } break; - case 74 : - // InternalExport.g:1:457: RULE_STRING + case 110 : + // InternalExport.g:1:701: RULE_STRING { mRULE_STRING(); } break; - case 75 : - // InternalExport.g:1:469: RULE_ML_COMMENT + case 111 : + // InternalExport.g:1:713: RULE_ML_COMMENT { mRULE_ML_COMMENT(); } break; - case 76 : - // InternalExport.g:1:485: RULE_SL_COMMENT + case 112 : + // InternalExport.g:1:729: RULE_SL_COMMENT { mRULE_SL_COMMENT(); } break; - case 77 : - // InternalExport.g:1:501: RULE_WS + case 113 : + // InternalExport.g:1:745: RULE_WS { mRULE_WS(); } break; - case 78 : - // InternalExport.g:1:509: RULE_ANY_OTHER + case 114 : + // InternalExport.g:1:753: RULE_ANY_OTHER { mRULE_ANY_OTHER(); @@ -2679,75 +4022,81 @@ public void mTokens() throws RecognitionException { } - protected DFA14 dfa14 = new DFA14(this); - static final String DFA14_eotS = - "\1\uffff\1\61\1\63\1\65\1\67\1\uffff\1\72\1\uffff\1\76\13\101\2\uffff\1\101\7\uffff\2\101\1\150\1\101\1\uffff\1\154\1\157\3\101\1\57\1\164\1\57\1\uffff\2\57\21\uffff\2\101\1\uffff\25\101\1\u0092\2\uffff\1\u0093\1\101\7\uffff\4\101\2\uffff\2\101\5\uffff\3\101\2\uffff\1\164\2\uffff\15\101\1\u00ab\1\101\1\u00ae\7\101\1\u00b6\2\101\2\uffff\5\101\1\u00bf\5\101\1\u00c5\10\101\1\u00ce\1\u00cf\1\101\1\uffff\1\u00d1\1\101\1\uffff\2\101\1\u00d5\1\u00d6\2\101\1\u00d9\1\uffff\4\101\1\uffff\1\101\1\u00df\1\101\1\uffff\5\101\1\uffff\10\101\2\uffff\1\101\1\uffff\1\101\1\u00f0\1\u00f1\2\uffff\2\101\1\uffff\5\101\1\uffff\6\101\1\u0100\1\u0101\1\u0102\1\u0103\1\101\1\u0105\1\u0106\2\101\1\u0109\2\uffff\3\101\1\u010d\2\101\1\u0110\1\101\1\u0112\3\101\1\u0116\1\101\4\uffff\1\101\2\uffff\2\101\1\uffff\3\101\1\uffff\1\u011e\1\101\1\uffff\1\u0120\1\uffff\2\101\2\uffff\7\101\1\uffff\1\101\1\uffff\3\101\1\uffff\1\u012e\1\u012f\2\101\1\u0132\1\u0133\1\u0134\1\u0135\1\101\2\uffff\1\u0137\1\u0138\4\uffff\1\u0139\3\uffff"; - static final String DFA14_eofS = - "\u013a\uffff"; - static final String DFA14_minS = - "\1\0\4\75\1\uffff\1\76\1\uffff\1\52\1\141\2\145\1\154\1\145\1\141\1\150\1\157\1\151\1\145\1\146\2\uffff\1\163\7\uffff\1\156\1\141\1\72\1\145\1\uffff\1\60\1\174\1\114\1\165\1\142\1\46\1\56\1\101\1\uffff\2\0\21\uffff\1\154\1\163\1\uffff\1\154\1\162\1\151\1\152\1\151\1\141\1\163\1\164\1\167\1\154\1\162\1\154\1\145\1\165\1\145\1\160\1\154\1\163\2\164\1\160\1\60\2\uffff\1\60\1\164\7\uffff\2\151\1\164\1\146\2\uffff\1\164\1\157\5\uffff\1\117\1\141\1\152\2\uffff\1\56\2\uffff\1\154\2\145\2\164\1\145\1\157\1\163\1\157\1\145\1\154\1\145\1\105\1\60\1\154\1\60\1\163\1\154\1\145\1\156\1\145\1\154\1\164\1\60\1\145\1\154\2\uffff\1\162\1\55\1\161\2\141\1\60\1\153\1\102\1\154\2\145\1\60\1\143\1\102\2\143\1\165\1\164\1\162\1\156\2\60\1\170\1\uffff\1\60\1\154\1\uffff\1\145\1\144\2\60\1\123\1\145\1\60\1\uffff\2\162\2\151\1\uffff\1\165\1\60\1\165\1\uffff\1\165\1\101\1\151\2\143\1\uffff\1\164\1\171\1\150\1\164\1\162\1\163\1\164\1\163\2\uffff\1\151\1\uffff\1\154\2\60\2\uffff\1\145\1\143\1\uffff\1\146\1\164\1\145\1\142\1\145\1\uffff\1\154\1\160\1\114\1\146\2\164\4\60\1\143\2\60\1\151\1\163\1\60\2\uffff\1\154\1\164\1\141\1\60\1\163\1\165\1\60\1\164\1\60\1\126\1\151\1\55\1\60\1\151\4\uffff\1\145\2\uffff\1\157\1\164\1\uffff\1\145\1\151\1\143\1\uffff\1\60\1\164\1\uffff\1\60\1\uffff\1\101\1\145\2\uffff\1\162\1\55\1\156\1\163\1\143\1\157\1\145\1\uffff\1\145\1\uffff\1\122\1\144\1\163\1\uffff\2\60\1\164\1\156\4\60\1\164\2\uffff\2\60\4\uffff\1\60\3\uffff"; - static final String DFA14_maxS = - "\1\uffff\4\75\1\uffff\1\76\1\uffff\1\57\1\157\1\167\1\145\1\170\1\165\1\157\1\171\1\157\1\151\1\145\1\156\2\uffff\1\164\7\uffff\1\162\1\145\1\72\1\157\1\uffff\1\71\1\174\1\114\1\165\1\142\1\46\1\71\1\172\1\uffff\2\uffff\21\uffff\1\154\1\163\1\uffff\1\154\1\162\1\151\1\163\1\164\1\141\1\163\1\164\1\167\1\154\1\162\1\154\1\145\1\165\1\145\1\160\1\154\1\163\2\164\1\160\1\172\2\uffff\1\172\1\164\7\uffff\2\151\1\164\1\146\2\uffff\1\164\1\157\5\uffff\1\117\1\141\1\152\2\uffff\1\71\2\uffff\1\154\2\145\2\164\1\145\1\157\1\163\1\157\1\145\1\154\1\145\1\105\1\172\1\154\1\172\1\163\1\154\1\145\1\156\1\145\1\154\1\164\1\172\1\145\1\157\2\uffff\1\162\1\55\1\161\2\141\1\172\1\153\1\102\1\154\2\145\1\172\1\143\1\102\2\143\1\165\1\164\1\162\1\156\2\172\1\170\1\uffff\1\172\1\154\1\uffff\1\145\1\144\2\172\1\123\1\145\1\172\1\uffff\2\162\2\151\1\uffff\1\165\1\172\1\165\1\uffff\1\165\1\101\1\151\2\143\1\uffff\1\164\1\171\1\150\1\164\1\162\1\163\1\164\1\163\2\uffff\1\151\1\uffff\1\154\2\172\2\uffff\1\145\1\143\1\uffff\1\146\1\164\1\145\1\142\1\145\1\uffff\1\154\1\160\1\114\1\146\2\164\4\172\1\143\2\172\1\151\1\163\1\172\2\uffff\1\154\1\164\1\141\1\172\1\163\1\165\1\172\1\164\1\172\1\126\1\151\1\55\1\172\1\151\4\uffff\1\145\2\uffff\1\157\1\164\1\uffff\1\145\1\151\1\143\1\uffff\1\172\1\164\1\uffff\1\172\1\uffff\1\101\1\145\2\uffff\1\162\1\55\1\156\1\163\1\143\1\157\1\145\1\uffff\1\145\1\uffff\1\122\1\144\1\163\1\uffff\2\172\1\164\1\156\4\172\1\164\2\uffff\2\172\4\uffff\1\172\3\uffff"; - static final String DFA14_acceptS = - "\5\uffff\1\7\1\uffff\1\11\14\uffff\1\34\1\35\1\uffff\1\41\1\42\1\43\1\45\1\46\1\50\1\51\4\uffff\1\62\10\uffff\1\110\2\uffff\1\115\1\116\1\1\1\44\1\2\1\13\1\3\1\5\1\4\1\6\1\7\1\61\1\10\1\11\1\113\1\114\1\12\2\uffff\1\110\26\uffff\1\34\1\35\2\uffff\1\41\1\42\1\43\1\45\1\46\1\50\1\51\4\uffff\1\56\1\60\2\uffff\1\62\1\71\1\107\1\102\1\72\3\uffff\1\103\1\111\1\uffff\1\112\1\115\32\uffff\1\63\1\37\27\uffff\1\74\2\uffff\1\32\7\uffff\1\30\4\uffff\1\52\3\uffff\1\57\5\uffff\1\70\10\uffff\1\47\1\65\1\uffff\1\106\3\uffff\1\24\1\64\2\uffff\1\27\5\uffff\1\55\20\uffff\1\25\1\54\16\uffff\1\15\1\22\1\66\1\17\1\uffff\1\20\1\31\2\uffff\1\23\3\uffff\1\36\2\uffff\1\77\1\uffff\1\75\2\uffff\1\100\1\14\7\uffff\1\104\1\uffff\1\67\3\uffff\1\101\11\uffff\1\40\1\21\2\uffff\1\33\1\53\1\73\1\76\1\uffff\1\105\1\26\1\16"; - static final String DFA14_specialS = - "\1\0\53\uffff\1\1\1\2\u010c\uffff}>"; - static final String[] DFA14_transitionS = { - "\11\57\2\56\2\57\1\56\22\57\1\56\1\2\1\54\3\57\1\50\1\55\1\34\1\35\1\7\1\5\1\32\1\6\1\43\1\10\12\51\1\40\1\27\1\4\1\1\1\3\1\42\1\33\2\53\1\20\3\53\1\45\4\53\1\21\6\53\1\22\7\53\1\30\1\57\1\31\1\52\1\53\1\57\1\26\1\53\1\11\1\37\1\14\1\16\2\53\1\23\2\53\1\41\1\53\1\15\1\47\1\53\1\46\1\13\1\12\1\17\1\36\5\53\1\24\1\44\1\25\uff82\57", - "\1\60", - "\1\62", - "\1\64", - "\1\66", - "", - "\1\71", + protected DFA23 dfa23 = new DFA23(this); + static final String DFA23_eotS = + "\1\uffff\1\67\1\71\1\73\1\75\1\77\1\102\1\105\1\111\1\114\1\120\12\123\1\153\1\155\1\161\2\123\2\uffff\1\123\7\uffff\2\123\1\u0087\2\123\1\uffff\3\123\2\u0092\1\64\5\uffff\1\u0097\6\uffff\1\u0099\24\uffff\2\123\1\uffff\26\123\2\uffff\1\u00bb\5\uffff\3\123\1\u00c1\2\uffff\1\u00c2\1\123\7\uffff\4\123\1\u00c8\2\uffff\3\123\1\uffff\3\123\1\uffff\2\u0092\10\uffff\22\123\1\u00e1\1\123\1\u00e4\4\123\1\u00e9\5\123\1\u00ef\2\uffff\1\u00f0\1\u00f1\3\123\2\uffff\5\123\1\uffff\1\u00fb\6\123\1\u0102\15\123\1\u0110\1\u0111\1\123\1\uffff\1\u0113\1\123\1\uffff\3\123\1\u0118\1\uffff\1\u0119\3\123\1\u011e\3\uffff\5\123\1\uffff\1\123\1\u0125\1\123\1\uffff\6\123\1\uffff\1\u012d\3\123\1\u0131\10\123\2\uffff\1\123\1\uffff\1\123\1\u013d\1\u013e\1\123\2\uffff\1\u0140\3\123\1\uffff\6\123\1\uffff\3\123\1\u014d\3\123\1\uffff\1\u0152\1\u0153\1\u0154\1\uffff\1\u0155\1\123\1\u0157\1\u0158\1\123\1\u015a\2\123\1\u015d\1\123\1\u015f\2\uffff\1\123\1\uffff\1\u0161\2\123\1\u0164\4\123\1\u0169\1\123\1\u016b\1\123\1\uffff\2\123\1\u016f\1\123\4\uffff\1\123\2\uffff\1\123\1\uffff\1\u0173\1\123\1\uffff\1\123\1\uffff\1\u0176\1\uffff\2\123\1\uffff\1\u0179\3\123\1\uffff\1\u017d\1\uffff\2\123\2\uffff\3\123\1\uffff\2\123\1\uffff\2\123\1\uffff\3\123\1\uffff\4\123\1\uffff\1\u018e\1\u018f\2\123\1\u0192\1\123\1\u0194\1\u0195\1\u0196\2\123\2\uffff\1\u0199\1\u019a\1\uffff\1\u019b\3\uffff\1\u019c\1\123\4\uffff\1\u019e\1\uffff"; + static final String DFA23_eofS = + "\u019f\uffff"; + static final String DFA23_minS = + "\1\0\1\75\1\174\1\46\3\75\1\53\1\55\2\52\1\141\2\145\1\154\1\145\1\141\1\150\1\157\1\151\1\145\1\75\2\56\1\141\1\146\2\uffff\1\163\7\uffff\1\156\1\141\1\72\1\145\1\114\1\uffff\1\150\1\165\1\142\2\56\1\44\5\uffff\1\75\6\uffff\1\75\24\uffff\1\154\1\163\1\uffff\1\154\1\162\1\141\1\160\1\151\1\156\1\152\1\151\1\141\1\163\1\164\1\167\1\154\1\162\1\154\1\145\1\165\1\145\1\160\1\154\1\163\1\164\2\uffff\1\74\5\uffff\1\154\1\160\1\163\1\44\2\uffff\1\44\1\164\7\uffff\2\151\1\164\1\146\1\44\2\uffff\1\164\1\157\1\117\1\uffff\1\151\1\141\1\152\1\uffff\1\56\1\60\10\uffff\1\154\1\145\1\143\1\145\2\164\1\145\1\164\1\143\1\145\1\165\1\157\1\163\1\145\1\157\1\154\1\145\1\105\1\44\1\154\1\44\1\163\1\154\1\141\1\145\1\44\1\156\1\157\1\145\1\154\1\164\1\44\2\uffff\2\44\1\154\1\145\1\164\2\uffff\1\162\1\55\1\161\2\141\1\uffff\1\44\1\153\1\102\2\154\2\145\1\44\1\150\1\143\1\102\1\151\1\162\1\143\1\150\1\143\1\162\1\165\1\164\1\156\1\162\2\44\1\170\1\uffff\1\44\1\154\1\uffff\1\145\1\144\1\154\1\44\1\uffff\1\44\1\167\1\123\1\145\1\44\3\uffff\1\162\1\151\1\162\1\141\1\151\1\uffff\1\165\1\44\1\165\1\uffff\1\165\1\101\1\145\1\151\2\143\1\uffff\1\44\1\164\1\171\1\143\1\44\1\150\1\162\1\164\1\156\1\162\1\163\1\144\1\164\2\uffff\1\151\1\uffff\1\154\2\44\1\154\2\uffff\1\44\1\146\1\145\1\143\1\uffff\1\164\1\145\1\146\1\156\1\142\1\145\1\uffff\1\154\1\160\1\114\1\44\1\146\2\164\1\uffff\3\44\1\uffff\1\44\1\157\2\44\1\143\1\44\1\163\1\151\1\44\1\163\1\44\2\uffff\1\171\1\uffff\1\44\1\154\1\164\1\44\1\163\1\141\1\143\1\165\1\44\1\164\1\44\1\126\1\uffff\1\151\1\55\1\44\1\151\4\uffff\1\156\2\uffff\1\145\1\uffff\1\44\1\157\1\uffff\1\164\1\uffff\1\44\1\uffff\1\145\1\151\1\uffff\1\44\1\143\1\145\1\164\1\uffff\1\44\1\uffff\1\101\1\145\2\uffff\1\162\1\151\1\55\1\uffff\1\156\1\163\1\uffff\1\143\1\157\1\uffff\1\145\1\157\1\145\1\uffff\1\122\1\144\1\163\1\172\1\uffff\2\44\1\164\1\156\1\44\1\146\3\44\1\164\1\145\2\uffff\2\44\1\uffff\1\44\3\uffff\1\44\1\144\4\uffff\1\44\1\uffff"; + static final String DFA23_maxS = + "\1\uffff\1\76\1\174\1\46\2\75\1\76\1\75\1\76\2\75\1\157\1\171\1\145\1\170\1\165\1\157\1\171\1\157\1\151\1\145\1\75\1\71\1\72\1\141\1\156\2\uffff\1\164\7\uffff\1\162\1\157\1\72\1\157\1\114\1\uffff\1\150\1\165\1\142\1\170\1\154\1\172\5\uffff\1\75\6\uffff\1\75\24\uffff\1\154\1\164\1\uffff\1\154\1\162\1\141\1\160\1\151\1\156\2\164\1\141\1\163\1\164\1\167\1\154\1\162\1\154\1\156\1\171\1\162\1\160\1\154\1\163\1\164\2\uffff\1\74\5\uffff\1\162\1\160\1\164\1\172\2\uffff\1\172\1\164\7\uffff\2\151\1\164\1\146\1\172\2\uffff\1\164\1\157\1\117\1\uffff\1\151\1\141\1\152\1\uffff\2\154\10\uffff\1\154\1\145\1\143\1\145\2\164\1\145\1\164\1\143\1\145\1\165\1\157\1\163\1\145\1\157\1\154\1\145\1\105\1\172\1\154\1\172\1\163\1\154\1\141\1\145\1\172\1\156\1\157\1\145\1\154\1\164\1\172\2\uffff\2\172\1\157\1\145\1\164\2\uffff\1\162\1\55\1\161\2\141\1\uffff\1\172\1\153\1\102\2\154\2\145\1\172\1\150\1\143\1\102\1\151\1\162\1\143\1\150\1\143\1\162\1\165\1\164\1\156\1\162\2\172\1\170\1\uffff\1\172\1\154\1\uffff\1\145\1\144\1\154\1\172\1\uffff\1\172\1\167\1\157\1\145\1\172\3\uffff\1\162\1\151\1\162\1\141\1\151\1\uffff\1\165\1\172\1\165\1\uffff\1\165\1\101\1\145\1\151\2\143\1\uffff\1\172\1\164\1\171\1\143\1\172\1\150\1\162\1\164\1\156\1\162\2\163\1\164\2\uffff\1\151\1\uffff\1\154\2\172\1\154\2\uffff\1\172\1\146\1\145\1\143\1\uffff\1\164\1\145\1\146\1\156\1\142\1\145\1\uffff\1\154\1\160\1\114\1\172\1\146\2\164\1\uffff\3\172\1\uffff\1\172\1\157\2\172\1\143\1\172\1\163\1\151\1\172\1\163\1\172\2\uffff\1\171\1\uffff\1\172\1\154\1\164\1\172\1\163\1\141\1\143\1\165\1\172\1\164\1\172\1\126\1\uffff\1\151\1\55\1\172\1\151\4\uffff\1\156\2\uffff\1\145\1\uffff\1\172\1\157\1\uffff\1\164\1\uffff\1\172\1\uffff\1\145\1\151\1\uffff\1\172\1\143\1\145\1\164\1\uffff\1\172\1\uffff\1\101\1\145\2\uffff\1\162\1\151\1\55\1\uffff\1\156\1\163\1\uffff\1\143\1\157\1\uffff\1\145\1\157\1\145\1\uffff\1\122\1\144\1\163\1\172\1\uffff\2\172\1\164\1\156\1\172\1\146\3\172\1\164\1\145\2\uffff\2\172\1\uffff\1\172\3\uffff\1\172\1\144\4\uffff\1\172\1\uffff"; + static final String DFA23_acceptS = + "\32\uffff\1\67\1\70\1\uffff\1\72\1\73\1\74\1\75\1\76\1\100\1\101\5\uffff\1\124\6\uffff\1\155\2\156\1\161\1\162\1\uffff\1\46\1\1\1\2\1\120\1\3\1\137\1\uffff\1\16\1\6\1\10\1\7\1\47\1\11\1\34\1\53\1\12\1\35\1\43\1\54\1\13\1\36\1\51\1\14\1\37\1\157\1\160\1\15\2\uffff\1\155\26\uffff\1\40\1\52\1\uffff\1\55\1\151\1\50\1\147\1\111\4\uffff\1\67\1\70\2\uffff\1\72\1\73\1\74\1\75\1\76\1\100\1\101\5\uffff\1\106\1\110\3\uffff\1\124\3\uffff\1\152\2\uffff\1\153\1\154\1\156\1\161\1\41\1\4\1\42\1\5\40\uffff\1\44\1\45\5\uffff\1\112\1\71\5\uffff\1\126\30\uffff\1\122\2\uffff\1\65\4\uffff\1\133\5\uffff\1\33\1\56\1\150\5\uffff\1\102\3\uffff\1\107\6\uffff\1\117\15\uffff\1\77\1\114\1\uffff\1\127\4\uffff\1\27\1\113\4\uffff\1\32\6\uffff\1\105\7\uffff\1\136\3\uffff\1\63\13\uffff\1\30\1\104\1\uffff\1\131\14\uffff\1\125\4\uffff\1\20\1\25\1\60\1\115\1\uffff\1\22\1\132\1\uffff\1\23\2\uffff\1\64\1\uffff\1\26\1\uffff\1\130\2\uffff\1\61\4\uffff\1\142\1\uffff\1\140\2\uffff\1\143\1\17\3\uffff\1\57\2\uffff\1\134\2\uffff\1\145\3\uffff\1\116\4\uffff\1\144\13\uffff\1\62\1\24\2\uffff\1\66\1\uffff\1\103\1\121\1\141\2\uffff\1\146\1\31\1\123\1\21\1\uffff\1\135"; + static final String DFA23_specialS = + "\1\0\u019e\uffff}>"; + static final String[] DFA23_transitionS = { + "\11\64\2\63\2\64\1\63\22\64\1\63\1\4\1\61\1\51\1\60\1\25\1\3\1\62\1\42\1\43\1\11\1\7\1\40\1\10\1\26\1\12\1\55\11\56\1\46\1\35\1\6\1\1\1\5\1\27\1\41\2\60\1\22\3\60\1\50\4\60\1\23\6\60\1\24\7\60\1\36\1\64\1\37\1\57\1\60\1\64\1\34\1\60\1\13\1\45\1\16\1\20\2\60\1\31\2\60\1\47\1\60\1\17\1\54\1\60\1\53\1\15\1\14\1\21\1\44\1\30\1\52\3\60\1\32\1\2\1\33\uff82\64", + "\1\65\1\66", + "\1\70", + "\1\72", + "\1\74", + "\1\76", + "\1\100\1\101", + "\1\104\21\uffff\1\103", + "\1\110\17\uffff\1\106\1\107", + "\1\113\22\uffff\1\112", + "\1\116\4\uffff\1\117\15\uffff\1\115", + "\1\122\15\uffff\1\121", + "\1\124\11\uffff\1\125\4\uffff\1\126\1\127\1\uffff\1\130\1\uffff\1\131", + "\1\132", + "\1\135\11\uffff\1\134\1\uffff\1\133", + "\1\137\11\uffff\1\136\5\uffff\1\140", + "\1\142\7\uffff\1\143\5\uffff\1\141", + "\1\145\11\uffff\1\144\6\uffff\1\146", + "\1\147", + "\1\150", + "\1\151", + "\1\152", + "\1\154\1\uffff\12\156", + "\1\160\13\uffff\1\157", + "\1\162", + "\1\165\6\uffff\1\163\1\164", "", - "\1\74\4\uffff\1\75", - "\1\100\15\uffff\1\77", - "\1\102\11\uffff\1\103\7\uffff\1\104", - "\1\105", - "\1\110\11\uffff\1\107\1\uffff\1\106", - "\1\112\11\uffff\1\111\5\uffff\1\113", - "\1\115\7\uffff\1\116\5\uffff\1\114", - "\1\120\11\uffff\1\117\6\uffff\1\121", - "\1\122", - "\1\123", - "\1\124", - "\1\127\6\uffff\1\126\1\125", "", + "\1\170\1\171", "", - "\1\132\1\133", "", "", "", "", "", "", + "\1\u0082\3\uffff\1\u0081", + "\1\u0083\3\uffff\1\u0084\11\uffff\1\u0085", + "\1\u0086", + "\1\u0088\11\uffff\1\u0089", + "\1\u008a", "", - "\1\144\3\uffff\1\143", - "\1\145\3\uffff\1\146", - "\1\147", - "\1\151\11\uffff\1\152", + "\1\u008c", + "\1\u008d", + "\1\u008e", + "\1\156\1\uffff\12\u0090\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\13\uffff\1\u008f\6\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\13\uffff\1\u008f", + "\1\156\1\uffff\12\u0090\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\22\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093", + "\1\123\34\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "", - "\12\155", - "\1\156", - "\1\160", - "\1\161", - "\1\162", - "\1\163", - "\1\155\1\uffff\12\165", - "\32\101\4\uffff\1\101\1\uffff\32\101", "", - "\0\166", - "\0\166", "", "", "", + "\1\u0096", "", "", "", "", "", "", + "\1\u0098", "", "", "", @@ -2756,35 +4105,9 @@ public void mTokens() throws RecognitionException { "", "", "", - "\1\170", - "\1\171", "", - "\1\172", - "\1\173", - "\1\174", - "\1\175\10\uffff\1\176", - "\1\177\6\uffff\1\u0080\3\uffff\1\u0081", - "\1\u0082", - "\1\u0083", - "\1\u0084", - "\1\u0085", - "\1\u0086", - "\1\u0087", - "\1\u0088", - "\1\u0089", - "\1\u008a", - "\1\u008b", - "\1\u008c", - "\1\u008d", - "\1\u008e", - "\1\u008f", - "\1\u0090", - "\1\u0091", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", "", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u0094", "", "", "", @@ -2792,382 +4115,493 @@ public void mTokens() throws RecognitionException { "", "", "", - "\1\u0095", - "\1\u0096", - "\1\u0097", - "\1\u0098", "", "", - "\1\u0099", "\1\u009a", + "\1\u009b\1\u009c", "", - "", - "", - "", - "", - "\1\u009b", - "\1\u009c", "\1\u009d", - "", - "", - "\1\155\1\uffff\12\165", - "", - "", "\1\u009e", "\1\u009f", "\1\u00a0", "\1\u00a1", "\1\u00a2", - "\1\u00a3", - "\1\u00a4", - "\1\u00a5", - "\1\u00a6", - "\1\u00a7", - "\1\u00a8", + "\1\u00a3\10\uffff\1\u00a5\1\u00a4", + "\1\u00a6\6\uffff\1\u00a8\3\uffff\1\u00a7", "\1\u00a9", "\1\u00aa", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00ab", "\1\u00ac", - "\12\101\7\uffff\1\u00ad\31\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00ad", + "\1\u00ae", "\1\u00af", - "\1\u00b0", - "\1\u00b1", - "\1\u00b2", - "\1\u00b3", - "\1\u00b4", - "\1\u00b5", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00b0\10\uffff\1\u00b1", + "\1\u00b2\3\uffff\1\u00b3", + "\1\u00b4\14\uffff\1\u00b5", + "\1\u00b6", "\1\u00b7", - "\1\u00b9\2\uffff\1\u00b8", + "\1\u00b8", + "\1\u00b9", "", "", "\1\u00ba", - "\1\u00bb", - "\1\u00bc", - "\1\u00bd", + "", + "", + "", + "", + "", + "\1\u00bc\5\uffff\1\u00bd", "\1\u00be", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u00c0", - "\1\u00c1", - "\1\u00c2", + "\1\u00c0\1\u00bf", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u00c3", + "", + "", + "", + "", + "", + "", + "", "\1\u00c4", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00c5", "\1\u00c6", "\1\u00c7", - "\1\u00c8", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "", "\1\u00c9", "\1\u00ca", "\1\u00cb", + "", "\1\u00cc", "\1\u00cd", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u00d0", + "\1\u00ce", + "", + "\1\156\1\uffff\12\u0090\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\22\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093", + "\12\u0091\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\22\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u00d2", "", + "", + "", + "", + "", + "", + "", + "\1\u00cf", + "\1\u00d0", + "\1\u00d1", + "\1\u00d2", "\1\u00d3", "\1\u00d4", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00d5", + "\1\u00d6", "\1\u00d7", "\1\u00d8", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "", + "\1\u00d9", "\1\u00da", "\1\u00db", "\1\u00dc", "\1\u00dd", - "", "\1\u00de", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00df", "\1\u00e0", - "", - "\1\u00e1", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u00e2", - "\1\u00e3", - "\1\u00e4", + "\1\123\13\uffff\12\123\7\uffff\1\u00e3\31\123\4\uffff\1\123\1\uffff\32\123", "\1\u00e5", - "", "\1\u00e6", "\1\u00e7", "\1\u00e8", - "\1\u00e9", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u00ea", "\1\u00eb", "\1\u00ec", "\1\u00ed", - "", - "", "\1\u00ee", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "", - "\1\u00ef", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "", - "", - "\1\u00f2", - "\1\u00f3", "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u00f3\2\uffff\1\u00f2", "\1\u00f4", "\1\u00f5", + "", + "", "\1\u00f6", "\1\u00f7", "\1\u00f8", - "", "\1\u00f9", "\1\u00fa", - "\1\u00fb", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u00fc", "\1\u00fd", "\1\u00fe", - "\12\101\7\uffff\5\101\1\u00ff\24\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u00ff", + "\1\u0100", + "\1\u0101", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0103", "\1\u0104", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u0105", + "\1\u0106", "\1\u0107", "\1\u0108", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "", - "", + "\1\u0109", "\1\u010a", "\1\u010b", "\1\u010c", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u010d", "\1\u010e", "\1\u010f", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u0111", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u0113", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0112", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u0114", + "", "\1\u0115", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\u0116", "\1\u0117", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "", - "", - "", - "", - "\1\u0118", - "", - "", - "\1\u0119", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u011a", - "", - "\1\u011b", - "\1\u011c", + "\1\u011c\33\uffff\1\u011b", "\1\u011d", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\1\u011f", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", "", + "\1\u011f", + "\1\u0120", "\1\u0121", "\1\u0122", - "", - "", "\1\u0123", + "", "\1\u0124", - "\1\u0125", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "\1\u0126", + "", "\1\u0127", "\1\u0128", "\1\u0129", - "", "\1\u012a", - "", "\1\u012b", "\1\u012c", - "\1\u012d", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u012e", + "\1\u012f", "\1\u0130", - "\1\u0131", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0132", + "\1\u0133", + "\1\u0134", + "\1\u0135", "\1\u0136", + "\1\u0137", + "\1\u0138\16\uffff\1\u0139", + "\1\u013a", + "", + "", + "\1\u013b", + "", + "\1\u013c", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u013f", + "", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0141", + "\1\u0142", + "\1\u0143", + "", + "\1\u0144", + "\1\u0145", + "\1\u0146", + "\1\u0147", + "\1\u0148", + "\1\u0149", + "", + "\1\u014a", + "\1\u014b", + "\1\u014c", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u014e", + "\1\u014f", + "\1\u0150", + "", + "\1\123\13\uffff\12\123\7\uffff\5\123\1\u0151\24\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0156", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0159", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u015b", + "\1\u015c", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u015e", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", "", + "\1\u0160", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0162", + "\1\u0163", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0165", + "\1\u0166", + "\1\u0167", + "\1\u0168", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u016a", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u016c", "", + "\1\u016d", + "\1\u016e", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0170", "", "", "", - "\12\101\7\uffff\32\101\4\uffff\1\101\1\uffff\32\101", "", + "\1\u0171", "", + "", + "\1\u0172", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0174", + "", + "\1\u0175", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "\1\u0177", + "\1\u0178", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u017a", + "\1\u017b", + "\1\u017c", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "\1\u017e", + "\1\u017f", + "", + "", + "\1\u0180", + "\1\u0181", + "\1\u0182", + "", + "\1\u0183", + "\1\u0184", + "", + "\1\u0185", + "\1\u0186", + "", + "\1\u0187", + "\1\u0188", + "\1\u0189", + "", + "\1\u018a", + "\1\u018b", + "\1\u018c", + "\1\u018d", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0190", + "\1\u0191", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0193", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u0197", + "\1\u0198", + "", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "", + "", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", + "\1\u019d", + "", + "", + "", + "", + "\1\123\13\uffff\12\123\7\uffff\32\123\4\uffff\1\123\1\uffff\32\123", "" }; - static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); - static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); - static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); - static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); - static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); - static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); - static final short[][] DFA14_transition; + static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); + static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); + static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); + static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); + static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); + static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); + static final short[][] DFA23_transition; static { - int numStates = DFA14_transitionS.length; - DFA14_transition = new short[numStates][]; + int numStates = DFA23_transitionS.length; + DFA23_transition = new short[numStates][]; for (int i=0; i') ) {s = 3;} + else if ( (LA23_0=='|') ) {s = 2;} - else if ( (LA14_0=='<') ) {s = 4;} + else if ( (LA23_0=='&') ) {s = 3;} - else if ( (LA14_0=='+') ) {s = 5;} + else if ( (LA23_0=='!') ) {s = 4;} - else if ( (LA14_0=='-') ) {s = 6;} + else if ( (LA23_0=='>') ) {s = 5;} - else if ( (LA14_0=='*') ) {s = 7;} + else if ( (LA23_0=='<') ) {s = 6;} - else if ( (LA14_0=='/') ) {s = 8;} + else if ( (LA23_0=='+') ) {s = 7;} - else if ( (LA14_0=='c') ) {s = 9;} + else if ( (LA23_0=='-') ) {s = 8;} - else if ( (LA14_0=='s') ) {s = 10;} + else if ( (LA23_0=='*') ) {s = 9;} - else if ( (LA14_0=='r') ) {s = 11;} + else if ( (LA23_0=='/') ) {s = 10;} - else if ( (LA14_0=='e') ) {s = 12;} + else if ( (LA23_0=='c') ) {s = 11;} - else if ( (LA14_0=='n') ) {s = 13;} + else if ( (LA23_0=='s') ) {s = 12;} - else if ( (LA14_0=='f') ) {s = 14;} + else if ( (LA23_0=='r') ) {s = 13;} - else if ( (LA14_0=='t') ) {s = 15;} + else if ( (LA23_0=='e') ) {s = 14;} - else if ( (LA14_0=='C') ) {s = 16;} + else if ( (LA23_0=='n') ) {s = 15;} - else if ( (LA14_0=='L') ) {s = 17;} + else if ( (LA23_0=='f') ) {s = 16;} - else if ( (LA14_0=='S') ) {s = 18;} + else if ( (LA23_0=='t') ) {s = 17;} - else if ( (LA14_0=='i') ) {s = 19;} + else if ( (LA23_0=='C') ) {s = 18;} - else if ( (LA14_0=='{') ) {s = 20;} + else if ( (LA23_0=='L') ) {s = 19;} - else if ( (LA14_0=='}') ) {s = 21;} + else if ( (LA23_0=='S') ) {s = 20;} - else if ( (LA14_0=='a') ) {s = 22;} + else if ( (LA23_0=='%') ) {s = 21;} - else if ( (LA14_0==';') ) {s = 23;} + else if ( (LA23_0=='.') ) {s = 22;} - else if ( (LA14_0=='[') ) {s = 24;} + else if ( (LA23_0=='?') ) {s = 23;} - else if ( (LA14_0==']') ) {s = 25;} + else if ( (LA23_0=='v') ) {s = 24;} - else if ( (LA14_0==',') ) {s = 26;} + else if ( (LA23_0=='i') ) {s = 25;} - else if ( (LA14_0=='@') ) {s = 27;} + else if ( (LA23_0=='{') ) {s = 26;} - else if ( (LA14_0=='(') ) {s = 28;} + else if ( (LA23_0=='}') ) {s = 27;} - else if ( (LA14_0==')') ) {s = 29;} + else if ( (LA23_0=='a') ) {s = 28;} - else if ( (LA14_0=='u') ) {s = 30;} + else if ( (LA23_0==';') ) {s = 29;} - else if ( (LA14_0=='d') ) {s = 31;} + else if ( (LA23_0=='[') ) {s = 30;} - else if ( (LA14_0==':') ) {s = 32;} + else if ( (LA23_0==']') ) {s = 31;} - else if ( (LA14_0=='l') ) {s = 33;} + else if ( (LA23_0==',') ) {s = 32;} - else if ( (LA14_0=='?') ) {s = 34;} + else if ( (LA23_0=='@') ) {s = 33;} - else if ( (LA14_0=='.') ) {s = 35;} + else if ( (LA23_0=='(') ) {s = 34;} - else if ( (LA14_0=='|') ) {s = 36;} + else if ( (LA23_0==')') ) {s = 35;} - else if ( (LA14_0=='G') ) {s = 37;} + else if ( (LA23_0=='u') ) {s = 36;} - else if ( (LA14_0=='q') ) {s = 38;} + else if ( (LA23_0=='d') ) {s = 37;} - else if ( (LA14_0=='o') ) {s = 39;} + else if ( (LA23_0==':') ) {s = 38;} - else if ( (LA14_0=='&') ) {s = 40;} + else if ( (LA23_0=='l') ) {s = 39;} - else if ( ((LA14_0>='0' && LA14_0<='9')) ) {s = 41;} + else if ( (LA23_0=='G') ) {s = 40;} - else if ( (LA14_0=='^') ) {s = 42;} + else if ( (LA23_0=='#') ) {s = 41;} - else if ( ((LA14_0>='A' && LA14_0<='B')||(LA14_0>='D' && LA14_0<='F')||(LA14_0>='H' && LA14_0<='K')||(LA14_0>='M' && LA14_0<='R')||(LA14_0>='T' && LA14_0<='Z')||LA14_0=='_'||LA14_0=='b'||(LA14_0>='g' && LA14_0<='h')||(LA14_0>='j' && LA14_0<='k')||LA14_0=='m'||LA14_0=='p'||(LA14_0>='v' && LA14_0<='z')) ) {s = 43;} + else if ( (LA23_0=='w') ) {s = 42;} - else if ( (LA14_0=='\"') ) {s = 44;} + else if ( (LA23_0=='q') ) {s = 43;} - else if ( (LA14_0=='\'') ) {s = 45;} + else if ( (LA23_0=='o') ) {s = 44;} - else if ( ((LA14_0>='\t' && LA14_0<='\n')||LA14_0=='\r'||LA14_0==' ') ) {s = 46;} + else if ( (LA23_0=='0') ) {s = 45;} - else if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||(LA14_0>='#' && LA14_0<='%')||LA14_0=='\\'||LA14_0=='`'||(LA14_0>='~' && LA14_0<='\uFFFF')) ) {s = 47;} + else if ( ((LA23_0>='1' && LA23_0<='9')) ) {s = 46;} - if ( s>=0 ) return s; - break; - case 1 : - int LA14_44 = input.LA(1); + else if ( (LA23_0=='^') ) {s = 47;} - s = -1; - if ( ((LA14_44>='\u0000' && LA14_44<='\uFFFF')) ) {s = 118;} + else if ( (LA23_0=='$'||(LA23_0>='A' && LA23_0<='B')||(LA23_0>='D' && LA23_0<='F')||(LA23_0>='H' && LA23_0<='K')||(LA23_0>='M' && LA23_0<='R')||(LA23_0>='T' && LA23_0<='Z')||LA23_0=='_'||LA23_0=='b'||(LA23_0>='g' && LA23_0<='h')||(LA23_0>='j' && LA23_0<='k')||LA23_0=='m'||LA23_0=='p'||(LA23_0>='x' && LA23_0<='z')) ) {s = 48;} - else s = 47; + else if ( (LA23_0=='\"') ) {s = 49;} - if ( s>=0 ) return s; - break; - case 2 : - int LA14_45 = input.LA(1); + else if ( (LA23_0=='\'') ) {s = 50;} - s = -1; - if ( ((LA14_45>='\u0000' && LA14_45<='\uFFFF')) ) {s = 118;} + else if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {s = 51;} - else s = 47; + else if ( ((LA23_0>='\u0000' && LA23_0<='\b')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\u001F')||LA23_0=='\\'||LA23_0=='`'||(LA23_0>='~' && LA23_0<='\uFFFF')) ) {s = 52;} if ( s>=0 ) return s; break; } NoViableAltException nvae = - new NoViableAltException(getDescription(), 14, _s, input); + new NoViableAltException(getDescription(), 23, _s, input); error(nvae); throw nvae; } diff --git a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportParser.java b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportParser.java index 6e68fd3970..b05f403101 100644 --- a/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportParser.java +++ b/com.avaloq.tools.ddk.xtext.export.ide/src-gen/com/avaloq/tools/ddk/xtext/export/ide/contentassist/antlr/internal/InternalExportParser.java @@ -23,21 +23,14 @@ @SuppressWarnings("all") public class InternalExportParser extends AbstractInternalContentAssistParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_ID", "RULE_STRING", "RULE_INT", "RULE_REAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'Collection'", "'List'", "'Set'", "'export'", "'for'", "'interface'", "'{'", "'}'", "'import'", "'as'", "'extension'", "';'", "'['", "']'", "'='", "','", "'@'", "'eval'", "'('", "')'", "'uri-fragment'", "'attribute'", "'field'", "'data'", "'::'", "'let'", "':'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'case'", "'.'", "'|'", "'GLOBALVAR'", "'new'", "'lookup'", "'qualified'", "'unique'", "'object-fingerprint'", "'resource-fingerprint'", "'||'", "'&&'", "'implies'", "'typeSelect'", "'null'" + "", "", "", "", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_STRING", "RULE_REAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'='", "'||'", "'&&'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'Collection'", "'List'", "'Set'", "'+='", "'-='", "'*='", "'/='", "'%='", "'==='", "'!=='", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'**'", "'%'", "'++'", "'--'", "'.'", "'val'", "'extends'", "'static'", "'import'", "'extension'", "'super'", "'export'", "'for'", "'interface'", "'{'", "'}'", "'as'", "';'", "'['", "']'", "','", "'@'", "'eval'", "'('", "')'", "'uri-fragment'", "'attribute'", "'field'", "'data'", "'::'", "'let'", "':'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'case'", "'|'", "'GLOBALVAR'", "'new'", "'instanceof'", "'#'", "'while'", "'do'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'&'", "'lookup'", "'qualified'", "'unique'", "'object-fingerprint'", "'resource-fingerprint'", "'implies'", "'typeSelect'", "'?.'", "'var'" }; + public static final int RULE_HEX=5; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -46,54 +39,27 @@ public class InternalExportParser extends AbstractInternalContentAssistParser { public static final int T__60=60; public static final int T__61=61; public static final int RULE_ID=4; - public static final int RULE_REAL=7; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; + public static final int RULE_REAL=9; public static final int RULE_INT=6; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=5; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -104,6 +70,76 @@ public class InternalExportParser extends AbstractInternalContentAssistParser { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=8; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -4295,212 +4331,230 @@ public final void ruleIdentifier() throws RecognitionException { // $ANTLR end "ruleIdentifier" - // $ANTLR start "rule__InterfaceItem__Alternatives" - // InternalExport.g:1278:1: rule__InterfaceItem__Alternatives : ( ( ruleInterfaceField ) | ( ruleInterfaceNavigation ) | ( ruleInterfaceExpression ) ); - public final void rule__InterfaceItem__Alternatives() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpression" + // InternalExport.g:1279:1: entryRuleXExpression : ruleXExpression EOF ; + public final void entryRuleXExpression() throws RecognitionException { try { - // InternalExport.g:1282:1: ( ( ruleInterfaceField ) | ( ruleInterfaceNavigation ) | ( ruleInterfaceExpression ) ) - int alt1=3; - switch ( input.LA(1) ) { - case RULE_ID: - case 18: - { - alt1=1; - } - break; - case 49: - { - alt1=2; - } - break; - case 50: - { - alt1=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 1, 0, input); + // InternalExport.g:1280:1: ( ruleXExpression EOF ) + // InternalExport.g:1281:1: ruleXExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionRule()); } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - switch (alt1) { - case 1 : - // InternalExport.g:1283:2: ( ruleInterfaceField ) - { - // InternalExport.g:1283:2: ( ruleInterfaceField ) - // InternalExport.g:1284:3: ruleInterfaceField - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleInterfaceField(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXExpression" - } + // $ANTLR start "ruleXExpression" + // InternalExport.g:1288:1: ruleXExpression : ( ruleXAssignment ) ; + public final void ruleXExpression() throws RecognitionException { - } - break; - case 2 : - // InternalExport.g:1289:2: ( ruleInterfaceNavigation ) - { - // InternalExport.g:1289:2: ( ruleInterfaceNavigation ) - // InternalExport.g:1290:3: ruleInterfaceNavigation - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleInterfaceNavigation(); + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1292:2: ( ( ruleXAssignment ) ) + // InternalExport.g:1293:2: ( ruleXAssignment ) + { + // InternalExport.g:1293:2: ( ruleXAssignment ) + // InternalExport.g:1294:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } - } + } - } - break; - case 3 : - // InternalExport.g:1295:2: ( ruleInterfaceExpression ) - { - // InternalExport.g:1295:2: ( ruleInterfaceExpression ) - // InternalExport.g:1296:3: ruleInterfaceExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleInterfaceExpression(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXExpression" - } - break; + + // $ANTLR start "entryRuleXAssignment" + // InternalExport.g:1304:1: entryRuleXAssignment : ruleXAssignment EOF ; + public final void entryRuleXAssignment() throws RecognitionException { + try { + // InternalExport.g:1305:1: ( ruleXAssignment EOF ) + // InternalExport.g:1306:1: ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_1); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceItem__Alternatives" + // $ANTLR end "entryRuleXAssignment" - // $ANTLR start "rule__Export__Alternatives_7_0" - // InternalExport.g:1305:1: rule__Export__Alternatives_7_0 : ( ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) | ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) ); - public final void rule__Export__Alternatives_7_0() throws RecognitionException { + // $ANTLR start "ruleXAssignment" + // InternalExport.g:1313:1: ruleXAssignment : ( ( rule__XAssignment__Alternatives ) ) ; + public final void ruleXAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1309:1: ( ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) | ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) ) - int alt2=2; - int LA2_0 = input.LA(1); + // InternalExport.g:1317:2: ( ( ( rule__XAssignment__Alternatives ) ) ) + // InternalExport.g:1318:2: ( ( rule__XAssignment__Alternatives ) ) + { + // InternalExport.g:1318:2: ( ( rule__XAssignment__Alternatives ) ) + // InternalExport.g:1319:3: ( rule__XAssignment__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getAlternatives()); + } + // InternalExport.g:1320:3: ( rule__XAssignment__Alternatives ) + // InternalExport.g:1320:4: rule__XAssignment__Alternatives + { + pushFollow(FOLLOW_2); + rule__XAssignment__Alternatives(); + + state._fsp--; + if (state.failed) return ; - if ( (LA2_0==75) ) { - alt2=1; } - else if ( (LA2_0==76) ) { - alt2=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getAlternatives()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 2, 0, input); - throw nvae; } - switch (alt2) { - case 1 : - // InternalExport.g:1310:2: ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) - { - // InternalExport.g:1310:2: ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) - // InternalExport.g:1311:3: ( rule__Export__FingerprintAssignment_7_0_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); - } - // InternalExport.g:1312:3: ( rule__Export__FingerprintAssignment_7_0_0 ) - // InternalExport.g:1312:4: rule__Export__FingerprintAssignment_7_0_0 - { - pushFollow(FOLLOW_2); - rule__Export__FingerprintAssignment_7_0_0(); - state._fsp--; - if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXAssignment" - } - break; - case 2 : - // InternalExport.g:1316:2: ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) - { - // InternalExport.g:1316:2: ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) - // InternalExport.g:1317:3: ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); - } - // InternalExport.g:1318:3: ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) - // InternalExport.g:1318:4: rule__Export__ResourceFingerprintAssignment_7_0_1 - { - pushFollow(FOLLOW_2); - rule__Export__ResourceFingerprintAssignment_7_0_1(); - state._fsp--; - if (state.failed) return ; + // $ANTLR start "entryRuleOpSingleAssign" + // InternalExport.g:1329:1: entryRuleOpSingleAssign : ruleOpSingleAssign EOF ; + public final void entryRuleOpSingleAssign() throws RecognitionException { + try { + // InternalExport.g:1330:1: ( ruleOpSingleAssign EOF ) + // InternalExport.g:1331:1: ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignRule()); + } + pushFollow(FOLLOW_1); + ruleOpSingleAssign(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpSingleAssign" - } - break; + // $ANTLR start "ruleOpSingleAssign" + // InternalExport.g:1338:1: ruleOpSingleAssign : ( '=' ) ; + public final void ruleOpSingleAssign() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1342:2: ( ( '=' ) ) + // InternalExport.g:1343:2: ( '=' ) + { + // InternalExport.g:1343:2: ( '=' ) + // InternalExport.g:1344:3: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } } + + + } + } catch (RecognitionException re) { reportError(re); @@ -4513,601 +4567,399 @@ else if ( (LA2_0==76) ) { } return ; } - // $ANTLR end "rule__Export__Alternatives_7_0" - + // $ANTLR end "ruleOpSingleAssign" - // $ANTLR start "rule__Export__Alternatives_8" - // InternalExport.g:1326:1: rule__Export__Alternatives_8 : ( ( ( rule__Export__Group_8_0__0 ) ) | ( ( rule__Export__Group_8_1__0 ) ) ); - public final void rule__Export__Alternatives_8() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpMultiAssign" + // InternalExport.g:1354:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ; + public final void entryRuleOpMultiAssign() throws RecognitionException { try { - // InternalExport.g:1330:1: ( ( ( rule__Export__Group_8_0__0 ) ) | ( ( rule__Export__Group_8_1__0 ) ) ) - int alt3=2; - int LA3_0 = input.LA(1); + // InternalExport.g:1355:1: ( ruleOpMultiAssign EOF ) + // InternalExport.g:1356:1: ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_1); + ruleOpMultiAssign(); - if ( (LA3_0==55) ) { - alt3=1; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignRule()); } - else if ( (LA3_0==56) ) { - alt3=2; + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); - throw nvae; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpMultiAssign" + + + // $ANTLR start "ruleOpMultiAssign" + // InternalExport.g:1363:1: ruleOpMultiAssign : ( ( rule__OpMultiAssign__Alternatives ) ) ; + public final void ruleOpMultiAssign() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1367:2: ( ( ( rule__OpMultiAssign__Alternatives ) ) ) + // InternalExport.g:1368:2: ( ( rule__OpMultiAssign__Alternatives ) ) + { + // InternalExport.g:1368:2: ( ( rule__OpMultiAssign__Alternatives ) ) + // InternalExport.g:1369:3: ( rule__OpMultiAssign__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } - switch (alt3) { - case 1 : - // InternalExport.g:1331:2: ( ( rule__Export__Group_8_0__0 ) ) - { - // InternalExport.g:1331:2: ( ( rule__Export__Group_8_0__0 ) ) - // InternalExport.g:1332:3: ( rule__Export__Group_8_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_8_0()); - } - // InternalExport.g:1333:3: ( rule__Export__Group_8_0__0 ) - // InternalExport.g:1333:4: rule__Export__Group_8_0__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_8_0__0(); + // InternalExport.g:1370:3: ( rule__OpMultiAssign__Alternatives ) + // InternalExport.g:1370:4: rule__OpMultiAssign__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Alternatives(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_8_0()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); + } - } + } - } - break; - case 2 : - // InternalExport.g:1337:2: ( ( rule__Export__Group_8_1__0 ) ) - { - // InternalExport.g:1337:2: ( ( rule__Export__Group_8_1__0 ) ) - // InternalExport.g:1338:3: ( rule__Export__Group_8_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_8_1()); - } - // InternalExport.g:1339:3: ( rule__Export__Group_8_1__0 ) - // InternalExport.g:1339:4: rule__Export__Group_8_1__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_8_1__0(); + } - state._fsp--; - if (state.failed) return ; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_8_1()); - } + } + return ; + } + // $ANTLR end "ruleOpMultiAssign" - } + // $ANTLR start "entryRuleXOrExpression" + // InternalExport.g:1379:1: entryRuleXOrExpression : ruleXOrExpression EOF ; + public final void entryRuleXOrExpression() throws RecognitionException { + try { + // InternalExport.g:1380:1: ( ruleXOrExpression EOF ) + // InternalExport.g:1381:1: ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXOrExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Alternatives_8" + // $ANTLR end "entryRuleXOrExpression" - // $ANTLR start "rule__Expression__Alternatives" - // InternalExport.g:1347:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ); - public final void rule__Expression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXOrExpression" + // InternalExport.g:1388:1: ruleXOrExpression : ( ( rule__XOrExpression__Group__0 ) ) ; + public final void ruleXOrExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1351:1: ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ) - int alt4=3; - alt4 = dfa4.predict(input); - switch (alt4) { - case 1 : - // InternalExport.g:1352:2: ( ruleLetExpression ) - { - // InternalExport.g:1352:2: ( ruleLetExpression ) - // InternalExport.g:1353:3: ruleLetExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleLetExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); - } - - } + // InternalExport.g:1392:2: ( ( ( rule__XOrExpression__Group__0 ) ) ) + // InternalExport.g:1393:2: ( ( rule__XOrExpression__Group__0 ) ) + { + // InternalExport.g:1393:2: ( ( rule__XOrExpression__Group__0 ) ) + // InternalExport.g:1394:3: ( rule__XOrExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup()); + } + // InternalExport.g:1395:3: ( rule__XOrExpression__Group__0 ) + // InternalExport.g:1395:4: rule__XOrExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__0(); + state._fsp--; + if (state.failed) return ; - } - break; - case 2 : - // InternalExport.g:1358:2: ( ( ruleCastedExpression ) ) - { - // InternalExport.g:1358:2: ( ( ruleCastedExpression ) ) - // InternalExport.g:1359:3: ( ruleCastedExpression ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - // InternalExport.g:1360:3: ( ruleCastedExpression ) - // InternalExport.g:1360:4: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + } - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 3 : - // InternalExport.g:1364:2: ( ruleChainExpression ) - { - // InternalExport.g:1364:2: ( ruleChainExpression ) - // InternalExport.g:1365:3: ruleChainExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleChainExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); - } + } + return ; + } + // $ANTLR end "ruleXOrExpression" - } + // $ANTLR start "entryRuleOpOr" + // InternalExport.g:1404:1: entryRuleOpOr : ruleOpOr EOF ; + public final void entryRuleOpOr() throws RecognitionException { + try { + // InternalExport.g:1405:1: ( ruleOpOr EOF ) + // InternalExport.g:1406:1: ruleOpOr EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_1); + ruleOpOr(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Expression__Alternatives" + // $ANTLR end "entryRuleOpOr" - // $ANTLR start "rule__ChainedExpression__Alternatives" - // InternalExport.g:1374:1: rule__ChainedExpression__Alternatives : ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ); - public final void rule__ChainedExpression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleOpOr" + // InternalExport.g:1413:1: ruleOpOr : ( '||' ) ; + public final void ruleOpOr() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1378:1: ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ) - int alt5=3; - switch ( input.LA(1) ) { - case 62: - { - alt5=1; - } - break; - case RULE_ID: - case RULE_STRING: - case RULE_INT: - case RULE_REAL: - case 19: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 39: - case 51: - case 70: - case 71: - case 80: - case 81: - { - alt5=2; - } - break; - case 65: - { - alt5=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 5, 0, input); - - throw nvae; + // InternalExport.g:1417:2: ( ( '||' ) ) + // InternalExport.g:1418:2: ( '||' ) + { + // InternalExport.g:1418:2: ( '||' ) + // InternalExport.g:1419:3: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + } + match(input,15,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } - switch (alt5) { - case 1 : - // InternalExport.g:1379:2: ( ruleIfExpressionKw ) - { - // InternalExport.g:1379:2: ( ruleIfExpressionKw ) - // InternalExport.g:1380:3: ruleIfExpressionKw - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleIfExpressionKw(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1385:2: ( ruleIfExpressionTri ) - { - // InternalExport.g:1385:2: ( ruleIfExpressionTri ) - // InternalExport.g:1386:3: ruleIfExpressionTri - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleIfExpressionTri(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 3 : - // InternalExport.g:1391:2: ( ruleSwitchExpression ) - { - // InternalExport.g:1391:2: ( ruleSwitchExpression ) - // InternalExport.g:1392:3: ruleSwitchExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleSwitchExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); - } + } + return ; + } + // $ANTLR end "ruleOpOr" - } + // $ANTLR start "entryRuleXAndExpression" + // InternalExport.g:1429:1: entryRuleXAndExpression : ruleXAndExpression EOF ; + public final void entryRuleXAndExpression() throws RecognitionException { + try { + // InternalExport.g:1430:1: ( ruleXAndExpression EOF ) + // InternalExport.g:1431:1: ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXAndExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainedExpression__Alternatives" + // $ANTLR end "entryRuleXAndExpression" - // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // InternalExport.g:1401:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ); - public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "ruleXAndExpression" + // InternalExport.g:1438:1: ruleXAndExpression : ( ( rule__XAndExpression__Group__0 ) ) ; + public final void ruleXAndExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1405:1: ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ) - int alt6=6; - switch ( input.LA(1) ) { - case 12: - { - alt6=1; - } - break; - case 13: - { - alt6=2; - } - break; - case 14: - { - alt6=3; - } - break; - case 15: - { - alt6=4; - } - break; - case 16: - { - alt6=5; - } - break; - case 17: - { - alt6=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 6, 0, input); - - throw nvae; + // InternalExport.g:1442:2: ( ( ( rule__XAndExpression__Group__0 ) ) ) + // InternalExport.g:1443:2: ( ( rule__XAndExpression__Group__0 ) ) + { + // InternalExport.g:1443:2: ( ( rule__XAndExpression__Group__0 ) ) + // InternalExport.g:1444:3: ( rule__XAndExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup()); } + // InternalExport.g:1445:3: ( rule__XAndExpression__Group__0 ) + // InternalExport.g:1445:4: rule__XAndExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__0(); - switch (alt6) { - case 1 : - // InternalExport.g:1406:2: ( '==' ) - { - // InternalExport.g:1406:2: ( '==' ) - // InternalExport.g:1407:3: '==' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); - } - match(input,12,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1412:2: ( '!=' ) - { - // InternalExport.g:1412:2: ( '!=' ) - // InternalExport.g:1413:3: '!=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } - match(input,13,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } - - } - - - } - break; - case 3 : - // InternalExport.g:1418:2: ( '>=' ) - { - // InternalExport.g:1418:2: ( '>=' ) - // InternalExport.g:1419:3: '>=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); - } - match(input,14,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); - } - - } + state._fsp--; + if (state.failed) return ; + } - } - break; - case 4 : - // InternalExport.g:1424:2: ( '<=' ) - { - // InternalExport.g:1424:2: ( '<=' ) - // InternalExport.g:1425:3: '<=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - } - match(input,15,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup()); + } - } + } - } - break; - case 5 : - // InternalExport.g:1430:2: ( '>' ) - { - // InternalExport.g:1430:2: ( '>' ) - // InternalExport.g:1431:3: '>' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } - match(input,16,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - } - break; - case 6 : - // InternalExport.g:1436:2: ( '<' ) - { - // InternalExport.g:1436:2: ( '<' ) - // InternalExport.g:1437:3: '<' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); - } - match(input,17,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); - } + } + return ; + } + // $ANTLR end "ruleXAndExpression" - } + // $ANTLR start "entryRuleOpAnd" + // InternalExport.g:1454:1: entryRuleOpAnd : ruleOpAnd EOF ; + public final void entryRuleOpAnd() throws RecognitionException { + try { + // InternalExport.g:1455:1: ( ruleOpAnd EOF ) + // InternalExport.g:1456:1: ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_1); + ruleOpAnd(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // $ANTLR end "entryRuleOpAnd" - // $ANTLR start "rule__AdditiveExpression__NameAlternatives_1_1_0" - // InternalExport.g:1446:1: rule__AdditiveExpression__NameAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) ); - public final void rule__AdditiveExpression__NameAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "ruleOpAnd" + // InternalExport.g:1463:1: ruleOpAnd : ( '&&' ) ; + public final void ruleOpAnd() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1450:1: ( ( '+' ) | ( '-' ) ) - int alt7=2; - int LA7_0 = input.LA(1); - - if ( (LA7_0==18) ) { - alt7=1; + // InternalExport.g:1467:2: ( ( '&&' ) ) + // InternalExport.g:1468:2: ( '&&' ) + { + // InternalExport.g:1468:2: ( '&&' ) + // InternalExport.g:1469:3: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } - else if ( (LA7_0==19) ) { - alt7=2; + match(input,16,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 7, 0, input); - throw nvae; } - switch (alt7) { - case 1 : - // InternalExport.g:1451:2: ( '+' ) - { - // InternalExport.g:1451:2: ( '+' ) - // InternalExport.g:1452:3: '+' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); - } - match(input,18,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1457:2: ( '-' ) - { - // InternalExport.g:1457:2: ( '-' ) - // InternalExport.g:1458:3: '-' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); - } - match(input,19,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); - } - } - - - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5120,242 +4972,164 @@ else if ( (LA7_0==19) ) { } return ; } - // $ANTLR end "rule__AdditiveExpression__NameAlternatives_1_1_0" - + // $ANTLR end "ruleOpAnd" - // $ANTLR start "rule__MultiplicativeExpression__NameAlternatives_1_1_0" - // InternalExport.g:1467:1: rule__MultiplicativeExpression__NameAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) ); - public final void rule__MultiplicativeExpression__NameAlternatives_1_1_0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXEqualityExpression" + // InternalExport.g:1479:1: entryRuleXEqualityExpression : ruleXEqualityExpression EOF ; + public final void entryRuleXEqualityExpression() throws RecognitionException { try { - // InternalExport.g:1471:1: ( ( '*' ) | ( '/' ) ) - int alt8=2; - int LA8_0 = input.LA(1); - - if ( (LA8_0==20) ) { - alt8=1; - } - else if ( (LA8_0==21) ) { - alt8=2; + // InternalExport.g:1480:1: ( ruleXEqualityExpression EOF ) + // InternalExport.g:1481:1: ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + pushFollow(FOLLOW_1); + ruleXEqualityExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionRule()); } - switch (alt8) { - case 1 : - // InternalExport.g:1472:2: ( '*' ) - { - // InternalExport.g:1472:2: ( '*' ) - // InternalExport.g:1473:3: '*' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); - } - match(input,20,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1478:2: ( '/' ) - { - // InternalExport.g:1478:2: ( '/' ) - // InternalExport.g:1479:3: '/' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); - } - match(input,21,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); - } - - } - - - } - break; + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__MultiplicativeExpression__NameAlternatives_1_1_0" + // $ANTLR end "entryRuleXEqualityExpression" - // $ANTLR start "rule__UnaryOrInfixExpression__Alternatives" - // InternalExport.g:1488:1: rule__UnaryOrInfixExpression__Alternatives : ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ); - public final void rule__UnaryOrInfixExpression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXEqualityExpression" + // InternalExport.g:1488:1: ruleXEqualityExpression : ( ( rule__XEqualityExpression__Group__0 ) ) ; + public final void ruleXEqualityExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1492:1: ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ) - int alt9=2; - int LA9_0 = input.LA(1); + // InternalExport.g:1492:2: ( ( ( rule__XEqualityExpression__Group__0 ) ) ) + // InternalExport.g:1493:2: ( ( rule__XEqualityExpression__Group__0 ) ) + { + // InternalExport.g:1493:2: ( ( rule__XEqualityExpression__Group__0 ) ) + // InternalExport.g:1494:3: ( rule__XEqualityExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup()); + } + // InternalExport.g:1495:3: ( rule__XEqualityExpression__Group__0 ) + // InternalExport.g:1495:4: rule__XEqualityExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( (LA9_0==19||LA9_0==22) ) { - alt9=1; } - else if ( ((LA9_0>=RULE_ID && LA9_0<=RULE_REAL)||(LA9_0>=23 && LA9_0<=35)||LA9_0==39||LA9_0==51||(LA9_0>=70 && LA9_0<=71)||(LA9_0>=80 && LA9_0<=81)) ) { - alt9=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 9, 0, input); - throw nvae; } - switch (alt9) { - case 1 : - // InternalExport.g:1493:2: ( ruleUnaryExpression ) - { - // InternalExport.g:1493:2: ( ruleUnaryExpression ) - // InternalExport.g:1494:3: ruleUnaryExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleUnaryExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalExport.g:1499:2: ( ruleInfixExpression ) - { - // InternalExport.g:1499:2: ( ruleInfixExpression ) - // InternalExport.g:1500:3: ruleInfixExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleInfixExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); - } + } + return ; + } + // $ANTLR end "ruleXEqualityExpression" - } + // $ANTLR start "entryRuleOpEquality" + // InternalExport.g:1504:1: entryRuleOpEquality : ruleOpEquality EOF ; + public final void entryRuleOpEquality() throws RecognitionException { + try { + // InternalExport.g:1505:1: ( ruleOpEquality EOF ) + // InternalExport.g:1506:1: ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_1); + ruleOpEquality(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__UnaryOrInfixExpression__Alternatives" + // $ANTLR end "entryRuleOpEquality" - // $ANTLR start "rule__UnaryExpression__NameAlternatives_0_0" - // InternalExport.g:1509:1: rule__UnaryExpression__NameAlternatives_0_0 : ( ( '!' ) | ( '-' ) ); - public final void rule__UnaryExpression__NameAlternatives_0_0() throws RecognitionException { + // $ANTLR start "ruleOpEquality" + // InternalExport.g:1513:1: ruleOpEquality : ( ( rule__OpEquality__Alternatives ) ) ; + public final void ruleOpEquality() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1513:1: ( ( '!' ) | ( '-' ) ) - int alt10=2; - int LA10_0 = input.LA(1); - - if ( (LA10_0==22) ) { - alt10=1; - } - else if ( (LA10_0==19) ) { - alt10=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 10, 0, input); - - throw nvae; + // InternalExport.g:1517:2: ( ( ( rule__OpEquality__Alternatives ) ) ) + // InternalExport.g:1518:2: ( ( rule__OpEquality__Alternatives ) ) + { + // InternalExport.g:1518:2: ( ( rule__OpEquality__Alternatives ) ) + // InternalExport.g:1519:3: ( rule__OpEquality__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getAlternatives()); } - switch (alt10) { - case 1 : - // InternalExport.g:1514:2: ( '!' ) - { - // InternalExport.g:1514:2: ( '!' ) - // InternalExport.g:1515:3: '!' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); - } - match(input,22,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); - } - - } + // InternalExport.g:1520:3: ( rule__OpEquality__Alternatives ) + // InternalExport.g:1520:4: rule__OpEquality__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpEquality__Alternatives(); + state._fsp--; + if (state.failed) return ; - } - break; - case 2 : - // InternalExport.g:1520:2: ( '-' ) - { - // InternalExport.g:1520:2: ( '-' ) - // InternalExport.g:1521:3: '-' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); - } - match(input,19,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5368,200 +5142,164 @@ else if ( (LA10_0==19) ) { } return ; } - // $ANTLR end "rule__UnaryExpression__NameAlternatives_0_0" - + // $ANTLR end "ruleOpEquality" - // $ANTLR start "rule__InfixExpression__Alternatives_1" - // InternalExport.g:1530:1: rule__InfixExpression__Alternatives_1 : ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ); - public final void rule__InfixExpression__Alternatives_1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXRelationalExpression" + // InternalExport.g:1529:1: entryRuleXRelationalExpression : ruleXRelationalExpression EOF ; + public final void entryRuleXRelationalExpression() throws RecognitionException { try { - // InternalExport.g:1534:1: ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ) - int alt11=4; - int LA11_0 = input.LA(1); + // InternalExport.g:1530:1: ( ruleXRelationalExpression EOF ) + // InternalExport.g:1531:1: ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXRelationalExpression(); - if ( (LA11_0==68) ) { - switch ( input.LA(2) ) { - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - { - alt11=4; - } - break; - case 33: - case 34: - case 35: - { - alt11=2; - } - break; - case RULE_ID: - { - int LA11_4 = input.LA(3); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - if ( (LA11_4==EOF||(LA11_4>=12 && LA11_4<=21)||(LA11_4>=39 && LA11_4<=40)||(LA11_4>=44 && LA11_4<=46)||LA11_4==48||LA11_4==52||LA11_4==57||(LA11_4>=59 && LA11_4<=61)||(LA11_4>=63 && LA11_4<=64)||(LA11_4>=66 && LA11_4<=68)||(LA11_4>=77 && LA11_4<=79)) ) { - alt11=2; - } - else if ( (LA11_4==51) ) { - alt11=1; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 11, 4, input); + } - throw nvae; - } - } - break; - case 80: - { - alt11=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 11, 1, input); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXRelationalExpression" - throw nvae; - } - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 11, 0, input); + // $ANTLR start "ruleXRelationalExpression" + // InternalExport.g:1538:1: ruleXRelationalExpression : ( ( rule__XRelationalExpression__Group__0 ) ) ; + public final void ruleXRelationalExpression() throws RecognitionException { - throw nvae; + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1542:2: ( ( ( rule__XRelationalExpression__Group__0 ) ) ) + // InternalExport.g:1543:2: ( ( rule__XRelationalExpression__Group__0 ) ) + { + // InternalExport.g:1543:2: ( ( rule__XRelationalExpression__Group__0 ) ) + // InternalExport.g:1544:3: ( rule__XRelationalExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup()); } - switch (alt11) { - case 1 : - // InternalExport.g:1535:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) - { - // InternalExport.g:1535:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) - // InternalExport.g:1536:3: ( rule__InfixExpression__Group_1_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); - } - // InternalExport.g:1537:3: ( rule__InfixExpression__Group_1_0__0 ) - // InternalExport.g:1537:4: rule__InfixExpression__Group_1_0__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__0(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExport.g:1545:3: ( rule__XRelationalExpression__Group__0 ) + // InternalExport.g:1545:4: rule__XRelationalExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup()); + } - } - break; - case 2 : - // InternalExport.g:1541:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) - { - // InternalExport.g:1541:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) - // InternalExport.g:1542:3: ( rule__InfixExpression__Group_1_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); - } - // InternalExport.g:1543:3: ( rule__InfixExpression__Group_1_1__0 ) - // InternalExport.g:1543:4: rule__InfixExpression__Group_1_1__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__0(); + } - state._fsp--; - if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXRelationalExpression" - } - break; - case 3 : - // InternalExport.g:1547:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) - { - // InternalExport.g:1547:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) - // InternalExport.g:1548:3: ( rule__InfixExpression__Group_1_2__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); - } - // InternalExport.g:1549:3: ( rule__InfixExpression__Group_1_2__0 ) - // InternalExport.g:1549:4: rule__InfixExpression__Group_1_2__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__0(); - state._fsp--; - if (state.failed) return ; + // $ANTLR start "entryRuleOpCompare" + // InternalExport.g:1554:1: entryRuleOpCompare : ruleOpCompare EOF ; + public final void entryRuleOpCompare() throws RecognitionException { + try { + // InternalExport.g:1555:1: ( ruleOpCompare EOF ) + // InternalExport.g:1556:1: ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_1); + ruleOpCompare(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpCompare" - } - break; - case 4 : - // InternalExport.g:1553:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) - { - // InternalExport.g:1553:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) - // InternalExport.g:1554:3: ( rule__InfixExpression__Group_1_3__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); - } - // InternalExport.g:1555:3: ( rule__InfixExpression__Group_1_3__0 ) - // InternalExport.g:1555:4: rule__InfixExpression__Group_1_3__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__0(); + // $ANTLR start "ruleOpCompare" + // InternalExport.g:1563:1: ruleOpCompare : ( ( rule__OpCompare__Alternatives ) ) ; + public final void ruleOpCompare() throws RecognitionException { - state._fsp--; - if (state.failed) return ; + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1567:2: ( ( ( rule__OpCompare__Alternatives ) ) ) + // InternalExport.g:1568:2: ( ( rule__OpCompare__Alternatives ) ) + { + // InternalExport.g:1568:2: ( ( rule__OpCompare__Alternatives ) ) + // InternalExport.g:1569:3: ( rule__OpCompare__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getAlternatives()); + } + // InternalExport.g:1570:3: ( rule__OpCompare__Alternatives ) + // InternalExport.g:1570:4: rule__OpCompare__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpCompare__Alternatives(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5574,222 +5312,164 @@ else if ( (LA11_4==51) ) { } return ; } - // $ANTLR end "rule__InfixExpression__Alternatives_1" - + // $ANTLR end "ruleOpCompare" - // $ANTLR start "rule__InfixExpression__NameAlternatives_1_3_2_0" - // InternalExport.g:1563:1: rule__InfixExpression__NameAlternatives_1_3_2_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); - public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXOtherOperatorExpression" + // InternalExport.g:1579:1: entryRuleXOtherOperatorExpression : ruleXOtherOperatorExpression EOF ; + public final void entryRuleXOtherOperatorExpression() throws RecognitionException { try { - // InternalExport.g:1567:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) - int alt12=8; - switch ( input.LA(1) ) { - case 23: - { - alt12=1; - } - break; - case 24: - { - alt12=2; - } - break; - case 25: - { - alt12=3; - } - break; - case 26: - { - alt12=4; - } - break; - case 27: - { - alt12=5; - } - break; - case 28: - { - alt12=6; - } - break; - case 29: - { - alt12=7; - } - break; - case 30: - { - alt12=8; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 12, 0, input); + // InternalExport.g:1580:1: ( ruleXOtherOperatorExpression EOF ) + // InternalExport.g:1581:1: ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXOtherOperatorExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionRule()); } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - switch (alt12) { - case 1 : - // InternalExport.g:1568:2: ( 'collect' ) - { - // InternalExport.g:1568:2: ( 'collect' ) - // InternalExport.g:1569:3: 'collect' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); - } - match(input,23,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" - } - break; - case 2 : - // InternalExport.g:1574:2: ( 'select' ) - { - // InternalExport.g:1574:2: ( 'select' ) - // InternalExport.g:1575:3: 'select' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); - } - match(input,24,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); - } + // $ANTLR start "ruleXOtherOperatorExpression" + // InternalExport.g:1588:1: ruleXOtherOperatorExpression : ( ( rule__XOtherOperatorExpression__Group__0 ) ) ; + public final void ruleXOtherOperatorExpression() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1592:2: ( ( ( rule__XOtherOperatorExpression__Group__0 ) ) ) + // InternalExport.g:1593:2: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + { + // InternalExport.g:1593:2: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + // InternalExport.g:1594:3: ( rule__XOtherOperatorExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } + // InternalExport.g:1595:3: ( rule__XOtherOperatorExpression__Group__0 ) + // InternalExport.g:1595:4: rule__XOtherOperatorExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__0(); + state._fsp--; + if (state.failed) return ; - } - break; - case 3 : - // InternalExport.g:1580:2: ( 'selectFirst' ) - { - // InternalExport.g:1580:2: ( 'selectFirst' ) - // InternalExport.g:1581:3: 'selectFirst' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); - } - match(input,25,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } + } - } - break; - case 4 : - // InternalExport.g:1586:2: ( 'reject' ) - { - // InternalExport.g:1586:2: ( 'reject' ) - // InternalExport.g:1587:3: 'reject' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); - } - match(input,26,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 5 : - // InternalExport.g:1592:2: ( 'exists' ) - { - // InternalExport.g:1592:2: ( 'exists' ) - // InternalExport.g:1593:3: 'exists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); - } - match(input,27,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleXOtherOperatorExpression" - } - break; - case 6 : - // InternalExport.g:1598:2: ( 'notExists' ) - { - // InternalExport.g:1598:2: ( 'notExists' ) - // InternalExport.g:1599:3: 'notExists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); - } - match(input,28,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); - } + // $ANTLR start "entryRuleOpOther" + // InternalExport.g:1604:1: entryRuleOpOther : ruleOpOther EOF ; + public final void entryRuleOpOther() throws RecognitionException { + try { + // InternalExport.g:1605:1: ( ruleOpOther EOF ) + // InternalExport.g:1606:1: ruleOpOther EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherRule()); + } + pushFollow(FOLLOW_1); + ruleOpOther(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 7 : - // InternalExport.g:1604:2: ( 'sortBy' ) - { - // InternalExport.g:1604:2: ( 'sortBy' ) - // InternalExport.g:1605:3: 'sortBy' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); - } - match(input,29,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpOther" - } + // $ANTLR start "ruleOpOther" + // InternalExport.g:1613:1: ruleOpOther : ( ( rule__OpOther__Alternatives ) ) ; + public final void ruleOpOther() throws RecognitionException { - } - break; - case 8 : - // InternalExport.g:1610:2: ( 'forAll' ) - { - // InternalExport.g:1610:2: ( 'forAll' ) - // InternalExport.g:1611:3: 'forAll' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); - } - match(input,30,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); - } + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1617:2: ( ( ( rule__OpOther__Alternatives ) ) ) + // InternalExport.g:1618:2: ( ( rule__OpOther__Alternatives ) ) + { + // InternalExport.g:1618:2: ( ( rule__OpOther__Alternatives ) ) + // InternalExport.g:1619:3: ( rule__OpOther__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives()); + } + // InternalExport.g:1620:3: ( rule__OpOther__Alternatives ) + // InternalExport.g:1620:4: rule__OpOther__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives(); - } + state._fsp--; + if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives()); + } + + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5802,215 +5482,164 @@ public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws Recog } return ; } - // $ANTLR end "rule__InfixExpression__NameAlternatives_1_3_2_0" + // $ANTLR end "ruleOpOther" - // $ANTLR start "rule__PrimaryExpression__Alternatives" - // InternalExport.g:1620:1: rule__PrimaryExpression__Alternatives : ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ); - public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXAdditiveExpression" + // InternalExport.g:1629:1: entryRuleXAdditiveExpression : ruleXAdditiveExpression EOF ; + public final void entryRuleXAdditiveExpression() throws RecognitionException { try { - // InternalExport.g:1624:1: ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ) - int alt13=6; - switch ( input.LA(1) ) { - case RULE_STRING: - case RULE_INT: - case RULE_REAL: - case 31: - case 32: - case 81: - { - alt13=1; - } - break; - case RULE_ID: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 33: - case 34: - case 35: - case 80: - { - alt13=2; - } - break; - case 39: - { - alt13=3; - } - break; - case 71: - { - alt13=4; - } - break; - case 70: - { - alt13=5; - } - break; - case 51: - { - alt13=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 13, 0, input); + // InternalExport.g:1630:1: ( ruleXAdditiveExpression EOF ) + // InternalExport.g:1631:1: ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXAdditiveExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionRule()); } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - switch (alt13) { - case 1 : - // InternalExport.g:1625:2: ( ruleLiteral ) - { - // InternalExport.g:1625:2: ( ruleLiteral ) - // InternalExport.g:1626:3: ruleLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAdditiveExpression" - } + // $ANTLR start "ruleXAdditiveExpression" + // InternalExport.g:1638:1: ruleXAdditiveExpression : ( ( rule__XAdditiveExpression__Group__0 ) ) ; + public final void ruleXAdditiveExpression() throws RecognitionException { - } - break; - case 2 : - // InternalExport.g:1631:2: ( ruleFeatureCall ) - { - // InternalExport.g:1631:2: ( ruleFeatureCall ) - // InternalExport.g:1632:3: ruleFeatureCall - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleFeatureCall(); + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1642:2: ( ( ( rule__XAdditiveExpression__Group__0 ) ) ) + // InternalExport.g:1643:2: ( ( rule__XAdditiveExpression__Group__0 ) ) + { + // InternalExport.g:1643:2: ( ( rule__XAdditiveExpression__Group__0 ) ) + // InternalExport.g:1644:3: ( rule__XAdditiveExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); + } + // InternalExport.g:1645:3: ( rule__XAdditiveExpression__Group__0 ) + // InternalExport.g:1645:4: rule__XAdditiveExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__0(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); + } - } - break; - case 3 : - // InternalExport.g:1637:2: ( ruleListLiteral ) - { - // InternalExport.g:1637:2: ( ruleListLiteral ) - // InternalExport.g:1638:3: ruleListLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleListLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 4 : - // InternalExport.g:1643:2: ( ruleConstructorCallExpression ) - { - // InternalExport.g:1643:2: ( ruleConstructorCallExpression ) - // InternalExport.g:1644:3: ruleConstructorCallExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleConstructorCallExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); - } + } + return ; + } + // $ANTLR end "ruleXAdditiveExpression" - } + // $ANTLR start "entryRuleOpAdd" + // InternalExport.g:1654:1: entryRuleOpAdd : ruleOpAdd EOF ; + public final void entryRuleOpAdd() throws RecognitionException { + try { + // InternalExport.g:1655:1: ( ruleOpAdd EOF ) + // InternalExport.g:1656:1: ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_1); + ruleOpAdd(); - } - break; - case 5 : - // InternalExport.g:1649:2: ( ruleGlobalVarExpression ) - { - // InternalExport.g:1649:2: ( ruleGlobalVarExpression ) - // InternalExport.g:1650:3: ruleGlobalVarExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); - } - pushFollow(FOLLOW_2); - ruleGlobalVarExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpAdd" - } - break; - case 6 : - // InternalExport.g:1655:2: ( ruleParanthesizedExpression ) - { - // InternalExport.g:1655:2: ( ruleParanthesizedExpression ) - // InternalExport.g:1656:3: ruleParanthesizedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); - } - pushFollow(FOLLOW_2); - ruleParanthesizedExpression(); + // $ANTLR start "ruleOpAdd" + // InternalExport.g:1663:1: ruleOpAdd : ( ( rule__OpAdd__Alternatives ) ) ; + public final void ruleOpAdd() throws RecognitionException { - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); - } + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1667:2: ( ( ( rule__OpAdd__Alternatives ) ) ) + // InternalExport.g:1668:2: ( ( rule__OpAdd__Alternatives ) ) + { + // InternalExport.g:1668:2: ( ( rule__OpAdd__Alternatives ) ) + // InternalExport.g:1669:3: ( rule__OpAdd__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getAlternatives()); + } + // InternalExport.g:1670:3: ( rule__OpAdd__Alternatives ) + // InternalExport.g:1670:4: rule__OpAdd__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpAdd__Alternatives(); - } + state._fsp--; + if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getAlternatives()); + } + + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6023,171 +5652,164 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce } return ; } - // $ANTLR end "rule__PrimaryExpression__Alternatives" + // $ANTLR end "ruleOpAdd" - // $ANTLR start "rule__Literal__Alternatives" - // InternalExport.g:1665:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ); - public final void rule__Literal__Alternatives() throws RecognitionException { + // $ANTLR start "entryRuleXMultiplicativeExpression" + // InternalExport.g:1679:1: entryRuleXMultiplicativeExpression : ruleXMultiplicativeExpression EOF ; + public final void entryRuleXMultiplicativeExpression() throws RecognitionException { + try { + // InternalExport.g:1680:1: ( ruleXMultiplicativeExpression EOF ) + // InternalExport.g:1681:1: ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // InternalExport.g:1688:1: ruleXMultiplicativeExpression : ( ( rule__XMultiplicativeExpression__Group__0 ) ) ; + public final void ruleXMultiplicativeExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1669:1: ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ) - int alt14=5; - switch ( input.LA(1) ) { - case 31: - case 32: - { - alt14=1; - } - break; - case RULE_INT: - { - alt14=2; - } - break; - case 81: - { - alt14=3; - } - break; - case RULE_REAL: - { - alt14=4; - } - break; - case RULE_STRING: - { - alt14=5; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 14, 0, input); - - throw nvae; + // InternalExport.g:1692:2: ( ( ( rule__XMultiplicativeExpression__Group__0 ) ) ) + // InternalExport.g:1693:2: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + { + // InternalExport.g:1693:2: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + // InternalExport.g:1694:3: ( rule__XMultiplicativeExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } + // InternalExport.g:1695:3: ( rule__XMultiplicativeExpression__Group__0 ) + // InternalExport.g:1695:4: rule__XMultiplicativeExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__0(); - switch (alt14) { - case 1 : - // InternalExport.g:1670:2: ( ruleBooleanLiteral ) - { - // InternalExport.g:1670:2: ( ruleBooleanLiteral ) - // InternalExport.g:1671:3: ruleBooleanLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleBooleanLiteral(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); + } + } - } - break; - case 2 : - // InternalExport.g:1676:2: ( ruleIntegerLiteral ) - { - // InternalExport.g:1676:2: ( ruleIntegerLiteral ) - // InternalExport.g:1677:3: ruleIntegerLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleIntegerLiteral(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - } - break; - case 3 : - // InternalExport.g:1682:2: ( ruleNullLiteral ) - { - // InternalExport.g:1682:2: ( ruleNullLiteral ) - // InternalExport.g:1683:3: ruleNullLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleNullLiteral(); + } + return ; + } + // $ANTLR end "ruleXMultiplicativeExpression" - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); - } - } + // $ANTLR start "entryRuleOpMulti" + // InternalExport.g:1704:1: entryRuleOpMulti : ruleOpMulti EOF ; + public final void entryRuleOpMulti() throws RecognitionException { + try { + // InternalExport.g:1705:1: ( ruleOpMulti EOF ) + // InternalExport.g:1706:1: ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_1); + ruleOpMulti(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - } - break; - case 4 : - // InternalExport.g:1688:2: ( ruleRealLiteral ) - { - // InternalExport.g:1688:2: ( ruleRealLiteral ) - // InternalExport.g:1689:3: ruleRealLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleRealLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpMulti" - } + // $ANTLR start "ruleOpMulti" + // InternalExport.g:1713:1: ruleOpMulti : ( ( rule__OpMulti__Alternatives ) ) ; + public final void ruleOpMulti() throws RecognitionException { - } - break; - case 5 : - // InternalExport.g:1694:2: ( ruleStringLiteral ) - { - // InternalExport.g:1694:2: ( ruleStringLiteral ) - // InternalExport.g:1695:3: ruleStringLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); - } - pushFollow(FOLLOW_2); - ruleStringLiteral(); + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1717:2: ( ( ( rule__OpMulti__Alternatives ) ) ) + // InternalExport.g:1718:2: ( ( rule__OpMulti__Alternatives ) ) + { + // InternalExport.g:1718:2: ( ( rule__OpMulti__Alternatives ) ) + // InternalExport.g:1719:3: ( rule__OpMulti__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAlternatives()); + } + // InternalExport.g:1720:3: ( rule__OpMulti__Alternatives ) + // InternalExport.g:1720:4: rule__OpMulti__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpMulti__Alternatives(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); - } + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6200,479 +5822,249 @@ public final void rule__Literal__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__Literal__Alternatives" + // $ANTLR end "ruleOpMulti" - // $ANTLR start "rule__BooleanLiteral__ValAlternatives_0" - // InternalExport.g:1704:1: rule__BooleanLiteral__ValAlternatives_0 : ( ( 'true' ) | ( 'false' ) ); - public final void rule__BooleanLiteral__ValAlternatives_0() throws RecognitionException { + // $ANTLR start "entryRuleXUnaryOperation" + // InternalExport.g:1729:1: entryRuleXUnaryOperation : ruleXUnaryOperation EOF ; + public final void entryRuleXUnaryOperation() throws RecognitionException { + try { + // InternalExport.g:1730:1: ( ruleXUnaryOperation EOF ) + // InternalExport.g:1731:1: ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_1); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXUnaryOperation" + + + // $ANTLR start "ruleXUnaryOperation" + // InternalExport.g:1738:1: ruleXUnaryOperation : ( ( rule__XUnaryOperation__Alternatives ) ) ; + public final void ruleXUnaryOperation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1708:1: ( ( 'true' ) | ( 'false' ) ) - int alt15=2; - int LA15_0 = input.LA(1); + // InternalExport.g:1742:2: ( ( ( rule__XUnaryOperation__Alternatives ) ) ) + // InternalExport.g:1743:2: ( ( rule__XUnaryOperation__Alternatives ) ) + { + // InternalExport.g:1743:2: ( ( rule__XUnaryOperation__Alternatives ) ) + // InternalExport.g:1744:3: ( rule__XUnaryOperation__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); + } + // InternalExport.g:1745:3: ( rule__XUnaryOperation__Alternatives ) + // InternalExport.g:1745:4: rule__XUnaryOperation__Alternatives + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Alternatives(); + + state._fsp--; + if (state.failed) return ; - if ( (LA15_0==31) ) { - alt15=1; } - else if ( (LA15_0==32) ) { - alt15=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 15, 0, input); - throw nvae; } - switch (alt15) { - case 1 : - // InternalExport.g:1709:2: ( 'true' ) - { - // InternalExport.g:1709:2: ( 'true' ) - // InternalExport.g:1710:3: 'true' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); - } - match(input,31,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); - } - } + } - } - break; - case 2 : - // InternalExport.g:1715:2: ( 'false' ) - { - // InternalExport.g:1715:2: ( 'false' ) - // InternalExport.g:1716:3: 'false' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); - } - match(input,32,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleXUnaryOperation" - } - break; + // $ANTLR start "entryRuleOpUnary" + // InternalExport.g:1754:1: entryRuleOpUnary : ruleOpUnary EOF ; + public final void entryRuleOpUnary() throws RecognitionException { + try { + // InternalExport.g:1755:1: ( ruleOpUnary EOF ) + // InternalExport.g:1756:1: ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_1); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__BooleanLiteral__ValAlternatives_0" + // $ANTLR end "entryRuleOpUnary" - // $ANTLR start "rule__FeatureCall__Alternatives" - // InternalExport.g:1725:1: rule__FeatureCall__Alternatives : ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ); - public final void rule__FeatureCall__Alternatives() throws RecognitionException { + // $ANTLR start "ruleOpUnary" + // InternalExport.g:1763:1: ruleOpUnary : ( ( rule__OpUnary__Alternatives ) ) ; + public final void ruleOpUnary() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1729:1: ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ) - int alt16=4; - switch ( input.LA(1) ) { - case RULE_ID: - { - int LA16_1 = input.LA(2); - - if ( (LA16_1==EOF||(LA16_1>=12 && LA16_1<=21)||(LA16_1>=39 && LA16_1<=40)||(LA16_1>=44 && LA16_1<=46)||LA16_1==48||LA16_1==52||LA16_1==57||(LA16_1>=59 && LA16_1<=61)||(LA16_1>=63 && LA16_1<=64)||(LA16_1>=66 && LA16_1<=68)||(LA16_1>=77 && LA16_1<=79)) ) { - alt16=2; - } - else if ( (LA16_1==51) ) { - alt16=1; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 16, 1, input); + // InternalExport.g:1767:2: ( ( ( rule__OpUnary__Alternatives ) ) ) + // InternalExport.g:1768:2: ( ( rule__OpUnary__Alternatives ) ) + { + // InternalExport.g:1768:2: ( ( rule__OpUnary__Alternatives ) ) + // InternalExport.g:1769:3: ( rule__OpUnary__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getAlternatives()); + } + // InternalExport.g:1770:3: ( rule__OpUnary__Alternatives ) + // InternalExport.g:1770:4: rule__OpUnary__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpUnary__Alternatives(); - throw nvae; - } - } - break; - case 33: - case 34: - case 35: - { - alt16=2; - } - break; - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - { - alt16=3; - } - break; - case 80: - { - alt16=4; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 16, 0, input); + state._fsp--; + if (state.failed) return ; - throw nvae; } - switch (alt16) { - case 1 : - // InternalExport.g:1730:2: ( ruleOperationCall ) - { - // InternalExport.g:1730:2: ( ruleOperationCall ) - // InternalExport.g:1731:3: ruleOperationCall - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleOperationCall(); + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getAlternatives()); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); - } + } - } + } - } - break; - case 2 : - // InternalExport.g:1736:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) - { - // InternalExport.g:1736:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) - // InternalExport.g:1737:3: ( rule__FeatureCall__TypeAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); - } - // InternalExport.g:1738:3: ( rule__FeatureCall__TypeAssignment_1 ) - // InternalExport.g:1738:4: rule__FeatureCall__TypeAssignment_1 - { - pushFollow(FOLLOW_2); - rule__FeatureCall__TypeAssignment_1(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); - } - - } - - - } - break; - case 3 : - // InternalExport.g:1742:2: ( ruleCollectionExpression ) - { - // InternalExport.g:1742:2: ( ruleCollectionExpression ) - // InternalExport.g:1743:3: ruleCollectionExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleCollectionExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); - } - - } - + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 4 : - // InternalExport.g:1748:2: ( ruleTypeSelectExpression ) - { - // InternalExport.g:1748:2: ( ruleTypeSelectExpression ) - // InternalExport.g:1749:3: ruleTypeSelectExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleTypeSelectExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); - } + } + return ; + } + // $ANTLR end "ruleOpUnary" - } + // $ANTLR start "entryRuleXCastedExpression" + // InternalExport.g:1779:1: entryRuleXCastedExpression : ruleXCastedExpression EOF ; + public final void entryRuleXCastedExpression() throws RecognitionException { + try { + // InternalExport.g:1780:1: ( ruleXCastedExpression EOF ) + // InternalExport.g:1781:1: ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXCastedExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__FeatureCall__Alternatives" + // $ANTLR end "entryRuleXCastedExpression" - // $ANTLR start "rule__CollectionExpression__NameAlternatives_0_0" - // InternalExport.g:1758:1: rule__CollectionExpression__NameAlternatives_0_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); - public final void rule__CollectionExpression__NameAlternatives_0_0() throws RecognitionException { + // $ANTLR start "ruleXCastedExpression" + // InternalExport.g:1788:1: ruleXCastedExpression : ( ( rule__XCastedExpression__Group__0 ) ) ; + public final void ruleXCastedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1762:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) - int alt17=8; - switch ( input.LA(1) ) { - case 23: - { - alt17=1; - } - break; - case 24: - { - alt17=2; - } - break; - case 25: - { - alt17=3; - } - break; - case 26: - { - alt17=4; - } - break; - case 27: - { - alt17=5; - } - break; - case 28: - { - alt17=6; - } - break; - case 29: - { - alt17=7; - } - break; - case 30: - { - alt17=8; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 17, 0, input); - - throw nvae; + // InternalExport.g:1792:2: ( ( ( rule__XCastedExpression__Group__0 ) ) ) + // InternalExport.g:1793:2: ( ( rule__XCastedExpression__Group__0 ) ) + { + // InternalExport.g:1793:2: ( ( rule__XCastedExpression__Group__0 ) ) + // InternalExport.g:1794:3: ( rule__XCastedExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup()); } + // InternalExport.g:1795:3: ( rule__XCastedExpression__Group__0 ) + // InternalExport.g:1795:4: rule__XCastedExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__0(); - switch (alt17) { - case 1 : - // InternalExport.g:1763:2: ( 'collect' ) - { - // InternalExport.g:1763:2: ( 'collect' ) - // InternalExport.g:1764:3: 'collect' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); - } - match(input,23,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1769:2: ( 'select' ) - { - // InternalExport.g:1769:2: ( 'select' ) - // InternalExport.g:1770:3: 'select' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); - } - match(input,24,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); - } - - } - - - } - break; - case 3 : - // InternalExport.g:1775:2: ( 'selectFirst' ) - { - // InternalExport.g:1775:2: ( 'selectFirst' ) - // InternalExport.g:1776:3: 'selectFirst' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); - } - match(input,25,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); - } - - } - - - } - break; - case 4 : - // InternalExport.g:1781:2: ( 'reject' ) - { - // InternalExport.g:1781:2: ( 'reject' ) - // InternalExport.g:1782:3: 'reject' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); - } - match(input,26,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); - } - - } - - - } - break; - case 5 : - // InternalExport.g:1787:2: ( 'exists' ) - { - // InternalExport.g:1787:2: ( 'exists' ) - // InternalExport.g:1788:3: 'exists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); - } - match(input,27,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); - } - - } - - - } - break; - case 6 : - // InternalExport.g:1793:2: ( 'notExists' ) - { - // InternalExport.g:1793:2: ( 'notExists' ) - // InternalExport.g:1794:3: 'notExists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); - } - match(input,28,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); - } - - } - - - } - break; - case 7 : - // InternalExport.g:1799:2: ( 'sortBy' ) - { - // InternalExport.g:1799:2: ( 'sortBy' ) - // InternalExport.g:1800:3: 'sortBy' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); - } - match(input,29,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); - } - - } - + state._fsp--; + if (state.failed) return ; - } - break; - case 8 : - // InternalExport.g:1805:2: ( 'forAll' ) - { - // InternalExport.g:1805:2: ( 'forAll' ) - // InternalExport.g:1806:3: 'forAll' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); - } - match(input,30,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6685,190 +6077,79 @@ public final void rule__CollectionExpression__NameAlternatives_0_0() throws Reco } return ; } - // $ANTLR end "rule__CollectionExpression__NameAlternatives_0_0" - + // $ANTLR end "ruleXCastedExpression" - // $ANTLR start "rule__Type__Alternatives" - // InternalExport.g:1815:1: rule__Type__Alternatives : ( ( ruleCollectionType ) | ( ruleSimpleType ) ); - public final void rule__Type__Alternatives() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXPostfixOperation" + // InternalExport.g:1804:1: entryRuleXPostfixOperation : ruleXPostfixOperation EOF ; + public final void entryRuleXPostfixOperation() throws RecognitionException { try { - // InternalExport.g:1819:1: ( ( ruleCollectionType ) | ( ruleSimpleType ) ) - int alt18=2; - int LA18_0 = input.LA(1); - - if ( ((LA18_0>=33 && LA18_0<=35)) ) { - alt18=1; - } - else if ( (LA18_0==RULE_ID) ) { - alt18=2; + // InternalExport.g:1805:1: ( ruleXPostfixOperation EOF ) + // InternalExport.g:1806:1: ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 18, 0, input); + pushFollow(FOLLOW_1); + ruleXPostfixOperation(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationRule()); } - switch (alt18) { - case 1 : - // InternalExport.g:1820:2: ( ruleCollectionType ) - { - // InternalExport.g:1820:2: ( ruleCollectionType ) - // InternalExport.g:1821:3: ruleCollectionType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleCollectionType(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1826:2: ( ruleSimpleType ) - { - // InternalExport.g:1826:2: ( ruleSimpleType ) - // InternalExport.g:1827:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); - } - - } - - - } - break; + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Type__Alternatives" + // $ANTLR end "entryRuleXPostfixOperation" - // $ANTLR start "rule__CollectionType__ClAlternatives_0_0" - // InternalExport.g:1836:1: rule__CollectionType__ClAlternatives_0_0 : ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ); - public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionException { + // $ANTLR start "ruleXPostfixOperation" + // InternalExport.g:1813:1: ruleXPostfixOperation : ( ( rule__XPostfixOperation__Group__0 ) ) ; + public final void ruleXPostfixOperation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1840:1: ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ) - int alt19=3; - switch ( input.LA(1) ) { - case 33: - { - alt19=1; - } - break; - case 34: - { - alt19=2; - } - break; - case 35: - { - alt19=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 19, 0, input); - - throw nvae; + // InternalExport.g:1817:2: ( ( ( rule__XPostfixOperation__Group__0 ) ) ) + // InternalExport.g:1818:2: ( ( rule__XPostfixOperation__Group__0 ) ) + { + // InternalExport.g:1818:2: ( ( rule__XPostfixOperation__Group__0 ) ) + // InternalExport.g:1819:3: ( rule__XPostfixOperation__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup()); } + // InternalExport.g:1820:3: ( rule__XPostfixOperation__Group__0 ) + // InternalExport.g:1820:4: rule__XPostfixOperation__Group__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__0(); - switch (alt19) { - case 1 : - // InternalExport.g:1841:2: ( 'Collection' ) - { - // InternalExport.g:1841:2: ( 'Collection' ) - // InternalExport.g:1842:3: 'Collection' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); - } - match(input,33,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExport.g:1847:2: ( 'List' ) - { - // InternalExport.g:1847:2: ( 'List' ) - // InternalExport.g:1848:3: 'List' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); - } - match(input,34,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); - } - - } - + state._fsp--; + if (state.failed) return ; - } - break; - case 3 : - // InternalExport.g:1853:2: ( 'Set' ) - { - // InternalExport.g:1853:2: ( 'Set' ) - // InternalExport.g:1854:3: 'Set' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); - } - match(input,35,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6881,29 +6162,28 @@ public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionE } return ; } - // $ANTLR end "rule__CollectionType__ClAlternatives_0_0" - + // $ANTLR end "ruleXPostfixOperation" - // $ANTLR start "rule__ExportModel__Group__0" - // InternalExport.g:1863:1: rule__ExportModel__Group__0 : rule__ExportModel__Group__0__Impl rule__ExportModel__Group__1 ; - public final void rule__ExportModel__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpPostfix" + // InternalExport.g:1829:1: entryRuleOpPostfix : ruleOpPostfix EOF ; + public final void entryRuleOpPostfix() throws RecognitionException { try { - // InternalExport.g:1867:1: ( rule__ExportModel__Group__0__Impl rule__ExportModel__Group__1 ) - // InternalExport.g:1868:2: rule__ExportModel__Group__0__Impl rule__ExportModel__Group__1 + // InternalExport.g:1830:1: ( ruleOpPostfix EOF ) + // InternalExport.g:1831:1: ruleOpPostfix EOF { - pushFollow(FOLLOW_3); - rule__ExportModel__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_1); + ruleOpPostfix(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6913,55 +6193,41 @@ public final void rule__ExportModel__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group__0" + // $ANTLR end "entryRuleOpPostfix" - // $ANTLR start "rule__ExportModel__Group__0__Impl" - // InternalExport.g:1875:1: rule__ExportModel__Group__0__Impl : ( ( rule__ExportModel__Group_0__0 )? ) ; - public final void rule__ExportModel__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleOpPostfix" + // InternalExport.g:1838:1: ruleOpPostfix : ( ( rule__OpPostfix__Alternatives ) ) ; + public final void ruleOpPostfix() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1879:1: ( ( ( rule__ExportModel__Group_0__0 )? ) ) - // InternalExport.g:1880:1: ( ( rule__ExportModel__Group_0__0 )? ) + // InternalExport.g:1842:2: ( ( ( rule__OpPostfix__Alternatives ) ) ) + // InternalExport.g:1843:2: ( ( rule__OpPostfix__Alternatives ) ) { - // InternalExport.g:1880:1: ( ( rule__ExportModel__Group_0__0 )? ) - // InternalExport.g:1881:2: ( rule__ExportModel__Group_0__0 )? + // InternalExport.g:1843:2: ( ( rule__OpPostfix__Alternatives ) ) + // InternalExport.g:1844:3: ( rule__OpPostfix__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getGroup_0()); + before(grammarAccess.getOpPostfixAccess().getAlternatives()); } - // InternalExport.g:1882:2: ( rule__ExportModel__Group_0__0 )? - int alt20=2; - int LA20_0 = input.LA(1); - - if ( (LA20_0==36) ) { - alt20=1; - } - switch (alt20) { - case 1 : - // InternalExport.g:1882:3: rule__ExportModel__Group_0__0 - { - pushFollow(FOLLOW_2); - rule__ExportModel__Group_0__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:1845:3: ( rule__OpPostfix__Alternatives ) + // InternalExport.g:1845:4: rule__OpPostfix__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpPostfix__Alternatives(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getGroup_0()); + after(grammarAccess.getOpPostfixAccess().getAlternatives()); } } @@ -6981,29 +6247,28 @@ public final void rule__ExportModel__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ExportModel__Group__0__Impl" - + // $ANTLR end "ruleOpPostfix" - // $ANTLR start "rule__ExportModel__Group__1" - // InternalExport.g:1890:1: rule__ExportModel__Group__1 : rule__ExportModel__Group__1__Impl rule__ExportModel__Group__2 ; - public final void rule__ExportModel__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXMemberFeatureCall" + // InternalExport.g:1854:1: entryRuleXMemberFeatureCall : ruleXMemberFeatureCall EOF ; + public final void entryRuleXMemberFeatureCall() throws RecognitionException { try { - // InternalExport.g:1894:1: ( rule__ExportModel__Group__1__Impl rule__ExportModel__Group__2 ) - // InternalExport.g:1895:2: rule__ExportModel__Group__1__Impl rule__ExportModel__Group__2 + // InternalExport.g:1855:1: ( ruleXMemberFeatureCall EOF ) + // InternalExport.g:1856:1: ruleXMemberFeatureCall EOF { - pushFollow(FOLLOW_4); - rule__ExportModel__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallRule()); + } + pushFollow(FOLLOW_1); + ruleXMemberFeatureCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7013,39 +6278,33 @@ public final void rule__ExportModel__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group__1" + // $ANTLR end "entryRuleXMemberFeatureCall" - // $ANTLR start "rule__ExportModel__Group__1__Impl" - // InternalExport.g:1902:1: rule__ExportModel__Group__1__Impl : ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) ; - public final void rule__ExportModel__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXMemberFeatureCall" + // InternalExport.g:1863:1: ruleXMemberFeatureCall : ( ( rule__XMemberFeatureCall__Group__0 ) ) ; + public final void ruleXMemberFeatureCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1906:1: ( ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) ) - // InternalExport.g:1907:1: ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) - { - // InternalExport.g:1907:1: ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) - // InternalExport.g:1908:2: ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) + // InternalExport.g:1867:2: ( ( ( rule__XMemberFeatureCall__Group__0 ) ) ) + // InternalExport.g:1868:2: ( ( rule__XMemberFeatureCall__Group__0 ) ) { - // InternalExport.g:1908:2: ( ( rule__ExportModel__ImportsAssignment_1 ) ) - // InternalExport.g:1909:3: ( rule__ExportModel__ImportsAssignment_1 ) + // InternalExport.g:1868:2: ( ( rule__XMemberFeatureCall__Group__0 ) ) + // InternalExport.g:1869:3: ( rule__XMemberFeatureCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); + before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } - // InternalExport.g:1910:3: ( rule__ExportModel__ImportsAssignment_1 ) - // InternalExport.g:1910:4: rule__ExportModel__ImportsAssignment_1 + // InternalExport.g:1870:3: ( rule__XMemberFeatureCall__Group__0 ) + // InternalExport.g:1870:4: rule__XMemberFeatureCall__Group__0 { - pushFollow(FOLLOW_5); - rule__ExportModel__ImportsAssignment_1(); + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__0(); state._fsp--; if (state.failed) return ; @@ -7053,52 +6312,93 @@ public final void rule__ExportModel__Group__1__Impl() throws RecognitionExceptio } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); + after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } } - // InternalExport.g:1913:2: ( ( rule__ExportModel__ImportsAssignment_1 )* ) - // InternalExport.g:1914:3: ( rule__ExportModel__ImportsAssignment_1 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); + } - // InternalExport.g:1915:3: ( rule__ExportModel__ImportsAssignment_1 )* - loop21: - do { - int alt21=2; - int LA21_0 = input.LA(1); - if ( (LA21_0==41) ) { - alt21=1; - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - switch (alt21) { - case 1 : - // InternalExport.g:1915:4: rule__ExportModel__ImportsAssignment_1 - { - pushFollow(FOLLOW_5); - rule__ExportModel__ImportsAssignment_1(); + } + return ; + } + // $ANTLR end "ruleXMemberFeatureCall" - state._fsp--; - if (state.failed) return ; - } - break; + // $ANTLR start "entryRuleXPrimaryExpression" + // InternalExport.g:1879:1: entryRuleXPrimaryExpression : ruleXPrimaryExpression EOF ; + public final void entryRuleXPrimaryExpression() throws RecognitionException { + try { + // InternalExport.g:1880:1: ( ruleXPrimaryExpression EOF ) + // InternalExport.g:1881:1: ruleXPrimaryExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXPrimaryExpression(); - default : - break loop21; - } - } while (true); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXPrimaryExpression" + + + // $ANTLR start "ruleXPrimaryExpression" + // InternalExport.g:1888:1: ruleXPrimaryExpression : ( ( rule__XPrimaryExpression__Alternatives ) ) ; + public final void ruleXPrimaryExpression() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:1892:2: ( ( ( rule__XPrimaryExpression__Alternatives ) ) ) + // InternalExport.g:1893:2: ( ( rule__XPrimaryExpression__Alternatives ) ) + { + // InternalExport.g:1893:2: ( ( rule__XPrimaryExpression__Alternatives ) ) + // InternalExport.g:1894:3: ( rule__XPrimaryExpression__Alternatives ) + { if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); + before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } + // InternalExport.g:1895:3: ( rule__XPrimaryExpression__Alternatives ) + // InternalExport.g:1895:4: rule__XPrimaryExpression__Alternatives + { + pushFollow(FOLLOW_2); + rule__XPrimaryExpression__Alternatives(); + + state._fsp--; + if (state.failed) return ; } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); + } } @@ -7117,29 +6417,28 @@ public final void rule__ExportModel__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ExportModel__Group__1__Impl" + // $ANTLR end "ruleXPrimaryExpression" - // $ANTLR start "rule__ExportModel__Group__2" - // InternalExport.g:1924:1: rule__ExportModel__Group__2 : rule__ExportModel__Group__2__Impl rule__ExportModel__Group__3 ; - public final void rule__ExportModel__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXLiteral" + // InternalExport.g:1904:1: entryRuleXLiteral : ruleXLiteral EOF ; + public final void entryRuleXLiteral() throws RecognitionException { try { - // InternalExport.g:1928:1: ( rule__ExportModel__Group__2__Impl rule__ExportModel__Group__3 ) - // InternalExport.g:1929:2: rule__ExportModel__Group__2__Impl rule__ExportModel__Group__3 + // InternalExport.g:1905:1: ( ruleXLiteral EOF ) + // InternalExport.g:1906:1: ruleXLiteral EOF { - pushFollow(FOLLOW_4); - rule__ExportModel__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7149,62 +6448,41 @@ public final void rule__ExportModel__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group__2" + // $ANTLR end "entryRuleXLiteral" - // $ANTLR start "rule__ExportModel__Group__2__Impl" - // InternalExport.g:1936:1: rule__ExportModel__Group__2__Impl : ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) ; - public final void rule__ExportModel__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXLiteral" + // InternalExport.g:1913:1: ruleXLiteral : ( ( rule__XLiteral__Alternatives ) ) ; + public final void ruleXLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1940:1: ( ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) ) - // InternalExport.g:1941:1: ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) + // InternalExport.g:1917:2: ( ( ( rule__XLiteral__Alternatives ) ) ) + // InternalExport.g:1918:2: ( ( rule__XLiteral__Alternatives ) ) { - // InternalExport.g:1941:1: ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) - // InternalExport.g:1942:2: ( rule__ExportModel__ExtensionsAssignment_2 )* + // InternalExport.g:1918:2: ( ( rule__XLiteral__Alternatives ) ) + // InternalExport.g:1919:3: ( rule__XLiteral__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); + before(grammarAccess.getXLiteralAccess().getAlternatives()); } - // InternalExport.g:1943:2: ( rule__ExportModel__ExtensionsAssignment_2 )* - loop22: - do { - int alt22=2; - int LA22_0 = input.LA(1); - - if ( (LA22_0==43) ) { - alt22=1; - } - - - switch (alt22) { - case 1 : - // InternalExport.g:1943:3: rule__ExportModel__ExtensionsAssignment_2 - { - pushFollow(FOLLOW_6); - rule__ExportModel__ExtensionsAssignment_2(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:1920:3: ( rule__XLiteral__Alternatives ) + // InternalExport.g:1920:4: rule__XLiteral__Alternatives + { + pushFollow(FOLLOW_2); + rule__XLiteral__Alternatives(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop22; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); + after(grammarAccess.getXLiteralAccess().getAlternatives()); } } @@ -7224,29 +6502,28 @@ public final void rule__ExportModel__Group__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ExportModel__Group__2__Impl" - + // $ANTLR end "ruleXLiteral" - // $ANTLR start "rule__ExportModel__Group__3" - // InternalExport.g:1951:1: rule__ExportModel__Group__3 : rule__ExportModel__Group__3__Impl rule__ExportModel__Group__4 ; - public final void rule__ExportModel__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCollectionLiteral" + // InternalExport.g:1929:1: entryRuleXCollectionLiteral : ruleXCollectionLiteral EOF ; + public final void entryRuleXCollectionLiteral() throws RecognitionException { try { - // InternalExport.g:1955:1: ( rule__ExportModel__Group__3__Impl rule__ExportModel__Group__4 ) - // InternalExport.g:1956:2: rule__ExportModel__Group__3__Impl rule__ExportModel__Group__4 + // InternalExport.g:1930:1: ( ruleXCollectionLiteral EOF ) + // InternalExport.g:1931:1: ruleXCollectionLiteral EOF { - pushFollow(FOLLOW_4); - rule__ExportModel__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXCollectionLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7256,55 +6533,41 @@ public final void rule__ExportModel__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group__3" + // $ANTLR end "entryRuleXCollectionLiteral" - // $ANTLR start "rule__ExportModel__Group__3__Impl" - // InternalExport.g:1963:1: rule__ExportModel__Group__3__Impl : ( ( rule__ExportModel__Group_3__0 )? ) ; - public final void rule__ExportModel__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXCollectionLiteral" + // InternalExport.g:1938:1: ruleXCollectionLiteral : ( ( rule__XCollectionLiteral__Alternatives ) ) ; + public final void ruleXCollectionLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1967:1: ( ( ( rule__ExportModel__Group_3__0 )? ) ) - // InternalExport.g:1968:1: ( ( rule__ExportModel__Group_3__0 )? ) + // InternalExport.g:1942:2: ( ( ( rule__XCollectionLiteral__Alternatives ) ) ) + // InternalExport.g:1943:2: ( ( rule__XCollectionLiteral__Alternatives ) ) { - // InternalExport.g:1968:1: ( ( rule__ExportModel__Group_3__0 )? ) - // InternalExport.g:1969:2: ( rule__ExportModel__Group_3__0 )? + // InternalExport.g:1943:2: ( ( rule__XCollectionLiteral__Alternatives ) ) + // InternalExport.g:1944:3: ( rule__XCollectionLiteral__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getGroup_3()); + before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } - // InternalExport.g:1970:2: ( rule__ExportModel__Group_3__0 )? - int alt23=2; - int LA23_0 = input.LA(1); - - if ( (LA23_0==38) ) { - alt23=1; - } - switch (alt23) { - case 1 : - // InternalExport.g:1970:3: rule__ExportModel__Group_3__0 - { - pushFollow(FOLLOW_2); - rule__ExportModel__Group_3__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:1945:3: ( rule__XCollectionLiteral__Alternatives ) + // InternalExport.g:1945:4: rule__XCollectionLiteral__Alternatives + { + pushFollow(FOLLOW_2); + rule__XCollectionLiteral__Alternatives(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getGroup_3()); + after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } } @@ -7324,24 +6587,28 @@ public final void rule__ExportModel__Group__3__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ExportModel__Group__3__Impl" - + // $ANTLR end "ruleXCollectionLiteral" - // $ANTLR start "rule__ExportModel__Group__4" - // InternalExport.g:1978:1: rule__ExportModel__Group__4 : rule__ExportModel__Group__4__Impl ; - public final void rule__ExportModel__Group__4() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSetLiteral" + // InternalExport.g:1954:1: entryRuleXSetLiteral : ruleXSetLiteral EOF ; + public final void entryRuleXSetLiteral() throws RecognitionException { try { - // InternalExport.g:1982:1: ( rule__ExportModel__Group__4__Impl ) - // InternalExport.g:1983:2: rule__ExportModel__Group__4__Impl + // InternalExport.g:1955:1: ( ruleXSetLiteral EOF ) + // InternalExport.g:1956:1: ruleXSetLiteral EOF { - pushFollow(FOLLOW_2); - rule__ExportModel__Group__4__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXSetLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7351,39 +6618,33 @@ public final void rule__ExportModel__Group__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group__4" + // $ANTLR end "entryRuleXSetLiteral" - // $ANTLR start "rule__ExportModel__Group__4__Impl" - // InternalExport.g:1989:1: rule__ExportModel__Group__4__Impl : ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) ; - public final void rule__ExportModel__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXSetLiteral" + // InternalExport.g:1963:1: ruleXSetLiteral : ( ( rule__XSetLiteral__Group__0 ) ) ; + public final void ruleXSetLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:1993:1: ( ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) ) - // InternalExport.g:1994:1: ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) + // InternalExport.g:1967:2: ( ( ( rule__XSetLiteral__Group__0 ) ) ) + // InternalExport.g:1968:2: ( ( rule__XSetLiteral__Group__0 ) ) { - // InternalExport.g:1994:1: ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) - // InternalExport.g:1995:2: ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) - { - // InternalExport.g:1995:2: ( ( rule__ExportModel__ExportsAssignment_4 ) ) - // InternalExport.g:1996:3: ( rule__ExportModel__ExportsAssignment_4 ) + // InternalExport.g:1968:2: ( ( rule__XSetLiteral__Group__0 ) ) + // InternalExport.g:1969:3: ( rule__XSetLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); + before(grammarAccess.getXSetLiteralAccess().getGroup()); } - // InternalExport.g:1997:3: ( rule__ExportModel__ExportsAssignment_4 ) - // InternalExport.g:1997:4: rule__ExportModel__ExportsAssignment_4 + // InternalExport.g:1970:3: ( rule__XSetLiteral__Group__0 ) + // InternalExport.g:1970:4: rule__XSetLiteral__Group__0 { - pushFollow(FOLLOW_7); - rule__ExportModel__ExportsAssignment_4(); + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -7391,53 +6652,9 @@ public final void rule__ExportModel__Group__4__Impl() throws RecognitionExceptio } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); - } - - } - - // InternalExport.g:2000:2: ( ( rule__ExportModel__ExportsAssignment_4 )* ) - // InternalExport.g:2001:3: ( rule__ExportModel__ExportsAssignment_4 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); - } - // InternalExport.g:2002:3: ( rule__ExportModel__ExportsAssignment_4 )* - loop24: - do { - int alt24=2; - int LA24_0 = input.LA(1); - - if ( (LA24_0==36) ) { - alt24=1; - } - - - switch (alt24) { - case 1 : - // InternalExport.g:2002:4: rule__ExportModel__ExportsAssignment_4 - { - pushFollow(FOLLOW_7); - rule__ExportModel__ExportsAssignment_4(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop24; - } - } while (true); - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); - } - + after(grammarAccess.getXSetLiteralAccess().getGroup()); } - } @@ -7455,29 +6672,28 @@ public final void rule__ExportModel__Group__4__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ExportModel__Group__4__Impl" - + // $ANTLR end "ruleXSetLiteral" - // $ANTLR start "rule__ExportModel__Group_0__0" - // InternalExport.g:2012:1: rule__ExportModel__Group_0__0 : rule__ExportModel__Group_0__0__Impl rule__ExportModel__Group_0__1 ; - public final void rule__ExportModel__Group_0__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXListLiteral" + // InternalExport.g:1979:1: entryRuleXListLiteral : ruleXListLiteral EOF ; + public final void entryRuleXListLiteral() throws RecognitionException { try { - // InternalExport.g:2016:1: ( rule__ExportModel__Group_0__0__Impl rule__ExportModel__Group_0__1 ) - // InternalExport.g:2017:2: rule__ExportModel__Group_0__0__Impl rule__ExportModel__Group_0__1 + // InternalExport.g:1980:1: ( ruleXListLiteral EOF ) + // InternalExport.g:1981:1: ruleXListLiteral EOF { - pushFollow(FOLLOW_8); - rule__ExportModel__Group_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_0__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXListLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7487,34 +6703,41 @@ public final void rule__ExportModel__Group_0__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_0__0" + // $ANTLR end "entryRuleXListLiteral" - // $ANTLR start "rule__ExportModel__Group_0__0__Impl" - // InternalExport.g:2024:1: rule__ExportModel__Group_0__0__Impl : ( 'export' ) ; - public final void rule__ExportModel__Group_0__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXListLiteral" + // InternalExport.g:1988:1: ruleXListLiteral : ( ( rule__XListLiteral__Group__0 ) ) ; + public final void ruleXListLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2028:1: ( ( 'export' ) ) - // InternalExport.g:2029:1: ( 'export' ) + // InternalExport.g:1992:2: ( ( ( rule__XListLiteral__Group__0 ) ) ) + // InternalExport.g:1993:2: ( ( rule__XListLiteral__Group__0 ) ) { - // InternalExport.g:2029:1: ( 'export' ) - // InternalExport.g:2030:2: 'export' + // InternalExport.g:1993:2: ( ( rule__XListLiteral__Group__0 ) ) + // InternalExport.g:1994:3: ( rule__XListLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); + before(grammarAccess.getXListLiteralAccess().getGroup()); } - match(input,36,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:1995:3: ( rule__XListLiteral__Group__0 ) + // InternalExport.g:1995:4: rule__XListLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); + after(grammarAccess.getXListLiteralAccess().getGroup()); } } @@ -7534,29 +6757,28 @@ public final void rule__ExportModel__Group_0__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_0__0__Impl" - + // $ANTLR end "ruleXListLiteral" - // $ANTLR start "rule__ExportModel__Group_0__1" - // InternalExport.g:2039:1: rule__ExportModel__Group_0__1 : rule__ExportModel__Group_0__1__Impl rule__ExportModel__Group_0__2 ; - public final void rule__ExportModel__Group_0__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXClosure" + // InternalExport.g:2004:1: entryRuleXClosure : ruleXClosure EOF ; + public final void entryRuleXClosure() throws RecognitionException { try { - // InternalExport.g:2043:1: ( rule__ExportModel__Group_0__1__Impl rule__ExportModel__Group_0__2 ) - // InternalExport.g:2044:2: rule__ExportModel__Group_0__1__Impl rule__ExportModel__Group_0__2 + // InternalExport.g:2005:1: ( ruleXClosure EOF ) + // InternalExport.g:2006:1: ruleXClosure EOF { - pushFollow(FOLLOW_8); - rule__ExportModel__Group_0__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_0__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXClosure(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7566,55 +6788,41 @@ public final void rule__ExportModel__Group_0__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_0__1" + // $ANTLR end "entryRuleXClosure" - // $ANTLR start "rule__ExportModel__Group_0__1__Impl" - // InternalExport.g:2051:1: rule__ExportModel__Group_0__1__Impl : ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) ; - public final void rule__ExportModel__Group_0__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXClosure" + // InternalExport.g:2013:1: ruleXClosure : ( ( rule__XClosure__Group__0 ) ) ; + public final void ruleXClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2055:1: ( ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) ) - // InternalExport.g:2056:1: ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) + // InternalExport.g:2017:2: ( ( ( rule__XClosure__Group__0 ) ) ) + // InternalExport.g:2018:2: ( ( rule__XClosure__Group__0 ) ) { - // InternalExport.g:2056:1: ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) - // InternalExport.g:2057:2: ( rule__ExportModel__ExtensionAssignment_0_1 )? + // InternalExport.g:2018:2: ( ( rule__XClosure__Group__0 ) ) + // InternalExport.g:2019:3: ( rule__XClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); - } - // InternalExport.g:2058:2: ( rule__ExportModel__ExtensionAssignment_0_1 )? - int alt25=2; - int LA25_0 = input.LA(1); - - if ( (LA25_0==43) ) { - alt25=1; + before(grammarAccess.getXClosureAccess().getGroup()); } - switch (alt25) { - case 1 : - // InternalExport.g:2058:3: rule__ExportModel__ExtensionAssignment_0_1 - { - pushFollow(FOLLOW_2); - rule__ExportModel__ExtensionAssignment_0_1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2020:3: ( rule__XClosure__Group__0 ) + // InternalExport.g:2020:4: rule__XClosure__Group__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); + after(grammarAccess.getXClosureAccess().getGroup()); } } @@ -7634,29 +6842,28 @@ public final void rule__ExportModel__Group_0__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_0__1__Impl" - + // $ANTLR end "ruleXClosure" - // $ANTLR start "rule__ExportModel__Group_0__2" - // InternalExport.g:2066:1: rule__ExportModel__Group_0__2 : rule__ExportModel__Group_0__2__Impl rule__ExportModel__Group_0__3 ; - public final void rule__ExportModel__Group_0__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpressionInClosure" + // InternalExport.g:2029:1: entryRuleXExpressionInClosure : ruleXExpressionInClosure EOF ; + public final void entryRuleXExpressionInClosure() throws RecognitionException { try { - // InternalExport.g:2070:1: ( rule__ExportModel__Group_0__2__Impl rule__ExportModel__Group_0__3 ) - // InternalExport.g:2071:2: rule__ExportModel__Group_0__2__Impl rule__ExportModel__Group_0__3 + // InternalExport.g:2030:1: ( ruleXExpressionInClosure EOF ) + // InternalExport.g:2031:1: ruleXExpressionInClosure EOF { - pushFollow(FOLLOW_9); - rule__ExportModel__Group_0__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_0__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXExpressionInClosure(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7666,36 +6873,33 @@ public final void rule__ExportModel__Group_0__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_0__2" + // $ANTLR end "entryRuleXExpressionInClosure" - // $ANTLR start "rule__ExportModel__Group_0__2__Impl" - // InternalExport.g:2078:1: rule__ExportModel__Group_0__2__Impl : ( ( rule__ExportModel__NameAssignment_0_2 ) ) ; - public final void rule__ExportModel__Group_0__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXExpressionInClosure" + // InternalExport.g:2038:1: ruleXExpressionInClosure : ( ( rule__XExpressionInClosure__Group__0 ) ) ; + public final void ruleXExpressionInClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2082:1: ( ( ( rule__ExportModel__NameAssignment_0_2 ) ) ) - // InternalExport.g:2083:1: ( ( rule__ExportModel__NameAssignment_0_2 ) ) + // InternalExport.g:2042:2: ( ( ( rule__XExpressionInClosure__Group__0 ) ) ) + // InternalExport.g:2043:2: ( ( rule__XExpressionInClosure__Group__0 ) ) { - // InternalExport.g:2083:1: ( ( rule__ExportModel__NameAssignment_0_2 ) ) - // InternalExport.g:2084:2: ( rule__ExportModel__NameAssignment_0_2 ) + // InternalExport.g:2043:2: ( ( rule__XExpressionInClosure__Group__0 ) ) + // InternalExport.g:2044:3: ( rule__XExpressionInClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); + before(grammarAccess.getXExpressionInClosureAccess().getGroup()); } - // InternalExport.g:2085:2: ( rule__ExportModel__NameAssignment_0_2 ) - // InternalExport.g:2085:3: rule__ExportModel__NameAssignment_0_2 + // InternalExport.g:2045:3: ( rule__XExpressionInClosure__Group__0 ) + // InternalExport.g:2045:4: rule__XExpressionInClosure__Group__0 { pushFollow(FOLLOW_2); - rule__ExportModel__NameAssignment_0_2(); + rule__XExpressionInClosure__Group__0(); state._fsp--; if (state.failed) return ; @@ -7703,7 +6907,7 @@ public final void rule__ExportModel__Group_0__2__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); + after(grammarAccess.getXExpressionInClosureAccess().getGroup()); } } @@ -7723,29 +6927,28 @@ public final void rule__ExportModel__Group_0__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_0__2__Impl" - + // $ANTLR end "ruleXExpressionInClosure" - // $ANTLR start "rule__ExportModel__Group_0__3" - // InternalExport.g:2093:1: rule__ExportModel__Group_0__3 : rule__ExportModel__Group_0__3__Impl rule__ExportModel__Group_0__4 ; - public final void rule__ExportModel__Group_0__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXShortClosure" + // InternalExport.g:2054:1: entryRuleXShortClosure : ruleXShortClosure EOF ; + public final void entryRuleXShortClosure() throws RecognitionException { try { - // InternalExport.g:2097:1: ( rule__ExportModel__Group_0__3__Impl rule__ExportModel__Group_0__4 ) - // InternalExport.g:2098:2: rule__ExportModel__Group_0__3__Impl rule__ExportModel__Group_0__4 + // InternalExport.g:2055:1: ( ruleXShortClosure EOF ) + // InternalExport.g:2056:1: ruleXShortClosure EOF { - pushFollow(FOLLOW_10); - rule__ExportModel__Group_0__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_0__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXShortClosure(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7755,34 +6958,41 @@ public final void rule__ExportModel__Group_0__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_0__3" + // $ANTLR end "entryRuleXShortClosure" - // $ANTLR start "rule__ExportModel__Group_0__3__Impl" - // InternalExport.g:2105:1: rule__ExportModel__Group_0__3__Impl : ( 'for' ) ; - public final void rule__ExportModel__Group_0__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXShortClosure" + // InternalExport.g:2063:1: ruleXShortClosure : ( ( rule__XShortClosure__Group__0 ) ) ; + public final void ruleXShortClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2109:1: ( ( 'for' ) ) - // InternalExport.g:2110:1: ( 'for' ) + // InternalExport.g:2067:2: ( ( ( rule__XShortClosure__Group__0 ) ) ) + // InternalExport.g:2068:2: ( ( rule__XShortClosure__Group__0 ) ) { - // InternalExport.g:2110:1: ( 'for' ) - // InternalExport.g:2111:2: 'for' + // InternalExport.g:2068:2: ( ( rule__XShortClosure__Group__0 ) ) + // InternalExport.g:2069:3: ( rule__XShortClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getForKeyword_0_3()); + before(grammarAccess.getXShortClosureAccess().getGroup()); + } + // InternalExport.g:2070:3: ( rule__XShortClosure__Group__0 ) + // InternalExport.g:2070:4: rule__XShortClosure__Group__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getForKeyword_0_3()); + after(grammarAccess.getXShortClosureAccess().getGroup()); } } @@ -7802,24 +7012,28 @@ public final void rule__ExportModel__Group_0__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_0__3__Impl" + // $ANTLR end "ruleXShortClosure" - // $ANTLR start "rule__ExportModel__Group_0__4" - // InternalExport.g:2120:1: rule__ExportModel__Group_0__4 : rule__ExportModel__Group_0__4__Impl ; - public final void rule__ExportModel__Group_0__4() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXParenthesizedExpression" + // InternalExport.g:2079:1: entryRuleXParenthesizedExpression : ruleXParenthesizedExpression EOF ; + public final void entryRuleXParenthesizedExpression() throws RecognitionException { try { - // InternalExport.g:2124:1: ( rule__ExportModel__Group_0__4__Impl ) - // InternalExport.g:2125:2: rule__ExportModel__Group_0__4__Impl + // InternalExport.g:2080:1: ( ruleXParenthesizedExpression EOF ) + // InternalExport.g:2081:1: ruleXParenthesizedExpression EOF { - pushFollow(FOLLOW_2); - rule__ExportModel__Group_0__4__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXParenthesizedExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7829,36 +7043,33 @@ public final void rule__ExportModel__Group_0__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_0__4" + // $ANTLR end "entryRuleXParenthesizedExpression" - // $ANTLR start "rule__ExportModel__Group_0__4__Impl" - // InternalExport.g:2131:1: rule__ExportModel__Group_0__4__Impl : ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) ; - public final void rule__ExportModel__Group_0__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXParenthesizedExpression" + // InternalExport.g:2088:1: ruleXParenthesizedExpression : ( ( rule__XParenthesizedExpression__Group__0 ) ) ; + public final void ruleXParenthesizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2135:1: ( ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) ) - // InternalExport.g:2136:1: ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) + // InternalExport.g:2092:2: ( ( ( rule__XParenthesizedExpression__Group__0 ) ) ) + // InternalExport.g:2093:2: ( ( rule__XParenthesizedExpression__Group__0 ) ) { - // InternalExport.g:2136:1: ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) - // InternalExport.g:2137:2: ( rule__ExportModel__TargetGrammarAssignment_0_4 ) + // InternalExport.g:2093:2: ( ( rule__XParenthesizedExpression__Group__0 ) ) + // InternalExport.g:2094:3: ( rule__XParenthesizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); + before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } - // InternalExport.g:2138:2: ( rule__ExportModel__TargetGrammarAssignment_0_4 ) - // InternalExport.g:2138:3: rule__ExportModel__TargetGrammarAssignment_0_4 + // InternalExport.g:2095:3: ( rule__XParenthesizedExpression__Group__0 ) + // InternalExport.g:2095:4: rule__XParenthesizedExpression__Group__0 { pushFollow(FOLLOW_2); - rule__ExportModel__TargetGrammarAssignment_0_4(); + rule__XParenthesizedExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -7866,7 +7077,7 @@ public final void rule__ExportModel__Group_0__4__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); + after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } } @@ -7886,29 +7097,28 @@ public final void rule__ExportModel__Group_0__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_0__4__Impl" - + // $ANTLR end "ruleXParenthesizedExpression" - // $ANTLR start "rule__ExportModel__Group_3__0" - // InternalExport.g:2147:1: rule__ExportModel__Group_3__0 : rule__ExportModel__Group_3__0__Impl rule__ExportModel__Group_3__1 ; - public final void rule__ExportModel__Group_3__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXIfExpression" + // InternalExport.g:2104:1: entryRuleXIfExpression : ruleXIfExpression EOF ; + public final void entryRuleXIfExpression() throws RecognitionException { try { - // InternalExport.g:2151:1: ( rule__ExportModel__Group_3__0__Impl rule__ExportModel__Group_3__1 ) - // InternalExport.g:2152:2: rule__ExportModel__Group_3__0__Impl rule__ExportModel__Group_3__1 + // InternalExport.g:2105:1: ( ruleXIfExpression EOF ) + // InternalExport.g:2106:1: ruleXIfExpression EOF { - pushFollow(FOLLOW_11); - rule__ExportModel__Group_3__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_3__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXIfExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7918,34 +7128,41 @@ public final void rule__ExportModel__Group_3__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_3__0" + // $ANTLR end "entryRuleXIfExpression" - // $ANTLR start "rule__ExportModel__Group_3__0__Impl" - // InternalExport.g:2159:1: rule__ExportModel__Group_3__0__Impl : ( 'interface' ) ; - public final void rule__ExportModel__Group_3__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXIfExpression" + // InternalExport.g:2113:1: ruleXIfExpression : ( ( rule__XIfExpression__Group__0 ) ) ; + public final void ruleXIfExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2163:1: ( ( 'interface' ) ) - // InternalExport.g:2164:1: ( 'interface' ) + // InternalExport.g:2117:2: ( ( ( rule__XIfExpression__Group__0 ) ) ) + // InternalExport.g:2118:2: ( ( rule__XIfExpression__Group__0 ) ) { - // InternalExport.g:2164:1: ( 'interface' ) - // InternalExport.g:2165:2: 'interface' + // InternalExport.g:2118:2: ( ( rule__XIfExpression__Group__0 ) ) + // InternalExport.g:2119:3: ( rule__XIfExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); + before(grammarAccess.getXIfExpressionAccess().getGroup()); } - match(input,38,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:2120:3: ( rule__XIfExpression__Group__0 ) + // InternalExport.g:2120:4: rule__XIfExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); + after(grammarAccess.getXIfExpressionAccess().getGroup()); } } @@ -7965,29 +7182,28 @@ public final void rule__ExportModel__Group_3__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_3__0__Impl" + // $ANTLR end "ruleXIfExpression" - // $ANTLR start "rule__ExportModel__Group_3__1" - // InternalExport.g:2174:1: rule__ExportModel__Group_3__1 : rule__ExportModel__Group_3__1__Impl rule__ExportModel__Group_3__2 ; - public final void rule__ExportModel__Group_3__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSwitchExpression" + // InternalExport.g:2129:1: entryRuleXSwitchExpression : ruleXSwitchExpression EOF ; + public final void entryRuleXSwitchExpression() throws RecognitionException { try { - // InternalExport.g:2178:1: ( rule__ExportModel__Group_3__1__Impl rule__ExportModel__Group_3__2 ) - // InternalExport.g:2179:2: rule__ExportModel__Group_3__1__Impl rule__ExportModel__Group_3__2 + // InternalExport.g:2130:1: ( ruleXSwitchExpression EOF ) + // InternalExport.g:2131:1: ruleXSwitchExpression EOF { - pushFollow(FOLLOW_10); - rule__ExportModel__Group_3__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_3__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXSwitchExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7997,34 +7213,41 @@ public final void rule__ExportModel__Group_3__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_3__1" + // $ANTLR end "entryRuleXSwitchExpression" - // $ANTLR start "rule__ExportModel__Group_3__1__Impl" - // InternalExport.g:2186:1: rule__ExportModel__Group_3__1__Impl : ( '{' ) ; - public final void rule__ExportModel__Group_3__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXSwitchExpression" + // InternalExport.g:2138:1: ruleXSwitchExpression : ( ( rule__XSwitchExpression__Group__0 ) ) ; + public final void ruleXSwitchExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2190:1: ( ( '{' ) ) - // InternalExport.g:2191:1: ( '{' ) + // InternalExport.g:2142:2: ( ( ( rule__XSwitchExpression__Group__0 ) ) ) + // InternalExport.g:2143:2: ( ( rule__XSwitchExpression__Group__0 ) ) { - // InternalExport.g:2191:1: ( '{' ) - // InternalExport.g:2192:2: '{' + // InternalExport.g:2143:2: ( ( rule__XSwitchExpression__Group__0 ) ) + // InternalExport.g:2144:3: ( rule__XSwitchExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); + before(grammarAccess.getXSwitchExpressionAccess().getGroup()); + } + // InternalExport.g:2145:3: ( rule__XSwitchExpression__Group__0 ) + // InternalExport.g:2145:4: rule__XSwitchExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); + after(grammarAccess.getXSwitchExpressionAccess().getGroup()); } } @@ -8044,29 +7267,28 @@ public final void rule__ExportModel__Group_3__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_3__1__Impl" - + // $ANTLR end "ruleXSwitchExpression" - // $ANTLR start "rule__ExportModel__Group_3__2" - // InternalExport.g:2201:1: rule__ExportModel__Group_3__2 : rule__ExportModel__Group_3__2__Impl rule__ExportModel__Group_3__3 ; - public final void rule__ExportModel__Group_3__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCasePart" + // InternalExport.g:2154:1: entryRuleXCasePart : ruleXCasePart EOF ; + public final void entryRuleXCasePart() throws RecognitionException { try { - // InternalExport.g:2205:1: ( rule__ExportModel__Group_3__2__Impl rule__ExportModel__Group_3__3 ) - // InternalExport.g:2206:2: rule__ExportModel__Group_3__2__Impl rule__ExportModel__Group_3__3 + // InternalExport.g:2155:1: ( ruleXCasePart EOF ) + // InternalExport.g:2156:1: ruleXCasePart EOF { - pushFollow(FOLLOW_12); - rule__ExportModel__Group_3__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ExportModel__Group_3__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_1); + ruleXCasePart(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8076,39 +7298,33 @@ public final void rule__ExportModel__Group_3__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_3__2" + // $ANTLR end "entryRuleXCasePart" - // $ANTLR start "rule__ExportModel__Group_3__2__Impl" - // InternalExport.g:2213:1: rule__ExportModel__Group_3__2__Impl : ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) ; - public final void rule__ExportModel__Group_3__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXCasePart" + // InternalExport.g:2163:1: ruleXCasePart : ( ( rule__XCasePart__Group__0 ) ) ; + public final void ruleXCasePart() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2217:1: ( ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) ) - // InternalExport.g:2218:1: ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) - { - // InternalExport.g:2218:1: ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) - // InternalExport.g:2219:2: ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) + // InternalExport.g:2167:2: ( ( ( rule__XCasePart__Group__0 ) ) ) + // InternalExport.g:2168:2: ( ( rule__XCasePart__Group__0 ) ) { - // InternalExport.g:2219:2: ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) - // InternalExport.g:2220:3: ( rule__ExportModel__InterfacesAssignment_3_2 ) + // InternalExport.g:2168:2: ( ( rule__XCasePart__Group__0 ) ) + // InternalExport.g:2169:3: ( rule__XCasePart__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); + before(grammarAccess.getXCasePartAccess().getGroup()); } - // InternalExport.g:2221:3: ( rule__ExportModel__InterfacesAssignment_3_2 ) - // InternalExport.g:2221:4: rule__ExportModel__InterfacesAssignment_3_2 + // InternalExport.g:2170:3: ( rule__XCasePart__Group__0 ) + // InternalExport.g:2170:4: rule__XCasePart__Group__0 { - pushFollow(FOLLOW_13); - rule__ExportModel__InterfacesAssignment_3_2(); + pushFollow(FOLLOW_2); + rule__XCasePart__Group__0(); state._fsp--; if (state.failed) return ; @@ -8116,48 +7332,7 @@ public final void rule__ExportModel__Group_3__2__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); - } - - } - - // InternalExport.g:2224:2: ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) - // InternalExport.g:2225:3: ( rule__ExportModel__InterfacesAssignment_3_2 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); - } - // InternalExport.g:2226:3: ( rule__ExportModel__InterfacesAssignment_3_2 )* - loop26: - do { - int alt26=2; - int LA26_0 = input.LA(1); - - if ( (LA26_0==RULE_ID) ) { - alt26=1; - } - - - switch (alt26) { - case 1 : - // InternalExport.g:2226:4: rule__ExportModel__InterfacesAssignment_3_2 - { - pushFollow(FOLLOW_13); - rule__ExportModel__InterfacesAssignment_3_2(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop26; - } - } while (true); - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); + after(grammarAccess.getXCasePartAccess().getGroup()); } } @@ -8165,9 +7340,6 @@ public final void rule__ExportModel__Group_3__2__Impl() throws RecognitionExcept } - - } - } catch (RecognitionException re) { reportError(re); @@ -8180,24 +7352,28 @@ public final void rule__ExportModel__Group_3__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_3__2__Impl" + // $ANTLR end "ruleXCasePart" - // $ANTLR start "rule__ExportModel__Group_3__3" - // InternalExport.g:2235:1: rule__ExportModel__Group_3__3 : rule__ExportModel__Group_3__3__Impl ; - public final void rule__ExportModel__Group_3__3() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXForLoopExpression" + // InternalExport.g:2179:1: entryRuleXForLoopExpression : ruleXForLoopExpression EOF ; + public final void entryRuleXForLoopExpression() throws RecognitionException { try { - // InternalExport.g:2239:1: ( rule__ExportModel__Group_3__3__Impl ) - // InternalExport.g:2240:2: rule__ExportModel__Group_3__3__Impl + // InternalExport.g:2180:1: ( ruleXForLoopExpression EOF ) + // InternalExport.g:2181:1: ruleXForLoopExpression EOF { - pushFollow(FOLLOW_2); - rule__ExportModel__Group_3__3__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXForLoopExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8207,34 +7383,41 @@ public final void rule__ExportModel__Group_3__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ExportModel__Group_3__3" + // $ANTLR end "entryRuleXForLoopExpression" - // $ANTLR start "rule__ExportModel__Group_3__3__Impl" - // InternalExport.g:2246:1: rule__ExportModel__Group_3__3__Impl : ( '}' ) ; - public final void rule__ExportModel__Group_3__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXForLoopExpression" + // InternalExport.g:2188:1: ruleXForLoopExpression : ( ( rule__XForLoopExpression__Group__0 ) ) ; + public final void ruleXForLoopExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2250:1: ( ( '}' ) ) - // InternalExport.g:2251:1: ( '}' ) + // InternalExport.g:2192:2: ( ( ( rule__XForLoopExpression__Group__0 ) ) ) + // InternalExport.g:2193:2: ( ( rule__XForLoopExpression__Group__0 ) ) { - // InternalExport.g:2251:1: ( '}' ) - // InternalExport.g:2252:2: '}' + // InternalExport.g:2193:2: ( ( rule__XForLoopExpression__Group__0 ) ) + // InternalExport.g:2194:3: ( rule__XForLoopExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); + before(grammarAccess.getXForLoopExpressionAccess().getGroup()); } - match(input,40,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:2195:3: ( rule__XForLoopExpression__Group__0 ) + // InternalExport.g:2195:4: rule__XForLoopExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); + after(grammarAccess.getXForLoopExpressionAccess().getGroup()); } } @@ -8254,29 +7437,28 @@ public final void rule__ExportModel__Group_3__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ExportModel__Group_3__3__Impl" + // $ANTLR end "ruleXForLoopExpression" - // $ANTLR start "rule__Import__Group__0" - // InternalExport.g:2262:1: rule__Import__Group__0 : rule__Import__Group__0__Impl rule__Import__Group__1 ; - public final void rule__Import__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBasicForLoopExpression" + // InternalExport.g:2204:1: entryRuleXBasicForLoopExpression : ruleXBasicForLoopExpression EOF ; + public final void entryRuleXBasicForLoopExpression() throws RecognitionException { try { - // InternalExport.g:2266:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 ) - // InternalExport.g:2267:2: rule__Import__Group__0__Impl rule__Import__Group__1 + // InternalExport.g:2205:1: ( ruleXBasicForLoopExpression EOF ) + // InternalExport.g:2206:1: ruleXBasicForLoopExpression EOF { - pushFollow(FOLLOW_14); - rule__Import__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Import__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXBasicForLoopExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8286,34 +7468,41 @@ public final void rule__Import__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group__0" + // $ANTLR end "entryRuleXBasicForLoopExpression" - // $ANTLR start "rule__Import__Group__0__Impl" - // InternalExport.g:2274:1: rule__Import__Group__0__Impl : ( 'import' ) ; - public final void rule__Import__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXBasicForLoopExpression" + // InternalExport.g:2213:1: ruleXBasicForLoopExpression : ( ( rule__XBasicForLoopExpression__Group__0 ) ) ; + public final void ruleXBasicForLoopExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2278:1: ( ( 'import' ) ) - // InternalExport.g:2279:1: ( 'import' ) + // InternalExport.g:2217:2: ( ( ( rule__XBasicForLoopExpression__Group__0 ) ) ) + // InternalExport.g:2218:2: ( ( rule__XBasicForLoopExpression__Group__0 ) ) { - // InternalExport.g:2279:1: ( 'import' ) - // InternalExport.g:2280:2: 'import' + // InternalExport.g:2218:2: ( ( rule__XBasicForLoopExpression__Group__0 ) ) + // InternalExport.g:2219:3: ( rule__XBasicForLoopExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getImportKeyword_0()); + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); + } + // InternalExport.g:2220:3: ( rule__XBasicForLoopExpression__Group__0 ) + // InternalExport.g:2220:4: rule__XBasicForLoopExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,41,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getImportKeyword_0()); + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } } @@ -8333,29 +7522,28 @@ public final void rule__Import__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group__0__Impl" - + // $ANTLR end "ruleXBasicForLoopExpression" - // $ANTLR start "rule__Import__Group__1" - // InternalExport.g:2289:1: rule__Import__Group__1 : rule__Import__Group__1__Impl rule__Import__Group__2 ; - public final void rule__Import__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXWhileExpression" + // InternalExport.g:2229:1: entryRuleXWhileExpression : ruleXWhileExpression EOF ; + public final void entryRuleXWhileExpression() throws RecognitionException { try { - // InternalExport.g:2293:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 ) - // InternalExport.g:2294:2: rule__Import__Group__1__Impl rule__Import__Group__2 + // InternalExport.g:2230:1: ( ruleXWhileExpression EOF ) + // InternalExport.g:2231:1: ruleXWhileExpression EOF { - pushFollow(FOLLOW_15); - rule__Import__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Import__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXWhileExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8365,36 +7553,33 @@ public final void rule__Import__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group__1" + // $ANTLR end "entryRuleXWhileExpression" - // $ANTLR start "rule__Import__Group__1__Impl" - // InternalExport.g:2301:1: rule__Import__Group__1__Impl : ( ( rule__Import__PackageAssignment_1 ) ) ; - public final void rule__Import__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXWhileExpression" + // InternalExport.g:2238:1: ruleXWhileExpression : ( ( rule__XWhileExpression__Group__0 ) ) ; + public final void ruleXWhileExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2305:1: ( ( ( rule__Import__PackageAssignment_1 ) ) ) - // InternalExport.g:2306:1: ( ( rule__Import__PackageAssignment_1 ) ) + // InternalExport.g:2242:2: ( ( ( rule__XWhileExpression__Group__0 ) ) ) + // InternalExport.g:2243:2: ( ( rule__XWhileExpression__Group__0 ) ) { - // InternalExport.g:2306:1: ( ( rule__Import__PackageAssignment_1 ) ) - // InternalExport.g:2307:2: ( rule__Import__PackageAssignment_1 ) + // InternalExport.g:2243:2: ( ( rule__XWhileExpression__Group__0 ) ) + // InternalExport.g:2244:3: ( rule__XWhileExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getPackageAssignment_1()); + before(grammarAccess.getXWhileExpressionAccess().getGroup()); } - // InternalExport.g:2308:2: ( rule__Import__PackageAssignment_1 ) - // InternalExport.g:2308:3: rule__Import__PackageAssignment_1 + // InternalExport.g:2245:3: ( rule__XWhileExpression__Group__0 ) + // InternalExport.g:2245:4: rule__XWhileExpression__Group__0 { pushFollow(FOLLOW_2); - rule__Import__PackageAssignment_1(); + rule__XWhileExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -8402,7 +7587,7 @@ public final void rule__Import__Group__1__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getPackageAssignment_1()); + after(grammarAccess.getXWhileExpressionAccess().getGroup()); } } @@ -8422,24 +7607,28 @@ public final void rule__Import__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group__1__Impl" - + // $ANTLR end "ruleXWhileExpression" - // $ANTLR start "rule__Import__Group__2" - // InternalExport.g:2316:1: rule__Import__Group__2 : rule__Import__Group__2__Impl ; - public final void rule__Import__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXDoWhileExpression" + // InternalExport.g:2254:1: entryRuleXDoWhileExpression : ruleXDoWhileExpression EOF ; + public final void entryRuleXDoWhileExpression() throws RecognitionException { try { - // InternalExport.g:2320:1: ( rule__Import__Group__2__Impl ) - // InternalExport.g:2321:2: rule__Import__Group__2__Impl + // InternalExport.g:2255:1: ( ruleXDoWhileExpression EOF ) + // InternalExport.g:2256:1: ruleXDoWhileExpression EOF { - pushFollow(FOLLOW_2); - rule__Import__Group__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXDoWhileExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8449,55 +7638,41 @@ public final void rule__Import__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group__2" + // $ANTLR end "entryRuleXDoWhileExpression" - // $ANTLR start "rule__Import__Group__2__Impl" - // InternalExport.g:2327:1: rule__Import__Group__2__Impl : ( ( rule__Import__Group_2__0 )? ) ; - public final void rule__Import__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXDoWhileExpression" + // InternalExport.g:2263:1: ruleXDoWhileExpression : ( ( rule__XDoWhileExpression__Group__0 ) ) ; + public final void ruleXDoWhileExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2331:1: ( ( ( rule__Import__Group_2__0 )? ) ) - // InternalExport.g:2332:1: ( ( rule__Import__Group_2__0 )? ) + // InternalExport.g:2267:2: ( ( ( rule__XDoWhileExpression__Group__0 ) ) ) + // InternalExport.g:2268:2: ( ( rule__XDoWhileExpression__Group__0 ) ) { - // InternalExport.g:2332:1: ( ( rule__Import__Group_2__0 )? ) - // InternalExport.g:2333:2: ( rule__Import__Group_2__0 )? + // InternalExport.g:2268:2: ( ( rule__XDoWhileExpression__Group__0 ) ) + // InternalExport.g:2269:3: ( rule__XDoWhileExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getGroup_2()); - } - // InternalExport.g:2334:2: ( rule__Import__Group_2__0 )? - int alt27=2; - int LA27_0 = input.LA(1); - - if ( (LA27_0==42) ) { - alt27=1; + before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } - switch (alt27) { - case 1 : - // InternalExport.g:2334:3: rule__Import__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__Import__Group_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2270:3: ( rule__XDoWhileExpression__Group__0 ) + // InternalExport.g:2270:4: rule__XDoWhileExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getGroup_2()); + after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } } @@ -8517,29 +7692,28 @@ public final void rule__Import__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group__2__Impl" - + // $ANTLR end "ruleXDoWhileExpression" - // $ANTLR start "rule__Import__Group_2__0" - // InternalExport.g:2343:1: rule__Import__Group_2__0 : rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ; - public final void rule__Import__Group_2__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBlockExpression" + // InternalExport.g:2279:1: entryRuleXBlockExpression : ruleXBlockExpression EOF ; + public final void entryRuleXBlockExpression() throws RecognitionException { try { - // InternalExport.g:2347:1: ( rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ) - // InternalExport.g:2348:2: rule__Import__Group_2__0__Impl rule__Import__Group_2__1 + // InternalExport.g:2280:1: ( ruleXBlockExpression EOF ) + // InternalExport.g:2281:1: ruleXBlockExpression EOF { - pushFollow(FOLLOW_10); - rule__Import__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Import__Group_2__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXBlockExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8549,34 +7723,41 @@ public final void rule__Import__Group_2__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group_2__0" + // $ANTLR end "entryRuleXBlockExpression" - // $ANTLR start "rule__Import__Group_2__0__Impl" - // InternalExport.g:2355:1: rule__Import__Group_2__0__Impl : ( 'as' ) ; - public final void rule__Import__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXBlockExpression" + // InternalExport.g:2288:1: ruleXBlockExpression : ( ( rule__XBlockExpression__Group__0 ) ) ; + public final void ruleXBlockExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2359:1: ( ( 'as' ) ) - // InternalExport.g:2360:1: ( 'as' ) + // InternalExport.g:2292:2: ( ( ( rule__XBlockExpression__Group__0 ) ) ) + // InternalExport.g:2293:2: ( ( rule__XBlockExpression__Group__0 ) ) { - // InternalExport.g:2360:1: ( 'as' ) - // InternalExport.g:2361:2: 'as' + // InternalExport.g:2293:2: ( ( rule__XBlockExpression__Group__0 ) ) + // InternalExport.g:2294:3: ( rule__XBlockExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getAsKeyword_2_0()); + before(grammarAccess.getXBlockExpressionAccess().getGroup()); + } + // InternalExport.g:2295:3: ( rule__XBlockExpression__Group__0 ) + // InternalExport.g:2295:4: rule__XBlockExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,42,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getAsKeyword_2_0()); + after(grammarAccess.getXBlockExpressionAccess().getGroup()); } } @@ -8596,24 +7777,28 @@ public final void rule__Import__Group_2__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group_2__0__Impl" + // $ANTLR end "ruleXBlockExpression" - // $ANTLR start "rule__Import__Group_2__1" - // InternalExport.g:2370:1: rule__Import__Group_2__1 : rule__Import__Group_2__1__Impl ; - public final void rule__Import__Group_2__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpressionOrVarDeclaration" + // InternalExport.g:2304:1: entryRuleXExpressionOrVarDeclaration : ruleXExpressionOrVarDeclaration EOF ; + public final void entryRuleXExpressionOrVarDeclaration() throws RecognitionException { try { - // InternalExport.g:2374:1: ( rule__Import__Group_2__1__Impl ) - // InternalExport.g:2375:2: rule__Import__Group_2__1__Impl + // InternalExport.g:2305:1: ( ruleXExpressionOrVarDeclaration EOF ) + // InternalExport.g:2306:1: ruleXExpressionOrVarDeclaration EOF { - pushFollow(FOLLOW_2); - rule__Import__Group_2__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXExpressionOrVarDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8623,36 +7808,33 @@ public final void rule__Import__Group_2__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group_2__1" + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" - // $ANTLR start "rule__Import__Group_2__1__Impl" - // InternalExport.g:2381:1: rule__Import__Group_2__1__Impl : ( ( rule__Import__NameAssignment_2_1 ) ) ; - public final void rule__Import__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // InternalExport.g:2313:1: ruleXExpressionOrVarDeclaration : ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ; + public final void ruleXExpressionOrVarDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2385:1: ( ( ( rule__Import__NameAssignment_2_1 ) ) ) - // InternalExport.g:2386:1: ( ( rule__Import__NameAssignment_2_1 ) ) + // InternalExport.g:2317:2: ( ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ) + // InternalExport.g:2318:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) { - // InternalExport.g:2386:1: ( ( rule__Import__NameAssignment_2_1 ) ) - // InternalExport.g:2387:2: ( rule__Import__NameAssignment_2_1 ) + // InternalExport.g:2318:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) + // InternalExport.g:2319:3: ( rule__XExpressionOrVarDeclaration__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getNameAssignment_2_1()); + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } - // InternalExport.g:2388:2: ( rule__Import__NameAssignment_2_1 ) - // InternalExport.g:2388:3: rule__Import__NameAssignment_2_1 + // InternalExport.g:2320:3: ( rule__XExpressionOrVarDeclaration__Alternatives ) + // InternalExport.g:2320:4: rule__XExpressionOrVarDeclaration__Alternatives { pushFollow(FOLLOW_2); - rule__Import__NameAssignment_2_1(); + rule__XExpressionOrVarDeclaration__Alternatives(); state._fsp--; if (state.failed) return ; @@ -8660,7 +7842,7 @@ public final void rule__Import__Group_2__1__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getNameAssignment_2_1()); + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } } @@ -8680,29 +7862,28 @@ public final void rule__Import__Group_2__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group_2__1__Impl" - + // $ANTLR end "ruleXExpressionOrVarDeclaration" - // $ANTLR start "rule__Extension__Group__0" - // InternalExport.g:2397:1: rule__Extension__Group__0 : rule__Extension__Group__0__Impl rule__Extension__Group__1 ; - public final void rule__Extension__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXVariableDeclaration" + // InternalExport.g:2329:1: entryRuleXVariableDeclaration : ruleXVariableDeclaration EOF ; + public final void entryRuleXVariableDeclaration() throws RecognitionException { try { - // InternalExport.g:2401:1: ( rule__Extension__Group__0__Impl rule__Extension__Group__1 ) - // InternalExport.g:2402:2: rule__Extension__Group__0__Impl rule__Extension__Group__1 + // InternalExport.g:2330:1: ( ruleXVariableDeclaration EOF ) + // InternalExport.g:2331:1: ruleXVariableDeclaration EOF { - pushFollow(FOLLOW_10); - rule__Extension__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Extension__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXVariableDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8712,34 +7893,41 @@ public final void rule__Extension__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Extension__Group__0" + // $ANTLR end "entryRuleXVariableDeclaration" - // $ANTLR start "rule__Extension__Group__0__Impl" - // InternalExport.g:2409:1: rule__Extension__Group__0__Impl : ( 'extension' ) ; - public final void rule__Extension__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXVariableDeclaration" + // InternalExport.g:2338:1: ruleXVariableDeclaration : ( ( rule__XVariableDeclaration__Group__0 ) ) ; + public final void ruleXVariableDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2413:1: ( ( 'extension' ) ) - // InternalExport.g:2414:1: ( 'extension' ) + // InternalExport.g:2342:2: ( ( ( rule__XVariableDeclaration__Group__0 ) ) ) + // InternalExport.g:2343:2: ( ( rule__XVariableDeclaration__Group__0 ) ) { - // InternalExport.g:2414:1: ( 'extension' ) - // InternalExport.g:2415:2: 'extension' + // InternalExport.g:2343:2: ( ( rule__XVariableDeclaration__Group__0 ) ) + // InternalExport.g:2344:3: ( rule__XVariableDeclaration__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); + before(grammarAccess.getXVariableDeclarationAccess().getGroup()); + } + // InternalExport.g:2345:3: ( rule__XVariableDeclaration__Group__0 ) + // InternalExport.g:2345:4: rule__XVariableDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,43,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); + after(grammarAccess.getXVariableDeclarationAccess().getGroup()); } } @@ -8759,24 +7947,28 @@ public final void rule__Extension__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Extension__Group__0__Impl" + // $ANTLR end "ruleXVariableDeclaration" - // $ANTLR start "rule__Extension__Group__1" - // InternalExport.g:2424:1: rule__Extension__Group__1 : rule__Extension__Group__1__Impl ; - public final void rule__Extension__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmFormalParameter" + // InternalExport.g:2354:1: entryRuleJvmFormalParameter : ruleJvmFormalParameter EOF ; + public final void entryRuleJvmFormalParameter() throws RecognitionException { try { - // InternalExport.g:2428:1: ( rule__Extension__Group__1__Impl ) - // InternalExport.g:2429:2: rule__Extension__Group__1__Impl + // InternalExport.g:2355:1: ( ruleJvmFormalParameter EOF ) + // InternalExport.g:2356:1: ruleJvmFormalParameter EOF { - pushFollow(FOLLOW_2); - rule__Extension__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + ruleJvmFormalParameter(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8786,36 +7978,33 @@ public final void rule__Extension__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Extension__Group__1" + // $ANTLR end "entryRuleJvmFormalParameter" - // $ANTLR start "rule__Extension__Group__1__Impl" - // InternalExport.g:2435:1: rule__Extension__Group__1__Impl : ( ( rule__Extension__ExtensionAssignment_1 ) ) ; - public final void rule__Extension__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmFormalParameter" + // InternalExport.g:2363:1: ruleJvmFormalParameter : ( ( rule__JvmFormalParameter__Group__0 ) ) ; + public final void ruleJvmFormalParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2439:1: ( ( ( rule__Extension__ExtensionAssignment_1 ) ) ) - // InternalExport.g:2440:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) + // InternalExport.g:2367:2: ( ( ( rule__JvmFormalParameter__Group__0 ) ) ) + // InternalExport.g:2368:2: ( ( rule__JvmFormalParameter__Group__0 ) ) { - // InternalExport.g:2440:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) - // InternalExport.g:2441:2: ( rule__Extension__ExtensionAssignment_1 ) + // InternalExport.g:2368:2: ( ( rule__JvmFormalParameter__Group__0 ) ) + // InternalExport.g:2369:3: ( rule__JvmFormalParameter__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); + before(grammarAccess.getJvmFormalParameterAccess().getGroup()); } - // InternalExport.g:2442:2: ( rule__Extension__ExtensionAssignment_1 ) - // InternalExport.g:2442:3: rule__Extension__ExtensionAssignment_1 + // InternalExport.g:2370:3: ( rule__JvmFormalParameter__Group__0 ) + // InternalExport.g:2370:4: rule__JvmFormalParameter__Group__0 { pushFollow(FOLLOW_2); - rule__Extension__ExtensionAssignment_1(); + rule__JvmFormalParameter__Group__0(); state._fsp--; if (state.failed) return ; @@ -8823,7 +8012,7 @@ public final void rule__Extension__Group__1__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); + after(grammarAccess.getJvmFormalParameterAccess().getGroup()); } } @@ -8843,29 +8032,28 @@ public final void rule__Extension__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Extension__Group__1__Impl" - + // $ANTLR end "ruleJvmFormalParameter" - // $ANTLR start "rule__Interface__Group__0" - // InternalExport.g:2451:1: rule__Interface__Group__0 : rule__Interface__Group__0__Impl rule__Interface__Group__1 ; - public final void rule__Interface__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleFullJvmFormalParameter" + // InternalExport.g:2379:1: entryRuleFullJvmFormalParameter : ruleFullJvmFormalParameter EOF ; + public final void entryRuleFullJvmFormalParameter() throws RecognitionException { try { - // InternalExport.g:2455:1: ( rule__Interface__Group__0__Impl rule__Interface__Group__1 ) - // InternalExport.g:2456:2: rule__Interface__Group__0__Impl rule__Interface__Group__1 + // InternalExport.g:2380:1: ( ruleFullJvmFormalParameter EOF ) + // InternalExport.g:2381:1: ruleFullJvmFormalParameter EOF { - pushFollow(FOLLOW_16); - rule__Interface__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + ruleFullJvmFormalParameter(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8875,36 +8063,33 @@ public final void rule__Interface__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group__0" + // $ANTLR end "entryRuleFullJvmFormalParameter" - // $ANTLR start "rule__Interface__Group__0__Impl" - // InternalExport.g:2463:1: rule__Interface__Group__0__Impl : ( ( rule__Interface__TypeAssignment_0 ) ) ; - public final void rule__Interface__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleFullJvmFormalParameter" + // InternalExport.g:2388:1: ruleFullJvmFormalParameter : ( ( rule__FullJvmFormalParameter__Group__0 ) ) ; + public final void ruleFullJvmFormalParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2467:1: ( ( ( rule__Interface__TypeAssignment_0 ) ) ) - // InternalExport.g:2468:1: ( ( rule__Interface__TypeAssignment_0 ) ) + // InternalExport.g:2392:2: ( ( ( rule__FullJvmFormalParameter__Group__0 ) ) ) + // InternalExport.g:2393:2: ( ( rule__FullJvmFormalParameter__Group__0 ) ) { - // InternalExport.g:2468:1: ( ( rule__Interface__TypeAssignment_0 ) ) - // InternalExport.g:2469:2: ( rule__Interface__TypeAssignment_0 ) + // InternalExport.g:2393:2: ( ( rule__FullJvmFormalParameter__Group__0 ) ) + // InternalExport.g:2394:3: ( rule__FullJvmFormalParameter__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); + before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } - // InternalExport.g:2470:2: ( rule__Interface__TypeAssignment_0 ) - // InternalExport.g:2470:3: rule__Interface__TypeAssignment_0 + // InternalExport.g:2395:3: ( rule__FullJvmFormalParameter__Group__0 ) + // InternalExport.g:2395:4: rule__FullJvmFormalParameter__Group__0 { pushFollow(FOLLOW_2); - rule__Interface__TypeAssignment_0(); + rule__FullJvmFormalParameter__Group__0(); state._fsp--; if (state.failed) return ; @@ -8912,7 +8097,7 @@ public final void rule__Interface__Group__0__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); + after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } } @@ -8932,29 +8117,28 @@ public final void rule__Interface__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Interface__Group__0__Impl" - + // $ANTLR end "ruleFullJvmFormalParameter" - // $ANTLR start "rule__Interface__Group__1" - // InternalExport.g:2478:1: rule__Interface__Group__1 : rule__Interface__Group__1__Impl rule__Interface__Group__2 ; - public final void rule__Interface__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXFeatureCall" + // InternalExport.g:2404:1: entryRuleXFeatureCall : ruleXFeatureCall EOF ; + public final void entryRuleXFeatureCall() throws RecognitionException { try { - // InternalExport.g:2482:1: ( rule__Interface__Group__1__Impl rule__Interface__Group__2 ) - // InternalExport.g:2483:2: rule__Interface__Group__1__Impl rule__Interface__Group__2 + // InternalExport.g:2405:1: ( ruleXFeatureCall EOF ) + // InternalExport.g:2406:1: ruleXFeatureCall EOF { - pushFollow(FOLLOW_16); - rule__Interface__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_1); + ruleXFeatureCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8964,55 +8148,41 @@ public final void rule__Interface__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group__1" + // $ANTLR end "entryRuleXFeatureCall" - // $ANTLR start "rule__Interface__Group__1__Impl" - // InternalExport.g:2490:1: rule__Interface__Group__1__Impl : ( ( rule__Interface__Group_1__0 )? ) ; - public final void rule__Interface__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXFeatureCall" + // InternalExport.g:2413:1: ruleXFeatureCall : ( ( rule__XFeatureCall__Group__0 ) ) ; + public final void ruleXFeatureCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2494:1: ( ( ( rule__Interface__Group_1__0 )? ) ) - // InternalExport.g:2495:1: ( ( rule__Interface__Group_1__0 )? ) + // InternalExport.g:2417:2: ( ( ( rule__XFeatureCall__Group__0 ) ) ) + // InternalExport.g:2418:2: ( ( rule__XFeatureCall__Group__0 ) ) { - // InternalExport.g:2495:1: ( ( rule__Interface__Group_1__0 )? ) - // InternalExport.g:2496:2: ( rule__Interface__Group_1__0 )? + // InternalExport.g:2418:2: ( ( rule__XFeatureCall__Group__0 ) ) + // InternalExport.g:2419:3: ( rule__XFeatureCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getGroup_1()); - } - // InternalExport.g:2497:2: ( rule__Interface__Group_1__0 )? - int alt28=2; - int LA28_0 = input.LA(1); - - if ( (LA28_0==45) ) { - alt28=1; + before(grammarAccess.getXFeatureCallAccess().getGroup()); } - switch (alt28) { - case 1 : - // InternalExport.g:2497:3: rule__Interface__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__Interface__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2420:3: ( rule__XFeatureCall__Group__0 ) + // InternalExport.g:2420:4: rule__XFeatureCall__Group__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getGroup_1()); + after(grammarAccess.getXFeatureCallAccess().getGroup()); } } @@ -9032,29 +8202,28 @@ public final void rule__Interface__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Interface__Group__1__Impl" - + // $ANTLR end "ruleXFeatureCall" - // $ANTLR start "rule__Interface__Group__2" - // InternalExport.g:2505:1: rule__Interface__Group__2 : rule__Interface__Group__2__Impl rule__Interface__Group__3 ; - public final void rule__Interface__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleFeatureCallID" + // InternalExport.g:2429:1: entryRuleFeatureCallID : ruleFeatureCallID EOF ; + public final void entryRuleFeatureCallID() throws RecognitionException { try { - // InternalExport.g:2509:1: ( rule__Interface__Group__2__Impl rule__Interface__Group__3 ) - // InternalExport.g:2510:2: rule__Interface__Group__2__Impl rule__Interface__Group__3 + // InternalExport.g:2430:1: ( ruleFeatureCallID EOF ) + // InternalExport.g:2431:1: ruleFeatureCallID EOF { - pushFollow(FOLLOW_16); - rule__Interface__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_1); + ruleFeatureCallID(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9064,62 +8233,41 @@ public final void rule__Interface__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group__2" + // $ANTLR end "entryRuleFeatureCallID" - // $ANTLR start "rule__Interface__Group__2__Impl" - // InternalExport.g:2517:1: rule__Interface__Group__2__Impl : ( ( rule__Interface__Group_2__0 )* ) ; - public final void rule__Interface__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleFeatureCallID" + // InternalExport.g:2438:1: ruleFeatureCallID : ( ( rule__FeatureCallID__Alternatives ) ) ; + public final void ruleFeatureCallID() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2521:1: ( ( ( rule__Interface__Group_2__0 )* ) ) - // InternalExport.g:2522:1: ( ( rule__Interface__Group_2__0 )* ) + // InternalExport.g:2442:2: ( ( ( rule__FeatureCallID__Alternatives ) ) ) + // InternalExport.g:2443:2: ( ( rule__FeatureCallID__Alternatives ) ) { - // InternalExport.g:2522:1: ( ( rule__Interface__Group_2__0 )* ) - // InternalExport.g:2523:2: ( rule__Interface__Group_2__0 )* + // InternalExport.g:2443:2: ( ( rule__FeatureCallID__Alternatives ) ) + // InternalExport.g:2444:3: ( rule__FeatureCallID__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getGroup_2()); + before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } - // InternalExport.g:2524:2: ( rule__Interface__Group_2__0 )* - loop29: - do { - int alt29=2; - int LA29_0 = input.LA(1); - - if ( (LA29_0==47) ) { - alt29=1; - } - - - switch (alt29) { - case 1 : - // InternalExport.g:2524:3: rule__Interface__Group_2__0 - { - pushFollow(FOLLOW_17); - rule__Interface__Group_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2445:3: ( rule__FeatureCallID__Alternatives ) + // InternalExport.g:2445:4: rule__FeatureCallID__Alternatives + { + pushFollow(FOLLOW_2); + rule__FeatureCallID__Alternatives(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop29; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getGroup_2()); + after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } } @@ -9139,24 +8287,28 @@ public final void rule__Interface__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Interface__Group__2__Impl" + // $ANTLR end "ruleFeatureCallID" - // $ANTLR start "rule__Interface__Group__3" - // InternalExport.g:2532:1: rule__Interface__Group__3 : rule__Interface__Group__3__Impl ; - public final void rule__Interface__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleIdOrSuper" + // InternalExport.g:2454:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ; + public final void entryRuleIdOrSuper() throws RecognitionException { try { - // InternalExport.g:2536:1: ( rule__Interface__Group__3__Impl ) - // InternalExport.g:2537:2: rule__Interface__Group__3__Impl + // InternalExport.g:2455:1: ( ruleIdOrSuper EOF ) + // InternalExport.g:2456:1: ruleIdOrSuper EOF { - pushFollow(FOLLOW_2); - rule__Interface__Group__3__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_1); + ruleIdOrSuper(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9166,34 +8318,41 @@ public final void rule__Interface__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group__3" + // $ANTLR end "entryRuleIdOrSuper" - // $ANTLR start "rule__Interface__Group__3__Impl" - // InternalExport.g:2543:1: rule__Interface__Group__3__Impl : ( ';' ) ; - public final void rule__Interface__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleIdOrSuper" + // InternalExport.g:2463:1: ruleIdOrSuper : ( ( rule__IdOrSuper__Alternatives ) ) ; + public final void ruleIdOrSuper() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2547:1: ( ( ';' ) ) - // InternalExport.g:2548:1: ( ';' ) + // InternalExport.g:2467:2: ( ( ( rule__IdOrSuper__Alternatives ) ) ) + // InternalExport.g:2468:2: ( ( rule__IdOrSuper__Alternatives ) ) { - // InternalExport.g:2548:1: ( ';' ) - // InternalExport.g:2549:2: ';' + // InternalExport.g:2468:2: ( ( rule__IdOrSuper__Alternatives ) ) + // InternalExport.g:2469:3: ( rule__IdOrSuper__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); + before(grammarAccess.getIdOrSuperAccess().getAlternatives()); + } + // InternalExport.g:2470:3: ( rule__IdOrSuper__Alternatives ) + // InternalExport.g:2470:4: rule__IdOrSuper__Alternatives + { + pushFollow(FOLLOW_2); + rule__IdOrSuper__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,44,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); + after(grammarAccess.getIdOrSuperAccess().getAlternatives()); } } @@ -9213,29 +8372,28 @@ public final void rule__Interface__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Interface__Group__3__Impl" + // $ANTLR end "ruleIdOrSuper" - // $ANTLR start "rule__Interface__Group_1__0" - // InternalExport.g:2559:1: rule__Interface__Group_1__0 : rule__Interface__Group_1__0__Impl rule__Interface__Group_1__1 ; - public final void rule__Interface__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXConstructorCall" + // InternalExport.g:2479:1: entryRuleXConstructorCall : ruleXConstructorCall EOF ; + public final void entryRuleXConstructorCall() throws RecognitionException { try { - // InternalExport.g:2563:1: ( rule__Interface__Group_1__0__Impl rule__Interface__Group_1__1 ) - // InternalExport.g:2564:2: rule__Interface__Group_1__0__Impl rule__Interface__Group_1__1 + // InternalExport.g:2480:1: ( ruleXConstructorCall EOF ) + // InternalExport.g:2481:1: ruleXConstructorCall EOF { - pushFollow(FOLLOW_18); - rule__Interface__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_1); + ruleXConstructorCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9245,34 +8403,41 @@ public final void rule__Interface__Group_1__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_1__0" + // $ANTLR end "entryRuleXConstructorCall" - // $ANTLR start "rule__Interface__Group_1__0__Impl" - // InternalExport.g:2571:1: rule__Interface__Group_1__0__Impl : ( '[' ) ; - public final void rule__Interface__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXConstructorCall" + // InternalExport.g:2488:1: ruleXConstructorCall : ( ( rule__XConstructorCall__Group__0 ) ) ; + public final void ruleXConstructorCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2575:1: ( ( '[' ) ) - // InternalExport.g:2576:1: ( '[' ) + // InternalExport.g:2492:2: ( ( ( rule__XConstructorCall__Group__0 ) ) ) + // InternalExport.g:2493:2: ( ( rule__XConstructorCall__Group__0 ) ) { - // InternalExport.g:2576:1: ( '[' ) - // InternalExport.g:2577:2: '[' + // InternalExport.g:2493:2: ( ( rule__XConstructorCall__Group__0 ) ) + // InternalExport.g:2494:3: ( rule__XConstructorCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); + before(grammarAccess.getXConstructorCallAccess().getGroup()); + } + // InternalExport.g:2495:3: ( rule__XConstructorCall__Group__0 ) + // InternalExport.g:2495:4: rule__XConstructorCall__Group__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); + after(grammarAccess.getXConstructorCallAccess().getGroup()); } } @@ -9292,29 +8457,28 @@ public final void rule__Interface__Group_1__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__Group_1__0__Impl" - + // $ANTLR end "ruleXConstructorCall" - // $ANTLR start "rule__Interface__Group_1__1" - // InternalExport.g:2586:1: rule__Interface__Group_1__1 : rule__Interface__Group_1__1__Impl rule__Interface__Group_1__2 ; - public final void rule__Interface__Group_1__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBooleanLiteral" + // InternalExport.g:2504:1: entryRuleXBooleanLiteral : ruleXBooleanLiteral EOF ; + public final void entryRuleXBooleanLiteral() throws RecognitionException { try { - // InternalExport.g:2590:1: ( rule__Interface__Group_1__1__Impl rule__Interface__Group_1__2 ) - // InternalExport.g:2591:2: rule__Interface__Group_1__1__Impl rule__Interface__Group_1__2 + // InternalExport.g:2505:1: ( ruleXBooleanLiteral EOF ) + // InternalExport.g:2506:1: ruleXBooleanLiteral EOF { - pushFollow(FOLLOW_19); - rule__Interface__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXBooleanLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9324,36 +8488,33 @@ public final void rule__Interface__Group_1__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_1__1" + // $ANTLR end "entryRuleXBooleanLiteral" - // $ANTLR start "rule__Interface__Group_1__1__Impl" - // InternalExport.g:2598:1: rule__Interface__Group_1__1__Impl : ( ( rule__Interface__GuardAssignment_1_1 ) ) ; - public final void rule__Interface__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXBooleanLiteral" + // InternalExport.g:2513:1: ruleXBooleanLiteral : ( ( rule__XBooleanLiteral__Group__0 ) ) ; + public final void ruleXBooleanLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2602:1: ( ( ( rule__Interface__GuardAssignment_1_1 ) ) ) - // InternalExport.g:2603:1: ( ( rule__Interface__GuardAssignment_1_1 ) ) + // InternalExport.g:2517:2: ( ( ( rule__XBooleanLiteral__Group__0 ) ) ) + // InternalExport.g:2518:2: ( ( rule__XBooleanLiteral__Group__0 ) ) { - // InternalExport.g:2603:1: ( ( rule__Interface__GuardAssignment_1_1 ) ) - // InternalExport.g:2604:2: ( rule__Interface__GuardAssignment_1_1 ) + // InternalExport.g:2518:2: ( ( rule__XBooleanLiteral__Group__0 ) ) + // InternalExport.g:2519:3: ( rule__XBooleanLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); + before(grammarAccess.getXBooleanLiteralAccess().getGroup()); } - // InternalExport.g:2605:2: ( rule__Interface__GuardAssignment_1_1 ) - // InternalExport.g:2605:3: rule__Interface__GuardAssignment_1_1 + // InternalExport.g:2520:3: ( rule__XBooleanLiteral__Group__0 ) + // InternalExport.g:2520:4: rule__XBooleanLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__Interface__GuardAssignment_1_1(); + rule__XBooleanLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -9361,7 +8522,7 @@ public final void rule__Interface__Group_1__1__Impl() throws RecognitionExceptio } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); + after(grammarAccess.getXBooleanLiteralAccess().getGroup()); } } @@ -9381,24 +8542,28 @@ public final void rule__Interface__Group_1__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__Group_1__1__Impl" - + // $ANTLR end "ruleXBooleanLiteral" - // $ANTLR start "rule__Interface__Group_1__2" - // InternalExport.g:2613:1: rule__Interface__Group_1__2 : rule__Interface__Group_1__2__Impl ; - public final void rule__Interface__Group_1__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXNullLiteral" + // InternalExport.g:2529:1: entryRuleXNullLiteral : ruleXNullLiteral EOF ; + public final void entryRuleXNullLiteral() throws RecognitionException { try { - // InternalExport.g:2617:1: ( rule__Interface__Group_1__2__Impl ) - // InternalExport.g:2618:2: rule__Interface__Group_1__2__Impl + // InternalExport.g:2530:1: ( ruleXNullLiteral EOF ) + // InternalExport.g:2531:1: ruleXNullLiteral EOF { - pushFollow(FOLLOW_2); - rule__Interface__Group_1__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXNullLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9408,34 +8573,41 @@ public final void rule__Interface__Group_1__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_1__2" + // $ANTLR end "entryRuleXNullLiteral" - // $ANTLR start "rule__Interface__Group_1__2__Impl" - // InternalExport.g:2624:1: rule__Interface__Group_1__2__Impl : ( ']' ) ; - public final void rule__Interface__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXNullLiteral" + // InternalExport.g:2538:1: ruleXNullLiteral : ( ( rule__XNullLiteral__Group__0 ) ) ; + public final void ruleXNullLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2628:1: ( ( ']' ) ) - // InternalExport.g:2629:1: ( ']' ) + // InternalExport.g:2542:2: ( ( ( rule__XNullLiteral__Group__0 ) ) ) + // InternalExport.g:2543:2: ( ( rule__XNullLiteral__Group__0 ) ) { - // InternalExport.g:2629:1: ( ']' ) - // InternalExport.g:2630:2: ']' + // InternalExport.g:2543:2: ( ( rule__XNullLiteral__Group__0 ) ) + // InternalExport.g:2544:3: ( rule__XNullLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); + before(grammarAccess.getXNullLiteralAccess().getGroup()); + } + // InternalExport.g:2545:3: ( rule__XNullLiteral__Group__0 ) + // InternalExport.g:2545:4: rule__XNullLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); + after(grammarAccess.getXNullLiteralAccess().getGroup()); } } @@ -9455,29 +8627,28 @@ public final void rule__Interface__Group_1__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__Group_1__2__Impl" - + // $ANTLR end "ruleXNullLiteral" - // $ANTLR start "rule__Interface__Group_2__0" - // InternalExport.g:2640:1: rule__Interface__Group_2__0 : rule__Interface__Group_2__0__Impl rule__Interface__Group_2__1 ; - public final void rule__Interface__Group_2__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXNumberLiteral" + // InternalExport.g:2554:1: entryRuleXNumberLiteral : ruleXNumberLiteral EOF ; + public final void entryRuleXNumberLiteral() throws RecognitionException { try { - // InternalExport.g:2644:1: ( rule__Interface__Group_2__0__Impl rule__Interface__Group_2__1 ) - // InternalExport.g:2645:2: rule__Interface__Group_2__0__Impl rule__Interface__Group_2__1 + // InternalExport.g:2555:1: ( ruleXNumberLiteral EOF ) + // InternalExport.g:2556:1: ruleXNumberLiteral EOF { - pushFollow(FOLLOW_20); - rule__Interface__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group_2__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXNumberLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9487,34 +8658,41 @@ public final void rule__Interface__Group_2__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_2__0" + // $ANTLR end "entryRuleXNumberLiteral" - // $ANTLR start "rule__Interface__Group_2__0__Impl" - // InternalExport.g:2652:1: rule__Interface__Group_2__0__Impl : ( '=' ) ; - public final void rule__Interface__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXNumberLiteral" + // InternalExport.g:2563:1: ruleXNumberLiteral : ( ( rule__XNumberLiteral__Group__0 ) ) ; + public final void ruleXNumberLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2656:1: ( ( '=' ) ) - // InternalExport.g:2657:1: ( '=' ) + // InternalExport.g:2567:2: ( ( ( rule__XNumberLiteral__Group__0 ) ) ) + // InternalExport.g:2568:2: ( ( rule__XNumberLiteral__Group__0 ) ) { - // InternalExport.g:2657:1: ( '=' ) - // InternalExport.g:2658:2: '=' + // InternalExport.g:2568:2: ( ( rule__XNumberLiteral__Group__0 ) ) + // InternalExport.g:2569:3: ( rule__XNumberLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); + before(grammarAccess.getXNumberLiteralAccess().getGroup()); + } + // InternalExport.g:2570:3: ( rule__XNumberLiteral__Group__0 ) + // InternalExport.g:2570:4: rule__XNumberLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); + after(grammarAccess.getXNumberLiteralAccess().getGroup()); } } @@ -9534,29 +8712,28 @@ public final void rule__Interface__Group_2__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__Group_2__0__Impl" + // $ANTLR end "ruleXNumberLiteral" - // $ANTLR start "rule__Interface__Group_2__1" - // InternalExport.g:2667:1: rule__Interface__Group_2__1 : rule__Interface__Group_2__1__Impl rule__Interface__Group_2__2 ; - public final void rule__Interface__Group_2__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXStringLiteral" + // InternalExport.g:2579:1: entryRuleXStringLiteral : ruleXStringLiteral EOF ; + public final void entryRuleXStringLiteral() throws RecognitionException { try { - // InternalExport.g:2671:1: ( rule__Interface__Group_2__1__Impl rule__Interface__Group_2__2 ) - // InternalExport.g:2672:2: rule__Interface__Group_2__1__Impl rule__Interface__Group_2__2 + // InternalExport.g:2580:1: ( ruleXStringLiteral EOF ) + // InternalExport.g:2581:1: ruleXStringLiteral EOF { - pushFollow(FOLLOW_21); - rule__Interface__Group_2__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group_2__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXStringLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9566,36 +8743,33 @@ public final void rule__Interface__Group_2__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_2__1" + // $ANTLR end "entryRuleXStringLiteral" - // $ANTLR start "rule__Interface__Group_2__1__Impl" - // InternalExport.g:2679:1: rule__Interface__Group_2__1__Impl : ( ( rule__Interface__ItemsAssignment_2_1 ) ) ; - public final void rule__Interface__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXStringLiteral" + // InternalExport.g:2588:1: ruleXStringLiteral : ( ( rule__XStringLiteral__Group__0 ) ) ; + public final void ruleXStringLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2683:1: ( ( ( rule__Interface__ItemsAssignment_2_1 ) ) ) - // InternalExport.g:2684:1: ( ( rule__Interface__ItemsAssignment_2_1 ) ) + // InternalExport.g:2592:2: ( ( ( rule__XStringLiteral__Group__0 ) ) ) + // InternalExport.g:2593:2: ( ( rule__XStringLiteral__Group__0 ) ) { - // InternalExport.g:2684:1: ( ( rule__Interface__ItemsAssignment_2_1 ) ) - // InternalExport.g:2685:2: ( rule__Interface__ItemsAssignment_2_1 ) + // InternalExport.g:2593:2: ( ( rule__XStringLiteral__Group__0 ) ) + // InternalExport.g:2594:3: ( rule__XStringLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); + before(grammarAccess.getXStringLiteralAccess().getGroup()); } - // InternalExport.g:2686:2: ( rule__Interface__ItemsAssignment_2_1 ) - // InternalExport.g:2686:3: rule__Interface__ItemsAssignment_2_1 + // InternalExport.g:2595:3: ( rule__XStringLiteral__Group__0 ) + // InternalExport.g:2595:4: rule__XStringLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__Interface__ItemsAssignment_2_1(); + rule__XStringLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -9603,7 +8777,7 @@ public final void rule__Interface__Group_2__1__Impl() throws RecognitionExceptio } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); + after(grammarAccess.getXStringLiteralAccess().getGroup()); } } @@ -9623,24 +8797,28 @@ public final void rule__Interface__Group_2__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__Group_2__1__Impl" + // $ANTLR end "ruleXStringLiteral" - // $ANTLR start "rule__Interface__Group_2__2" - // InternalExport.g:2694:1: rule__Interface__Group_2__2 : rule__Interface__Group_2__2__Impl ; - public final void rule__Interface__Group_2__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXTypeLiteral" + // InternalExport.g:2604:1: entryRuleXTypeLiteral : ruleXTypeLiteral EOF ; + public final void entryRuleXTypeLiteral() throws RecognitionException { try { - // InternalExport.g:2698:1: ( rule__Interface__Group_2__2__Impl ) - // InternalExport.g:2699:2: rule__Interface__Group_2__2__Impl + // InternalExport.g:2605:1: ( ruleXTypeLiteral EOF ) + // InternalExport.g:2606:1: ruleXTypeLiteral EOF { - pushFollow(FOLLOW_2); - rule__Interface__Group_2__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXTypeLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9650,62 +8828,41 @@ public final void rule__Interface__Group_2__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_2__2" + // $ANTLR end "entryRuleXTypeLiteral" - // $ANTLR start "rule__Interface__Group_2__2__Impl" - // InternalExport.g:2705:1: rule__Interface__Group_2__2__Impl : ( ( rule__Interface__Group_2_2__0 )* ) ; - public final void rule__Interface__Group_2__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXTypeLiteral" + // InternalExport.g:2613:1: ruleXTypeLiteral : ( ( rule__XTypeLiteral__Group__0 ) ) ; + public final void ruleXTypeLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2709:1: ( ( ( rule__Interface__Group_2_2__0 )* ) ) - // InternalExport.g:2710:1: ( ( rule__Interface__Group_2_2__0 )* ) + // InternalExport.g:2617:2: ( ( ( rule__XTypeLiteral__Group__0 ) ) ) + // InternalExport.g:2618:2: ( ( rule__XTypeLiteral__Group__0 ) ) { - // InternalExport.g:2710:1: ( ( rule__Interface__Group_2_2__0 )* ) - // InternalExport.g:2711:2: ( rule__Interface__Group_2_2__0 )* + // InternalExport.g:2618:2: ( ( rule__XTypeLiteral__Group__0 ) ) + // InternalExport.g:2619:3: ( rule__XTypeLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getGroup_2_2()); + before(grammarAccess.getXTypeLiteralAccess().getGroup()); } - // InternalExport.g:2712:2: ( rule__Interface__Group_2_2__0 )* - loop30: - do { - int alt30=2; - int LA30_0 = input.LA(1); - - if ( (LA30_0==48) ) { - alt30=1; - } - - - switch (alt30) { - case 1 : - // InternalExport.g:2712:3: rule__Interface__Group_2_2__0 - { - pushFollow(FOLLOW_22); - rule__Interface__Group_2_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2620:3: ( rule__XTypeLiteral__Group__0 ) + // InternalExport.g:2620:4: rule__XTypeLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop30; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getGroup_2_2()); + after(grammarAccess.getXTypeLiteralAccess().getGroup()); } } @@ -9725,29 +8882,28 @@ public final void rule__Interface__Group_2__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__Group_2__2__Impl" + // $ANTLR end "ruleXTypeLiteral" - // $ANTLR start "rule__Interface__Group_2_2__0" - // InternalExport.g:2721:1: rule__Interface__Group_2_2__0 : rule__Interface__Group_2_2__0__Impl rule__Interface__Group_2_2__1 ; - public final void rule__Interface__Group_2_2__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXThrowExpression" + // InternalExport.g:2629:1: entryRuleXThrowExpression : ruleXThrowExpression EOF ; + public final void entryRuleXThrowExpression() throws RecognitionException { try { - // InternalExport.g:2725:1: ( rule__Interface__Group_2_2__0__Impl rule__Interface__Group_2_2__1 ) - // InternalExport.g:2726:2: rule__Interface__Group_2_2__0__Impl rule__Interface__Group_2_2__1 + // InternalExport.g:2630:1: ( ruleXThrowExpression EOF ) + // InternalExport.g:2631:1: ruleXThrowExpression EOF { - pushFollow(FOLLOW_20); - rule__Interface__Group_2_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Interface__Group_2_2__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXThrowExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9757,34 +8913,41 @@ public final void rule__Interface__Group_2_2__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_2_2__0" + // $ANTLR end "entryRuleXThrowExpression" - // $ANTLR start "rule__Interface__Group_2_2__0__Impl" - // InternalExport.g:2733:1: rule__Interface__Group_2_2__0__Impl : ( ',' ) ; - public final void rule__Interface__Group_2_2__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXThrowExpression" + // InternalExport.g:2638:1: ruleXThrowExpression : ( ( rule__XThrowExpression__Group__0 ) ) ; + public final void ruleXThrowExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2737:1: ( ( ',' ) ) - // InternalExport.g:2738:1: ( ',' ) + // InternalExport.g:2642:2: ( ( ( rule__XThrowExpression__Group__0 ) ) ) + // InternalExport.g:2643:2: ( ( rule__XThrowExpression__Group__0 ) ) { - // InternalExport.g:2738:1: ( ',' ) - // InternalExport.g:2739:2: ',' + // InternalExport.g:2643:2: ( ( rule__XThrowExpression__Group__0 ) ) + // InternalExport.g:2644:3: ( rule__XThrowExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); + before(grammarAccess.getXThrowExpressionAccess().getGroup()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:2645:3: ( rule__XThrowExpression__Group__0 ) + // InternalExport.g:2645:4: rule__XThrowExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); + after(grammarAccess.getXThrowExpressionAccess().getGroup()); } } @@ -9804,24 +8967,28 @@ public final void rule__Interface__Group_2_2__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__Interface__Group_2_2__0__Impl" + // $ANTLR end "ruleXThrowExpression" - // $ANTLR start "rule__Interface__Group_2_2__1" - // InternalExport.g:2748:1: rule__Interface__Group_2_2__1 : rule__Interface__Group_2_2__1__Impl ; - public final void rule__Interface__Group_2_2__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXReturnExpression" + // InternalExport.g:2654:1: entryRuleXReturnExpression : ruleXReturnExpression EOF ; + public final void entryRuleXReturnExpression() throws RecognitionException { try { - // InternalExport.g:2752:1: ( rule__Interface__Group_2_2__1__Impl ) - // InternalExport.g:2753:2: rule__Interface__Group_2_2__1__Impl + // InternalExport.g:2655:1: ( ruleXReturnExpression EOF ) + // InternalExport.g:2656:1: ruleXReturnExpression EOF { - pushFollow(FOLLOW_2); - rule__Interface__Group_2_2__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXReturnExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9831,36 +8998,33 @@ public final void rule__Interface__Group_2_2__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Interface__Group_2_2__1" + // $ANTLR end "entryRuleXReturnExpression" - // $ANTLR start "rule__Interface__Group_2_2__1__Impl" - // InternalExport.g:2759:1: rule__Interface__Group_2_2__1__Impl : ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) ; - public final void rule__Interface__Group_2_2__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXReturnExpression" + // InternalExport.g:2663:1: ruleXReturnExpression : ( ( rule__XReturnExpression__Group__0 ) ) ; + public final void ruleXReturnExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2763:1: ( ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) ) - // InternalExport.g:2764:1: ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) + // InternalExport.g:2667:2: ( ( ( rule__XReturnExpression__Group__0 ) ) ) + // InternalExport.g:2668:2: ( ( rule__XReturnExpression__Group__0 ) ) { - // InternalExport.g:2764:1: ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) - // InternalExport.g:2765:2: ( rule__Interface__ItemsAssignment_2_2_1 ) + // InternalExport.g:2668:2: ( ( rule__XReturnExpression__Group__0 ) ) + // InternalExport.g:2669:3: ( rule__XReturnExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); + before(grammarAccess.getXReturnExpressionAccess().getGroup()); } - // InternalExport.g:2766:2: ( rule__Interface__ItemsAssignment_2_2_1 ) - // InternalExport.g:2766:3: rule__Interface__ItemsAssignment_2_2_1 + // InternalExport.g:2670:3: ( rule__XReturnExpression__Group__0 ) + // InternalExport.g:2670:4: rule__XReturnExpression__Group__0 { pushFollow(FOLLOW_2); - rule__Interface__ItemsAssignment_2_2_1(); + rule__XReturnExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -9868,7 +9032,7 @@ public final void rule__Interface__Group_2_2__1__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); + after(grammarAccess.getXReturnExpressionAccess().getGroup()); } } @@ -9888,29 +9052,28 @@ public final void rule__Interface__Group_2_2__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__Interface__Group_2_2__1__Impl" - + // $ANTLR end "ruleXReturnExpression" - // $ANTLR start "rule__InterfaceField__Group__0" - // InternalExport.g:2775:1: rule__InterfaceField__Group__0 : rule__InterfaceField__Group__0__Impl rule__InterfaceField__Group__1 ; - public final void rule__InterfaceField__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXTryCatchFinallyExpression" + // InternalExport.g:2679:1: entryRuleXTryCatchFinallyExpression : ruleXTryCatchFinallyExpression EOF ; + public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException { try { - // InternalExport.g:2779:1: ( rule__InterfaceField__Group__0__Impl rule__InterfaceField__Group__1 ) - // InternalExport.g:2780:2: rule__InterfaceField__Group__0__Impl rule__InterfaceField__Group__1 + // InternalExport.g:2680:1: ( ruleXTryCatchFinallyExpression EOF ) + // InternalExport.g:2681:1: ruleXTryCatchFinallyExpression EOF { - pushFollow(FOLLOW_23); - rule__InterfaceField__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceField__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXTryCatchFinallyExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9920,55 +9083,41 @@ public final void rule__InterfaceField__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceField__Group__0" + // $ANTLR end "entryRuleXTryCatchFinallyExpression" - // $ANTLR start "rule__InterfaceField__Group__0__Impl" - // InternalExport.g:2787:1: rule__InterfaceField__Group__0__Impl : ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) ; - public final void rule__InterfaceField__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXTryCatchFinallyExpression" + // InternalExport.g:2688:1: ruleXTryCatchFinallyExpression : ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ; + public final void ruleXTryCatchFinallyExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2791:1: ( ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) ) - // InternalExport.g:2792:1: ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) + // InternalExport.g:2692:2: ( ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ) + // InternalExport.g:2693:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) { - // InternalExport.g:2792:1: ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) - // InternalExport.g:2793:2: ( rule__InterfaceField__UnorderedAssignment_0 )? + // InternalExport.g:2693:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) + // InternalExport.g:2694:3: ( rule__XTryCatchFinallyExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } - // InternalExport.g:2794:2: ( rule__InterfaceField__UnorderedAssignment_0 )? - int alt31=2; - int LA31_0 = input.LA(1); - - if ( (LA31_0==18) ) { - alt31=1; - } - switch (alt31) { - case 1 : - // InternalExport.g:2794:3: rule__InterfaceField__UnorderedAssignment_0 - { - pushFollow(FOLLOW_2); - rule__InterfaceField__UnorderedAssignment_0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2695:3: ( rule__XTryCatchFinallyExpression__Group__0 ) + // InternalExport.g:2695:4: rule__XTryCatchFinallyExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } } @@ -9988,24 +9137,28 @@ public final void rule__InterfaceField__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__InterfaceField__Group__0__Impl" - + // $ANTLR end "ruleXTryCatchFinallyExpression" - // $ANTLR start "rule__InterfaceField__Group__1" - // InternalExport.g:2802:1: rule__InterfaceField__Group__1 : rule__InterfaceField__Group__1__Impl ; - public final void rule__InterfaceField__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSynchronizedExpression" + // InternalExport.g:2704:1: entryRuleXSynchronizedExpression : ruleXSynchronizedExpression EOF ; + public final void entryRuleXSynchronizedExpression() throws RecognitionException { try { - // InternalExport.g:2806:1: ( rule__InterfaceField__Group__1__Impl ) - // InternalExport.g:2807:2: rule__InterfaceField__Group__1__Impl + // InternalExport.g:2705:1: ( ruleXSynchronizedExpression EOF ) + // InternalExport.g:2706:1: ruleXSynchronizedExpression EOF { - pushFollow(FOLLOW_2); - rule__InterfaceField__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXSynchronizedExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10015,36 +9168,33 @@ public final void rule__InterfaceField__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceField__Group__1" + // $ANTLR end "entryRuleXSynchronizedExpression" - // $ANTLR start "rule__InterfaceField__Group__1__Impl" - // InternalExport.g:2813:1: rule__InterfaceField__Group__1__Impl : ( ( rule__InterfaceField__FieldAssignment_1 ) ) ; - public final void rule__InterfaceField__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXSynchronizedExpression" + // InternalExport.g:2713:1: ruleXSynchronizedExpression : ( ( rule__XSynchronizedExpression__Group__0 ) ) ; + public final void ruleXSynchronizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2817:1: ( ( ( rule__InterfaceField__FieldAssignment_1 ) ) ) - // InternalExport.g:2818:1: ( ( rule__InterfaceField__FieldAssignment_1 ) ) + // InternalExport.g:2717:2: ( ( ( rule__XSynchronizedExpression__Group__0 ) ) ) + // InternalExport.g:2718:2: ( ( rule__XSynchronizedExpression__Group__0 ) ) { - // InternalExport.g:2818:1: ( ( rule__InterfaceField__FieldAssignment_1 ) ) - // InternalExport.g:2819:2: ( rule__InterfaceField__FieldAssignment_1 ) + // InternalExport.g:2718:2: ( ( rule__XSynchronizedExpression__Group__0 ) ) + // InternalExport.g:2719:3: ( rule__XSynchronizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } - // InternalExport.g:2820:2: ( rule__InterfaceField__FieldAssignment_1 ) - // InternalExport.g:2820:3: rule__InterfaceField__FieldAssignment_1 + // InternalExport.g:2720:3: ( rule__XSynchronizedExpression__Group__0 ) + // InternalExport.g:2720:4: rule__XSynchronizedExpression__Group__0 { pushFollow(FOLLOW_2); - rule__InterfaceField__FieldAssignment_1(); + rule__XSynchronizedExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -10052,7 +9202,7 @@ public final void rule__InterfaceField__Group__1__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } } @@ -10072,29 +9222,28 @@ public final void rule__InterfaceField__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__InterfaceField__Group__1__Impl" + // $ANTLR end "ruleXSynchronizedExpression" - // $ANTLR start "rule__InterfaceNavigation__Group__0" - // InternalExport.g:2829:1: rule__InterfaceNavigation__Group__0 : rule__InterfaceNavigation__Group__0__Impl rule__InterfaceNavigation__Group__1 ; - public final void rule__InterfaceNavigation__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCatchClause" + // InternalExport.g:2729:1: entryRuleXCatchClause : ruleXCatchClause EOF ; + public final void entryRuleXCatchClause() throws RecognitionException { try { - // InternalExport.g:2833:1: ( rule__InterfaceNavigation__Group__0__Impl rule__InterfaceNavigation__Group__1 ) - // InternalExport.g:2834:2: rule__InterfaceNavigation__Group__0__Impl rule__InterfaceNavigation__Group__1 + // InternalExport.g:2730:1: ( ruleXCatchClause EOF ) + // InternalExport.g:2731:1: ruleXCatchClause EOF { - pushFollow(FOLLOW_23); - rule__InterfaceNavigation__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceNavigation__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_1); + ruleXCatchClause(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10104,34 +9253,41 @@ public final void rule__InterfaceNavigation__Group__0() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceNavigation__Group__0" + // $ANTLR end "entryRuleXCatchClause" - // $ANTLR start "rule__InterfaceNavigation__Group__0__Impl" - // InternalExport.g:2841:1: rule__InterfaceNavigation__Group__0__Impl : ( '@' ) ; - public final void rule__InterfaceNavigation__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXCatchClause" + // InternalExport.g:2738:1: ruleXCatchClause : ( ( rule__XCatchClause__Group__0 ) ) ; + public final void ruleXCatchClause() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2845:1: ( ( '@' ) ) - // InternalExport.g:2846:1: ( '@' ) + // InternalExport.g:2742:2: ( ( ( rule__XCatchClause__Group__0 ) ) ) + // InternalExport.g:2743:2: ( ( rule__XCatchClause__Group__0 ) ) { - // InternalExport.g:2846:1: ( '@' ) - // InternalExport.g:2847:2: '@' + // InternalExport.g:2743:2: ( ( rule__XCatchClause__Group__0 ) ) + // InternalExport.g:2744:3: ( rule__XCatchClause__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); + before(grammarAccess.getXCatchClauseAccess().getGroup()); + } + // InternalExport.g:2745:3: ( rule__XCatchClause__Group__0 ) + // InternalExport.g:2745:4: rule__XCatchClause__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,49,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); + after(grammarAccess.getXCatchClauseAccess().getGroup()); } } @@ -10151,29 +9307,28 @@ public final void rule__InterfaceNavigation__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceNavigation__Group__0__Impl" - + // $ANTLR end "ruleXCatchClause" - // $ANTLR start "rule__InterfaceNavigation__Group__1" - // InternalExport.g:2856:1: rule__InterfaceNavigation__Group__1 : rule__InterfaceNavigation__Group__1__Impl rule__InterfaceNavigation__Group__2 ; - public final void rule__InterfaceNavigation__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedName" + // InternalExport.g:2754:1: entryRuleQualifiedName : ruleQualifiedName EOF ; + public final void entryRuleQualifiedName() throws RecognitionException { try { - // InternalExport.g:2860:1: ( rule__InterfaceNavigation__Group__1__Impl rule__InterfaceNavigation__Group__2 ) - // InternalExport.g:2861:2: rule__InterfaceNavigation__Group__1__Impl rule__InterfaceNavigation__Group__2 + // InternalExport.g:2755:1: ( ruleQualifiedName EOF ) + // InternalExport.g:2756:1: ruleQualifiedName EOF { - pushFollow(FOLLOW_23); - rule__InterfaceNavigation__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceNavigation__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedName(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10183,55 +9338,41 @@ public final void rule__InterfaceNavigation__Group__1() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceNavigation__Group__1" + // $ANTLR end "entryRuleQualifiedName" - // $ANTLR start "rule__InterfaceNavigation__Group__1__Impl" - // InternalExport.g:2868:1: rule__InterfaceNavigation__Group__1__Impl : ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) ; - public final void rule__InterfaceNavigation__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedName" + // InternalExport.g:2763:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; + public final void ruleQualifiedName() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2872:1: ( ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) ) - // InternalExport.g:2873:1: ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) + // InternalExport.g:2767:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) + // InternalExport.g:2768:2: ( ( rule__QualifiedName__Group__0 ) ) { - // InternalExport.g:2873:1: ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) - // InternalExport.g:2874:2: ( rule__InterfaceNavigation__UnorderedAssignment_1 )? + // InternalExport.g:2768:2: ( ( rule__QualifiedName__Group__0 ) ) + // InternalExport.g:2769:3: ( rule__QualifiedName__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); + before(grammarAccess.getQualifiedNameAccess().getGroup()); } - // InternalExport.g:2875:2: ( rule__InterfaceNavigation__UnorderedAssignment_1 )? - int alt32=2; - int LA32_0 = input.LA(1); - - if ( (LA32_0==18) ) { - alt32=1; - } - switch (alt32) { - case 1 : - // InternalExport.g:2875:3: rule__InterfaceNavigation__UnorderedAssignment_1 - { - pushFollow(FOLLOW_2); - rule__InterfaceNavigation__UnorderedAssignment_1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2770:3: ( rule__QualifiedName__Group__0 ) + // InternalExport.g:2770:4: rule__QualifiedName__Group__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); + after(grammarAccess.getQualifiedNameAccess().getGroup()); } } @@ -10251,24 +9392,31 @@ public final void rule__InterfaceNavigation__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceNavigation__Group__1__Impl" + // $ANTLR end "ruleQualifiedName" - // $ANTLR start "rule__InterfaceNavigation__Group__2" - // InternalExport.g:2883:1: rule__InterfaceNavigation__Group__2 : rule__InterfaceNavigation__Group__2__Impl ; - public final void rule__InterfaceNavigation__Group__2() throws RecognitionException { + // $ANTLR start "entryRuleNumber" + // InternalExport.g:2779:1: entryRuleNumber : ruleNumber EOF ; + public final void entryRuleNumber() throws RecognitionException { + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); - int stackSize = keepStackSize(); - try { - // InternalExport.g:2887:1: ( rule__InterfaceNavigation__Group__2__Impl ) - // InternalExport.g:2888:2: rule__InterfaceNavigation__Group__2__Impl + // InternalExport.g:2783:1: ( ruleNumber EOF ) + // InternalExport.g:2784:1: ruleNumber EOF { - pushFollow(FOLLOW_2); - rule__InterfaceNavigation__Group__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_1); + ruleNumber(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10279,35 +9427,36 @@ public final void rule__InterfaceNavigation__Group__2() throws RecognitionExcept } finally { - restoreStackSize(stackSize); + myHiddenTokenState.restore(); } return ; } - // $ANTLR end "rule__InterfaceNavigation__Group__2" + // $ANTLR end "entryRuleNumber" - // $ANTLR start "rule__InterfaceNavigation__Group__2__Impl" - // InternalExport.g:2894:1: rule__InterfaceNavigation__Group__2__Impl : ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) ; - public final void rule__InterfaceNavigation__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleNumber" + // InternalExport.g:2794:1: ruleNumber : ( ( rule__Number__Alternatives ) ) ; + public final void ruleNumber() throws RecognitionException { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); int stackSize = keepStackSize(); try { - // InternalExport.g:2898:1: ( ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) ) - // InternalExport.g:2899:1: ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) + // InternalExport.g:2799:2: ( ( ( rule__Number__Alternatives ) ) ) + // InternalExport.g:2800:2: ( ( rule__Number__Alternatives ) ) { - // InternalExport.g:2899:1: ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) - // InternalExport.g:2900:2: ( rule__InterfaceNavigation__RefAssignment_2 ) + // InternalExport.g:2800:2: ( ( rule__Number__Alternatives ) ) + // InternalExport.g:2801:3: ( rule__Number__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); + before(grammarAccess.getNumberAccess().getAlternatives()); } - // InternalExport.g:2901:2: ( rule__InterfaceNavigation__RefAssignment_2 ) - // InternalExport.g:2901:3: rule__InterfaceNavigation__RefAssignment_2 + // InternalExport.g:2802:3: ( rule__Number__Alternatives ) + // InternalExport.g:2802:4: rule__Number__Alternatives { pushFollow(FOLLOW_2); - rule__InterfaceNavigation__RefAssignment_2(); + rule__Number__Alternatives(); state._fsp--; if (state.failed) return ; @@ -10315,7 +9464,7 @@ public final void rule__InterfaceNavigation__Group__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); + after(grammarAccess.getNumberAccess().getAlternatives()); } } @@ -10331,33 +9480,33 @@ public final void rule__InterfaceNavigation__Group__2__Impl() throws Recognition finally { restoreStackSize(stackSize); + myHiddenTokenState.restore(); } return ; } - // $ANTLR end "rule__InterfaceNavigation__Group__2__Impl" - + // $ANTLR end "ruleNumber" - // $ANTLR start "rule__InterfaceExpression__Group__0" - // InternalExport.g:2910:1: rule__InterfaceExpression__Group__0 : rule__InterfaceExpression__Group__0__Impl rule__InterfaceExpression__Group__1 ; - public final void rule__InterfaceExpression__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmTypeReference" + // InternalExport.g:2812:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ; + public final void entryRuleJvmTypeReference() throws RecognitionException { try { - // InternalExport.g:2914:1: ( rule__InterfaceExpression__Group__0__Impl rule__InterfaceExpression__Group__1 ) - // InternalExport.g:2915:2: rule__InterfaceExpression__Group__0__Impl rule__InterfaceExpression__Group__1 + // InternalExport.g:2813:1: ( ruleJvmTypeReference EOF ) + // InternalExport.g:2814:1: ruleJvmTypeReference EOF { - pushFollow(FOLLOW_24); - rule__InterfaceExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10367,34 +9516,41 @@ public final void rule__InterfaceExpression__Group__0() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__0" + // $ANTLR end "entryRuleJvmTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__0__Impl" - // InternalExport.g:2922:1: rule__InterfaceExpression__Group__0__Impl : ( 'eval' ) ; - public final void rule__InterfaceExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmTypeReference" + // InternalExport.g:2821:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ; + public final void ruleJvmTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2926:1: ( ( 'eval' ) ) - // InternalExport.g:2927:1: ( 'eval' ) + // InternalExport.g:2825:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) ) + // InternalExport.g:2826:2: ( ( rule__JvmTypeReference__Alternatives ) ) { - // InternalExport.g:2927:1: ( 'eval' ) - // InternalExport.g:2928:2: 'eval' + // InternalExport.g:2826:2: ( ( rule__JvmTypeReference__Alternatives ) ) + // InternalExport.g:2827:3: ( rule__JvmTypeReference__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); + before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } - match(input,50,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:2828:3: ( rule__JvmTypeReference__Alternatives ) + // InternalExport.g:2828:4: rule__JvmTypeReference__Alternatives + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); + after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } } @@ -10414,29 +9570,28 @@ public final void rule__InterfaceExpression__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__0__Impl" - + // $ANTLR end "ruleJvmTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__1" - // InternalExport.g:2937:1: rule__InterfaceExpression__Group__1 : rule__InterfaceExpression__Group__1__Impl rule__InterfaceExpression__Group__2 ; - public final void rule__InterfaceExpression__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleArrayBrackets" + // InternalExport.g:2837:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ; + public final void entryRuleArrayBrackets() throws RecognitionException { try { - // InternalExport.g:2941:1: ( rule__InterfaceExpression__Group__1__Impl rule__InterfaceExpression__Group__2 ) - // InternalExport.g:2942:2: rule__InterfaceExpression__Group__1__Impl rule__InterfaceExpression__Group__2 + // InternalExport.g:2838:1: ( ruleArrayBrackets EOF ) + // InternalExport.g:2839:1: ruleArrayBrackets EOF { - pushFollow(FOLLOW_24); - rule__InterfaceExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceExpression__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + ruleArrayBrackets(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10446,55 +9601,41 @@ public final void rule__InterfaceExpression__Group__1() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__1" + // $ANTLR end "entryRuleArrayBrackets" - // $ANTLR start "rule__InterfaceExpression__Group__1__Impl" - // InternalExport.g:2949:1: rule__InterfaceExpression__Group__1__Impl : ( ( rule__InterfaceExpression__RefAssignment_1 )? ) ; - public final void rule__InterfaceExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleArrayBrackets" + // InternalExport.g:2846:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ; + public final void ruleArrayBrackets() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2953:1: ( ( ( rule__InterfaceExpression__RefAssignment_1 )? ) ) - // InternalExport.g:2954:1: ( ( rule__InterfaceExpression__RefAssignment_1 )? ) + // InternalExport.g:2850:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) ) + // InternalExport.g:2851:2: ( ( rule__ArrayBrackets__Group__0 ) ) { - // InternalExport.g:2954:1: ( ( rule__InterfaceExpression__RefAssignment_1 )? ) - // InternalExport.g:2955:2: ( rule__InterfaceExpression__RefAssignment_1 )? + // InternalExport.g:2851:2: ( ( rule__ArrayBrackets__Group__0 ) ) + // InternalExport.g:2852:3: ( rule__ArrayBrackets__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); - } - // InternalExport.g:2956:2: ( rule__InterfaceExpression__RefAssignment_1 )? - int alt33=2; - int LA33_0 = input.LA(1); - - if ( (LA33_0==49) ) { - alt33=1; + before(grammarAccess.getArrayBracketsAccess().getGroup()); } - switch (alt33) { - case 1 : - // InternalExport.g:2956:3: rule__InterfaceExpression__RefAssignment_1 - { - pushFollow(FOLLOW_2); - rule__InterfaceExpression__RefAssignment_1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2853:3: ( rule__ArrayBrackets__Group__0 ) + // InternalExport.g:2853:4: rule__ArrayBrackets__Group__0 + { + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); + after(grammarAccess.getArrayBracketsAccess().getGroup()); } } @@ -10514,29 +9655,28 @@ public final void rule__InterfaceExpression__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__1__Impl" - + // $ANTLR end "ruleArrayBrackets" - // $ANTLR start "rule__InterfaceExpression__Group__2" - // InternalExport.g:2964:1: rule__InterfaceExpression__Group__2 : rule__InterfaceExpression__Group__2__Impl rule__InterfaceExpression__Group__3 ; - public final void rule__InterfaceExpression__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalExport.g:2862:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ; + public final void entryRuleXFunctionTypeRef() throws RecognitionException { try { - // InternalExport.g:2968:1: ( rule__InterfaceExpression__Group__2__Impl rule__InterfaceExpression__Group__3 ) - // InternalExport.g:2969:2: rule__InterfaceExpression__Group__2__Impl rule__InterfaceExpression__Group__3 + // InternalExport.g:2863:1: ( ruleXFunctionTypeRef EOF ) + // InternalExport.g:2864:1: ruleXFunctionTypeRef EOF { - pushFollow(FOLLOW_24); - rule__InterfaceExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceExpression__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + ruleXFunctionTypeRef(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10546,55 +9686,41 @@ public final void rule__InterfaceExpression__Group__2() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__2" + // $ANTLR end "entryRuleXFunctionTypeRef" - // $ANTLR start "rule__InterfaceExpression__Group__2__Impl" - // InternalExport.g:2976:1: rule__InterfaceExpression__Group__2__Impl : ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) ; - public final void rule__InterfaceExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXFunctionTypeRef" + // InternalExport.g:2871:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ; + public final void ruleXFunctionTypeRef() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:2980:1: ( ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) ) - // InternalExport.g:2981:1: ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) + // InternalExport.g:2875:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) ) + // InternalExport.g:2876:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) { - // InternalExport.g:2981:1: ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) - // InternalExport.g:2982:2: ( rule__InterfaceExpression__UnorderedAssignment_2 )? + // InternalExport.g:2876:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) + // InternalExport.g:2877:3: ( rule__XFunctionTypeRef__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); - } - // InternalExport.g:2983:2: ( rule__InterfaceExpression__UnorderedAssignment_2 )? - int alt34=2; - int LA34_0 = input.LA(1); - - if ( (LA34_0==18) ) { - alt34=1; + before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } - switch (alt34) { - case 1 : - // InternalExport.g:2983:3: rule__InterfaceExpression__UnorderedAssignment_2 - { - pushFollow(FOLLOW_2); - rule__InterfaceExpression__UnorderedAssignment_2(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:2878:3: ( rule__XFunctionTypeRef__Group__0 ) + // InternalExport.g:2878:4: rule__XFunctionTypeRef__Group__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); + after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } } @@ -10614,29 +9740,28 @@ public final void rule__InterfaceExpression__Group__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__2__Impl" - + // $ANTLR end "ruleXFunctionTypeRef" - // $ANTLR start "rule__InterfaceExpression__Group__3" - // InternalExport.g:2991:1: rule__InterfaceExpression__Group__3 : rule__InterfaceExpression__Group__3__Impl rule__InterfaceExpression__Group__4 ; - public final void rule__InterfaceExpression__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalExport.g:2887:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ; + public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException { try { - // InternalExport.g:2995:1: ( rule__InterfaceExpression__Group__3__Impl rule__InterfaceExpression__Group__4 ) - // InternalExport.g:2996:2: rule__InterfaceExpression__Group__3__Impl rule__InterfaceExpression__Group__4 + // InternalExport.g:2888:1: ( ruleJvmParameterizedTypeReference EOF ) + // InternalExport.g:2889:1: ruleJvmParameterizedTypeReference EOF { - pushFollow(FOLLOW_18); - rule__InterfaceExpression__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceExpression__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmParameterizedTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10646,34 +9771,41 @@ public final void rule__InterfaceExpression__Group__3() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__3" + // $ANTLR end "entryRuleJvmParameterizedTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__3__Impl" - // InternalExport.g:3003:1: rule__InterfaceExpression__Group__3__Impl : ( '(' ) ; - public final void rule__InterfaceExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalExport.g:2896:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ; + public final void ruleJvmParameterizedTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3007:1: ( ( '(' ) ) - // InternalExport.g:3008:1: ( '(' ) + // InternalExport.g:2900:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ) + // InternalExport.g:2901:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) { - // InternalExport.g:3008:1: ( '(' ) - // InternalExport.g:3009:2: '(' + // InternalExport.g:2901:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) + // InternalExport.g:2902:3: ( rule__JvmParameterizedTypeReference__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:2903:3: ( rule__JvmParameterizedTypeReference__Group__0 ) + // InternalExport.g:2903:4: rule__JvmParameterizedTypeReference__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } } @@ -10693,29 +9825,28 @@ public final void rule__InterfaceExpression__Group__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__3__Impl" - + // $ANTLR end "ruleJvmParameterizedTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__4" - // InternalExport.g:3018:1: rule__InterfaceExpression__Group__4 : rule__InterfaceExpression__Group__4__Impl rule__InterfaceExpression__Group__5 ; - public final void rule__InterfaceExpression__Group__4() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalExport.g:2912:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ; + public final void entryRuleJvmArgumentTypeReference() throws RecognitionException { try { - // InternalExport.g:3022:1: ( rule__InterfaceExpression__Group__4__Impl rule__InterfaceExpression__Group__5 ) - // InternalExport.g:3023:2: rule__InterfaceExpression__Group__4__Impl rule__InterfaceExpression__Group__5 + // InternalExport.g:2913:1: ( ruleJvmArgumentTypeReference EOF ) + // InternalExport.g:2914:1: ruleJvmArgumentTypeReference EOF { - pushFollow(FOLLOW_25); - rule__InterfaceExpression__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InterfaceExpression__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmArgumentTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10725,36 +9856,33 @@ public final void rule__InterfaceExpression__Group__4() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__4" + // $ANTLR end "entryRuleJvmArgumentTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__4__Impl" - // InternalExport.g:3030:1: rule__InterfaceExpression__Group__4__Impl : ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) ; - public final void rule__InterfaceExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalExport.g:2921:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ; + public final void ruleJvmArgumentTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3034:1: ( ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) ) - // InternalExport.g:3035:1: ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) + // InternalExport.g:2925:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ) + // InternalExport.g:2926:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) { - // InternalExport.g:3035:1: ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) - // InternalExport.g:3036:2: ( rule__InterfaceExpression__ExprAssignment_4 ) + // InternalExport.g:2926:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) + // InternalExport.g:2927:3: ( rule__JvmArgumentTypeReference__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } - // InternalExport.g:3037:2: ( rule__InterfaceExpression__ExprAssignment_4 ) - // InternalExport.g:3037:3: rule__InterfaceExpression__ExprAssignment_4 + // InternalExport.g:2928:3: ( rule__JvmArgumentTypeReference__Alternatives ) + // InternalExport.g:2928:4: rule__JvmArgumentTypeReference__Alternatives { pushFollow(FOLLOW_2); - rule__InterfaceExpression__ExprAssignment_4(); + rule__JvmArgumentTypeReference__Alternatives(); state._fsp--; if (state.failed) return ; @@ -10762,7 +9890,7 @@ public final void rule__InterfaceExpression__Group__4__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } } @@ -10782,24 +9910,28 @@ public final void rule__InterfaceExpression__Group__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__4__Impl" - + // $ANTLR end "ruleJvmArgumentTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__5" - // InternalExport.g:3045:1: rule__InterfaceExpression__Group__5 : rule__InterfaceExpression__Group__5__Impl ; - public final void rule__InterfaceExpression__Group__5() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalExport.g:2937:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ; + public final void entryRuleJvmWildcardTypeReference() throws RecognitionException { try { - // InternalExport.g:3049:1: ( rule__InterfaceExpression__Group__5__Impl ) - // InternalExport.g:3050:2: rule__InterfaceExpression__Group__5__Impl + // InternalExport.g:2938:1: ( ruleJvmWildcardTypeReference EOF ) + // InternalExport.g:2939:1: ruleJvmWildcardTypeReference EOF { - pushFollow(FOLLOW_2); - rule__InterfaceExpression__Group__5__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmWildcardTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10809,36 +9941,43 @@ public final void rule__InterfaceExpression__Group__5() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__5" + // $ANTLR end "entryRuleJvmWildcardTypeReference" - // $ANTLR start "rule__InterfaceExpression__Group__5__Impl" - // InternalExport.g:3056:1: rule__InterfaceExpression__Group__5__Impl : ( ')' ) ; - public final void rule__InterfaceExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalExport.g:2946:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ; + public final void ruleJvmWildcardTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3060:1: ( ( ')' ) ) - // InternalExport.g:3061:1: ( ')' ) + // InternalExport.g:2950:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ) + // InternalExport.g:2951:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) { - // InternalExport.g:3061:1: ( ')' ) - // InternalExport.g:3062:2: ')' + // InternalExport.g:2951:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) + // InternalExport.g:2952:3: ( rule__JvmWildcardTypeReference__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); - } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); - } - + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); + } + // InternalExport.g:2953:3: ( rule__JvmWildcardTypeReference__Group__0 ) + // InternalExport.g:2953:4: rule__JvmWildcardTypeReference__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); + } + } @@ -10856,29 +9995,28 @@ public final void rule__InterfaceExpression__Group__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InterfaceExpression__Group__5__Impl" - + // $ANTLR end "ruleJvmWildcardTypeReference" - // $ANTLR start "rule__Export__Group__0" - // InternalExport.g:3072:1: rule__Export__Group__0 : rule__Export__Group__0__Impl rule__Export__Group__1 ; - public final void rule__Export__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmUpperBound" + // InternalExport.g:2962:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ; + public final void entryRuleJvmUpperBound() throws RecognitionException { try { - // InternalExport.g:3076:1: ( rule__Export__Group__0__Impl rule__Export__Group__1 ) - // InternalExport.g:3077:2: rule__Export__Group__0__Impl rule__Export__Group__1 + // InternalExport.g:2963:1: ( ruleJvmUpperBound EOF ) + // InternalExport.g:2964:1: ruleJvmUpperBound EOF { - pushFollow(FOLLOW_26); - rule__Export__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + ruleJvmUpperBound(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10888,34 +10026,41 @@ public final void rule__Export__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__0" + // $ANTLR end "entryRuleJvmUpperBound" - // $ANTLR start "rule__Export__Group__0__Impl" - // InternalExport.g:3084:1: rule__Export__Group__0__Impl : ( 'export' ) ; - public final void rule__Export__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmUpperBound" + // InternalExport.g:2971:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ; + public final void ruleJvmUpperBound() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3088:1: ( ( 'export' ) ) - // InternalExport.g:3089:1: ( 'export' ) + // InternalExport.g:2975:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) ) + // InternalExport.g:2976:2: ( ( rule__JvmUpperBound__Group__0 ) ) { - // InternalExport.g:3089:1: ( 'export' ) - // InternalExport.g:3090:2: 'export' + // InternalExport.g:2976:2: ( ( rule__JvmUpperBound__Group__0 ) ) + // InternalExport.g:2977:3: ( rule__JvmUpperBound__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getExportKeyword_0()); + before(grammarAccess.getJvmUpperBoundAccess().getGroup()); } - match(input,36,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:2978:3: ( rule__JvmUpperBound__Group__0 ) + // InternalExport.g:2978:4: rule__JvmUpperBound__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getExportKeyword_0()); + after(grammarAccess.getJvmUpperBoundAccess().getGroup()); } } @@ -10935,29 +10080,28 @@ public final void rule__Export__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__0__Impl" - + // $ANTLR end "ruleJvmUpperBound" - // $ANTLR start "rule__Export__Group__1" - // InternalExport.g:3099:1: rule__Export__Group__1 : rule__Export__Group__1__Impl rule__Export__Group__2 ; - public final void rule__Export__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalExport.g:2987:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ; + public final void entryRuleJvmUpperBoundAnded() throws RecognitionException { try { - // InternalExport.g:3103:1: ( rule__Export__Group__1__Impl rule__Export__Group__2 ) - // InternalExport.g:3104:2: rule__Export__Group__1__Impl rule__Export__Group__2 + // InternalExport.g:2988:1: ( ruleJvmUpperBoundAnded EOF ) + // InternalExport.g:2989:1: ruleJvmUpperBoundAnded EOF { - pushFollow(FOLLOW_26); - rule__Export__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + ruleJvmUpperBoundAnded(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10967,55 +10111,41 @@ public final void rule__Export__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__1" + // $ANTLR end "entryRuleJvmUpperBoundAnded" - // $ANTLR start "rule__Export__Group__1__Impl" - // InternalExport.g:3111:1: rule__Export__Group__1__Impl : ( ( rule__Export__Group_1__0 )? ) ; - public final void rule__Export__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalExport.g:2996:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ; + public final void ruleJvmUpperBoundAnded() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3115:1: ( ( ( rule__Export__Group_1__0 )? ) ) - // InternalExport.g:3116:1: ( ( rule__Export__Group_1__0 )? ) + // InternalExport.g:3000:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ) + // InternalExport.g:3001:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) { - // InternalExport.g:3116:1: ( ( rule__Export__Group_1__0 )? ) - // InternalExport.g:3117:2: ( rule__Export__Group_1__0 )? + // InternalExport.g:3001:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) + // InternalExport.g:3002:3: ( rule__JvmUpperBoundAnded__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_1()); + before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } - // InternalExport.g:3118:2: ( rule__Export__Group_1__0 )? - int alt35=2; - int LA35_0 = input.LA(1); - - if ( (LA35_0==72) ) { - alt35=1; - } - switch (alt35) { - case 1 : - // InternalExport.g:3118:3: rule__Export__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3003:3: ( rule__JvmUpperBoundAnded__Group__0 ) + // InternalExport.g:3003:4: rule__JvmUpperBoundAnded__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_1()); + after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } } @@ -11035,29 +10165,28 @@ public final void rule__Export__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__1__Impl" - + // $ANTLR end "ruleJvmUpperBoundAnded" - // $ANTLR start "rule__Export__Group__2" - // InternalExport.g:3126:1: rule__Export__Group__2 : rule__Export__Group__2__Impl rule__Export__Group__3 ; - public final void rule__Export__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmLowerBound" + // InternalExport.g:3012:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ; + public final void entryRuleJvmLowerBound() throws RecognitionException { try { - // InternalExport.g:3130:1: ( rule__Export__Group__2__Impl rule__Export__Group__3 ) - // InternalExport.g:3131:2: rule__Export__Group__2__Impl rule__Export__Group__3 + // InternalExport.g:3013:1: ( ruleJvmLowerBound EOF ) + // InternalExport.g:3014:1: ruleJvmLowerBound EOF { - pushFollow(FOLLOW_27); - rule__Export__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + ruleJvmLowerBound(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11067,36 +10196,33 @@ public final void rule__Export__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__2" + // $ANTLR end "entryRuleJvmLowerBound" - // $ANTLR start "rule__Export__Group__2__Impl" - // InternalExport.g:3138:1: rule__Export__Group__2__Impl : ( ( rule__Export__TypeAssignment_2 ) ) ; - public final void rule__Export__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmLowerBound" + // InternalExport.g:3021:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ; + public final void ruleJvmLowerBound() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3142:1: ( ( ( rule__Export__TypeAssignment_2 ) ) ) - // InternalExport.g:3143:1: ( ( rule__Export__TypeAssignment_2 ) ) + // InternalExport.g:3025:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) ) + // InternalExport.g:3026:2: ( ( rule__JvmLowerBound__Group__0 ) ) { - // InternalExport.g:3143:1: ( ( rule__Export__TypeAssignment_2 ) ) - // InternalExport.g:3144:2: ( rule__Export__TypeAssignment_2 ) + // InternalExport.g:3026:2: ( ( rule__JvmLowerBound__Group__0 ) ) + // InternalExport.g:3027:3: ( rule__JvmLowerBound__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getTypeAssignment_2()); + before(grammarAccess.getJvmLowerBoundAccess().getGroup()); } - // InternalExport.g:3145:2: ( rule__Export__TypeAssignment_2 ) - // InternalExport.g:3145:3: rule__Export__TypeAssignment_2 + // InternalExport.g:3028:3: ( rule__JvmLowerBound__Group__0 ) + // InternalExport.g:3028:4: rule__JvmLowerBound__Group__0 { pushFollow(FOLLOW_2); - rule__Export__TypeAssignment_2(); + rule__JvmLowerBound__Group__0(); state._fsp--; if (state.failed) return ; @@ -11104,7 +10230,7 @@ public final void rule__Export__Group__2__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getTypeAssignment_2()); + after(grammarAccess.getJvmLowerBoundAccess().getGroup()); } } @@ -11124,29 +10250,28 @@ public final void rule__Export__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__2__Impl" - + // $ANTLR end "ruleJvmLowerBound" - // $ANTLR start "rule__Export__Group__3" - // InternalExport.g:3153:1: rule__Export__Group__3 : rule__Export__Group__3__Impl rule__Export__Group__4 ; - public final void rule__Export__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalExport.g:3037:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ; + public final void entryRuleJvmLowerBoundAnded() throws RecognitionException { try { - // InternalExport.g:3157:1: ( rule__Export__Group__3__Impl rule__Export__Group__4 ) - // InternalExport.g:3158:2: rule__Export__Group__3__Impl rule__Export__Group__4 + // InternalExport.g:3038:1: ( ruleJvmLowerBoundAnded EOF ) + // InternalExport.g:3039:1: ruleJvmLowerBoundAnded EOF { - pushFollow(FOLLOW_27); - rule__Export__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + ruleJvmLowerBoundAnded(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11156,55 +10281,41 @@ public final void rule__Export__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__3" + // $ANTLR end "entryRuleJvmLowerBoundAnded" - // $ANTLR start "rule__Export__Group__3__Impl" - // InternalExport.g:3165:1: rule__Export__Group__3__Impl : ( ( rule__Export__Group_3__0 )? ) ; - public final void rule__Export__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalExport.g:3046:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ; + public final void ruleJvmLowerBoundAnded() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3169:1: ( ( ( rule__Export__Group_3__0 )? ) ) - // InternalExport.g:3170:1: ( ( rule__Export__Group_3__0 )? ) + // InternalExport.g:3050:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ) + // InternalExport.g:3051:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) { - // InternalExport.g:3170:1: ( ( rule__Export__Group_3__0 )? ) - // InternalExport.g:3171:2: ( rule__Export__Group_3__0 )? + // InternalExport.g:3051:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) + // InternalExport.g:3052:3: ( rule__JvmLowerBoundAnded__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_3()); - } - // InternalExport.g:3172:2: ( rule__Export__Group_3__0 )? - int alt36=2; - int LA36_0 = input.LA(1); - - if ( (LA36_0==42) ) { - alt36=1; + before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } - switch (alt36) { - case 1 : - // InternalExport.g:3172:3: rule__Export__Group_3__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_3__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3053:3: ( rule__JvmLowerBoundAnded__Group__0 ) + // InternalExport.g:3053:4: rule__JvmLowerBoundAnded__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_3()); + after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } } @@ -11224,29 +10335,28 @@ public final void rule__Export__Group__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__3__Impl" - + // $ANTLR end "ruleJvmLowerBoundAnded" - // $ANTLR start "rule__Export__Group__4" - // InternalExport.g:3180:1: rule__Export__Group__4 : rule__Export__Group__4__Impl rule__Export__Group__5 ; - public final void rule__Export__Group__4() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalExport.g:3062:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ; + public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException { try { - // InternalExport.g:3184:1: ( rule__Export__Group__4__Impl rule__Export__Group__5 ) - // InternalExport.g:3185:2: rule__Export__Group__4__Impl rule__Export__Group__5 + // InternalExport.g:3063:1: ( ruleQualifiedNameWithWildcard EOF ) + // InternalExport.g:3064:1: ruleQualifiedNameWithWildcard EOF { - pushFollow(FOLLOW_27); - rule__Export__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedNameWithWildcard(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11256,55 +10366,41 @@ public final void rule__Export__Group__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__4" + // $ANTLR end "entryRuleQualifiedNameWithWildcard" - // $ANTLR start "rule__Export__Group__4__Impl" - // InternalExport.g:3192:1: rule__Export__Group__4__Impl : ( ( rule__Export__Group_4__0 )? ) ; - public final void rule__Export__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalExport.g:3071:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ; + public final void ruleQualifiedNameWithWildcard() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3196:1: ( ( ( rule__Export__Group_4__0 )? ) ) - // InternalExport.g:3197:1: ( ( rule__Export__Group_4__0 )? ) + // InternalExport.g:3075:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ) + // InternalExport.g:3076:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) { - // InternalExport.g:3197:1: ( ( rule__Export__Group_4__0 )? ) - // InternalExport.g:3198:2: ( rule__Export__Group_4__0 )? + // InternalExport.g:3076:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) + // InternalExport.g:3077:3: ( rule__QualifiedNameWithWildcard__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_4()); - } - // InternalExport.g:3199:2: ( rule__Export__Group_4__0 )? - int alt37=2; - int LA37_0 = input.LA(1); - - if ( (LA37_0==45) ) { - alt37=1; + before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } - switch (alt37) { - case 1 : - // InternalExport.g:3199:3: rule__Export__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_4__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3078:3: ( rule__QualifiedNameWithWildcard__Group__0 ) + // InternalExport.g:3078:4: rule__QualifiedNameWithWildcard__Group__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_4()); + after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } } @@ -11324,29 +10420,28 @@ public final void rule__Export__Group__4__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__4__Impl" - + // $ANTLR end "ruleQualifiedNameWithWildcard" - // $ANTLR start "rule__Export__Group__5" - // InternalExport.g:3207:1: rule__Export__Group__5 : rule__Export__Group__5__Impl rule__Export__Group__6 ; - public final void rule__Export__Group__5() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleValidID" + // InternalExport.g:3087:1: entryRuleValidID : ruleValidID EOF ; + public final void entryRuleValidID() throws RecognitionException { try { - // InternalExport.g:3211:1: ( rule__Export__Group__5__Impl rule__Export__Group__6 ) - // InternalExport.g:3212:2: rule__Export__Group__5__Impl rule__Export__Group__6 + // InternalExport.g:3088:1: ( ruleValidID EOF ) + // InternalExport.g:3089:1: ruleValidID EOF { - pushFollow(FOLLOW_28); - rule__Export__Group__5__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__6(); + if ( state.backtracking==0 ) { + before(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + ruleValidID(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getValidIDRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11356,34 +10451,31 @@ public final void rule__Export__Group__5() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__5" + // $ANTLR end "entryRuleValidID" - // $ANTLR start "rule__Export__Group__5__Impl" - // InternalExport.g:3219:1: rule__Export__Group__5__Impl : ( '{' ) ; - public final void rule__Export__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleValidID" + // InternalExport.g:3096:1: ruleValidID : ( RULE_ID ) ; + public final void ruleValidID() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3223:1: ( ( '{' ) ) - // InternalExport.g:3224:1: ( '{' ) + // InternalExport.g:3100:2: ( ( RULE_ID ) ) + // InternalExport.g:3101:2: ( RULE_ID ) { - // InternalExport.g:3224:1: ( '{' ) - // InternalExport.g:3225:2: '{' + // InternalExport.g:3101:2: ( RULE_ID ) + // InternalExport.g:3102:3: RULE_ID { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); + before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } - match(input,39,FOLLOW_2); if (state.failed) return ; + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); + after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } } @@ -11403,29 +10495,28 @@ public final void rule__Export__Group__5__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__5__Impl" - + // $ANTLR end "ruleValidID" - // $ANTLR start "rule__Export__Group__6" - // InternalExport.g:3234:1: rule__Export__Group__6 : rule__Export__Group__6__Impl rule__Export__Group__7 ; - public final void rule__Export__Group__6() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXImportDeclaration" + // InternalExport.g:3112:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ; + public final void entryRuleXImportDeclaration() throws RecognitionException { try { - // InternalExport.g:3238:1: ( rule__Export__Group__6__Impl rule__Export__Group__7 ) - // InternalExport.g:3239:2: rule__Export__Group__6__Impl rule__Export__Group__7 + // InternalExport.g:3113:1: ( ruleXImportDeclaration EOF ) + // InternalExport.g:3114:1: ruleXImportDeclaration EOF { - pushFollow(FOLLOW_28); - rule__Export__Group__6__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__7(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXImportDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11435,55 +10526,41 @@ public final void rule__Export__Group__6() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__6" + // $ANTLR end "entryRuleXImportDeclaration" - // $ANTLR start "rule__Export__Group__6__Impl" - // InternalExport.g:3246:1: rule__Export__Group__6__Impl : ( ( rule__Export__Group_6__0 )? ) ; - public final void rule__Export__Group__6__Impl() throws RecognitionException { + // $ANTLR start "ruleXImportDeclaration" + // InternalExport.g:3121:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ; + public final void ruleXImportDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3250:1: ( ( ( rule__Export__Group_6__0 )? ) ) - // InternalExport.g:3251:1: ( ( rule__Export__Group_6__0 )? ) + // InternalExport.g:3125:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) ) + // InternalExport.g:3126:2: ( ( rule__XImportDeclaration__Group__0 ) ) { - // InternalExport.g:3251:1: ( ( rule__Export__Group_6__0 )? ) - // InternalExport.g:3252:2: ( rule__Export__Group_6__0 )? + // InternalExport.g:3126:2: ( ( rule__XImportDeclaration__Group__0 ) ) + // InternalExport.g:3127:3: ( rule__XImportDeclaration__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_6()); - } - // InternalExport.g:3253:2: ( rule__Export__Group_6__0 )? - int alt38=2; - int LA38_0 = input.LA(1); - - if ( (LA38_0==53) ) { - alt38=1; + before(grammarAccess.getXImportDeclarationAccess().getGroup()); } - switch (alt38) { - case 1 : - // InternalExport.g:3253:3: rule__Export__Group_6__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_6__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3128:3: ( rule__XImportDeclaration__Group__0 ) + // InternalExport.g:3128:4: rule__XImportDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_6()); + after(grammarAccess.getXImportDeclarationAccess().getGroup()); } } @@ -11503,29 +10580,28 @@ public final void rule__Export__Group__6__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__6__Impl" + // $ANTLR end "ruleXImportDeclaration" - // $ANTLR start "rule__Export__Group__7" - // InternalExport.g:3261:1: rule__Export__Group__7 : rule__Export__Group__7__Impl rule__Export__Group__8 ; - public final void rule__Export__Group__7() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalExport.g:3137:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ; + public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException { try { - // InternalExport.g:3265:1: ( rule__Export__Group__7__Impl rule__Export__Group__8 ) - // InternalExport.g:3266:2: rule__Export__Group__7__Impl rule__Export__Group__8 + // InternalExport.g:3138:1: ( ruleQualifiedNameInStaticImport EOF ) + // InternalExport.g:3139:1: ruleQualifiedNameInStaticImport EOF { - pushFollow(FOLLOW_28); - rule__Export__Group__7__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__8(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedNameInStaticImport(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11535,148 +10611,77 @@ public final void rule__Export__Group__7() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Export__Group__7" + // $ANTLR end "entryRuleQualifiedNameInStaticImport" - // $ANTLR start "rule__Export__Group__7__Impl" - // InternalExport.g:3273:1: rule__Export__Group__7__Impl : ( ( rule__Export__Group_7__0 )? ) ; - public final void rule__Export__Group__7__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalExport.g:3146:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ; + public final void ruleQualifiedNameInStaticImport() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3277:1: ( ( ( rule__Export__Group_7__0 )? ) ) - // InternalExport.g:3278:1: ( ( rule__Export__Group_7__0 )? ) + // InternalExport.g:3150:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ) + // InternalExport.g:3151:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) { - // InternalExport.g:3278:1: ( ( rule__Export__Group_7__0 )? ) - // InternalExport.g:3279:2: ( rule__Export__Group_7__0 )? + // InternalExport.g:3151:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + // InternalExport.g:3152:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) + { + // InternalExport.g:3152:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) + // InternalExport.g:3153:4: ( rule__QualifiedNameInStaticImport__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_7()); - } - // InternalExport.g:3280:2: ( rule__Export__Group_7__0 )? - int alt39=2; - int LA39_0 = input.LA(1); - - if ( ((LA39_0>=75 && LA39_0<=76)) ) { - alt39=1; + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } - switch (alt39) { - case 1 : - // InternalExport.g:3280:3: rule__Export__Group_7__0 - { - pushFollow(FOLLOW_2); - rule__Export__Group_7__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3154:4: ( rule__QualifiedNameInStaticImport__Group__0 ) + // InternalExport.g:3154:5: rule__QualifiedNameInStaticImport__Group__0 + { + pushFollow(FOLLOW_3); + rule__QualifiedNameInStaticImport__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_7()); + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Export__Group__7__Impl" - - - // $ANTLR start "rule__Export__Group__8" - // InternalExport.g:3288:1: rule__Export__Group__8 : rule__Export__Group__8__Impl rule__Export__Group__9 ; - public final void rule__Export__Group__8() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3292:1: ( rule__Export__Group__8__Impl rule__Export__Group__9 ) - // InternalExport.g:3293:2: rule__Export__Group__8__Impl rule__Export__Group__9 + // InternalExport.g:3157:3: ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) + // InternalExport.g:3158:4: ( rule__QualifiedNameInStaticImport__Group__0 )* { - pushFollow(FOLLOW_28); - rule__Export__Group__8__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group__9(); - - state._fsp--; - if (state.failed) return ; - + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + // InternalExport.g:3159:4: ( rule__QualifiedNameInStaticImport__Group__0 )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Export__Group__8" - + if ( (LA1_0==RULE_ID) ) { + int LA1_2 = input.LA(2); - // $ANTLR start "rule__Export__Group__8__Impl" - // InternalExport.g:3300:1: rule__Export__Group__8__Impl : ( ( rule__Export__Alternatives_8 )* ) ; - public final void rule__Export__Group__8__Impl() throws RecognitionException { + if ( (LA1_2==58) ) { + alt1=1; + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3304:1: ( ( ( rule__Export__Alternatives_8 )* ) ) - // InternalExport.g:3305:1: ( ( rule__Export__Alternatives_8 )* ) - { - // InternalExport.g:3305:1: ( ( rule__Export__Alternatives_8 )* ) - // InternalExport.g:3306:2: ( rule__Export__Alternatives_8 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAlternatives_8()); - } - // InternalExport.g:3307:2: ( rule__Export__Alternatives_8 )* - loop40: - do { - int alt40=2; - int LA40_0 = input.LA(1); - if ( ((LA40_0>=55 && LA40_0<=56)) ) { - alt40=1; } - switch (alt40) { + switch (alt1) { case 1 : - // InternalExport.g:3307:3: rule__Export__Alternatives_8 + // InternalExport.g:3159:5: rule__QualifiedNameInStaticImport__Group__0 { - pushFollow(FOLLOW_29); - rule__Export__Alternatives_8(); + pushFollow(FOLLOW_3); + rule__QualifiedNameInStaticImport__Group__0(); state._fsp--; if (state.failed) return ; @@ -11685,14 +10690,17 @@ public final void rule__Export__Group__8__Impl() throws RecognitionException { break; default : - break loop40; + break loop1; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAlternatives_8()); + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); + } + } + } @@ -11710,68 +10718,115 @@ public final void rule__Export__Group__8__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__8__Impl" + // $ANTLR end "ruleQualifiedNameInStaticImport" - // $ANTLR start "rule__Export__Group__9" - // InternalExport.g:3315:1: rule__Export__Group__9 : rule__Export__Group__9__Impl ; - public final void rule__Export__Group__9() throws RecognitionException { + // $ANTLR start "rule__InterfaceItem__Alternatives" + // InternalExport.g:3168:1: rule__InterfaceItem__Alternatives : ( ( ruleInterfaceField ) | ( ruleInterfaceNavigation ) | ( ruleInterfaceExpression ) ); + public final void rule__InterfaceItem__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3319:1: ( rule__Export__Group__9__Impl ) - // InternalExport.g:3320:2: rule__Export__Group__9__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group__9__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3172:1: ( ( ruleInterfaceField ) | ( ruleInterfaceNavigation ) | ( ruleInterfaceExpression ) ) + int alt2=3; + switch ( input.LA(1) ) { + case RULE_ID: + case 23: + { + alt2=1; + } + break; + case 75: + { + alt2=2; + } + break; + case 76: + { + alt2=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 2, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt2) { + case 1 : + // InternalExport.g:3173:2: ( ruleInterfaceField ) + { + // InternalExport.g:3173:2: ( ruleInterfaceField ) + // InternalExport.g:3174:3: ruleInterfaceField + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleInterfaceField(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceItemAccess().getInterfaceFieldParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group__9" + } - // $ANTLR start "rule__Export__Group__9__Impl" - // InternalExport.g:3326:1: rule__Export__Group__9__Impl : ( '}' ) ; - public final void rule__Export__Group__9__Impl() throws RecognitionException { + } + break; + case 2 : + // InternalExport.g:3179:2: ( ruleInterfaceNavigation ) + { + // InternalExport.g:3179:2: ( ruleInterfaceNavigation ) + // InternalExport.g:3180:3: ruleInterfaceNavigation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleInterfaceNavigation(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3330:1: ( ( '}' ) ) - // InternalExport.g:3331:1: ( '}' ) - { - // InternalExport.g:3331:1: ( '}' ) - // InternalExport.g:3332:2: '}' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); - } - match(input,40,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceItemAccess().getInterfaceNavigationParserRuleCall_1()); + } - } + } - } + } + break; + case 3 : + // InternalExport.g:3185:2: ( ruleInterfaceExpression ) + { + // InternalExport.g:3185:2: ( ruleInterfaceExpression ) + // InternalExport.g:3186:3: ruleInterfaceExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleInterfaceExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceItemAccess().getInterfaceExpressionParserRuleCall_2()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -11784,116 +10839,94 @@ public final void rule__Export__Group__9__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group__9__Impl" + // $ANTLR end "rule__InterfaceItem__Alternatives" - // $ANTLR start "rule__Export__Group_1__0" - // InternalExport.g:3342:1: rule__Export__Group_1__0 : rule__Export__Group_1__0__Impl rule__Export__Group_1__1 ; - public final void rule__Export__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__Export__Alternatives_7_0" + // InternalExport.g:3195:1: rule__Export__Alternatives_7_0 : ( ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) | ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) ); + public final void rule__Export__Alternatives_7_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3346:1: ( rule__Export__Group_1__0__Impl rule__Export__Group_1__1 ) - // InternalExport.g:3347:2: rule__Export__Group_1__0__Impl rule__Export__Group_1__1 - { - pushFollow(FOLLOW_30); - rule__Export__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_1__1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3199:1: ( ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) | ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) ) + int alt3=2; + int LA3_0 = input.LA(1); + if ( (LA3_0==112) ) { + alt3=1; } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Export__Group_1__0" - - - // $ANTLR start "rule__Export__Group_1__0__Impl" - // InternalExport.g:3354:1: rule__Export__Group_1__0__Impl : ( ( rule__Export__LookupAssignment_1_0 ) ) ; - public final void rule__Export__Group_1__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3358:1: ( ( ( rule__Export__LookupAssignment_1_0 ) ) ) - // InternalExport.g:3359:1: ( ( rule__Export__LookupAssignment_1_0 ) ) - { - // InternalExport.g:3359:1: ( ( rule__Export__LookupAssignment_1_0 ) ) - // InternalExport.g:3360:2: ( rule__Export__LookupAssignment_1_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLookupAssignment_1_0()); + else if ( (LA3_0==113) ) { + alt3=2; } - // InternalExport.g:3361:2: ( rule__Export__LookupAssignment_1_0 ) - // InternalExport.g:3361:3: rule__Export__LookupAssignment_1_0 - { - pushFollow(FOLLOW_2); - rule__Export__LookupAssignment_1_0(); - - state._fsp--; - if (state.failed) return ; + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + throw nvae; } + switch (alt3) { + case 1 : + // InternalExport.g:3200:2: ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) + { + // InternalExport.g:3200:2: ( ( rule__Export__FingerprintAssignment_7_0_0 ) ) + // InternalExport.g:3201:3: ( rule__Export__FingerprintAssignment_7_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); + } + // InternalExport.g:3202:3: ( rule__Export__FingerprintAssignment_7_0_0 ) + // InternalExport.g:3202:4: rule__Export__FingerprintAssignment_7_0_0 + { + pushFollow(FOLLOW_2); + rule__Export__FingerprintAssignment_7_0_0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLookupAssignment_1_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFingerprintAssignment_7_0_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:3206:2: ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) + { + // InternalExport.g:3206:2: ( ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) ) + // InternalExport.g:3207:3: ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); + } + // InternalExport.g:3208:3: ( rule__Export__ResourceFingerprintAssignment_7_0_1 ) + // InternalExport.g:3208:4: rule__Export__ResourceFingerprintAssignment_7_0_1 + { + pushFollow(FOLLOW_2); + rule__Export__ResourceFingerprintAssignment_7_0_1(); - } - return ; - } - // $ANTLR end "rule__Export__Group_1__0__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__Export__Group_1__1" - // InternalExport.g:3369:1: rule__Export__Group_1__1 : rule__Export__Group_1__1__Impl ; - public final void rule__Export__Group_1__1() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getResourceFingerprintAssignment_7_0_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3373:1: ( rule__Export__Group_1__1__Impl ) - // InternalExport.g:3374:2: rule__Export__Group_1__1__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -11906,94 +10939,94 @@ public final void rule__Export__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_1__1" + // $ANTLR end "rule__Export__Alternatives_7_0" - // $ANTLR start "rule__Export__Group_1__1__Impl" - // InternalExport.g:3380:1: rule__Export__Group_1__1__Impl : ( ( rule__Export__Group_1_1__0 )? ) ; - public final void rule__Export__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Alternatives_8" + // InternalExport.g:3216:1: rule__Export__Alternatives_8 : ( ( ( rule__Export__Group_8_0__0 ) ) | ( ( rule__Export__Group_8_1__0 ) ) ); + public final void rule__Export__Alternatives_8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3384:1: ( ( ( rule__Export__Group_1_1__0 )? ) ) - // InternalExport.g:3385:1: ( ( rule__Export__Group_1_1__0 )? ) - { - // InternalExport.g:3385:1: ( ( rule__Export__Group_1_1__0 )? ) - // InternalExport.g:3386:2: ( rule__Export__Group_1_1__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_1_1()); + // InternalExport.g:3220:1: ( ( ( rule__Export__Group_8_0__0 ) ) | ( ( rule__Export__Group_8_1__0 ) ) ) + int alt4=2; + int LA4_0 = input.LA(1); + + if ( (LA4_0==81) ) { + alt4=1; } - // InternalExport.g:3387:2: ( rule__Export__Group_1_1__0 )? - int alt41=2; - int LA41_0 = input.LA(1); + else if ( (LA4_0==82) ) { + alt4=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); - if ( (LA41_0==45) ) { - alt41=1; + throw nvae; } - switch (alt41) { + switch (alt4) { case 1 : - // InternalExport.g:3387:3: rule__Export__Group_1_1__0 + // InternalExport.g:3221:2: ( ( rule__Export__Group_8_0__0 ) ) + { + // InternalExport.g:3221:2: ( ( rule__Export__Group_8_0__0 ) ) + // InternalExport.g:3222:3: ( rule__Export__Group_8_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getGroup_8_0()); + } + // InternalExport.g:3223:3: ( rule__Export__Group_8_0__0 ) + // InternalExport.g:3223:4: rule__Export__Group_8_0__0 { pushFollow(FOLLOW_2); - rule__Export__Group_1_1__0(); + rule__Export__Group_8_0__0(); state._fsp--; if (state.failed) return ; } - break; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_1_1()); - } - - } + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getGroup_8_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:3227:2: ( ( rule__Export__Group_8_1__0 ) ) + { + // InternalExport.g:3227:2: ( ( rule__Export__Group_8_1__0 ) ) + // InternalExport.g:3228:3: ( rule__Export__Group_8_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getGroup_8_1()); + } + // InternalExport.g:3229:3: ( rule__Export__Group_8_1__0 ) + // InternalExport.g:3229:4: rule__Export__Group_8_1__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_8_1__0(); - } - return ; - } - // $ANTLR end "rule__Export__Group_1__1__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__Export__Group_1_1__0" - // InternalExport.g:3396:1: rule__Export__Group_1_1__0 : rule__Export__Group_1_1__0__Impl rule__Export__Group_1_1__1 ; - public final void rule__Export__Group_1_1__0() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getGroup_8_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3400:1: ( rule__Export__Group_1_1__0__Impl rule__Export__Group_1_1__1 ) - // InternalExport.g:3401:2: rule__Export__Group_1_1__0__Impl rule__Export__Group_1_1__1 - { - pushFollow(FOLLOW_18); - rule__Export__Group_1_1__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_1_1__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12006,73 +11039,97 @@ public final void rule__Export__Group_1_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_1_1__0" + // $ANTLR end "rule__Export__Alternatives_8" - // $ANTLR start "rule__Export__Group_1_1__0__Impl" - // InternalExport.g:3408:1: rule__Export__Group_1_1__0__Impl : ( '[' ) ; - public final void rule__Export__Group_1_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Expression__Alternatives" + // InternalExport.g:3237:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ); + public final void rule__Expression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3412:1: ( ( '[' ) ) - // InternalExport.g:3413:1: ( '[' ) - { - // InternalExport.g:3413:1: ( '[' ) - // InternalExport.g:3414:2: '[' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); - } - match(input,45,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); - } + // InternalExport.g:3241:1: ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ) + int alt5=3; + alt5 = dfa5.predict(input); + switch (alt5) { + case 1 : + // InternalExport.g:3242:2: ( ruleLetExpression ) + { + // InternalExport.g:3242:2: ( ruleLetExpression ) + // InternalExport.g:3243:3: ruleLetExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleLetExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 2 : + // InternalExport.g:3248:2: ( ( ruleCastedExpression ) ) + { + // InternalExport.g:3248:2: ( ( ruleCastedExpression ) ) + // InternalExport.g:3249:3: ( ruleCastedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } + // InternalExport.g:3250:3: ( ruleCastedExpression ) + // InternalExport.g:3250:4: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__Export__Group_1_1__0__Impl" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } - // $ANTLR start "rule__Export__Group_1_1__1" - // InternalExport.g:3423:1: rule__Export__Group_1_1__1 : rule__Export__Group_1_1__1__Impl rule__Export__Group_1_1__2 ; - public final void rule__Export__Group_1_1__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3427:1: ( rule__Export__Group_1_1__1__Impl rule__Export__Group_1_1__2 ) - // InternalExport.g:3428:2: rule__Export__Group_1_1__1__Impl rule__Export__Group_1_1__2 - { - pushFollow(FOLLOW_19); - rule__Export__Group_1_1__1__Impl(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_1_1__2(); + } + break; + case 3 : + // InternalExport.g:3254:2: ( ruleChainExpression ) + { + // InternalExport.g:3254:2: ( ruleChainExpression ) + // InternalExport.g:3255:3: ruleChainExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleChainExpression(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12085,78 +11142,138 @@ public final void rule__Export__Group_1_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_1_1__1" + // $ANTLR end "rule__Expression__Alternatives" - // $ANTLR start "rule__Export__Group_1_1__1__Impl" - // InternalExport.g:3435:1: rule__Export__Group_1_1__1__Impl : ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) ; - public final void rule__Export__Group_1_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainedExpression__Alternatives" + // InternalExport.g:3264:1: rule__ChainedExpression__Alternatives : ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ); + public final void rule__ChainedExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3439:1: ( ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) ) - // InternalExport.g:3440:1: ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) - { - // InternalExport.g:3440:1: ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) - // InternalExport.g:3441:2: ( rule__Export__LookupPredicateAssignment_1_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); + // InternalExport.g:3268:1: ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ) + int alt6=3; + switch ( input.LA(1) ) { + case 87: + { + alt6=1; + } + break; + case RULE_ID: + case RULE_INT: + case RULE_STRING: + case RULE_REAL: + case 24: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + case 40: + case 68: + case 77: + case 94: + case 95: + case 100: + case 115: + { + alt6=2; + } + break; + case 90: + { + alt6=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + + throw nvae; } - // InternalExport.g:3442:2: ( rule__Export__LookupPredicateAssignment_1_1_1 ) - // InternalExport.g:3442:3: rule__Export__LookupPredicateAssignment_1_1_1 - { - pushFollow(FOLLOW_2); - rule__Export__LookupPredicateAssignment_1_1_1(); - state._fsp--; - if (state.failed) return ; + switch (alt6) { + case 1 : + // InternalExport.g:3269:2: ( ruleIfExpressionKw ) + { + // InternalExport.g:3269:2: ( ruleIfExpressionKw ) + // InternalExport.g:3270:3: ruleIfExpressionKw + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleIfExpressionKw(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); - } + } - } + } + break; + case 2 : + // InternalExport.g:3275:2: ( ruleIfExpressionTri ) + { + // InternalExport.g:3275:2: ( ruleIfExpressionTri ) + // InternalExport.g:3276:3: ruleIfExpressionTri + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleIfExpressionTri(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_1_1__1__Impl" + } + break; + case 3 : + // InternalExport.g:3281:2: ( ruleSwitchExpression ) + { + // InternalExport.g:3281:2: ( ruleSwitchExpression ) + // InternalExport.g:3282:3: ruleSwitchExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleSwitchExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); + } - // $ANTLR start "rule__Export__Group_1_1__2" - // InternalExport.g:3450:1: rule__Export__Group_1_1__2 : rule__Export__Group_1_1__2__Impl ; - public final void rule__Export__Group_1_1__2() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3454:1: ( rule__Export__Group_1_1__2__Impl ) - // InternalExport.g:3455:2: rule__Export__Group_1_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_1_1__2__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12169,73 +11286,174 @@ public final void rule__Export__Group_1_1__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_1_1__2" + // $ANTLR end "rule__ChainedExpression__Alternatives" - // $ANTLR start "rule__Export__Group_1_1__2__Impl" - // InternalExport.g:3461:1: rule__Export__Group_1_1__2__Impl : ( ']' ) ; - public final void rule__Export__Group_1_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // InternalExport.g:3291:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ); + public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3465:1: ( ( ']' ) ) - // InternalExport.g:3466:1: ( ']' ) - { - // InternalExport.g:3466:1: ( ']' ) - // InternalExport.g:3467:2: ']' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); - } - match(input,46,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); - } + // InternalExport.g:3295:1: ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ) + int alt7=6; + switch ( input.LA(1) ) { + case 17: + { + alt7=1; + } + break; + case 18: + { + alt7=2; + } + break; + case 19: + { + alt7=3; + } + break; + case 20: + { + alt7=4; + } + break; + case 21: + { + alt7=5; + } + break; + case 22: + { + alt7=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + throw nvae; } + switch (alt7) { + case 1 : + // InternalExport.g:3296:2: ( '==' ) + { + // InternalExport.g:3296:2: ( '==' ) + // InternalExport.g:3297:3: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); + } + match(input,17,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); + } - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_1_1__2__Impl" + } + break; + case 2 : + // InternalExport.g:3302:2: ( '!=' ) + { + // InternalExport.g:3302:2: ( '!=' ) + // InternalExport.g:3303:3: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + } + match(input,18,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + } + } - // $ANTLR start "rule__Export__Group_3__0" - // InternalExport.g:3477:1: rule__Export__Group_3__0 : rule__Export__Group_3__0__Impl rule__Export__Group_3__1 ; - public final void rule__Export__Group_3__0() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3481:1: ( rule__Export__Group_3__0__Impl rule__Export__Group_3__1 ) - // InternalExport.g:3482:2: rule__Export__Group_3__0__Impl rule__Export__Group_3__1 - { - pushFollow(FOLLOW_31); - rule__Export__Group_3__0__Impl(); + } + break; + case 3 : + // InternalExport.g:3308:2: ( '>=' ) + { + // InternalExport.g:3308:2: ( '>=' ) + // InternalExport.g:3309:3: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_3__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 4 : + // InternalExport.g:3314:2: ( '<=' ) + { + // InternalExport.g:3314:2: ( '<=' ) + // InternalExport.g:3315:3: '<=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + } + match(input,20,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + } + + } + + + } + break; + case 5 : + // InternalExport.g:3320:2: ( '>' ) + { + // InternalExport.g:3320:2: ( '>' ) + // InternalExport.g:3321:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + } + + } + + + } + break; + case 6 : + // InternalExport.g:3326:2: ( '<' ) + { + // InternalExport.g:3326:2: ( '<' ) + // InternalExport.g:3327:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12248,35 +11466,74 @@ public final void rule__Export__Group_3__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_3__0" + // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // $ANTLR start "rule__Export__Group_3__0__Impl" - // InternalExport.g:3489:1: rule__Export__Group_3__0__Impl : ( 'as' ) ; - public final void rule__Export__Group_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__NameAlternatives_1_1_0" + // InternalExport.g:3336:1: rule__AdditiveExpression__NameAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) ); + public final void rule__AdditiveExpression__NameAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3493:1: ( ( 'as' ) ) - // InternalExport.g:3494:1: ( 'as' ) - { - // InternalExport.g:3494:1: ( 'as' ) - // InternalExport.g:3495:2: 'as' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAsKeyword_3_0()); + // InternalExport.g:3340:1: ( ( '+' ) | ( '-' ) ) + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0==23) ) { + alt8=1; } - match(input,42,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAsKeyword_3_0()); + else if ( (LA8_0==24) ) { + alt8=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + throw nvae; } + switch (alt8) { + case 1 : + // InternalExport.g:3341:2: ( '+' ) + { + // InternalExport.g:3341:2: ( '+' ) + // InternalExport.g:3342:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); + } + } + + + } + break; + case 2 : + // InternalExport.g:3347:2: ( '-' ) + { + // InternalExport.g:3347:2: ( '-' ) + // InternalExport.g:3348:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12289,32 +11546,74 @@ public final void rule__Export__Group_3__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_3__0__Impl" + // $ANTLR end "rule__AdditiveExpression__NameAlternatives_1_1_0" - // $ANTLR start "rule__Export__Group_3__1" - // InternalExport.g:3504:1: rule__Export__Group_3__1 : rule__Export__Group_3__1__Impl rule__Export__Group_3__2 ; - public final void rule__Export__Group_3__1() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__NameAlternatives_1_1_0" + // InternalExport.g:3357:1: rule__MultiplicativeExpression__NameAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) ); + public final void rule__MultiplicativeExpression__NameAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3508:1: ( rule__Export__Group_3__1__Impl rule__Export__Group_3__2 ) - // InternalExport.g:3509:2: rule__Export__Group_3__1__Impl rule__Export__Group_3__2 - { - pushFollow(FOLLOW_31); - rule__Export__Group_3__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_3__2(); + // InternalExport.g:3361:1: ( ( '*' ) | ( '/' ) ) + int alt9=2; + int LA9_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA9_0==25) ) { + alt9=1; + } + else if ( (LA9_0==26) ) { + alt9=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + throw nvae; } + switch (alt9) { + case 1 : + // InternalExport.g:3362:2: ( '*' ) + { + // InternalExport.g:3362:2: ( '*' ) + // InternalExport.g:3363:3: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:3368:2: ( '/' ) + { + // InternalExport.g:3368:2: ( '/' ) + // InternalExport.g:3369:3: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); + } + match(input,26,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12327,56 +11626,82 @@ public final void rule__Export__Group_3__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_3__1" + // $ANTLR end "rule__MultiplicativeExpression__NameAlternatives_1_1_0" - // $ANTLR start "rule__Export__Group_3__1__Impl" - // InternalExport.g:3516:1: rule__Export__Group_3__1__Impl : ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) ; - public final void rule__Export__Group_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__UnaryOrInfixExpression__Alternatives" + // InternalExport.g:3378:1: rule__UnaryOrInfixExpression__Alternatives : ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ); + public final void rule__UnaryOrInfixExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3520:1: ( ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) ) - // InternalExport.g:3521:1: ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) - { - // InternalExport.g:3521:1: ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) - // InternalExport.g:3522:2: ( rule__Export__QualifiedNameAssignment_3_1 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); + // InternalExport.g:3382:1: ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ) + int alt10=2; + int LA10_0 = input.LA(1); + + if ( (LA10_0==24||LA10_0==27) ) { + alt10=1; } - // InternalExport.g:3523:2: ( rule__Export__QualifiedNameAssignment_3_1 )? - int alt42=2; - int LA42_0 = input.LA(1); + else if ( (LA10_0==RULE_ID||LA10_0==RULE_INT||(LA10_0>=RULE_STRING && LA10_0<=RULE_REAL)||(LA10_0>=28 && LA10_0<=40)||LA10_0==68||LA10_0==77||(LA10_0>=94 && LA10_0<=95)||LA10_0==100||LA10_0==115) ) { + alt10=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); - if ( (LA42_0==73) ) { - alt42=1; + throw nvae; } - switch (alt42) { + switch (alt10) { case 1 : - // InternalExport.g:3523:3: rule__Export__QualifiedNameAssignment_3_1 + // InternalExport.g:3383:2: ( ruleUnaryExpression ) + { + // InternalExport.g:3383:2: ( ruleUnaryExpression ) + // InternalExport.g:3384:3: ruleUnaryExpression { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); + } pushFollow(FOLLOW_2); - rule__Export__QualifiedNameAssignment_3_1(); + ruleUnaryExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); + } + + } + } break; + case 2 : + // InternalExport.g:3389:2: ( ruleInfixExpression ) + { + // InternalExport.g:3389:2: ( ruleInfixExpression ) + // InternalExport.g:3390:3: ruleInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleInfixExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12389,27 +11714,74 @@ public final void rule__Export__Group_3__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_3__1__Impl" + // $ANTLR end "rule__UnaryOrInfixExpression__Alternatives" - // $ANTLR start "rule__Export__Group_3__2" - // InternalExport.g:3531:1: rule__Export__Group_3__2 : rule__Export__Group_3__2__Impl ; - public final void rule__Export__Group_3__2() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__NameAlternatives_0_0" + // InternalExport.g:3399:1: rule__UnaryExpression__NameAlternatives_0_0 : ( ( '!' ) | ( '-' ) ); + public final void rule__UnaryExpression__NameAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3535:1: ( rule__Export__Group_3__2__Impl ) - // InternalExport.g:3536:2: rule__Export__Group_3__2__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_3__2__Impl(); + // InternalExport.g:3403:1: ( ( '!' ) | ( '-' ) ) + int alt11=2; + int LA11_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA11_0==27) ) { + alt11=1; + } + else if ( (LA11_0==24) ) { + alt11=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + throw nvae; } + switch (alt11) { + case 1 : + // InternalExport.g:3404:2: ( '!' ) + { + // InternalExport.g:3404:2: ( '!' ) + // InternalExport.g:3405:3: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); + } + match(input,27,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:3410:2: ( '-' ) + { + // InternalExport.g:3410:2: ( '-' ) + // InternalExport.g:3411:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12422,124 +11794,200 @@ public final void rule__Export__Group_3__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_3__2" + // $ANTLR end "rule__UnaryExpression__NameAlternatives_0_0" - // $ANTLR start "rule__Export__Group_3__2__Impl" - // InternalExport.g:3542:1: rule__Export__Group_3__2__Impl : ( ( rule__Export__NamingAssignment_3_2 ) ) ; - public final void rule__Export__Group_3__2__Impl() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Alternatives_1" + // InternalExport.g:3420:1: rule__InfixExpression__Alternatives_1 : ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ); + public final void rule__InfixExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3546:1: ( ( ( rule__Export__NamingAssignment_3_2 ) ) ) - // InternalExport.g:3547:1: ( ( rule__Export__NamingAssignment_3_2 ) ) - { - // InternalExport.g:3547:1: ( ( rule__Export__NamingAssignment_3_2 ) ) - // InternalExport.g:3548:2: ( rule__Export__NamingAssignment_3_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getNamingAssignment_3_2()); - } - // InternalExport.g:3549:2: ( rule__Export__NamingAssignment_3_2 ) - // InternalExport.g:3549:3: rule__Export__NamingAssignment_3_2 - { - pushFollow(FOLLOW_2); - rule__Export__NamingAssignment_3_2(); + // InternalExport.g:3424:1: ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ) + int alt12=4; + int LA12_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA12_0==58) ) { + switch ( input.LA(2) ) { + case 38: + case 39: + case 40: + { + alt12=2; + } + break; + case RULE_ID: + { + int LA12_3 = input.LA(3); - } + if ( (LA12_3==77) ) { + alt12=1; + } + else if ( (LA12_3==EOF||(LA12_3>=15 && LA12_3<=26)||LA12_3==48||LA12_3==58||(LA12_3>=68 && LA12_3<=69)||(LA12_3>=71 && LA12_3<=74)||LA12_3==78||LA12_3==83||(LA12_3>=85 && LA12_3<=86)||(LA12_3>=88 && LA12_3<=89)||(LA12_3>=91 && LA12_3<=92)||LA12_3==114) ) { + alt12=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 12, 3, input); + + throw nvae; + } + } + break; + case 115: + { + alt12=3; + } + break; + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + { + alt12=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 12, 1, input); + + throw nvae; + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + throw nvae; } + switch (alt12) { + case 1 : + // InternalExport.g:3425:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) + { + // InternalExport.g:3425:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) + // InternalExport.g:3426:3: ( rule__InfixExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:3427:3: ( rule__InfixExpression__Group_1_0__0 ) + // InternalExport.g:3427:4: rule__InfixExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_3__2__Impl" + } + break; + case 2 : + // InternalExport.g:3431:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) + { + // InternalExport.g:3431:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) + // InternalExport.g:3432:3: ( rule__InfixExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); + } + // InternalExport.g:3433:3: ( rule__InfixExpression__Group_1_1__0 ) + // InternalExport.g:3433:4: rule__InfixExpression__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__0(); - // $ANTLR start "rule__Export__Group_4__0" - // InternalExport.g:3558:1: rule__Export__Group_4__0 : rule__Export__Group_4__0__Impl rule__Export__Group_4__1 ; - public final void rule__Export__Group_4__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3562:1: ( rule__Export__Group_4__0__Impl rule__Export__Group_4__1 ) - // InternalExport.g:3563:2: rule__Export__Group_4__0__Impl rule__Export__Group_4__1 - { - pushFollow(FOLLOW_18); - rule__Export__Group_4__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_4__1(); + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); + } - state._fsp--; - if (state.failed) return ; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 3 : + // InternalExport.g:3437:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) + { + // InternalExport.g:3437:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) + // InternalExport.g:3438:3: ( rule__InfixExpression__Group_1_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); + } + // InternalExport.g:3439:3: ( rule__InfixExpression__Group_1_2__0 ) + // InternalExport.g:3439:4: rule__InfixExpression__Group_1_2__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__Export__Group_4__0" + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); + } + } - // $ANTLR start "rule__Export__Group_4__0__Impl" - // InternalExport.g:3570:1: rule__Export__Group_4__0__Impl : ( '[' ) ; - public final void rule__Export__Group_4__0__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3574:1: ( ( '[' ) ) - // InternalExport.g:3575:1: ( '[' ) - { - // InternalExport.g:3575:1: ( '[' ) - // InternalExport.g:3576:2: '[' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); - } - match(input,45,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); - } + } + break; + case 4 : + // InternalExport.g:3443:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) + { + // InternalExport.g:3443:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) + // InternalExport.g:3444:3: ( rule__InfixExpression__Group_1_3__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); + } + // InternalExport.g:3445:3: ( rule__InfixExpression__Group_1_3__0 ) + // InternalExport.g:3445:4: rule__InfixExpression__Group_1_3__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__0(); - } + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); + } + + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12552,157 +12000,222 @@ public final void rule__Export__Group_4__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_4__0__Impl" + // $ANTLR end "rule__InfixExpression__Alternatives_1" - // $ANTLR start "rule__Export__Group_4__1" - // InternalExport.g:3585:1: rule__Export__Group_4__1 : rule__Export__Group_4__1__Impl rule__Export__Group_4__2 ; - public final void rule__Export__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__NameAlternatives_1_3_2_0" + // InternalExport.g:3453:1: rule__InfixExpression__NameAlternatives_1_3_2_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); + public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3589:1: ( rule__Export__Group_4__1__Impl rule__Export__Group_4__2 ) - // InternalExport.g:3590:2: rule__Export__Group_4__1__Impl rule__Export__Group_4__2 - { - pushFollow(FOLLOW_19); - rule__Export__Group_4__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_4__2(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + // InternalExport.g:3457:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) + int alt13=8; + switch ( input.LA(1) ) { + case 28: + { + alt13=1; + } + break; + case 29: + { + alt13=2; + } + break; + case 30: + { + alt13=3; + } + break; + case 31: + { + alt13=4; + } + break; + case 32: + { + alt13=5; + } + break; + case 33: + { + alt13=6; + } + break; + case 34: + { + alt13=7; + } + break; + case 35: + { + alt13=8; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); - } - return ; - } - // $ANTLR end "rule__Export__Group_4__1" + throw nvae; + } + switch (alt13) { + case 1 : + // InternalExport.g:3458:2: ( 'collect' ) + { + // InternalExport.g:3458:2: ( 'collect' ) + // InternalExport.g:3459:3: 'collect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); + } + match(input,28,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); + } - // $ANTLR start "rule__Export__Group_4__1__Impl" - // InternalExport.g:3597:1: rule__Export__Group_4__1__Impl : ( ( rule__Export__GuardAssignment_4_1 ) ) ; - public final void rule__Export__Group_4__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3601:1: ( ( ( rule__Export__GuardAssignment_4_1 ) ) ) - // InternalExport.g:3602:1: ( ( rule__Export__GuardAssignment_4_1 ) ) - { - // InternalExport.g:3602:1: ( ( rule__Export__GuardAssignment_4_1 ) ) - // InternalExport.g:3603:2: ( rule__Export__GuardAssignment_4_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGuardAssignment_4_1()); - } - // InternalExport.g:3604:2: ( rule__Export__GuardAssignment_4_1 ) - // InternalExport.g:3604:3: rule__Export__GuardAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__Export__GuardAssignment_4_1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 2 : + // InternalExport.g:3464:2: ( 'select' ) + { + // InternalExport.g:3464:2: ( 'select' ) + // InternalExport.g:3465:3: 'select' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); + } + match(input,29,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGuardAssignment_4_1()); - } - } + } + break; + case 3 : + // InternalExport.g:3470:2: ( 'selectFirst' ) + { + // InternalExport.g:3470:2: ( 'selectFirst' ) + // InternalExport.g:3471:3: 'selectFirst' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); + } + match(input,30,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 4 : + // InternalExport.g:3476:2: ( 'reject' ) + { + // InternalExport.g:3476:2: ( 'reject' ) + // InternalExport.g:3477:3: 'reject' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); + } + match(input,31,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_4__1__Impl" + } + break; + case 5 : + // InternalExport.g:3482:2: ( 'exists' ) + { + // InternalExport.g:3482:2: ( 'exists' ) + // InternalExport.g:3483:3: 'exists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); + } + match(input,32,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); + } - // $ANTLR start "rule__Export__Group_4__2" - // InternalExport.g:3612:1: rule__Export__Group_4__2 : rule__Export__Group_4__2__Impl ; - public final void rule__Export__Group_4__2() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3616:1: ( rule__Export__Group_4__2__Impl ) - // InternalExport.g:3617:2: rule__Export__Group_4__2__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_4__2__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; + case 6 : + // InternalExport.g:3488:2: ( 'notExists' ) + { + // InternalExport.g:3488:2: ( 'notExists' ) + // InternalExport.g:3489:3: 'notExists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); + } + match(input,33,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 7 : + // InternalExport.g:3494:2: ( 'sortBy' ) + { + // InternalExport.g:3494:2: ( 'sortBy' ) + // InternalExport.g:3495:3: 'sortBy' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); + } + match(input,34,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_4__2" + } - // $ANTLR start "rule__Export__Group_4__2__Impl" - // InternalExport.g:3623:1: rule__Export__Group_4__2__Impl : ( ']' ) ; - public final void rule__Export__Group_4__2__Impl() throws RecognitionException { + } + break; + case 8 : + // InternalExport.g:3500:2: ( 'forAll' ) + { + // InternalExport.g:3500:2: ( 'forAll' ) + // InternalExport.g:3501:3: 'forAll' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); + } + match(input,35,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3627:1: ( ( ']' ) ) - // InternalExport.g:3628:1: ( ']' ) - { - // InternalExport.g:3628:1: ( ']' ) - // InternalExport.g:3629:2: ']' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); - } - match(input,46,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12715,152 +12228,215 @@ public final void rule__Export__Group_4__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_4__2__Impl" + // $ANTLR end "rule__InfixExpression__NameAlternatives_1_3_2_0" - // $ANTLR start "rule__Export__Group_6__0" - // InternalExport.g:3639:1: rule__Export__Group_6__0 : rule__Export__Group_6__0__Impl rule__Export__Group_6__1 ; - public final void rule__Export__Group_6__0() throws RecognitionException { + // $ANTLR start "rule__PrimaryExpression__Alternatives" + // InternalExport.g:3510:1: rule__PrimaryExpression__Alternatives : ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ); + public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3643:1: ( rule__Export__Group_6__0__Impl rule__Export__Group_6__1 ) - // InternalExport.g:3644:2: rule__Export__Group_6__0__Impl rule__Export__Group_6__1 - { - pushFollow(FOLLOW_32); - rule__Export__Group_6__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3514:1: ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ) + int alt14=6; + switch ( input.LA(1) ) { + case RULE_INT: + case RULE_STRING: + case RULE_REAL: + case 36: + case 37: + case 100: + { + alt14=1; + } + break; + case RULE_ID: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 38: + case 39: + case 40: + case 115: + { + alt14=2; + } + break; + case 68: + { + alt14=3; + } + break; + case 95: + { + alt14=4; + } + break; + case 94: + { + alt14=5; + } + break; + case 77: + { + alt14=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + switch (alt14) { + case 1 : + // InternalExport.g:3515:2: ( ruleLiteral ) + { + // InternalExport.g:3515:2: ( ruleLiteral ) + // InternalExport.g:3516:3: ruleLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleLiteral(); - } - return ; - } - // $ANTLR end "rule__Export__Group_6__0" + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); + } + } - // $ANTLR start "rule__Export__Group_6__0__Impl" - // InternalExport.g:3651:1: rule__Export__Group_6__0__Impl : ( 'uri-fragment' ) ; - public final void rule__Export__Group_6__0__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3655:1: ( ( 'uri-fragment' ) ) - // InternalExport.g:3656:1: ( 'uri-fragment' ) - { - // InternalExport.g:3656:1: ( 'uri-fragment' ) - // InternalExport.g:3657:2: 'uri-fragment' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); - } - match(input,53,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); - } + } + break; + case 2 : + // InternalExport.g:3521:2: ( ruleFeatureCall ) + { + // InternalExport.g:3521:2: ( ruleFeatureCall ) + // InternalExport.g:3522:3: ruleFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCall(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 3 : + // InternalExport.g:3527:2: ( ruleListLiteral ) + { + // InternalExport.g:3527:2: ( ruleListLiteral ) + // InternalExport.g:3528:3: ruleListLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleListLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__0__Impl" + } - // $ANTLR start "rule__Export__Group_6__1" - // InternalExport.g:3666:1: rule__Export__Group_6__1 : rule__Export__Group_6__1__Impl rule__Export__Group_6__2 ; - public final void rule__Export__Group_6__1() throws RecognitionException { + } + break; + case 4 : + // InternalExport.g:3533:2: ( ruleConstructorCallExpression ) + { + // InternalExport.g:3533:2: ( ruleConstructorCallExpression ) + // InternalExport.g:3534:3: ruleConstructorCallExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleConstructorCallExpression(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3670:1: ( rule__Export__Group_6__1__Impl rule__Export__Group_6__2 ) - // InternalExport.g:3671:2: rule__Export__Group_6__1__Impl rule__Export__Group_6__2 - { - pushFollow(FOLLOW_33); - rule__Export__Group_6__1__Impl(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__2(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 5 : + // InternalExport.g:3539:2: ( ruleGlobalVarExpression ) + { + // InternalExport.g:3539:2: ( ruleGlobalVarExpression ) + // InternalExport.g:3540:3: ruleGlobalVarExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleGlobalVarExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__1" + } + break; + case 6 : + // InternalExport.g:3545:2: ( ruleParanthesizedExpression ) + { + // InternalExport.g:3545:2: ( ruleParanthesizedExpression ) + // InternalExport.g:3546:3: ruleParanthesizedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleParanthesizedExpression(); - // $ANTLR start "rule__Export__Group_6__1__Impl" - // InternalExport.g:3678:1: rule__Export__Group_6__1__Impl : ( '=' ) ; - public final void rule__Export__Group_6__1__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3682:1: ( ( '=' ) ) - // InternalExport.g:3683:1: ( '=' ) - { - // InternalExport.g:3683:1: ( '=' ) - // InternalExport.g:3684:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); - } - match(input,47,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12873,132 +12449,171 @@ public final void rule__Export__Group_6__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_6__1__Impl" + // $ANTLR end "rule__PrimaryExpression__Alternatives" - // $ANTLR start "rule__Export__Group_6__2" - // InternalExport.g:3693:1: rule__Export__Group_6__2 : rule__Export__Group_6__2__Impl rule__Export__Group_6__3 ; - public final void rule__Export__Group_6__2() throws RecognitionException { + // $ANTLR start "rule__Literal__Alternatives" + // InternalExport.g:3555:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ); + public final void rule__Literal__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3697:1: ( rule__Export__Group_6__2__Impl rule__Export__Group_6__3 ) - // InternalExport.g:3698:2: rule__Export__Group_6__2__Impl rule__Export__Group_6__3 - { - pushFollow(FOLLOW_33); - rule__Export__Group_6__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__3(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3559:1: ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ) + int alt15=5; + switch ( input.LA(1) ) { + case 36: + case 37: + { + alt15=1; + } + break; + case RULE_INT: + { + alt15=2; + } + break; + case 100: + { + alt15=3; + } + break; + case RULE_REAL: + { + alt15=4; + } + break; + case RULE_STRING: + { + alt15=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Export__Group_6__2" + switch (alt15) { + case 1 : + // InternalExport.g:3560:2: ( ruleBooleanLiteral ) + { + // InternalExport.g:3560:2: ( ruleBooleanLiteral ) + // InternalExport.g:3561:3: ruleBooleanLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleBooleanLiteral(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); + } - // $ANTLR start "rule__Export__Group_6__2__Impl" - // InternalExport.g:3705:1: rule__Export__Group_6__2__Impl : ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) ; - public final void rule__Export__Group_6__2__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3709:1: ( ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) ) - // InternalExport.g:3710:1: ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) - { - // InternalExport.g:3710:1: ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) - // InternalExport.g:3711:2: ( rule__Export__FragmentUniqueAssignment_6_2 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); - } - // InternalExport.g:3712:2: ( rule__Export__FragmentUniqueAssignment_6_2 )? - int alt43=2; - int LA43_0 = input.LA(1); - if ( (LA43_0==74) ) { - alt43=1; - } - switch (alt43) { - case 1 : - // InternalExport.g:3712:3: rule__Export__FragmentUniqueAssignment_6_2 + } + break; + case 2 : + // InternalExport.g:3566:2: ( ruleIntegerLiteral ) + { + // InternalExport.g:3566:2: ( ruleIntegerLiteral ) + // InternalExport.g:3567:3: ruleIntegerLiteral { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); + } pushFollow(FOLLOW_2); - rule__Export__FragmentUniqueAssignment_6_2(); + ruleIntegerLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); + } } - break; - } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); - } + } + break; + case 3 : + // InternalExport.g:3572:2: ( ruleNullLiteral ) + { + // InternalExport.g:3572:2: ( ruleNullLiteral ) + // InternalExport.g:3573:3: ruleNullLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleNullLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 4 : + // InternalExport.g:3578:2: ( ruleRealLiteral ) + { + // InternalExport.g:3578:2: ( ruleRealLiteral ) + // InternalExport.g:3579:3: ruleRealLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleRealLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__2__Impl" + } - // $ANTLR start "rule__Export__Group_6__3" - // InternalExport.g:3720:1: rule__Export__Group_6__3 : rule__Export__Group_6__3__Impl rule__Export__Group_6__4 ; - public final void rule__Export__Group_6__3() throws RecognitionException { + } + break; + case 5 : + // InternalExport.g:3584:2: ( ruleStringLiteral ) + { + // InternalExport.g:3584:2: ( ruleStringLiteral ) + // InternalExport.g:3585:3: ruleStringLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleStringLiteral(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3724:1: ( rule__Export__Group_6__3__Impl rule__Export__Group_6__4 ) - // InternalExport.g:3725:2: rule__Export__Group_6__3__Impl rule__Export__Group_6__4 - { - pushFollow(FOLLOW_34); - rule__Export__Group_6__3__Impl(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__4(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13011,73 +12626,74 @@ public final void rule__Export__Group_6__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_6__3" + // $ANTLR end "rule__Literal__Alternatives" - // $ANTLR start "rule__Export__Group_6__3__Impl" - // InternalExport.g:3732:1: rule__Export__Group_6__3__Impl : ( 'attribute' ) ; - public final void rule__Export__Group_6__3__Impl() throws RecognitionException { + // $ANTLR start "rule__BooleanLiteral__ValAlternatives_0" + // InternalExport.g:3594:1: rule__BooleanLiteral__ValAlternatives_0 : ( ( 'true' ) | ( 'false' ) ); + public final void rule__BooleanLiteral__ValAlternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3736:1: ( ( 'attribute' ) ) - // InternalExport.g:3737:1: ( 'attribute' ) - { - // InternalExport.g:3737:1: ( 'attribute' ) - // InternalExport.g:3738:2: 'attribute' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); - } - match(input,54,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); - } + // InternalExport.g:3598:1: ( ( 'true' ) | ( 'false' ) ) + int alt16=2; + int LA16_0 = input.LA(1); + if ( (LA16_0==36) ) { + alt16=1; } - - + else if ( (LA16_0==37) ) { + alt16=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + throw nvae; + } + switch (alt16) { + case 1 : + // InternalExport.g:3599:2: ( 'true' ) + { + // InternalExport.g:3599:2: ( 'true' ) + // InternalExport.g:3600:3: 'true' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); + } + match(input,36,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__3__Impl" + } - // $ANTLR start "rule__Export__Group_6__4" - // InternalExport.g:3747:1: rule__Export__Group_6__4 : rule__Export__Group_6__4__Impl rule__Export__Group_6__5 ; - public final void rule__Export__Group_6__4() throws RecognitionException { + } + break; + case 2 : + // InternalExport.g:3605:2: ( 'false' ) + { + // InternalExport.g:3605:2: ( 'false' ) + // InternalExport.g:3606:3: 'false' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); + } + match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3751:1: ( rule__Export__Group_6__4__Impl rule__Export__Group_6__5 ) - // InternalExport.g:3752:2: rule__Export__Group_6__4__Impl rule__Export__Group_6__5 - { - pushFollow(FOLLOW_10); - rule__Export__Group_6__4__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__5(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13090,124 +12706,171 @@ public final void rule__Export__Group_6__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_6__4" + // $ANTLR end "rule__BooleanLiteral__ValAlternatives_0" - // $ANTLR start "rule__Export__Group_6__4__Impl" - // InternalExport.g:3759:1: rule__Export__Group_6__4__Impl : ( '(' ) ; - public final void rule__Export__Group_6__4__Impl() throws RecognitionException { + // $ANTLR start "rule__FeatureCall__Alternatives" + // InternalExport.g:3615:1: rule__FeatureCall__Alternatives : ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ); + public final void rule__FeatureCall__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3763:1: ( ( '(' ) ) - // InternalExport.g:3764:1: ( '(' ) - { - // InternalExport.g:3764:1: ( '(' ) - // InternalExport.g:3765:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); - } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); - } + // InternalExport.g:3619:1: ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ) + int alt17=4; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA17_1 = input.LA(2); - } + if ( (LA17_1==EOF||(LA17_1>=15 && LA17_1<=26)||LA17_1==48||LA17_1==58||(LA17_1>=68 && LA17_1<=69)||(LA17_1>=71 && LA17_1<=74)||LA17_1==78||LA17_1==83||(LA17_1>=85 && LA17_1<=86)||(LA17_1>=88 && LA17_1<=89)||(LA17_1>=91 && LA17_1<=92)||LA17_1==114) ) { + alt17=2; + } + else if ( (LA17_1==77) ) { + alt17=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 17, 1, input); + throw nvae; + } + } + break; + case 38: + case 39: + case 40: + { + alt17=2; + } + break; + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + { + alt17=3; + } + break; + case 115: + { + alt17=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + switch (alt17) { + case 1 : + // InternalExport.g:3620:2: ( ruleOperationCall ) + { + // InternalExport.g:3620:2: ( ruleOperationCall ) + // InternalExport.g:3621:3: ruleOperationCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleOperationCall(); - } - return ; - } - // $ANTLR end "rule__Export__Group_6__4__Impl" + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); + } + } - // $ANTLR start "rule__Export__Group_6__5" - // InternalExport.g:3774:1: rule__Export__Group_6__5 : rule__Export__Group_6__5__Impl rule__Export__Group_6__6 ; - public final void rule__Export__Group_6__5() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3778:1: ( rule__Export__Group_6__5__Impl rule__Export__Group_6__6 ) - // InternalExport.g:3779:2: rule__Export__Group_6__5__Impl rule__Export__Group_6__6 - { - pushFollow(FOLLOW_25); - rule__Export__Group_6__5__Impl(); + } + break; + case 2 : + // InternalExport.g:3626:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) + { + // InternalExport.g:3626:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) + // InternalExport.g:3627:3: ( rule__FeatureCall__TypeAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); + } + // InternalExport.g:3628:3: ( rule__FeatureCall__TypeAssignment_1 ) + // InternalExport.g:3628:4: rule__FeatureCall__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__FeatureCall__TypeAssignment_1(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__6(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_6__5" + } + break; + case 3 : + // InternalExport.g:3632:2: ( ruleCollectionExpression ) + { + // InternalExport.g:3632:2: ( ruleCollectionExpression ) + // InternalExport.g:3633:3: ruleCollectionExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleCollectionExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); + } - // $ANTLR start "rule__Export__Group_6__5__Impl" - // InternalExport.g:3786:1: rule__Export__Group_6__5__Impl : ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) ; - public final void rule__Export__Group_6__5__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3790:1: ( ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) ) - // InternalExport.g:3791:1: ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) - { - // InternalExport.g:3791:1: ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) - // InternalExport.g:3792:2: ( rule__Export__FragmentAttributeAssignment_6_5 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); - } - // InternalExport.g:3793:2: ( rule__Export__FragmentAttributeAssignment_6_5 ) - // InternalExport.g:3793:3: rule__Export__FragmentAttributeAssignment_6_5 - { - pushFollow(FOLLOW_2); - rule__Export__FragmentAttributeAssignment_6_5(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalExport.g:3638:2: ( ruleTypeSelectExpression ) + { + // InternalExport.g:3638:2: ( ruleTypeSelectExpression ) + // InternalExport.g:3639:3: ruleTypeSelectExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleTypeSelectExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13220,185 +12883,222 @@ public final void rule__Export__Group_6__5__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_6__5__Impl" + // $ANTLR end "rule__FeatureCall__Alternatives" - // $ANTLR start "rule__Export__Group_6__6" - // InternalExport.g:3801:1: rule__Export__Group_6__6 : rule__Export__Group_6__6__Impl rule__Export__Group_6__7 ; - public final void rule__Export__Group_6__6() throws RecognitionException { + // $ANTLR start "rule__CollectionExpression__NameAlternatives_0_0" + // InternalExport.g:3648:1: rule__CollectionExpression__NameAlternatives_0_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); + public final void rule__CollectionExpression__NameAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3805:1: ( rule__Export__Group_6__6__Impl rule__Export__Group_6__7 ) - // InternalExport.g:3806:2: rule__Export__Group_6__6__Impl rule__Export__Group_6__7 - { - pushFollow(FOLLOW_35); - rule__Export__Group_6__6__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_6__7(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3652:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) + int alt18=8; + switch ( input.LA(1) ) { + case 28: + { + alt18=1; + } + break; + case 29: + { + alt18=2; + } + break; + case 30: + { + alt18=3; + } + break; + case 31: + { + alt18=4; + } + break; + case 32: + { + alt18=5; + } + break; + case 33: + { + alt18=6; + } + break; + case 34: + { + alt18=7; + } + break; + case 35: + { + alt18=8; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt18) { + case 1 : + // InternalExport.g:3653:2: ( 'collect' ) + { + // InternalExport.g:3653:2: ( 'collect' ) + // InternalExport.g:3654:3: 'collect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); + } + match(input,28,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__6" + } + break; + case 2 : + // InternalExport.g:3659:2: ( 'select' ) + { + // InternalExport.g:3659:2: ( 'select' ) + // InternalExport.g:3660:3: 'select' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); + } + match(input,29,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); + } - // $ANTLR start "rule__Export__Group_6__6__Impl" - // InternalExport.g:3813:1: rule__Export__Group_6__6__Impl : ( ')' ) ; - public final void rule__Export__Group_6__6__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3817:1: ( ( ')' ) ) - // InternalExport.g:3818:1: ( ')' ) - { - // InternalExport.g:3818:1: ( ')' ) - // InternalExport.g:3819:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); - } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); - } - } + } + break; + case 3 : + // InternalExport.g:3665:2: ( 'selectFirst' ) + { + // InternalExport.g:3665:2: ( 'selectFirst' ) + // InternalExport.g:3666:3: 'selectFirst' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); + } + match(input,30,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__Export__Group_6__6__Impl" - - - // $ANTLR start "rule__Export__Group_6__7" - // InternalExport.g:3828:1: rule__Export__Group_6__7 : rule__Export__Group_6__7__Impl ; - public final void rule__Export__Group_6__7() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3832:1: ( rule__Export__Group_6__7__Impl ) - // InternalExport.g:3833:2: rule__Export__Group_6__7__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_6__7__Impl(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + } + break; + case 4 : + // InternalExport.g:3671:2: ( 'reject' ) + { + // InternalExport.g:3671:2: ( 'reject' ) + // InternalExport.g:3672:3: 'reject' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); + } + match(input,31,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__7" + } - // $ANTLR start "rule__Export__Group_6__7__Impl" - // InternalExport.g:3839:1: rule__Export__Group_6__7__Impl : ( ';' ) ; - public final void rule__Export__Group_6__7__Impl() throws RecognitionException { + } + break; + case 5 : + // InternalExport.g:3677:2: ( 'exists' ) + { + // InternalExport.g:3677:2: ( 'exists' ) + // InternalExport.g:3678:3: 'exists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); + } + match(input,32,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3843:1: ( ( ';' ) ) - // InternalExport.g:3844:1: ( ';' ) - { - // InternalExport.g:3844:1: ( ';' ) - // InternalExport.g:3845:2: ';' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); - } - match(input,44,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); - } + } - } + } + break; + case 6 : + // InternalExport.g:3683:2: ( 'notExists' ) + { + // InternalExport.g:3683:2: ( 'notExists' ) + // InternalExport.g:3684:3: 'notExists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); + } + match(input,33,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 7 : + // InternalExport.g:3689:2: ( 'sortBy' ) + { + // InternalExport.g:3689:2: ( 'sortBy' ) + // InternalExport.g:3690:3: 'sortBy' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); + } + match(input,34,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_6__7__Impl" + } - // $ANTLR start "rule__Export__Group_7__0" - // InternalExport.g:3855:1: rule__Export__Group_7__0 : rule__Export__Group_7__0__Impl rule__Export__Group_7__1 ; - public final void rule__Export__Group_7__0() throws RecognitionException { + } + break; + case 8 : + // InternalExport.g:3695:2: ( 'forAll' ) + { + // InternalExport.g:3695:2: ( 'forAll' ) + // InternalExport.g:3696:3: 'forAll' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); + } + match(input,35,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3859:1: ( rule__Export__Group_7__0__Impl rule__Export__Group_7__1 ) - // InternalExport.g:3860:2: rule__Export__Group_7__0__Impl rule__Export__Group_7__1 - { - pushFollow(FOLLOW_35); - rule__Export__Group_7__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_7__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13411,78 +13111,82 @@ public final void rule__Export__Group_7__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_7__0" + // $ANTLR end "rule__CollectionExpression__NameAlternatives_0_0" - // $ANTLR start "rule__Export__Group_7__0__Impl" - // InternalExport.g:3867:1: rule__Export__Group_7__0__Impl : ( ( rule__Export__Alternatives_7_0 ) ) ; - public final void rule__Export__Group_7__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Type__Alternatives" + // InternalExport.g:3705:1: rule__Type__Alternatives : ( ( ruleCollectionType ) | ( ruleSimpleType ) ); + public final void rule__Type__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3871:1: ( ( ( rule__Export__Alternatives_7_0 ) ) ) - // InternalExport.g:3872:1: ( ( rule__Export__Alternatives_7_0 ) ) - { - // InternalExport.g:3872:1: ( ( rule__Export__Alternatives_7_0 ) ) - // InternalExport.g:3873:2: ( rule__Export__Alternatives_7_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAlternatives_7_0()); - } - // InternalExport.g:3874:2: ( rule__Export__Alternatives_7_0 ) - // InternalExport.g:3874:3: rule__Export__Alternatives_7_0 - { - pushFollow(FOLLOW_2); - rule__Export__Alternatives_7_0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3709:1: ( ( ruleCollectionType ) | ( ruleSimpleType ) ) + int alt19=2; + int LA19_0 = input.LA(1); + if ( ((LA19_0>=38 && LA19_0<=40)) ) { + alt19=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAlternatives_7_0()); + else if ( (LA19_0==RULE_ID) ) { + alt19=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + throw nvae; } + switch (alt19) { + case 1 : + // InternalExport.g:3710:2: ( ruleCollectionType ) + { + // InternalExport.g:3710:2: ( ruleCollectionType ) + // InternalExport.g:3711:3: ruleCollectionType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleCollectionType(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); + } - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_7__0__Impl" + } + break; + case 2 : + // InternalExport.g:3716:2: ( ruleSimpleType ) + { + // InternalExport.g:3716:2: ( ruleSimpleType ) + // InternalExport.g:3717:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); + } - // $ANTLR start "rule__Export__Group_7__1" - // InternalExport.g:3882:1: rule__Export__Group_7__1 : rule__Export__Group_7__1__Impl ; - public final void rule__Export__Group_7__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3886:1: ( rule__Export__Group_7__1__Impl ) - // InternalExport.g:3887:2: rule__Export__Group_7__1__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_7__1__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13495,73 +13199,102 @@ public final void rule__Export__Group_7__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_7__1" + // $ANTLR end "rule__Type__Alternatives" - // $ANTLR start "rule__Export__Group_7__1__Impl" - // InternalExport.g:3893:1: rule__Export__Group_7__1__Impl : ( ';' ) ; - public final void rule__Export__Group_7__1__Impl() throws RecognitionException { + // $ANTLR start "rule__CollectionType__ClAlternatives_0_0" + // InternalExport.g:3726:1: rule__CollectionType__ClAlternatives_0_0 : ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ); + public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3897:1: ( ( ';' ) ) - // InternalExport.g:3898:1: ( ';' ) - { - // InternalExport.g:3898:1: ( ';' ) - // InternalExport.g:3899:2: ';' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); - } - match(input,44,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); - } + // InternalExport.g:3730:1: ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ) + int alt20=3; + switch ( input.LA(1) ) { + case 38: + { + alt20=1; + } + break; + case 39: + { + alt20=2; + } + break; + case 40: + { + alt20=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 20, 0, input); + throw nvae; } + switch (alt20) { + case 1 : + // InternalExport.g:3731:2: ( 'Collection' ) + { + // InternalExport.g:3731:2: ( 'Collection' ) + // InternalExport.g:3732:3: 'Collection' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); + } + match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:3737:2: ( 'List' ) + { + // InternalExport.g:3737:2: ( 'List' ) + // InternalExport.g:3738:3: 'List' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); + } + match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_7__1__Impl" + } - // $ANTLR start "rule__Export__Group_8_0__0" - // InternalExport.g:3909:1: rule__Export__Group_8_0__0 : rule__Export__Group_8_0__0__Impl rule__Export__Group_8_0__1 ; - public final void rule__Export__Group_8_0__0() throws RecognitionException { + } + break; + case 3 : + // InternalExport.g:3743:2: ( 'Set' ) + { + // InternalExport.g:3743:2: ( 'Set' ) + // InternalExport.g:3744:3: 'Set' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); + } + match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3913:1: ( rule__Export__Group_8_0__0__Impl rule__Export__Group_8_0__1 ) - // InternalExport.g:3914:2: rule__Export__Group_8_0__0__Impl rule__Export__Group_8_0__1 - { - pushFollow(FOLLOW_10); - rule__Export__Group_8_0__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_0__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13574,124 +13307,214 @@ public final void rule__Export__Group_8_0__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_8_0__0" + // $ANTLR end "rule__CollectionType__ClAlternatives_0_0" - // $ANTLR start "rule__Export__Group_8_0__0__Impl" - // InternalExport.g:3921:1: rule__Export__Group_8_0__0__Impl : ( 'field' ) ; - public final void rule__Export__Group_8_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XAssignment__Alternatives" + // InternalExport.g:3753:1: rule__XAssignment__Alternatives : ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ); + public final void rule__XAssignment__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3925:1: ( ( 'field' ) ) - // InternalExport.g:3926:1: ( 'field' ) - { - // InternalExport.g:3926:1: ( 'field' ) - // InternalExport.g:3927:2: 'field' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); - } - match(input,55,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); - } - - } + // InternalExport.g:3757:1: ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ) + int alt21=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA21_1 = input.LA(2); + if ( (LA21_1==14) ) { + alt21=1; + } + else if ( (LA21_1==EOF||(LA21_1>=RULE_ID && LA21_1<=RULE_STRING)||(LA21_1>=15 && LA21_1<=19)||(LA21_1>=21 && LA21_1<=27)||(LA21_1>=36 && LA21_1<=37)||(LA21_1>=41 && LA21_1<=64)||LA21_1==66||(LA21_1>=68 && LA21_1<=74)||(LA21_1>=77 && LA21_1<=78)||LA21_1==83||LA21_1==85||LA21_1==87||(LA21_1>=89 && LA21_1<=92)||(LA21_1>=95 && LA21_1<=107)||(LA21_1>=116 && LA21_1<=117)) ) { + alt21=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 1, input); - } + throw nvae; + } + } + break; + case 60: + { + int LA21_2 = input.LA(2); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( (LA21_2==EOF||(LA21_2>=RULE_ID && LA21_2<=RULE_STRING)||(LA21_2>=15 && LA21_2<=19)||(LA21_2>=21 && LA21_2<=27)||(LA21_2>=36 && LA21_2<=37)||(LA21_2>=41 && LA21_2<=64)||LA21_2==66||(LA21_2>=68 && LA21_2<=74)||(LA21_2>=77 && LA21_2<=78)||LA21_2==83||LA21_2==85||LA21_2==87||(LA21_2>=89 && LA21_2<=92)||(LA21_2>=95 && LA21_2<=107)||(LA21_2>=116 && LA21_2<=117)) ) { + alt21=2; + } + else if ( (LA21_2==14) ) { + alt21=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 2, input); - restoreStackSize(stackSize); + throw nvae; + } + } + break; + case 61: + { + int LA21_3 = input.LA(2); - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0__0__Impl" + if ( (LA21_3==14) ) { + alt21=1; + } + else if ( (LA21_3==EOF||(LA21_3>=RULE_ID && LA21_3<=RULE_STRING)||(LA21_3>=15 && LA21_3<=19)||(LA21_3>=21 && LA21_3<=27)||(LA21_3>=36 && LA21_3<=37)||(LA21_3>=41 && LA21_3<=64)||LA21_3==66||(LA21_3>=68 && LA21_3<=74)||(LA21_3>=77 && LA21_3<=78)||LA21_3==83||LA21_3==85||LA21_3==87||(LA21_3>=89 && LA21_3<=92)||(LA21_3>=95 && LA21_3<=107)||(LA21_3>=116 && LA21_3<=117)) ) { + alt21=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 3, input); + throw nvae; + } + } + break; + case 62: + { + int LA21_4 = input.LA(2); - // $ANTLR start "rule__Export__Group_8_0__1" - // InternalExport.g:3936:1: rule__Export__Group_8_0__1 : rule__Export__Group_8_0__1__Impl rule__Export__Group_8_0__2 ; - public final void rule__Export__Group_8_0__1() throws RecognitionException { + if ( (LA21_4==14) ) { + alt21=1; + } + else if ( (LA21_4==EOF||(LA21_4>=RULE_ID && LA21_4<=RULE_STRING)||(LA21_4>=15 && LA21_4<=19)||(LA21_4>=21 && LA21_4<=27)||(LA21_4>=36 && LA21_4<=37)||(LA21_4>=41 && LA21_4<=64)||LA21_4==66||(LA21_4>=68 && LA21_4<=74)||(LA21_4>=77 && LA21_4<=78)||LA21_4==83||LA21_4==85||LA21_4==87||(LA21_4>=89 && LA21_4<=92)||(LA21_4>=95 && LA21_4<=107)||(LA21_4>=116 && LA21_4<=117)) ) { + alt21=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 4, input); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3940:1: ( rule__Export__Group_8_0__1__Impl rule__Export__Group_8_0__2 ) - // InternalExport.g:3941:2: rule__Export__Group_8_0__1__Impl rule__Export__Group_8_0__2 - { - pushFollow(FOLLOW_36); - rule__Export__Group_8_0__1__Impl(); + throw nvae; + } + } + break; + case 63: + { + int LA21_5 = input.LA(2); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_0__2(); + if ( (LA21_5==14) ) { + alt21=1; + } + else if ( (LA21_5==EOF||(LA21_5>=RULE_ID && LA21_5<=RULE_STRING)||(LA21_5>=15 && LA21_5<=19)||(LA21_5>=21 && LA21_5<=27)||(LA21_5>=36 && LA21_5<=37)||(LA21_5>=41 && LA21_5<=64)||LA21_5==66||(LA21_5>=68 && LA21_5<=74)||(LA21_5>=77 && LA21_5<=78)||LA21_5==83||LA21_5==85||LA21_5==87||(LA21_5>=89 && LA21_5<=92)||(LA21_5>=95 && LA21_5<=107)||(LA21_5>=116 && LA21_5<=117)) ) { + alt21=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 5, input); - state._fsp--; - if (state.failed) return ; + throw nvae; + } + } + break; + case RULE_HEX: + case RULE_INT: + case RULE_DECIMAL: + case RULE_STRING: + case 22: + case 23: + case 24: + case 27: + case 36: + case 37: + case 64: + case 66: + case 68: + case 72: + case 77: + case 87: + case 90: + case 95: + case 97: + case 98: + case 99: + case 100: + case 101: + case 102: + case 103: + case 104: + case 106: + { + alt21=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt21) { + case 1 : + // InternalExport.g:3758:2: ( ( rule__XAssignment__Group_0__0 ) ) + { + // InternalExport.g:3758:2: ( ( rule__XAssignment__Group_0__0 ) ) + // InternalExport.g:3759:3: ( rule__XAssignment__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_0()); + } + // InternalExport.g:3760:3: ( rule__XAssignment__Group_0__0 ) + // InternalExport.g:3760:4: rule__XAssignment__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0__1" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_0()); + } - // $ANTLR start "rule__Export__Group_8_0__1__Impl" - // InternalExport.g:3948:1: rule__Export__Group_8_0__1__Impl : ( ( rule__Export__AttributesAssignment_8_0_1 ) ) ; - public final void rule__Export__Group_8_0__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3952:1: ( ( ( rule__Export__AttributesAssignment_8_0_1 ) ) ) - // InternalExport.g:3953:1: ( ( rule__Export__AttributesAssignment_8_0_1 ) ) - { - // InternalExport.g:3953:1: ( ( rule__Export__AttributesAssignment_8_0_1 ) ) - // InternalExport.g:3954:2: ( rule__Export__AttributesAssignment_8_0_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); - } - // InternalExport.g:3955:2: ( rule__Export__AttributesAssignment_8_0_1 ) - // InternalExport.g:3955:3: rule__Export__AttributesAssignment_8_0_1 - { - pushFollow(FOLLOW_2); - rule__Export__AttributesAssignment_8_0_1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 2 : + // InternalExport.g:3764:2: ( ( rule__XAssignment__Group_1__0 ) ) + { + // InternalExport.g:3764:2: ( ( rule__XAssignment__Group_1__0 ) ) + // InternalExport.g:3765:3: ( rule__XAssignment__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1()); + } + // InternalExport.g:3766:3: ( rule__XAssignment__Group_1__0 ) + // InternalExport.g:3766:4: rule__XAssignment__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__0(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1()); + } + + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13704,134 +13527,218 @@ public final void rule__Export__Group_8_0__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Export__Group_8_0__1__Impl" + // $ANTLR end "rule__XAssignment__Alternatives" - // $ANTLR start "rule__Export__Group_8_0__2" - // InternalExport.g:3963:1: rule__Export__Group_8_0__2 : rule__Export__Group_8_0__2__Impl rule__Export__Group_8_0__3 ; - public final void rule__Export__Group_8_0__2() throws RecognitionException { + // $ANTLR start "rule__OpMultiAssign__Alternatives" + // InternalExport.g:3774:1: rule__OpMultiAssign__Alternatives : ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ); + public final void rule__OpMultiAssign__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:3967:1: ( rule__Export__Group_8_0__2__Impl rule__Export__Group_8_0__3 ) - // InternalExport.g:3968:2: rule__Export__Group_8_0__2__Impl rule__Export__Group_8_0__3 - { - pushFollow(FOLLOW_36); - rule__Export__Group_8_0__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_0__3(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:3778:1: ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ) + int alt22=7; + switch ( input.LA(1) ) { + case 41: + { + alt22=1; + } + break; + case 42: + { + alt22=2; + } + break; + case 43: + { + alt22=3; + } + break; + case 44: + { + alt22=4; + } + break; + case 45: + { + alt22=5; + } + break; + case 22: + { + alt22=6; + } + break; + case 21: + { + alt22=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt22) { + case 1 : + // InternalExport.g:3779:2: ( '+=' ) + { + // InternalExport.g:3779:2: ( '+=' ) + // InternalExport.g:3780:3: '+=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + match(input,41,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0__2" + } + break; + case 2 : + // InternalExport.g:3785:2: ( '-=' ) + { + // InternalExport.g:3785:2: ( '-=' ) + // InternalExport.g:3786:3: '-=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + match(input,42,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } - // $ANTLR start "rule__Export__Group_8_0__2__Impl" - // InternalExport.g:3975:1: rule__Export__Group_8_0__2__Impl : ( ( rule__Export__Group_8_0_2__0 )* ) ; - public final void rule__Export__Group_8_0__2__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3979:1: ( ( ( rule__Export__Group_8_0_2__0 )* ) ) - // InternalExport.g:3980:1: ( ( rule__Export__Group_8_0_2__0 )* ) - { - // InternalExport.g:3980:1: ( ( rule__Export__Group_8_0_2__0 )* ) - // InternalExport.g:3981:2: ( rule__Export__Group_8_0_2__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_8_0_2()); - } - // InternalExport.g:3982:2: ( rule__Export__Group_8_0_2__0 )* - loop44: - do { - int alt44=2; - int LA44_0 = input.LA(1); - if ( (LA44_0==48) ) { - alt44=1; - } + } + break; + case 3 : + // InternalExport.g:3791:2: ( '*=' ) + { + // InternalExport.g:3791:2: ( '*=' ) + // InternalExport.g:3792:3: '*=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + match(input,43,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + } - switch (alt44) { - case 1 : - // InternalExport.g:3982:3: rule__Export__Group_8_0_2__0 - { - pushFollow(FOLLOW_22); - rule__Export__Group_8_0_2__0(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalExport.g:3797:2: ( '/=' ) + { + // InternalExport.g:3797:2: ( '/=' ) + // InternalExport.g:3798:3: '/=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + match(input,44,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } - } - break; + } - default : - break loop44; - } - } while (true); - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_8_0_2()); - } + } + break; + case 5 : + // InternalExport.g:3803:2: ( '%=' ) + { + // InternalExport.g:3803:2: ( '%=' ) + // InternalExport.g:3804:3: '%=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } - } + } - } + } + break; + case 6 : + // InternalExport.g:3809:2: ( ( rule__OpMultiAssign__Group_5__0 ) ) + { + // InternalExport.g:3809:2: ( ( rule__OpMultiAssign__Group_5__0 ) ) + // InternalExport.g:3810:3: ( rule__OpMultiAssign__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + // InternalExport.g:3811:3: ( rule__OpMultiAssign__Group_5__0 ) + // InternalExport.g:3811:4: rule__OpMultiAssign__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0__2__Impl" + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + } - // $ANTLR start "rule__Export__Group_8_0__3" - // InternalExport.g:3990:1: rule__Export__Group_8_0__3 : rule__Export__Group_8_0__3__Impl ; - public final void rule__Export__Group_8_0__3() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:3994:1: ( rule__Export__Group_8_0__3__Impl ) - // InternalExport.g:3995:2: rule__Export__Group_8_0__3__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_8_0__3__Impl(); + } + break; + case 7 : + // InternalExport.g:3815:2: ( ( rule__OpMultiAssign__Group_6__0 ) ) + { + // InternalExport.g:3815:2: ( ( rule__OpMultiAssign__Group_6__0 ) ) + // InternalExport.g:3816:3: ( rule__OpMultiAssign__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } + // InternalExport.g:3817:3: ( rule__OpMultiAssign__Group_6__0 ) + // InternalExport.g:3817:4: rule__OpMultiAssign__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13844,73 +13751,126 @@ public final void rule__Export__Group_8_0__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_8_0__3" + // $ANTLR end "rule__OpMultiAssign__Alternatives" - // $ANTLR start "rule__Export__Group_8_0__3__Impl" - // InternalExport.g:4001:1: rule__Export__Group_8_0__3__Impl : ( ';' ) ; - public final void rule__Export__Group_8_0__3__Impl() throws RecognitionException { + // $ANTLR start "rule__OpEquality__Alternatives" + // InternalExport.g:3825:1: rule__OpEquality__Alternatives : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ); + public final void rule__OpEquality__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4005:1: ( ( ';' ) ) - // InternalExport.g:4006:1: ( ';' ) - { - // InternalExport.g:4006:1: ( ';' ) - // InternalExport.g:4007:2: ';' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); - } - match(input,44,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); - } + // InternalExport.g:3829:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ) + int alt23=4; + switch ( input.LA(1) ) { + case 17: + { + alt23=1; + } + break; + case 18: + { + alt23=2; + } + break; + case 46: + { + alt23=3; + } + break; + case 47: + { + alt23=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 23, 0, input); + throw nvae; } + switch (alt23) { + case 1 : + // InternalExport.g:3830:2: ( '==' ) + { + // InternalExport.g:3830:2: ( '==' ) + // InternalExport.g:3831:3: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + match(input,17,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:3836:2: ( '!=' ) + { + // InternalExport.g:3836:2: ( '!=' ) + // InternalExport.g:3837:3: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + match(input,18,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0__3__Impl" + } - // $ANTLR start "rule__Export__Group_8_0_2__0" - // InternalExport.g:4017:1: rule__Export__Group_8_0_2__0 : rule__Export__Group_8_0_2__0__Impl rule__Export__Group_8_0_2__1 ; - public final void rule__Export__Group_8_0_2__0() throws RecognitionException { + } + break; + case 3 : + // InternalExport.g:3842:2: ( '===' ) + { + // InternalExport.g:3842:2: ( '===' ) + // InternalExport.g:3843:3: '===' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4021:1: ( rule__Export__Group_8_0_2__0__Impl rule__Export__Group_8_0_2__1 ) - // InternalExport.g:4022:2: rule__Export__Group_8_0_2__0__Impl rule__Export__Group_8_0_2__1 - { - pushFollow(FOLLOW_10); - rule__Export__Group_8_0_2__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_0_2__1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalExport.g:3848:2: ( '!==' ) + { + // InternalExport.g:3848:2: ( '!==' ) + // InternalExport.g:3849:3: '!==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13923,68 +13883,94 @@ public final void rule__Export__Group_8_0_2__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_8_0_2__0" + // $ANTLR end "rule__OpEquality__Alternatives" - // $ANTLR start "rule__Export__Group_8_0_2__0__Impl" - // InternalExport.g:4029:1: rule__Export__Group_8_0_2__0__Impl : ( ',' ) ; - public final void rule__Export__Group_8_0_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XRelationalExpression__Alternatives_1" + // InternalExport.g:3858:1: rule__XRelationalExpression__Alternatives_1 : ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ); + public final void rule__XRelationalExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4033:1: ( ( ',' ) ) - // InternalExport.g:4034:1: ( ',' ) - { - // InternalExport.g:4034:1: ( ',' ) - // InternalExport.g:4035:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); + // InternalExport.g:3862:1: ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ) + int alt24=2; + int LA24_0 = input.LA(1); + + if ( (LA24_0==96) ) { + alt24=1; } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); + else if ( (LA24_0==19||(LA24_0>=21 && LA24_0<=22)) ) { + alt24=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 24, 0, input); + throw nvae; } + switch (alt24) { + case 1 : + // InternalExport.g:3863:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + { + // InternalExport.g:3863:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + // InternalExport.g:3864:3: ( rule__XRelationalExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:3865:3: ( rule__XRelationalExpression__Group_1_0__0 ) + // InternalExport.g:3865:4: rule__XRelationalExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0_2__0__Impl" + } + break; + case 2 : + // InternalExport.g:3869:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + { + // InternalExport.g:3869:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + // InternalExport.g:3870:3: ( rule__XRelationalExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } + // InternalExport.g:3871:3: ( rule__XRelationalExpression__Group_1_1__0 ) + // InternalExport.g:3871:4: rule__XRelationalExpression__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__0(); - // $ANTLR start "rule__Export__Group_8_0_2__1" - // InternalExport.g:4044:1: rule__Export__Group_8_0_2__1 : rule__Export__Group_8_0_2__1__Impl ; - public final void rule__Export__Group_8_0_2__1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4048:1: ( rule__Export__Group_8_0_2__1__Impl ) - // InternalExport.g:4049:2: rule__Export__Group_8_0_2__1__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_8_0_2__1__Impl(); + } - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13997,124 +13983,145 @@ public final void rule__Export__Group_8_0_2__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_8_0_2__1" + // $ANTLR end "rule__XRelationalExpression__Alternatives_1" - // $ANTLR start "rule__Export__Group_8_0_2__1__Impl" - // InternalExport.g:4055:1: rule__Export__Group_8_0_2__1__Impl : ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) ; - public final void rule__Export__Group_8_0_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__OpCompare__Alternatives" + // InternalExport.g:3879:1: rule__OpCompare__Alternatives : ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ); + public final void rule__OpCompare__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4059:1: ( ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) ) - // InternalExport.g:4060:1: ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) - { - // InternalExport.g:4060:1: ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) - // InternalExport.g:4061:2: ( rule__Export__AttributesAssignment_8_0_2_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); - } - // InternalExport.g:4062:2: ( rule__Export__AttributesAssignment_8_0_2_1 ) - // InternalExport.g:4062:3: rule__Export__AttributesAssignment_8_0_2_1 - { - pushFollow(FOLLOW_2); - rule__Export__AttributesAssignment_8_0_2_1(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); - } + // InternalExport.g:3883:1: ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ) + int alt25=4; + switch ( input.LA(1) ) { + case 19: + { + alt25=1; + } + break; + case 22: + { + int LA25_2 = input.LA(2); - } + if ( (LA25_2==14) ) { + alt25=2; + } + else if ( (LA25_2==EOF||(LA25_2>=RULE_ID && LA25_2<=RULE_STRING)||(LA25_2>=22 && LA25_2<=24)||LA25_2==27||(LA25_2>=36 && LA25_2<=37)||(LA25_2>=60 && LA25_2<=64)||LA25_2==66||LA25_2==68||LA25_2==72||LA25_2==77||LA25_2==87||LA25_2==90||LA25_2==95||(LA25_2>=97 && LA25_2<=104)||LA25_2==106) ) { + alt25=4; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 25, 2, input); + throw nvae; + } + } + break; + case 21: + { + alt25=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + switch (alt25) { + case 1 : + // InternalExport.g:3884:2: ( '>=' ) + { + // InternalExport.g:3884:2: ( '>=' ) + // InternalExport.g:3885:3: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_0_2__1__Impl" + } - // $ANTLR start "rule__Export__Group_8_1__0" - // InternalExport.g:4071:1: rule__Export__Group_8_1__0 : rule__Export__Group_8_1__0__Impl rule__Export__Group_8_1__1 ; - public final void rule__Export__Group_8_1__0() throws RecognitionException { + } + break; + case 2 : + // InternalExport.g:3890:2: ( ( rule__OpCompare__Group_1__0 ) ) + { + // InternalExport.g:3890:2: ( ( rule__OpCompare__Group_1__0 ) ) + // InternalExport.g:3891:3: ( rule__OpCompare__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGroup_1()); + } + // InternalExport.g:3892:3: ( rule__OpCompare__Group_1__0 ) + // InternalExport.g:3892:4: rule__OpCompare__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__0(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4075:1: ( rule__Export__Group_8_1__0__Impl rule__Export__Group_8_1__1 ) - // InternalExport.g:4076:2: rule__Export__Group_8_1__0__Impl rule__Export__Group_8_1__1 - { - pushFollow(FOLLOW_10); - rule__Export__Group_8_1__0__Impl(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_1__1(); + } - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGroup_1()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 3 : + // InternalExport.g:3896:2: ( '>' ) + { + // InternalExport.g:3896:2: ( '>' ) + // InternalExport.g:3897:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_1__0" + } - // $ANTLR start "rule__Export__Group_8_1__0__Impl" - // InternalExport.g:4083:1: rule__Export__Group_8_1__0__Impl : ( 'data' ) ; - public final void rule__Export__Group_8_1__0__Impl() throws RecognitionException { + } + break; + case 4 : + // InternalExport.g:3902:2: ( '<' ) + { + // InternalExport.g:3902:2: ( '<' ) + // InternalExport.g:3903:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4087:1: ( ( 'data' ) ) - // InternalExport.g:4088:1: ( 'data' ) - { - // InternalExport.g:4088:1: ( 'data' ) - // InternalExport.g:4089:2: 'data' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); - } - match(input,56,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14127,190 +14134,223 @@ public final void rule__Export__Group_8_1__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Export__Group_8_1__0__Impl" + // $ANTLR end "rule__OpCompare__Alternatives" - // $ANTLR start "rule__Export__Group_8_1__1" - // InternalExport.g:4098:1: rule__Export__Group_8_1__1 : rule__Export__Group_8_1__1__Impl rule__Export__Group_8_1__2 ; - public final void rule__Export__Group_8_1__1() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives" + // InternalExport.g:3912:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ); + public final void rule__OpOther__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4102:1: ( rule__Export__Group_8_1__1__Impl rule__Export__Group_8_1__2 ) - // InternalExport.g:4103:2: rule__Export__Group_8_1__1__Impl rule__Export__Group_8_1__2 - { - pushFollow(FOLLOW_36); - rule__Export__Group_8_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_1__2(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExport.g:3916:1: ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ) + int alt26=9; + alt26 = dfa26.predict(input); + switch (alt26) { + case 1 : + // InternalExport.g:3917:2: ( '->' ) + { + // InternalExport.g:3917:2: ( '->' ) + // InternalExport.g:3918:3: '->' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + match(input,48,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_8_1__1" + } + break; + case 2 : + // InternalExport.g:3923:2: ( '..<' ) + { + // InternalExport.g:3923:2: ( '..<' ) + // InternalExport.g:3924:3: '..<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + match(input,49,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + } - // $ANTLR start "rule__Export__Group_8_1__1__Impl" - // InternalExport.g:4110:1: rule__Export__Group_8_1__1__Impl : ( ( rule__Export__UserDataAssignment_8_1_1 ) ) ; - public final void rule__Export__Group_8_1__1__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4114:1: ( ( ( rule__Export__UserDataAssignment_8_1_1 ) ) ) - // InternalExport.g:4115:1: ( ( rule__Export__UserDataAssignment_8_1_1 ) ) - { - // InternalExport.g:4115:1: ( ( rule__Export__UserDataAssignment_8_1_1 ) ) - // InternalExport.g:4116:2: ( rule__Export__UserDataAssignment_8_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); - } - // InternalExport.g:4117:2: ( rule__Export__UserDataAssignment_8_1_1 ) - // InternalExport.g:4117:3: rule__Export__UserDataAssignment_8_1_1 - { - pushFollow(FOLLOW_2); - rule__Export__UserDataAssignment_8_1_1(); + } + break; + case 3 : + // InternalExport.g:3929:2: ( ( rule__OpOther__Group_2__0 ) ) + { + // InternalExport.g:3929:2: ( ( rule__OpOther__Group_2__0 ) ) + // InternalExport.g:3930:3: ( rule__OpOther__Group_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_2()); + } + // InternalExport.g:3931:3: ( rule__OpOther__Group_2__0 ) + // InternalExport.g:3931:4: rule__OpOther__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_2()); + } - } + } - } + } + break; + case 4 : + // InternalExport.g:3935:2: ( '..' ) + { + // InternalExport.g:3935:2: ( '..' ) + // InternalExport.g:3936:3: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + match(input,50,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_8_1__1__Impl" + } + break; + case 5 : + // InternalExport.g:3941:2: ( '=>' ) + { + // InternalExport.g:3941:2: ( '=>' ) + // InternalExport.g:3942:3: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + } - // $ANTLR start "rule__Export__Group_8_1__2" - // InternalExport.g:4125:1: rule__Export__Group_8_1__2 : rule__Export__Group_8_1__2__Impl rule__Export__Group_8_1__3 ; - public final void rule__Export__Group_8_1__2() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4129:1: ( rule__Export__Group_8_1__2__Impl rule__Export__Group_8_1__3 ) - // InternalExport.g:4130:2: rule__Export__Group_8_1__2__Impl rule__Export__Group_8_1__3 - { - pushFollow(FOLLOW_36); - rule__Export__Group_8_1__2__Impl(); + } + break; + case 6 : + // InternalExport.g:3947:2: ( ( rule__OpOther__Group_5__0 ) ) + { + // InternalExport.g:3947:2: ( ( rule__OpOther__Group_5__0 ) ) + // InternalExport.g:3948:3: ( rule__OpOther__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5()); + } + // InternalExport.g:3949:3: ( rule__OpOther__Group_5__0 ) + // InternalExport.g:3949:4: rule__OpOther__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_1__3(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__Export__Group_8_1__2" + } + break; + case 7 : + // InternalExport.g:3953:2: ( ( rule__OpOther__Group_6__0 ) ) + { + // InternalExport.g:3953:2: ( ( rule__OpOther__Group_6__0 ) ) + // InternalExport.g:3954:3: ( rule__OpOther__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6()); + } + // InternalExport.g:3955:3: ( rule__OpOther__Group_6__0 ) + // InternalExport.g:3955:4: rule__OpOther__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__0(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__Export__Group_8_1__2__Impl" - // InternalExport.g:4137:1: rule__Export__Group_8_1__2__Impl : ( ( rule__Export__Group_8_1_2__0 )* ) ; - public final void rule__Export__Group_8_1__2__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4141:1: ( ( ( rule__Export__Group_8_1_2__0 )* ) ) - // InternalExport.g:4142:1: ( ( rule__Export__Group_8_1_2__0 )* ) - { - // InternalExport.g:4142:1: ( ( rule__Export__Group_8_1_2__0 )* ) - // InternalExport.g:4143:2: ( rule__Export__Group_8_1_2__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGroup_8_1_2()); - } - // InternalExport.g:4144:2: ( rule__Export__Group_8_1_2__0 )* - loop45: - do { - int alt45=2; - int LA45_0 = input.LA(1); + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6()); + } - if ( (LA45_0==48) ) { - alt45=1; - } + } - switch (alt45) { - case 1 : - // InternalExport.g:4144:3: rule__Export__Group_8_1_2__0 - { - pushFollow(FOLLOW_22); - rule__Export__Group_8_1_2__0(); + } + break; + case 8 : + // InternalExport.g:3959:2: ( '<>' ) + { + // InternalExport.g:3959:2: ( '<>' ) + // InternalExport.g:3960:3: '<>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } - state._fsp--; - if (state.failed) return ; + } - } - break; - default : - break loop45; - } - } while (true); + } + break; + case 9 : + // InternalExport.g:3965:2: ( '?:' ) + { + // InternalExport.g:3965:2: ( '?:' ) + // InternalExport.g:3966:3: '?:' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + match(input,53,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGroup_8_1_2()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14323,27 +14363,95 @@ public final void rule__Export__Group_8_1__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Export__Group_8_1__2__Impl" + // $ANTLR end "rule__OpOther__Alternatives" - // $ANTLR start "rule__Export__Group_8_1__3" - // InternalExport.g:4152:1: rule__Export__Group_8_1__3 : rule__Export__Group_8_1__3__Impl ; - public final void rule__Export__Group_8_1__3() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives_5_1" + // InternalExport.g:3975:1: rule__OpOther__Alternatives_5_1 : ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ); + public final void rule__OpOther__Alternatives_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4156:1: ( rule__Export__Group_8_1__3__Impl ) - // InternalExport.g:4157:2: rule__Export__Group_8_1__3__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_8_1__3__Impl(); + // InternalExport.g:3979:1: ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ) + int alt27=2; + int LA27_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA27_0==21) ) { + int LA27_1 = input.LA(2); + + if ( (LA27_1==EOF||(LA27_1>=RULE_ID && LA27_1<=RULE_STRING)||(LA27_1>=22 && LA27_1<=24)||LA27_1==27||(LA27_1>=36 && LA27_1<=37)||(LA27_1>=60 && LA27_1<=64)||LA27_1==66||LA27_1==68||LA27_1==72||LA27_1==77||LA27_1==87||LA27_1==90||LA27_1==95||(LA27_1>=97 && LA27_1<=104)||LA27_1==106) ) { + alt27=2; + } + else if ( (LA27_1==21) ) { + alt27=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 27, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 27, 0, input); + throw nvae; } + switch (alt27) { + case 1 : + // InternalExport.g:3980:2: ( ( rule__OpOther__Group_5_1_0__0 ) ) + { + // InternalExport.g:3980:2: ( ( rule__OpOther__Group_5_1_0__0 ) ) + // InternalExport.g:3981:3: ( rule__OpOther__Group_5_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } + // InternalExport.g:3982:3: ( rule__OpOther__Group_5_1_0__0 ) + // InternalExport.g:3982:4: rule__OpOther__Group_5_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:3986:2: ( '>' ) + { + // InternalExport.g:3986:2: ( '>' ) + // InternalExport.g:3987:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14356,73 +14464,117 @@ public final void rule__Export__Group_8_1__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_8_1__3" + // $ANTLR end "rule__OpOther__Alternatives_5_1" - // $ANTLR start "rule__Export__Group_8_1__3__Impl" - // InternalExport.g:4163:1: rule__Export__Group_8_1__3__Impl : ( ';' ) ; - public final void rule__Export__Group_8_1__3__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives_6_1" + // InternalExport.g:3996:1: rule__OpOther__Alternatives_6_1 : ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ); + public final void rule__OpOther__Alternatives_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4167:1: ( ( ';' ) ) - // InternalExport.g:4168:1: ( ';' ) - { - // InternalExport.g:4168:1: ( ';' ) - // InternalExport.g:4169:2: ';' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); + // InternalExport.g:4000:1: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ) + int alt28=3; + int LA28_0 = input.LA(1); + + if ( (LA28_0==22) ) { + int LA28_1 = input.LA(2); + + if ( (synpred75_InternalExport()) ) { + alt28=1; + } + else if ( (synpred76_InternalExport()) ) { + alt28=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 1, input); + + throw nvae; + } } - match(input,44,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); + else if ( (LA28_0==51) ) { + alt28=3; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 0, input); + throw nvae; } + switch (alt28) { + case 1 : + // InternalExport.g:4001:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // InternalExport.g:4001:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // InternalExport.g:4002:3: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // InternalExport.g:4003:3: ( rule__OpOther__Group_6_1_0__0 ) + // InternalExport.g:4003:4: rule__OpOther__Group_6_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_1__3__Impl" + } + break; + case 2 : + // InternalExport.g:4007:2: ( '<' ) + { + // InternalExport.g:4007:2: ( '<' ) + // InternalExport.g:4008:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + + } - // $ANTLR start "rule__Export__Group_8_1_2__0" - // InternalExport.g:4179:1: rule__Export__Group_8_1_2__0 : rule__Export__Group_8_1_2__0__Impl rule__Export__Group_8_1_2__1 ; - public final void rule__Export__Group_8_1_2__0() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4183:1: ( rule__Export__Group_8_1_2__0__Impl rule__Export__Group_8_1_2__1 ) - // InternalExport.g:4184:2: rule__Export__Group_8_1_2__0__Impl rule__Export__Group_8_1_2__1 - { - pushFollow(FOLLOW_10); - rule__Export__Group_8_1_2__0__Impl(); + } + break; + case 3 : + // InternalExport.g:4013:2: ( '=>' ) + { + // InternalExport.g:4013:2: ( '=>' ) + // InternalExport.g:4014:3: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Export__Group_8_1_2__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14435,35 +14587,74 @@ public final void rule__Export__Group_8_1_2__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__Group_8_1_2__0" + // $ANTLR end "rule__OpOther__Alternatives_6_1" - // $ANTLR start "rule__Export__Group_8_1_2__0__Impl" - // InternalExport.g:4191:1: rule__Export__Group_8_1_2__0__Impl : ( ',' ) ; - public final void rule__Export__Group_8_1_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpAdd__Alternatives" + // InternalExport.g:4023:1: rule__OpAdd__Alternatives : ( ( '+' ) | ( '-' ) ); + public final void rule__OpAdd__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4195:1: ( ( ',' ) ) - // InternalExport.g:4196:1: ( ',' ) - { - // InternalExport.g:4196:1: ( ',' ) - // InternalExport.g:4197:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); + // InternalExport.g:4027:1: ( ( '+' ) | ( '-' ) ) + int alt29=2; + int LA29_0 = input.LA(1); + + if ( (LA29_0==23) ) { + alt29=1; } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); + else if ( (LA29_0==24) ) { + alt29=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 29, 0, input); + throw nvae; } + switch (alt29) { + case 1 : + // InternalExport.g:4028:2: ( '+' ) + { + // InternalExport.g:4028:2: ( '+' ) + // InternalExport.g:4029:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + } + + + } + break; + case 2 : + // InternalExport.g:4034:2: ( '-' ) + { + // InternalExport.g:4034:2: ( '-' ) + // InternalExport.g:4035:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14476,78 +14667,126 @@ public final void rule__Export__Group_8_1_2__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Export__Group_8_1_2__0__Impl" + // $ANTLR end "rule__OpAdd__Alternatives" - // $ANTLR start "rule__Export__Group_8_1_2__1" - // InternalExport.g:4206:1: rule__Export__Group_8_1_2__1 : rule__Export__Group_8_1_2__1__Impl ; - public final void rule__Export__Group_8_1_2__1() throws RecognitionException { + // $ANTLR start "rule__OpMulti__Alternatives" + // InternalExport.g:4044:1: rule__OpMulti__Alternatives : ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ); + public final void rule__OpMulti__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4210:1: ( rule__Export__Group_8_1_2__1__Impl ) - // InternalExport.g:4211:2: rule__Export__Group_8_1_2__1__Impl - { - pushFollow(FOLLOW_2); - rule__Export__Group_8_1_2__1__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:4048:1: ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ) + int alt30=4; + switch ( input.LA(1) ) { + case 25: + { + alt30=1; + } + break; + case 54: + { + alt30=2; + } + break; + case 26: + { + alt30=3; + } + break; + case 55: + { + alt30=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 30, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt30) { + case 1 : + // InternalExport.g:4049:2: ( '*' ) + { + // InternalExport.g:4049:2: ( '*' ) + // InternalExport.g:4050:3: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__Export__Group_8_1_2__1" + } + break; + case 2 : + // InternalExport.g:4055:2: ( '**' ) + { + // InternalExport.g:4055:2: ( '**' ) + // InternalExport.g:4056:3: '**' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + match(input,54,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } - // $ANTLR start "rule__Export__Group_8_1_2__1__Impl" - // InternalExport.g:4217:1: rule__Export__Group_8_1_2__1__Impl : ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) ; - public final void rule__Export__Group_8_1_2__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4221:1: ( ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) ) - // InternalExport.g:4222:1: ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) - { - // InternalExport.g:4222:1: ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) - // InternalExport.g:4223:2: ( rule__Export__UserDataAssignment_8_1_2_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); - } - // InternalExport.g:4224:2: ( rule__Export__UserDataAssignment_8_1_2_1 ) - // InternalExport.g:4224:3: rule__Export__UserDataAssignment_8_1_2_1 - { - pushFollow(FOLLOW_2); - rule__Export__UserDataAssignment_8_1_2_1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 3 : + // InternalExport.g:4061:2: ( '/' ) + { + // InternalExport.g:4061:2: ( '/' ) + // InternalExport.g:4062:3: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + match(input,26,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); - } - } + } + break; + case 4 : + // InternalExport.g:4067:2: ( '%' ) + { + // InternalExport.g:4067:2: ( '%' ) + // InternalExport.g:4068:3: '%' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + match(input,55,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14560,83 +14799,88 @@ public final void rule__Export__Group_8_1_2__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Export__Group_8_1_2__1__Impl" + // $ANTLR end "rule__OpMulti__Alternatives" - // $ANTLR start "rule__UserData__Group__0" - // InternalExport.g:4233:1: rule__UserData__Group__0 : rule__UserData__Group__0__Impl rule__UserData__Group__1 ; - public final void rule__UserData__Group__0() throws RecognitionException { + // $ANTLR start "rule__XUnaryOperation__Alternatives" + // InternalExport.g:4077:1: rule__XUnaryOperation__Alternatives : ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ); + public final void rule__XUnaryOperation__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4237:1: ( rule__UserData__Group__0__Impl rule__UserData__Group__1 ) - // InternalExport.g:4238:2: rule__UserData__Group__0__Impl rule__UserData__Group__1 - { - pushFollow(FOLLOW_32); - rule__UserData__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__UserData__Group__1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:4081:1: ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ) + int alt31=2; + int LA31_0 = input.LA(1); + if ( ((LA31_0>=23 && LA31_0<=24)||LA31_0==27) ) { + alt31=1; + } + else if ( ((LA31_0>=RULE_ID && LA31_0<=RULE_STRING)||LA31_0==22||(LA31_0>=36 && LA31_0<=37)||(LA31_0>=60 && LA31_0<=64)||LA31_0==66||LA31_0==68||LA31_0==72||LA31_0==77||LA31_0==87||LA31_0==90||LA31_0==95||(LA31_0>=97 && LA31_0<=104)||LA31_0==106) ) { + alt31=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 31, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + throw nvae; + } + switch (alt31) { + case 1 : + // InternalExport.g:4082:2: ( ( rule__XUnaryOperation__Group_0__0 ) ) + { + // InternalExport.g:4082:2: ( ( rule__XUnaryOperation__Group_0__0 ) ) + // InternalExport.g:4083:3: ( rule__XUnaryOperation__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } + // InternalExport.g:4084:3: ( rule__XUnaryOperation__Group_0__0 ) + // InternalExport.g:4084:4: rule__XUnaryOperation__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__UserData__Group__0" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } - // $ANTLR start "rule__UserData__Group__0__Impl" - // InternalExport.g:4245:1: rule__UserData__Group__0__Impl : ( ( rule__UserData__NameAssignment_0 ) ) ; - public final void rule__UserData__Group__0__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4249:1: ( ( ( rule__UserData__NameAssignment_0 ) ) ) - // InternalExport.g:4250:1: ( ( rule__UserData__NameAssignment_0 ) ) - { - // InternalExport.g:4250:1: ( ( rule__UserData__NameAssignment_0 ) ) - // InternalExport.g:4251:2: ( rule__UserData__NameAssignment_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUserDataAccess().getNameAssignment_0()); - } - // InternalExport.g:4252:2: ( rule__UserData__NameAssignment_0 ) - // InternalExport.g:4252:3: rule__UserData__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__UserData__NameAssignment_0(); - state._fsp--; - if (state.failed) return ; + } + break; + case 2 : + // InternalExport.g:4088:2: ( ruleXCastedExpression ) + { + // InternalExport.g:4088:2: ( ruleXCastedExpression ) + // InternalExport.g:4089:3: ruleXCastedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXCastedExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getUserDataAccess().getNameAssignment_0()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14649,73 +14893,102 @@ public final void rule__UserData__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__UserData__Group__0__Impl" + // $ANTLR end "rule__XUnaryOperation__Alternatives" - // $ANTLR start "rule__UserData__Group__1" - // InternalExport.g:4260:1: rule__UserData__Group__1 : rule__UserData__Group__1__Impl rule__UserData__Group__2 ; - public final void rule__UserData__Group__1() throws RecognitionException { + // $ANTLR start "rule__OpUnary__Alternatives" + // InternalExport.g:4098:1: rule__OpUnary__Alternatives : ( ( '!' ) | ( '-' ) | ( '+' ) ); + public final void rule__OpUnary__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4264:1: ( rule__UserData__Group__1__Impl rule__UserData__Group__2 ) - // InternalExport.g:4265:2: rule__UserData__Group__1__Impl rule__UserData__Group__2 - { - pushFollow(FOLLOW_18); - rule__UserData__Group__1__Impl(); + // InternalExport.g:4102:1: ( ( '!' ) | ( '-' ) | ( '+' ) ) + int alt32=3; + switch ( input.LA(1) ) { + case 27: + { + alt32=1; + } + break; + case 24: + { + alt32=2; + } + break; + case 23: + { + alt32=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 32, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__UserData__Group__2(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt32) { + case 1 : + // InternalExport.g:4103:2: ( '!' ) + { + // InternalExport.g:4103:2: ( '!' ) + // InternalExport.g:4104:3: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + match(input,27,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:4109:2: ( '-' ) + { + // InternalExport.g:4109:2: ( '-' ) + // InternalExport.g:4110:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } - } - return ; - } - // $ANTLR end "rule__UserData__Group__1" + } - // $ANTLR start "rule__UserData__Group__1__Impl" - // InternalExport.g:4272:1: rule__UserData__Group__1__Impl : ( '=' ) ; - public final void rule__UserData__Group__1__Impl() throws RecognitionException { + } + break; + case 3 : + // InternalExport.g:4115:2: ( '+' ) + { + // InternalExport.g:4115:2: ( '+' ) + // InternalExport.g:4116:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4276:1: ( ( '=' ) ) - // InternalExport.g:4277:1: ( '=' ) - { - // InternalExport.g:4277:1: ( '=' ) - // InternalExport.g:4278:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); - } - match(input,47,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14728,27 +15001,74 @@ public final void rule__UserData__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__UserData__Group__1__Impl" + // $ANTLR end "rule__OpUnary__Alternatives" - // $ANTLR start "rule__UserData__Group__2" - // InternalExport.g:4287:1: rule__UserData__Group__2 : rule__UserData__Group__2__Impl ; - public final void rule__UserData__Group__2() throws RecognitionException { + // $ANTLR start "rule__OpPostfix__Alternatives" + // InternalExport.g:4125:1: rule__OpPostfix__Alternatives : ( ( '++' ) | ( '--' ) ); + public final void rule__OpPostfix__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4291:1: ( rule__UserData__Group__2__Impl ) - // InternalExport.g:4292:2: rule__UserData__Group__2__Impl - { - pushFollow(FOLLOW_2); - rule__UserData__Group__2__Impl(); + // InternalExport.g:4129:1: ( ( '++' ) | ( '--' ) ) + int alt33=2; + int LA33_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA33_0==56) ) { + alt33=1; + } + else if ( (LA33_0==57) ) { + alt33=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 33, 0, input); + throw nvae; } + switch (alt33) { + case 1 : + // InternalExport.g:4130:2: ( '++' ) + { + // InternalExport.g:4130:2: ( '++' ) + // InternalExport.g:4131:3: '++' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + match(input,56,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4136:2: ( '--' ) + { + // InternalExport.g:4136:2: ( '--' ) + // InternalExport.g:4137:3: '--' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + match(input,57,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14761,83 +15081,80 @@ public final void rule__UserData__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__UserData__Group__2" + // $ANTLR end "rule__OpPostfix__Alternatives" - // $ANTLR start "rule__UserData__Group__2__Impl" - // InternalExport.g:4298:1: rule__UserData__Group__2__Impl : ( ( rule__UserData__ExprAssignment_2 ) ) ; - public final void rule__UserData__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1" + // InternalExport.g:4146:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4302:1: ( ( ( rule__UserData__ExprAssignment_2 ) ) ) - // InternalExport.g:4303:1: ( ( rule__UserData__ExprAssignment_2 ) ) - { - // InternalExport.g:4303:1: ( ( rule__UserData__ExprAssignment_2 ) ) - // InternalExport.g:4304:2: ( rule__UserData__ExprAssignment_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUserDataAccess().getExprAssignment_2()); - } - // InternalExport.g:4305:2: ( rule__UserData__ExprAssignment_2 ) - // InternalExport.g:4305:3: rule__UserData__ExprAssignment_2 - { - pushFollow(FOLLOW_2); - rule__UserData__ExprAssignment_2(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExport.g:4150:1: ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) ) + int alt34=2; + alt34 = dfa34.predict(input); + switch (alt34) { + case 1 : + // InternalExport.g:4151:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) + { + // InternalExport.g:4151:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) + // InternalExport.g:4152:3: ( rule__XMemberFeatureCall__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); + } + // InternalExport.g:4153:3: ( rule__XMemberFeatureCall__Group_1_0__0 ) + // InternalExport.g:4153:4: rule__XMemberFeatureCall__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getUserDataAccess().getExprAssignment_2()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:4157:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) + { + // InternalExport.g:4157:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) + // InternalExport.g:4158:3: ( rule__XMemberFeatureCall__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); + } + // InternalExport.g:4159:3: ( rule__XMemberFeatureCall__Group_1_1__0 ) + // InternalExport.g:4159:4: rule__XMemberFeatureCall__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__0(); - } - return ; - } - // $ANTLR end "rule__UserData__Group__2__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__QualifiedID__Group__0" - // InternalExport.g:4314:1: rule__QualifiedID__Group__0 : rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ; - public final void rule__QualifiedID__Group__0() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4318:1: ( rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ) - // InternalExport.g:4319:2: rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 - { - pushFollow(FOLLOW_37); - rule__QualifiedID__Group__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__QualifiedID__Group__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14850,68 +15167,84 @@ public final void rule__QualifiedID__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group__0" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1" - // $ANTLR start "rule__QualifiedID__Group__0__Impl" - // InternalExport.g:4326:1: rule__QualifiedID__Group__0__Impl : ( RULE_ID ) ; - public final void rule__QualifiedID__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1" + // InternalExport.g:4167:1: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_0_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4330:1: ( ( RULE_ID ) ) - // InternalExport.g:4331:1: ( RULE_ID ) - { - // InternalExport.g:4331:1: ( RULE_ID ) - // InternalExport.g:4332:2: RULE_ID - { - if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); + // InternalExport.g:4171:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) ) + int alt35=2; + int LA35_0 = input.LA(1); + + if ( (LA35_0==58) ) { + alt35=1; } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); + else if ( (LA35_0==83) ) { + alt35=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 35, 0, input); + throw nvae; } + switch (alt35) { + case 1 : + // InternalExport.g:4172:2: ( '.' ) + { + // InternalExport.g:4172:2: ( '.' ) + // InternalExport.g:4173:3: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 2 : + // InternalExport.g:4178:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) + { + // InternalExport.g:4178:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) + // InternalExport.g:4179:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); + } + // InternalExport.g:4180:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) + // InternalExport.g:4180:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__QualifiedID__Group__0__Impl" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); + } - // $ANTLR start "rule__QualifiedID__Group__1" - // InternalExport.g:4341:1: rule__QualifiedID__Group__1 : rule__QualifiedID__Group__1__Impl ; - public final void rule__QualifiedID__Group__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4345:1: ( rule__QualifiedID__Group__1__Impl ) - // InternalExport.g:4346:2: rule__QualifiedID__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__QualifiedID__Group__1__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14924,63 +15257,122 @@ public final void rule__QualifiedID__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group__1" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1" - // $ANTLR start "rule__QualifiedID__Group__1__Impl" - // InternalExport.g:4352:1: rule__QualifiedID__Group__1__Impl : ( ( rule__QualifiedID__Group_1__0 )* ) ; - public final void rule__QualifiedID__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1" + // InternalExport.g:4188:1: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_1_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4356:1: ( ( ( rule__QualifiedID__Group_1__0 )* ) ) - // InternalExport.g:4357:1: ( ( rule__QualifiedID__Group_1__0 )* ) - { - // InternalExport.g:4357:1: ( ( rule__QualifiedID__Group_1__0 )* ) - // InternalExport.g:4358:2: ( rule__QualifiedID__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getGroup_1()); + // InternalExport.g:4192:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) ) + int alt36=3; + switch ( input.LA(1) ) { + case 58: + { + alt36=1; + } + break; + case 116: + { + alt36=2; + } + break; + case 83: + { + alt36=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 36, 0, input); + + throw nvae; } - // InternalExport.g:4359:2: ( rule__QualifiedID__Group_1__0 )* - loop46: - do { - int alt46=2; - int LA46_0 = input.LA(1); - if ( (LA46_0==57) ) { - alt46=1; - } + switch (alt36) { + case 1 : + // InternalExport.g:4193:2: ( '.' ) + { + // InternalExport.g:4193:2: ( '.' ) + // InternalExport.g:4194:3: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + } - switch (alt46) { - case 1 : - // InternalExport.g:4359:3: rule__QualifiedID__Group_1__0 - { - pushFollow(FOLLOW_38); - rule__QualifiedID__Group_1__0(); - state._fsp--; - if (state.failed) return ; + } + break; + case 2 : + // InternalExport.g:4199:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) + { + // InternalExport.g:4199:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) + // InternalExport.g:4200:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); + } + // InternalExport.g:4201:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) + // InternalExport.g:4201:4: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop46; - } - } while (true); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getGroup_1()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); + } - } + } - } + } + break; + case 3 : + // InternalExport.g:4205:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) + { + // InternalExport.g:4205:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) + // InternalExport.g:4206:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); + } + // InternalExport.g:4207:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) + // InternalExport.g:4207:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14993,32 +15385,80 @@ public final void rule__QualifiedID__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__QualifiedID__Group__1__Impl" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1" - // $ANTLR start "rule__QualifiedID__Group_1__0" - // InternalExport.g:4368:1: rule__QualifiedID__Group_1__0 : rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ; - public final void rule__QualifiedID__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_3_1" + // InternalExport.g:4215:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_1_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4372:1: ( rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ) - // InternalExport.g:4373:2: rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 - { - pushFollow(FOLLOW_10); - rule__QualifiedID__Group_1__0__Impl(); + // InternalExport.g:4219:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) ) + int alt37=2; + alt37 = dfa37.predict(input); + switch (alt37) { + case 1 : + // InternalExport.g:4220:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + { + // InternalExport.g:4220:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + // InternalExport.g:4221:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + // InternalExport.g:4222:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + // InternalExport.g:4222:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__QualifiedID__Group_1__1(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4226:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) + { + // InternalExport.g:4226:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) + // InternalExport.g:4227:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); + } + // InternalExport.g:4228:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) + // InternalExport.g:4228:4: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15031,315 +15471,379 @@ public final void rule__QualifiedID__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group_1__0" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_3_1" - // $ANTLR start "rule__QualifiedID__Group_1__0__Impl" - // InternalExport.g:4380:1: rule__QualifiedID__Group_1__0__Impl : ( '::' ) ; - public final void rule__QualifiedID__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XPrimaryExpression__Alternatives" + // InternalExport.g:4236:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) ); + public final void rule__XPrimaryExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4384:1: ( ( '::' ) ) - // InternalExport.g:4385:1: ( '::' ) - { - // InternalExport.g:4385:1: ( '::' ) - // InternalExport.g:4386:2: '::' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); - } - match(input,57,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); - } - - } - - - } + // InternalExport.g:4240:1: ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) ) + int alt38=15; + alt38 = dfa38.predict(input); + switch (alt38) { + case 1 : + // InternalExport.g:4241:2: ( ruleXConstructorCall ) + { + // InternalExport.g:4241:2: ( ruleXConstructorCall ) + // InternalExport.g:4242:3: ruleXConstructorCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXConstructorCall(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__QualifiedID__Group_1__0__Impl" + } + break; + case 2 : + // InternalExport.g:4247:2: ( ruleXBlockExpression ) + { + // InternalExport.g:4247:2: ( ruleXBlockExpression ) + // InternalExport.g:4248:3: ruleXBlockExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXBlockExpression(); - // $ANTLR start "rule__QualifiedID__Group_1__1" - // InternalExport.g:4395:1: rule__QualifiedID__Group_1__1 : rule__QualifiedID__Group_1__1__Impl ; - public final void rule__QualifiedID__Group_1__1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4399:1: ( rule__QualifiedID__Group_1__1__Impl ) - // InternalExport.g:4400:2: rule__QualifiedID__Group_1__1__Impl - { - pushFollow(FOLLOW_2); - rule__QualifiedID__Group_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 3 : + // InternalExport.g:4253:2: ( ruleXSwitchExpression ) + { + // InternalExport.g:4253:2: ( ruleXSwitchExpression ) + // InternalExport.g:4254:3: ruleXSwitchExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleXSwitchExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__QualifiedID__Group_1__1" + } + break; + case 4 : + // InternalExport.g:4259:2: ( ( ruleXSynchronizedExpression ) ) + { + // InternalExport.g:4259:2: ( ( ruleXSynchronizedExpression ) ) + // InternalExport.g:4260:3: ( ruleXSynchronizedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + // InternalExport.g:4261:3: ( ruleXSynchronizedExpression ) + // InternalExport.g:4261:4: ruleXSynchronizedExpression + { + pushFollow(FOLLOW_2); + ruleXSynchronizedExpression(); - // $ANTLR start "rule__QualifiedID__Group_1__1__Impl" - // InternalExport.g:4406:1: rule__QualifiedID__Group_1__1__Impl : ( RULE_ID ) ; - public final void rule__QualifiedID__Group_1__1__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4410:1: ( ( RULE_ID ) ) - // InternalExport.g:4411:1: ( RULE_ID ) - { - // InternalExport.g:4411:1: ( RULE_ID ) - // InternalExport.g:4412:2: RULE_ID - { - if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); - } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 5 : + // InternalExport.g:4265:2: ( ruleXFeatureCall ) + { + // InternalExport.g:4265:2: ( ruleXFeatureCall ) + // InternalExport.g:4266:3: ruleXFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleXFeatureCall(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } - } - return ; - } - // $ANTLR end "rule__QualifiedID__Group_1__1__Impl" + } - // $ANTLR start "rule__LetExpression__Group__0" - // InternalExport.g:4422:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ; - public final void rule__LetExpression__Group__0() throws RecognitionException { + } + break; + case 6 : + // InternalExport.g:4271:2: ( ruleXLiteral ) + { + // InternalExport.g:4271:2: ( ruleXLiteral ) + // InternalExport.g:4272:3: ruleXLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleXLiteral(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4426:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ) - // InternalExport.g:4427:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 - { - pushFollow(FOLLOW_10); - rule__LetExpression__Group__0__Impl(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 7 : + // InternalExport.g:4277:2: ( ruleXIfExpression ) + { + // InternalExport.g:4277:2: ( ruleXIfExpression ) + // InternalExport.g:4278:3: ruleXIfExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } + pushFollow(FOLLOW_2); + ruleXIfExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__0" + } + break; + case 8 : + // InternalExport.g:4283:2: ( ( ruleXForLoopExpression ) ) + { + // InternalExport.g:4283:2: ( ( ruleXForLoopExpression ) ) + // InternalExport.g:4284:3: ( ruleXForLoopExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + // InternalExport.g:4285:3: ( ruleXForLoopExpression ) + // InternalExport.g:4285:4: ruleXForLoopExpression + { + pushFollow(FOLLOW_2); + ruleXForLoopExpression(); - // $ANTLR start "rule__LetExpression__Group__0__Impl" - // InternalExport.g:4434:1: rule__LetExpression__Group__0__Impl : ( 'let' ) ; - public final void rule__LetExpression__Group__0__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4438:1: ( ( 'let' ) ) - // InternalExport.g:4439:1: ( 'let' ) - { - // InternalExport.g:4439:1: ( 'let' ) - // InternalExport.g:4440:2: 'let' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); - } - match(input,58,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 9 : + // InternalExport.g:4289:2: ( ruleXBasicForLoopExpression ) + { + // InternalExport.g:4289:2: ( ruleXBasicForLoopExpression ) + // InternalExport.g:4290:3: ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + pushFollow(FOLLOW_2); + ruleXBasicForLoopExpression(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__0__Impl" + } - // $ANTLR start "rule__LetExpression__Group__1" - // InternalExport.g:4449:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ; - public final void rule__LetExpression__Group__1() throws RecognitionException { + } + break; + case 10 : + // InternalExport.g:4295:2: ( ruleXWhileExpression ) + { + // InternalExport.g:4295:2: ( ruleXWhileExpression ) + // InternalExport.g:4296:3: ruleXWhileExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } + pushFollow(FOLLOW_2); + ruleXWhileExpression(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4453:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ) - // InternalExport.g:4454:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 - { - pushFollow(FOLLOW_32); - rule__LetExpression__Group__1__Impl(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__2(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 11 : + // InternalExport.g:4301:2: ( ruleXDoWhileExpression ) + { + // InternalExport.g:4301:2: ( ruleXDoWhileExpression ) + // InternalExport.g:4302:3: ruleXDoWhileExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } + pushFollow(FOLLOW_2); + ruleXDoWhileExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__1" + } + break; + case 12 : + // InternalExport.g:4307:2: ( ruleXThrowExpression ) + { + // InternalExport.g:4307:2: ( ruleXThrowExpression ) + // InternalExport.g:4308:3: ruleXThrowExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } + pushFollow(FOLLOW_2); + ruleXThrowExpression(); - // $ANTLR start "rule__LetExpression__Group__1__Impl" - // InternalExport.g:4461:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ; - public final void rule__LetExpression__Group__1__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4465:1: ( ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ) - // InternalExport.g:4466:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) - { - // InternalExport.g:4466:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) - // InternalExport.g:4467:2: ( rule__LetExpression__IdentifierAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); - } - // InternalExport.g:4468:2: ( rule__LetExpression__IdentifierAssignment_1 ) - // InternalExport.g:4468:3: rule__LetExpression__IdentifierAssignment_1 - { - pushFollow(FOLLOW_2); - rule__LetExpression__IdentifierAssignment_1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 13 : + // InternalExport.g:4313:2: ( ruleXReturnExpression ) + { + // InternalExport.g:4313:2: ( ruleXReturnExpression ) + // InternalExport.g:4314:3: ruleXReturnExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + pushFollow(FOLLOW_2); + ruleXReturnExpression(); - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } - } + } - } + } + break; + case 14 : + // InternalExport.g:4319:2: ( ruleXTryCatchFinallyExpression ) + { + // InternalExport.g:4319:2: ( ruleXTryCatchFinallyExpression ) + // InternalExport.g:4320:3: ruleXTryCatchFinallyExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + pushFollow(FOLLOW_2); + ruleXTryCatchFinallyExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__1__Impl" + } + break; + case 15 : + // InternalExport.g:4325:2: ( ruleXParenthesizedExpression ) + { + // InternalExport.g:4325:2: ( ruleXParenthesizedExpression ) + // InternalExport.g:4326:3: ruleXParenthesizedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + pushFollow(FOLLOW_2); + ruleXParenthesizedExpression(); - // $ANTLR start "rule__LetExpression__Group__2" - // InternalExport.g:4476:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ; - public final void rule__LetExpression__Group__2() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4480:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ) - // InternalExport.g:4481:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 - { - pushFollow(FOLLOW_18); - rule__LetExpression__Group__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__3(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15352,162 +15856,235 @@ public final void rule__LetExpression__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__2" + // $ANTLR end "rule__XPrimaryExpression__Alternatives" - // $ANTLR start "rule__LetExpression__Group__2__Impl" - // InternalExport.g:4488:1: rule__LetExpression__Group__2__Impl : ( '=' ) ; - public final void rule__LetExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XLiteral__Alternatives" + // InternalExport.g:4335:1: rule__XLiteral__Alternatives : ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) ); + public final void rule__XLiteral__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4492:1: ( ( '=' ) ) - // InternalExport.g:4493:1: ( '=' ) - { - // InternalExport.g:4493:1: ( '=' ) - // InternalExport.g:4494:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); - } - match(input,47,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); - } + // InternalExport.g:4339:1: ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) ) + int alt39=7; + switch ( input.LA(1) ) { + case 97: + { + alt39=1; + } + break; + case 72: + { + alt39=2; + } + break; + case 36: + case 37: + { + alt39=3; + } + break; + case RULE_HEX: + case RULE_INT: + case RULE_DECIMAL: + { + alt39=4; + } + break; + case 100: + { + alt39=5; + } + break; + case RULE_STRING: + { + alt39=6; + } + break; + case 101: + { + alt39=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 39, 0, input); + throw nvae; } + switch (alt39) { + case 1 : + // InternalExport.g:4340:2: ( ruleXCollectionLiteral ) + { + // InternalExport.g:4340:2: ( ruleXCollectionLiteral ) + // InternalExport.g:4341:3: ruleXCollectionLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXCollectionLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__2__Impl" + } + break; + case 2 : + // InternalExport.g:4346:2: ( ( ruleXClosure ) ) + { + // InternalExport.g:4346:2: ( ( ruleXClosure ) ) + // InternalExport.g:4347:3: ( ruleXClosure ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } + // InternalExport.g:4348:3: ( ruleXClosure ) + // InternalExport.g:4348:4: ruleXClosure + { + pushFollow(FOLLOW_2); + ruleXClosure(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__LetExpression__Group__3" - // InternalExport.g:4503:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ; - public final void rule__LetExpression__Group__3() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4507:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ) - // InternalExport.g:4508:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 - { - pushFollow(FOLLOW_39); - rule__LetExpression__Group__3__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__4(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 3 : + // InternalExport.g:4352:2: ( ruleXBooleanLiteral ) + { + // InternalExport.g:4352:2: ( ruleXBooleanLiteral ) + // InternalExport.g:4353:3: ruleXBooleanLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleXBooleanLiteral(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__3" + } + break; + case 4 : + // InternalExport.g:4358:2: ( ruleXNumberLiteral ) + { + // InternalExport.g:4358:2: ( ruleXNumberLiteral ) + // InternalExport.g:4359:3: ruleXNumberLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleXNumberLiteral(); - // $ANTLR start "rule__LetExpression__Group__3__Impl" - // InternalExport.g:4515:1: rule__LetExpression__Group__3__Impl : ( ( rule__LetExpression__VarExprAssignment_3 ) ) ; - public final void rule__LetExpression__Group__3__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4519:1: ( ( ( rule__LetExpression__VarExprAssignment_3 ) ) ) - // InternalExport.g:4520:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) - { - // InternalExport.g:4520:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) - // InternalExport.g:4521:2: ( rule__LetExpression__VarExprAssignment_3 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); - } - // InternalExport.g:4522:2: ( rule__LetExpression__VarExprAssignment_3 ) - // InternalExport.g:4522:3: rule__LetExpression__VarExprAssignment_3 - { - pushFollow(FOLLOW_2); - rule__LetExpression__VarExprAssignment_3(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 5 : + // InternalExport.g:4364:2: ( ruleXNullLiteral ) + { + // InternalExport.g:4364:2: ( ruleXNullLiteral ) + // InternalExport.g:4365:3: ruleXNullLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleXNullLiteral(); - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } - } + } - } + } + break; + case 6 : + // InternalExport.g:4370:2: ( ruleXStringLiteral ) + { + // InternalExport.g:4370:2: ( ruleXStringLiteral ) + // InternalExport.g:4371:3: ruleXStringLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleXStringLiteral(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__3__Impl" + } + break; + case 7 : + // InternalExport.g:4376:2: ( ruleXTypeLiteral ) + { + // InternalExport.g:4376:2: ( ruleXTypeLiteral ) + // InternalExport.g:4377:3: ruleXTypeLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + pushFollow(FOLLOW_2); + ruleXTypeLiteral(); - // $ANTLR start "rule__LetExpression__Group__4" - // InternalExport.g:4530:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ; - public final void rule__LetExpression__Group__4() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4534:1: ( rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ) - // InternalExport.g:4535:2: rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 - { - pushFollow(FOLLOW_18); - rule__LetExpression__Group__4__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__5(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15520,68 +16097,93 @@ public final void rule__LetExpression__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__4" + // $ANTLR end "rule__XLiteral__Alternatives" - // $ANTLR start "rule__LetExpression__Group__4__Impl" - // InternalExport.g:4542:1: rule__LetExpression__Group__4__Impl : ( ':' ) ; - public final void rule__LetExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__XCollectionLiteral__Alternatives" + // InternalExport.g:4386:1: rule__XCollectionLiteral__Alternatives : ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) ); + public final void rule__XCollectionLiteral__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4546:1: ( ( ':' ) ) - // InternalExport.g:4547:1: ( ':' ) - { - // InternalExport.g:4547:1: ( ':' ) - // InternalExport.g:4548:2: ':' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); - } - match(input,59,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); - } + // InternalExport.g:4390:1: ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) ) + int alt40=2; + int LA40_0 = input.LA(1); - } + if ( (LA40_0==97) ) { + int LA40_1 = input.LA(2); + if ( (LA40_1==68) ) { + alt40=1; + } + else if ( (LA40_1==72) ) { + alt40=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 40, 1, input); + throw nvae; + } } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + throw nvae; + } + switch (alt40) { + case 1 : + // InternalExport.g:4391:2: ( ruleXSetLiteral ) + { + // InternalExport.g:4391:2: ( ruleXSetLiteral ) + // InternalExport.g:4392:3: ruleXSetLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXSetLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__4__Impl" + } - // $ANTLR start "rule__LetExpression__Group__5" - // InternalExport.g:4557:1: rule__LetExpression__Group__5 : rule__LetExpression__Group__5__Impl ; - public final void rule__LetExpression__Group__5() throws RecognitionException { + } + break; + case 2 : + // InternalExport.g:4397:2: ( ruleXListLiteral ) + { + // InternalExport.g:4397:2: ( ruleXListLiteral ) + // InternalExport.g:4398:3: ruleXListLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXListLiteral(); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4561:1: ( rule__LetExpression__Group__5__Impl ) - // InternalExport.g:4562:2: rule__LetExpression__Group__5__Impl - { - pushFollow(FOLLOW_2); - rule__LetExpression__Group__5__Impl(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15594,83 +16196,80 @@ public final void rule__LetExpression__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__5" + // $ANTLR end "rule__XCollectionLiteral__Alternatives" - // $ANTLR start "rule__LetExpression__Group__5__Impl" - // InternalExport.g:4568:1: rule__LetExpression__Group__5__Impl : ( ( rule__LetExpression__TargetAssignment_5 ) ) ; - public final void rule__LetExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__XSwitchExpression__Alternatives_2" + // InternalExport.g:4407:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) ); + public final void rule__XSwitchExpression__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4572:1: ( ( ( rule__LetExpression__TargetAssignment_5 ) ) ) - // InternalExport.g:4573:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) - { - // InternalExport.g:4573:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) - // InternalExport.g:4574:2: ( rule__LetExpression__TargetAssignment_5 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); - } - // InternalExport.g:4575:2: ( rule__LetExpression__TargetAssignment_5 ) - // InternalExport.g:4575:3: rule__LetExpression__TargetAssignment_5 - { - pushFollow(FOLLOW_2); - rule__LetExpression__TargetAssignment_5(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExport.g:4411:1: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) ) + int alt41=2; + alt41 = dfa41.predict(input); + switch (alt41) { + case 1 : + // InternalExport.g:4412:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + { + // InternalExport.g:4412:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + // InternalExport.g:4413:3: ( rule__XSwitchExpression__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + // InternalExport.g:4414:3: ( rule__XSwitchExpression__Group_2_0__0 ) + // InternalExport.g:4414:4: rule__XSwitchExpression__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:4418:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) ) + { + // InternalExport.g:4418:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) ) + // InternalExport.g:4419:3: ( rule__XSwitchExpression__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); + } + // InternalExport.g:4420:3: ( rule__XSwitchExpression__Group_2_1__0 ) + // InternalExport.g:4420:4: rule__XSwitchExpression__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__0(); - } - return ; - } - // $ANTLR end "rule__LetExpression__Group__5__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__CastedExpression__Group__0" - // InternalExport.g:4584:1: rule__CastedExpression__Group__0 : rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ; - public final void rule__CastedExpression__Group__0() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4588:1: ( rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ) - // InternalExport.g:4589:2: rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 - { - pushFollow(FOLLOW_40); - rule__CastedExpression__Group__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15683,73 +16282,94 @@ public final void rule__CastedExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__0" + // $ANTLR end "rule__XSwitchExpression__Alternatives_2" - // $ANTLR start "rule__CastedExpression__Group__0__Impl" - // InternalExport.g:4596:1: rule__CastedExpression__Group__0__Impl : ( '(' ) ; - public final void rule__CastedExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XCasePart__Alternatives_3" + // InternalExport.g:4428:1: rule__XCasePart__Alternatives_3 : ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) ); + public final void rule__XCasePart__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4600:1: ( ( '(' ) ) - // InternalExport.g:4601:1: ( '(' ) - { - // InternalExport.g:4601:1: ( '(' ) - // InternalExport.g:4602:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); + // InternalExport.g:4432:1: ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) ) + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==85) ) { + alt42=1; } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); + else if ( (LA42_0==74) ) { + alt42=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 42, 0, input); + throw nvae; } + switch (alt42) { + case 1 : + // InternalExport.g:4433:2: ( ( rule__XCasePart__Group_3_0__0 ) ) + { + // InternalExport.g:4433:2: ( ( rule__XCasePart__Group_3_0__0 ) ) + // InternalExport.g:4434:3: ( rule__XCasePart__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup_3_0()); + } + // InternalExport.g:4435:3: ( rule__XCasePart__Group_3_0__0 ) + // InternalExport.g:4435:4: rule__XCasePart__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getGroup_3_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__CastedExpression__Group__0__Impl" + } + break; + case 2 : + // InternalExport.g:4439:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) + { + // InternalExport.g:4439:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) + // InternalExport.g:4440:3: ( rule__XCasePart__FallThroughAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); + } + // InternalExport.g:4441:3: ( rule__XCasePart__FallThroughAssignment_3_1 ) + // InternalExport.g:4441:4: rule__XCasePart__FallThroughAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__FallThroughAssignment_3_1(); - // $ANTLR start "rule__CastedExpression__Group__1" - // InternalExport.g:4611:1: rule__CastedExpression__Group__1 : rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ; - public final void rule__CastedExpression__Group__1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4615:1: ( rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ) - // InternalExport.g:4616:2: rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 - { - pushFollow(FOLLOW_25); - rule__CastedExpression__Group__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__2(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15762,83 +16382,82 @@ public final void rule__CastedExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__1" + // $ANTLR end "rule__XCasePart__Alternatives_3" - // $ANTLR start "rule__CastedExpression__Group__1__Impl" - // InternalExport.g:4623:1: rule__CastedExpression__Group__1__Impl : ( ( rule__CastedExpression__TypeAssignment_1 ) ) ; - public final void rule__CastedExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XExpressionOrVarDeclaration__Alternatives" + // InternalExport.g:4449:1: rule__XExpressionOrVarDeclaration__Alternatives : ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) ); + public final void rule__XExpressionOrVarDeclaration__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4627:1: ( ( ( rule__CastedExpression__TypeAssignment_1 ) ) ) - // InternalExport.g:4628:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) - { - // InternalExport.g:4628:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) - // InternalExport.g:4629:2: ( rule__CastedExpression__TypeAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); - } - // InternalExport.g:4630:2: ( rule__CastedExpression__TypeAssignment_1 ) - // InternalExport.g:4630:3: rule__CastedExpression__TypeAssignment_1 - { - pushFollow(FOLLOW_2); - rule__CastedExpression__TypeAssignment_1(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExport.g:4453:1: ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) ) + int alt43=2; + int LA43_0 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); + if ( (LA43_0==59||LA43_0==117) ) { + alt43=1; } - + else if ( ((LA43_0>=RULE_ID && LA43_0<=RULE_STRING)||(LA43_0>=22 && LA43_0<=24)||LA43_0==27||(LA43_0>=36 && LA43_0<=37)||(LA43_0>=60 && LA43_0<=64)||LA43_0==66||LA43_0==68||LA43_0==72||LA43_0==77||LA43_0==87||LA43_0==90||LA43_0==95||(LA43_0>=97 && LA43_0<=104)||LA43_0==106) ) { + alt43=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 43, 0, input); - + throw nvae; } + switch (alt43) { + case 1 : + // InternalExport.g:4454:2: ( ruleXVariableDeclaration ) + { + // InternalExport.g:4454:2: ( ruleXVariableDeclaration ) + // InternalExport.g:4455:3: ruleXVariableDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXVariableDeclaration(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__CastedExpression__Group__1__Impl" + } + break; + case 2 : + // InternalExport.g:4460:2: ( ruleXExpression ) + { + // InternalExport.g:4460:2: ( ruleXExpression ) + // InternalExport.g:4461:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); - // $ANTLR start "rule__CastedExpression__Group__2" - // InternalExport.g:4638:1: rule__CastedExpression__Group__2 : rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ; - public final void rule__CastedExpression__Group__2() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4642:1: ( rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ) - // InternalExport.g:4643:2: rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 - { - pushFollow(FOLLOW_18); - rule__CastedExpression__Group__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__3(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15851,68 +16470,84 @@ public final void rule__CastedExpression__Group__2() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__2" + // $ANTLR end "rule__XExpressionOrVarDeclaration__Alternatives" - // $ANTLR start "rule__CastedExpression__Group__2__Impl" - // InternalExport.g:4650:1: rule__CastedExpression__Group__2__Impl : ( ')' ) ; - public final void rule__CastedExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XVariableDeclaration__Alternatives_1" + // InternalExport.g:4470:1: rule__XVariableDeclaration__Alternatives_1 : ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) ); + public final void rule__XVariableDeclaration__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4654:1: ( ( ')' ) ) - // InternalExport.g:4655:1: ( ')' ) - { - // InternalExport.g:4655:1: ( ')' ) - // InternalExport.g:4656:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + // InternalExport.g:4474:1: ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) ) + int alt44=2; + int LA44_0 = input.LA(1); + + if ( (LA44_0==117) ) { + alt44=1; } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + else if ( (LA44_0==59) ) { + alt44=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 44, 0, input); + throw nvae; } + switch (alt44) { + case 1 : + // InternalExport.g:4475:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) + { + // InternalExport.g:4475:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) + // InternalExport.g:4476:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); + } + // InternalExport.g:4477:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) + // InternalExport.g:4477:4: rule__XVariableDeclaration__WriteableAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__WriteableAssignment_1_0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__CastedExpression__Group__2__Impl" + } + break; + case 2 : + // InternalExport.g:4481:2: ( 'val' ) + { + // InternalExport.g:4481:2: ( 'val' ) + // InternalExport.g:4482:3: 'val' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + match(input,59,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } - // $ANTLR start "rule__CastedExpression__Group__3" - // InternalExport.g:4665:1: rule__CastedExpression__Group__3 : rule__CastedExpression__Group__3__Impl ; - public final void rule__CastedExpression__Group__3() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4669:1: ( rule__CastedExpression__Group__3__Impl ) - // InternalExport.g:4670:2: rule__CastedExpression__Group__3__Impl - { - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__3__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15925,83 +16560,108 @@ public final void rule__CastedExpression__Group__3() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__3" + // $ANTLR end "rule__XVariableDeclaration__Alternatives_1" - // $ANTLR start "rule__CastedExpression__Group__3__Impl" - // InternalExport.g:4676:1: rule__CastedExpression__Group__3__Impl : ( ( rule__CastedExpression__TargetAssignment_3 ) ) ; - public final void rule__CastedExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__XVariableDeclaration__Alternatives_2" + // InternalExport.g:4491:1: rule__XVariableDeclaration__Alternatives_2 : ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) ); + public final void rule__XVariableDeclaration__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4680:1: ( ( ( rule__CastedExpression__TargetAssignment_3 ) ) ) - // InternalExport.g:4681:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) - { - // InternalExport.g:4681:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) - // InternalExport.g:4682:2: ( rule__CastedExpression__TargetAssignment_3 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); - } - // InternalExport.g:4683:2: ( rule__CastedExpression__TargetAssignment_3 ) - // InternalExport.g:4683:3: rule__CastedExpression__TargetAssignment_3 - { - pushFollow(FOLLOW_2); - rule__CastedExpression__TargetAssignment_3(); + // InternalExport.g:4495:1: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) ) + int alt45=2; + int LA45_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA45_0==RULE_ID) ) { + int LA45_1 = input.LA(2); - } + if ( (synpred115_InternalExport()) ) { + alt45=1; + } + else if ( (true) ) { + alt45=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 45, 1, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); + throw nvae; + } } - + else if ( (LA45_0==51||LA45_0==77) ) { + alt45=1; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 45, 0, input); - + throw nvae; } + switch (alt45) { + case 1 : + // InternalExport.g:4496:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + { + // InternalExport.g:4496:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + // InternalExport.g:4497:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + // InternalExport.g:4498:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + // InternalExport.g:4498:4: rule__XVariableDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__CastedExpression__Group__3__Impl" + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + } - // $ANTLR start "rule__ChainExpression__Group__0" - // InternalExport.g:4692:1: rule__ChainExpression__Group__0 : rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ; - public final void rule__ChainExpression__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4696:1: ( rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ) - // InternalExport.g:4697:2: rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 - { - pushFollow(FOLLOW_41); - rule__ChainExpression__Group__0__Impl(); + } + break; + case 2 : + // InternalExport.g:4502:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) + { + // InternalExport.g:4502:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) + // InternalExport.g:4503:3: ( rule__XVariableDeclaration__NameAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); + } + // InternalExport.g:4504:3: ( rule__XVariableDeclaration__NameAssignment_2_1 ) + // InternalExport.g:4504:4: rule__XVariableDeclaration__NameAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__NameAssignment_2_1(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ChainExpression__Group__1(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16014,72 +16674,80 @@ public final void rule__ChainExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ChainExpression__Group__0" + // $ANTLR end "rule__XVariableDeclaration__Alternatives_2" - // $ANTLR start "rule__ChainExpression__Group__0__Impl" - // InternalExport.g:4704:1: rule__ChainExpression__Group__0__Impl : ( ruleChainedExpression ) ; - public final void rule__ChainExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XFeatureCall__Alternatives_3_1" + // InternalExport.g:4512:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) ); + public final void rule__XFeatureCall__Alternatives_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4708:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:4709:1: ( ruleChainedExpression ) - { - // InternalExport.g:4709:1: ( ruleChainedExpression ) - // InternalExport.g:4710:2: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + // InternalExport.g:4516:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) ) + int alt46=2; + alt46 = dfa46.predict(input); + switch (alt46) { + case 1 : + // InternalExport.g:4517:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + { + // InternalExport.g:4517:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + // InternalExport.g:4518:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + // InternalExport.g:4519:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + // InternalExport.g:4519:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:4523:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) + { + // InternalExport.g:4523:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) + // InternalExport.g:4524:3: ( rule__XFeatureCall__Group_3_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); + } + // InternalExport.g:4525:3: ( rule__XFeatureCall__Group_3_1_1__0 ) + // InternalExport.g:4525:4: rule__XFeatureCall__Group_3_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__0(); - } - return ; - } - // $ANTLR end "rule__ChainExpression__Group__0__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__ChainExpression__Group__1" - // InternalExport.g:4719:1: rule__ChainExpression__Group__1 : rule__ChainExpression__Group__1__Impl ; - public final void rule__ChainExpression__Group__1() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4723:1: ( rule__ChainExpression__Group__1__Impl ) - // InternalExport.g:4724:2: rule__ChainExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__ChainExpression__Group__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16092,63 +16760,154 @@ public final void rule__ChainExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ChainExpression__Group__1" + // $ANTLR end "rule__XFeatureCall__Alternatives_3_1" - // $ANTLR start "rule__ChainExpression__Group__1__Impl" - // InternalExport.g:4730:1: rule__ChainExpression__Group__1__Impl : ( ( rule__ChainExpression__Group_1__0 )* ) ; - public final void rule__ChainExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__FeatureCallID__Alternatives" + // InternalExport.g:4533:1: rule__FeatureCallID__Alternatives : ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) ); + public final void rule__FeatureCallID__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4734:1: ( ( ( rule__ChainExpression__Group_1__0 )* ) ) - // InternalExport.g:4735:1: ( ( rule__ChainExpression__Group_1__0 )* ) - { - // InternalExport.g:4735:1: ( ( rule__ChainExpression__Group_1__0 )* ) - // InternalExport.g:4736:2: ( rule__ChainExpression__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getGroup_1()); + // InternalExport.g:4537:1: ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) ) + int alt47=5; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt47=1; + } + break; + case 60: + { + alt47=2; + } + break; + case 61: + { + alt47=3; + } + break; + case 62: + { + alt47=4; + } + break; + case 63: + { + alt47=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 47, 0, input); + + throw nvae; } - // InternalExport.g:4737:2: ( rule__ChainExpression__Group_1__0 )* - loop47: - do { - int alt47=2; - int LA47_0 = input.LA(1); - if ( (LA47_0==60) ) { - alt47=1; - } + switch (alt47) { + case 1 : + // InternalExport.g:4538:2: ( ruleValidID ) + { + // InternalExport.g:4538:2: ( ruleValidID ) + // InternalExport.g:4539:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } - switch (alt47) { - case 1 : - // InternalExport.g:4737:3: rule__ChainExpression__Group_1__0 - { - pushFollow(FOLLOW_42); - rule__ChainExpression__Group_1__0(); + } - state._fsp--; - if (state.failed) return ; - } - break; + } + break; + case 2 : + // InternalExport.g:4544:2: ( 'extends' ) + { + // InternalExport.g:4544:2: ( 'extends' ) + // InternalExport.g:4545:3: 'extends' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + match(input,60,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } - default : - break loop47; - } - } while (true); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getGroup_1()); - } - } + } + break; + case 3 : + // InternalExport.g:4550:2: ( 'static' ) + { + // InternalExport.g:4550:2: ( 'static' ) + // InternalExport.g:4551:3: 'static' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + match(input,61,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + } + + + } + break; + case 4 : + // InternalExport.g:4556:2: ( 'import' ) + { + // InternalExport.g:4556:2: ( 'import' ) + // InternalExport.g:4557:3: 'import' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + match(input,62,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + + } + + + } + break; + case 5 : + // InternalExport.g:4562:2: ( 'extension' ) + { + // InternalExport.g:4562:2: ( 'extension' ) + // InternalExport.g:4563:3: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16161,32 +16920,78 @@ public final void rule__ChainExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ChainExpression__Group__1__Impl" + // $ANTLR end "rule__FeatureCallID__Alternatives" - // $ANTLR start "rule__ChainExpression__Group_1__0" - // InternalExport.g:4746:1: rule__ChainExpression__Group_1__0 : rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ; - public final void rule__ChainExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__IdOrSuper__Alternatives" + // InternalExport.g:4572:1: rule__IdOrSuper__Alternatives : ( ( ruleFeatureCallID ) | ( 'super' ) ); + public final void rule__IdOrSuper__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4750:1: ( rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ) - // InternalExport.g:4751:2: rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 - { - pushFollow(FOLLOW_41); - rule__ChainExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__1(); + // InternalExport.g:4576:1: ( ( ruleFeatureCallID ) | ( 'super' ) ) + int alt48=2; + int LA48_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA48_0==RULE_ID||(LA48_0>=60 && LA48_0<=63)) ) { + alt48=1; + } + else if ( (LA48_0==64) ) { + alt48=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 48, 0, input); + throw nvae; } + switch (alt48) { + case 1 : + // InternalExport.g:4577:2: ( ruleFeatureCallID ) + { + // InternalExport.g:4577:2: ( ruleFeatureCallID ) + // InternalExport.g:4578:3: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4583:2: ( 'super' ) + { + // InternalExport.g:4583:2: ( 'super' ) + // InternalExport.g:4584:3: 'super' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + match(input,64,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16199,73 +17004,80 @@ public final void rule__ChainExpression__Group_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__0" + // $ANTLR end "rule__IdOrSuper__Alternatives" - // $ANTLR start "rule__ChainExpression__Group_1__0__Impl" - // InternalExport.g:4758:1: rule__ChainExpression__Group_1__0__Impl : ( () ) ; - public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XConstructorCall__Alternatives_4_1" + // InternalExport.g:4593:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) ); + public final void rule__XConstructorCall__Alternatives_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4762:1: ( ( () ) ) - // InternalExport.g:4763:1: ( () ) - { - // InternalExport.g:4763:1: ( () ) - // InternalExport.g:4764:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); - } - // InternalExport.g:4765:2: () - // InternalExport.g:4765:3: - { - } + // InternalExport.g:4597:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) ) + int alt49=2; + alt49 = dfa49.predict(input); + switch (alt49) { + case 1 : + // InternalExport.g:4598:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + { + // InternalExport.g:4598:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + // InternalExport.g:4599:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + // InternalExport.g:4600:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + // InternalExport.g:4600:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } - } + } - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExport.g:4604:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) + { + // InternalExport.g:4604:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) + // InternalExport.g:4605:3: ( rule__XConstructorCall__Group_4_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); + } + // InternalExport.g:4606:3: ( rule__XConstructorCall__Group_4_1_1__0 ) + // InternalExport.g:4606:4: rule__XConstructorCall__Group_4_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__0(); - } - return ; - } - // $ANTLR end "rule__ChainExpression__Group_1__0__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__ChainExpression__Group_1__1" - // InternalExport.g:4773:1: rule__ChainExpression__Group_1__1 : rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ; - public final void rule__ChainExpression__Group_1__1() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4777:1: ( rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ) - // InternalExport.g:4778:2: rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 - { - pushFollow(FOLLOW_18); - rule__ChainExpression__Group_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__2(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -16278,68 +17090,84 @@ public final void rule__ChainExpression__Group_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__1" + // $ANTLR end "rule__XConstructorCall__Alternatives_4_1" - // $ANTLR start "rule__ChainExpression__Group_1__1__Impl" - // InternalExport.g:4785:1: rule__ChainExpression__Group_1__1__Impl : ( '->' ) ; - public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XBooleanLiteral__Alternatives_1" + // InternalExport.g:4614:1: rule__XBooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) ); + public final void rule__XBooleanLiteral__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4789:1: ( ( '->' ) ) - // InternalExport.g:4790:1: ( '->' ) - { - // InternalExport.g:4790:1: ( '->' ) - // InternalExport.g:4791:2: '->' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); + // InternalExport.g:4618:1: ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) ) + int alt50=2; + int LA50_0 = input.LA(1); + + if ( (LA50_0==37) ) { + alt50=1; } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); + else if ( (LA50_0==36) ) { + alt50=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 50, 0, input); + throw nvae; } + switch (alt50) { + case 1 : + // InternalExport.g:4619:2: ( 'false' ) + { + // InternalExport.g:4619:2: ( 'false' ) + // InternalExport.g:4620:3: 'false' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 2 : + // InternalExport.g:4625:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) + { + // InternalExport.g:4625:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) + // InternalExport.g:4626:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); + } + // InternalExport.g:4627:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) + // InternalExport.g:4627:4: rule__XBooleanLiteral__IsTrueAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__IsTrueAssignment_1_1(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__ChainExpression__Group_1__1__Impl" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); + } - // $ANTLR start "rule__ChainExpression__Group_1__2" - // InternalExport.g:4800:1: rule__ChainExpression__Group_1__2 : rule__ChainExpression__Group_1__2__Impl ; - public final void rule__ChainExpression__Group_1__2() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4804:1: ( rule__ChainExpression__Group_1__2__Impl ) - // InternalExport.g:4805:2: rule__ChainExpression__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__2__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -16352,83 +17180,94 @@ public final void rule__ChainExpression__Group_1__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__2" + // $ANTLR end "rule__XBooleanLiteral__Alternatives_1" - // $ANTLR start "rule__ChainExpression__Group_1__2__Impl" - // InternalExport.g:4811:1: rule__ChainExpression__Group_1__2__Impl : ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ; - public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XTryCatchFinallyExpression__Alternatives_3" + // InternalExport.g:4635:1: rule__XTryCatchFinallyExpression__Alternatives_3 : ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) ); + public final void rule__XTryCatchFinallyExpression__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4815:1: ( ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ) - // InternalExport.g:4816:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) - { - // InternalExport.g:4816:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) - // InternalExport.g:4817:2: ( rule__ChainExpression__NextAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); - } - // InternalExport.g:4818:2: ( rule__ChainExpression__NextAssignment_1_2 ) - // InternalExport.g:4818:3: rule__ChainExpression__NextAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__ChainExpression__NextAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:4639:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) ) + int alt51=2; + int LA51_0 = input.LA(1); + if ( (LA51_0==107) ) { + alt51=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); + else if ( (LA51_0==105) ) { + alt51=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 51, 0, input); + throw nvae; } + switch (alt51) { + case 1 : + // InternalExport.g:4640:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) + { + // InternalExport.g:4640:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) + // InternalExport.g:4641:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); + } + // InternalExport.g:4642:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) + // InternalExport.g:4642:4: rule__XTryCatchFinallyExpression__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ChainExpression__Group_1__2__Impl" + } + break; + case 2 : + // InternalExport.g:4646:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) + { + // InternalExport.g:4646:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) + // InternalExport.g:4647:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); + } + // InternalExport.g:4648:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) + // InternalExport.g:4648:4: rule__XTryCatchFinallyExpression__Group_3_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__0(); - // $ANTLR start "rule__IfExpressionTri__Group__0" - // InternalExport.g:4827:1: rule__IfExpressionTri__Group__0 : rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ; - public final void rule__IfExpressionTri__Group__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4831:1: ( rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ) - // InternalExport.g:4832:2: rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 - { - pushFollow(FOLLOW_43); - rule__IfExpressionTri__Group__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group__1(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16441,39 +17280,84 @@ public final void rule__IfExpressionTri__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__0" + // $ANTLR end "rule__XTryCatchFinallyExpression__Alternatives_3" - // $ANTLR start "rule__IfExpressionTri__Group__0__Impl" - // InternalExport.g:4839:1: rule__IfExpressionTri__Group__0__Impl : ( ruleOrExpression ) ; - public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives" + // InternalExport.g:4656:1: rule__Number__Alternatives : ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) ); + public final void rule__Number__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4843:1: ( ( ruleOrExpression ) ) - // InternalExport.g:4844:1: ( ruleOrExpression ) - { - // InternalExport.g:4844:1: ( ruleOrExpression ) - // InternalExport.g:4845:2: ruleOrExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleOrExpression(); + // InternalExport.g:4660:1: ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) ) + int alt52=2; + int LA52_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); + if ( (LA52_0==RULE_HEX) ) { + alt52=1; } - + else if ( ((LA52_0>=RULE_INT && LA52_0<=RULE_DECIMAL)) ) { + alt52=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 52, 0, input); - + throw nvae; } + switch (alt52) { + case 1 : + // InternalExport.g:4661:2: ( RULE_HEX ) + { + // InternalExport.g:4661:2: ( RULE_HEX ) + // InternalExport.g:4662:3: RULE_HEX + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + match(input,RULE_HEX,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4667:2: ( ( rule__Number__Group_1__0 ) ) + { + // InternalExport.g:4667:2: ( ( rule__Number__Group_1__0 ) ) + // InternalExport.g:4668:3: ( rule__Number__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getGroup_1()); + } + // InternalExport.g:4669:3: ( rule__Number__Group_1__0 ) + // InternalExport.g:4669:4: rule__Number__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__Number__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getGroup_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16486,27 +17370,74 @@ public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__0__Impl" + // $ANTLR end "rule__Number__Alternatives" - // $ANTLR start "rule__IfExpressionTri__Group__1" - // InternalExport.g:4854:1: rule__IfExpressionTri__Group__1 : rule__IfExpressionTri__Group__1__Impl ; - public final void rule__IfExpressionTri__Group__1() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives_1_0" + // InternalExport.g:4677:1: rule__Number__Alternatives_1_0 : ( ( RULE_INT ) | ( RULE_DECIMAL ) ); + public final void rule__Number__Alternatives_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4858:1: ( rule__IfExpressionTri__Group__1__Impl ) - // InternalExport.g:4859:2: rule__IfExpressionTri__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group__1__Impl(); + // InternalExport.g:4681:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) ) + int alt53=2; + int LA53_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA53_0==RULE_INT) ) { + alt53=1; + } + else if ( (LA53_0==RULE_DECIMAL) ) { + alt53=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 53, 0, input); + throw nvae; } + switch (alt53) { + case 1 : + // InternalExport.g:4682:2: ( RULE_INT ) + { + // InternalExport.g:4682:2: ( RULE_INT ) + // InternalExport.g:4683:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4688:2: ( RULE_DECIMAL ) + { + // InternalExport.g:4688:2: ( RULE_DECIMAL ) + // InternalExport.g:4689:3: RULE_DECIMAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16519,56 +17450,74 @@ public final void rule__IfExpressionTri__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__1" + // $ANTLR end "rule__Number__Alternatives_1_0" - // $ANTLR start "rule__IfExpressionTri__Group__1__Impl" - // InternalExport.g:4865:1: rule__IfExpressionTri__Group__1__Impl : ( ( rule__IfExpressionTri__Group_1__0 )? ) ; - public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives_1_1_1" + // InternalExport.g:4698:1: rule__Number__Alternatives_1_1_1 : ( ( RULE_INT ) | ( RULE_DECIMAL ) ); + public final void rule__Number__Alternatives_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4869:1: ( ( ( rule__IfExpressionTri__Group_1__0 )? ) ) - // InternalExport.g:4870:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) - { - // InternalExport.g:4870:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) - // InternalExport.g:4871:2: ( rule__IfExpressionTri__Group_1__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); + // InternalExport.g:4702:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) ) + int alt54=2; + int LA54_0 = input.LA(1); + + if ( (LA54_0==RULE_INT) ) { + alt54=1; } - // InternalExport.g:4872:2: ( rule__IfExpressionTri__Group_1__0 )? - int alt48=2; - int LA48_0 = input.LA(1); + else if ( (LA54_0==RULE_DECIMAL) ) { + alt54=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 54, 0, input); - if ( (LA48_0==61) ) { - alt48=1; + throw nvae; } - switch (alt48) { + switch (alt54) { case 1 : - // InternalExport.g:4872:3: rule__IfExpressionTri__Group_1__0 + // InternalExport.g:4703:2: ( RULE_INT ) { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__0(); + // InternalExport.g:4703:2: ( RULE_INT ) + // InternalExport.g:4704:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + + } - state._fsp--; - if (state.failed) return ; } break; + case 2 : + // InternalExport.g:4709:2: ( RULE_DECIMAL ) + { + // InternalExport.g:4709:2: ( RULE_DECIMAL ) + // InternalExport.g:4710:3: RULE_DECIMAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -16581,32 +17530,88 @@ public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__1__Impl" + // $ANTLR end "rule__Number__Alternatives_1_1_1" - // $ANTLR start "rule__IfExpressionTri__Group_1__0" - // InternalExport.g:4881:1: rule__IfExpressionTri__Group_1__0 : rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ; - public final void rule__IfExpressionTri__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__JvmTypeReference__Alternatives" + // InternalExport.g:4719:1: rule__JvmTypeReference__Alternatives : ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ); + public final void rule__JvmTypeReference__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4885:1: ( rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ) - // InternalExport.g:4886:2: rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 - { - pushFollow(FOLLOW_43); - rule__IfExpressionTri__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__1(); + // InternalExport.g:4723:1: ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ) + int alt55=2; + int LA55_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA55_0==RULE_ID) ) { + alt55=1; + } + else if ( (LA55_0==51||LA55_0==77) ) { + alt55=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 55, 0, input); + throw nvae; } + switch (alt55) { + case 1 : + // InternalExport.g:4724:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) + { + // InternalExport.g:4724:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) + // InternalExport.g:4725:3: ( rule__JvmTypeReference__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); + } + // InternalExport.g:4726:3: ( rule__JvmTypeReference__Group_0__0 ) + // InternalExport.g:4726:4: rule__JvmTypeReference__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); + } + + } + + } + break; + case 2 : + // InternalExport.g:4730:2: ( ruleXFunctionTypeRef ) + { + // InternalExport.g:4730:2: ( ruleXFunctionTypeRef ) + // InternalExport.g:4731:3: ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16619,73 +17624,82 @@ public final void rule__IfExpressionTri__Group_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__0" + // $ANTLR end "rule__JvmTypeReference__Alternatives" - // $ANTLR start "rule__IfExpressionTri__Group_1__0__Impl" - // InternalExport.g:4893:1: rule__IfExpressionTri__Group_1__0__Impl : ( () ) ; - public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__JvmArgumentTypeReference__Alternatives" + // InternalExport.g:4740:1: rule__JvmArgumentTypeReference__Alternatives : ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ); + public final void rule__JvmArgumentTypeReference__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4897:1: ( ( () ) ) - // InternalExport.g:4898:1: ( () ) - { - // InternalExport.g:4898:1: ( () ) - // InternalExport.g:4899:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); - } - // InternalExport.g:4900:2: () - // InternalExport.g:4900:3: - { - } + // InternalExport.g:4744:1: ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ) + int alt56=2; + int LA56_0 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); + if ( (LA56_0==RULE_ID||LA56_0==51||LA56_0==77) ) { + alt56=1; } - + else if ( (LA56_0==86) ) { + alt56=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 56, 0, input); - + throw nvae; } + switch (alt56) { + case 1 : + // InternalExport.g:4745:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:4745:2: ( ruleJvmTypeReference ) + // InternalExport.g:4746:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__IfExpressionTri__Group_1__0__Impl" + } + break; + case 2 : + // InternalExport.g:4751:2: ( ruleJvmWildcardTypeReference ) + { + // InternalExport.g:4751:2: ( ruleJvmWildcardTypeReference ) + // InternalExport.g:4752:3: ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleJvmWildcardTypeReference(); - // $ANTLR start "rule__IfExpressionTri__Group_1__1" - // InternalExport.g:4908:1: rule__IfExpressionTri__Group_1__1 : rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ; - public final void rule__IfExpressionTri__Group_1__1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:4912:1: ( rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ) - // InternalExport.g:4913:2: rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 - { - pushFollow(FOLLOW_18); - rule__IfExpressionTri__Group_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__2(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -16698,35 +17712,94 @@ public final void rule__IfExpressionTri__Group_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__1" + // $ANTLR end "rule__JvmArgumentTypeReference__Alternatives" - // $ANTLR start "rule__IfExpressionTri__Group_1__1__Impl" - // InternalExport.g:4920:1: rule__IfExpressionTri__Group_1__1__Impl : ( '?' ) ; - public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__JvmWildcardTypeReference__Alternatives_2" + // InternalExport.g:4761:1: rule__JvmWildcardTypeReference__Alternatives_2 : ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ); + public final void rule__JvmWildcardTypeReference__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4924:1: ( ( '?' ) ) - // InternalExport.g:4925:1: ( '?' ) - { - // InternalExport.g:4925:1: ( '?' ) - // InternalExport.g:4926:2: '?' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); + // InternalExport.g:4765:1: ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ) + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==60) ) { + alt57=1; } - match(input,61,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); + else if ( (LA57_0==64) ) { + alt57=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 57, 0, input); + throw nvae; } + switch (alt57) { + case 1 : + // InternalExport.g:4766:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) + { + // InternalExport.g:4766:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) + // InternalExport.g:4767:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); + } + // InternalExport.g:4768:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) + // InternalExport.g:4768:4: rule__JvmWildcardTypeReference__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__0(); + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4772:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) + { + // InternalExport.g:4772:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) + // InternalExport.g:4773:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); + } + // InternalExport.g:4774:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) + // InternalExport.g:4774:4: rule__JvmWildcardTypeReference__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16739,32 +17812,109 @@ public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__1__Impl" + // $ANTLR end "rule__JvmWildcardTypeReference__Alternatives_2" - // $ANTLR start "rule__IfExpressionTri__Group_1__2" - // InternalExport.g:4935:1: rule__IfExpressionTri__Group_1__2 : rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ; - public final void rule__IfExpressionTri__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__XImportDeclaration__Alternatives_1" + // InternalExport.g:4782:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ); + public final void rule__XImportDeclaration__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4939:1: ( rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ) - // InternalExport.g:4940:2: rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 - { - pushFollow(FOLLOW_39); - rule__IfExpressionTri__Group_1__2__Impl(); + // InternalExport.g:4786:1: ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ) + int alt58=3; + alt58 = dfa58.predict(input); + switch (alt58) { + case 1 : + // InternalExport.g:4787:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) + { + // InternalExport.g:4787:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) + // InternalExport.g:4788:3: ( rule__XImportDeclaration__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); + } + // InternalExport.g:4789:3: ( rule__XImportDeclaration__Group_1_0__0 ) + // InternalExport.g:4789:4: rule__XImportDeclaration__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__3(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4793:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) + { + // InternalExport.g:4793:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) + // InternalExport.g:4794:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); + } + // InternalExport.g:4795:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) + // InternalExport.g:4795:4: rule__XImportDeclaration__ImportedTypeAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedTypeAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); + } + + } + + } + break; + case 3 : + // InternalExport.g:4799:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) + { + // InternalExport.g:4799:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) + // InternalExport.g:4800:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); + } + // InternalExport.g:4801:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) + // InternalExport.g:4801:4: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedNamespaceAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16777,45 +17927,94 @@ public final void rule__IfExpressionTri__Group_1__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__2" + // $ANTLR end "rule__XImportDeclaration__Alternatives_1" - // $ANTLR start "rule__IfExpressionTri__Group_1__2__Impl" - // InternalExport.g:4947:1: rule__IfExpressionTri__Group_1__2__Impl : ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ; - public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XImportDeclaration__Alternatives_1_0_3" + // InternalExport.g:4809:1: rule__XImportDeclaration__Alternatives_1_0_3 : ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ); + public final void rule__XImportDeclaration__Alternatives_1_0_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4951:1: ( ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ) - // InternalExport.g:4952:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) - { - // InternalExport.g:4952:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) - // InternalExport.g:4953:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); - } - // InternalExport.g:4954:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) - // InternalExport.g:4954:3: rule__IfExpressionTri__ThenPartAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__ThenPartAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:4813:1: ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ) + int alt59=2; + int LA59_0 = input.LA(1); + if ( (LA59_0==25) ) { + alt59=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); + else if ( (LA59_0==RULE_ID) ) { + alt59=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 59, 0, input); + throw nvae; } + switch (alt59) { + case 1 : + // InternalExport.g:4814:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) + { + // InternalExport.g:4814:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) + // InternalExport.g:4815:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); + } + // InternalExport.g:4816:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) + // InternalExport.g:4816:4: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__WildcardAssignment_1_0_3_0(); + + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); + } + + } + + + } + break; + case 2 : + // InternalExport.g:4820:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) + { + // InternalExport.g:4820:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) + // InternalExport.g:4821:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); + } + // InternalExport.g:4822:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) + // InternalExport.g:4822:4: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__MemberNameAssignment_1_0_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16828,26 +18027,26 @@ public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__2__Impl" + // $ANTLR end "rule__XImportDeclaration__Alternatives_1_0_3" - // $ANTLR start "rule__IfExpressionTri__Group_1__3" - // InternalExport.g:4962:1: rule__IfExpressionTri__Group_1__3 : rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ; - public final void rule__IfExpressionTri__Group_1__3() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__0" + // InternalExport.g:4830:1: rule__ExportModel__Group__0 : rule__ExportModel__Group__0__Impl rule__ExportModel__Group__1 ; + public final void rule__ExportModel__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4966:1: ( rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ) - // InternalExport.g:4967:2: rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 + // InternalExport.g:4834:1: ( rule__ExportModel__Group__0__Impl rule__ExportModel__Group__1 ) + // InternalExport.g:4835:2: rule__ExportModel__Group__0__Impl rule__ExportModel__Group__1 { - pushFollow(FOLLOW_18); - rule__IfExpressionTri__Group_1__3__Impl(); + pushFollow(FOLLOW_4); + rule__ExportModel__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__4(); + rule__ExportModel__Group__1(); state._fsp--; if (state.failed) return ; @@ -16866,28 +18065,49 @@ public final void rule__IfExpressionTri__Group_1__3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__3" + // $ANTLR end "rule__ExportModel__Group__0" - // $ANTLR start "rule__IfExpressionTri__Group_1__3__Impl" - // InternalExport.g:4974:1: rule__IfExpressionTri__Group_1__3__Impl : ( ':' ) ; - public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__0__Impl" + // InternalExport.g:4842:1: rule__ExportModel__Group__0__Impl : ( ( rule__ExportModel__Group_0__0 )? ) ; + public final void rule__ExportModel__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4978:1: ( ( ':' ) ) - // InternalExport.g:4979:1: ( ':' ) + // InternalExport.g:4846:1: ( ( ( rule__ExportModel__Group_0__0 )? ) ) + // InternalExport.g:4847:1: ( ( rule__ExportModel__Group_0__0 )? ) { - // InternalExport.g:4979:1: ( ':' ) - // InternalExport.g:4980:2: ':' + // InternalExport.g:4847:1: ( ( rule__ExportModel__Group_0__0 )? ) + // InternalExport.g:4848:2: ( rule__ExportModel__Group_0__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); + before(grammarAccess.getExportModelAccess().getGroup_0()); } - match(input,59,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:4849:2: ( rule__ExportModel__Group_0__0 )? + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==65) ) { + alt60=1; + } + switch (alt60) { + case 1 : + // InternalExport.g:4849:3: rule__ExportModel__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__ExportModel__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); + after(grammarAccess.getExportModelAccess().getGroup_0()); } } @@ -16907,21 +18127,26 @@ public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__3__Impl" + // $ANTLR end "rule__ExportModel__Group__0__Impl" - // $ANTLR start "rule__IfExpressionTri__Group_1__4" - // InternalExport.g:4989:1: rule__IfExpressionTri__Group_1__4 : rule__IfExpressionTri__Group_1__4__Impl ; - public final void rule__IfExpressionTri__Group_1__4() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__1" + // InternalExport.g:4857:1: rule__ExportModel__Group__1 : rule__ExportModel__Group__1__Impl rule__ExportModel__Group__2 ; + public final void rule__ExportModel__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:4993:1: ( rule__IfExpressionTri__Group_1__4__Impl ) - // InternalExport.g:4994:2: rule__IfExpressionTri__Group_1__4__Impl + // InternalExport.g:4861:1: ( rule__ExportModel__Group__1__Impl rule__ExportModel__Group__2 ) + // InternalExport.g:4862:2: rule__ExportModel__Group__1__Impl rule__ExportModel__Group__2 { + pushFollow(FOLLOW_5); + rule__ExportModel__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__4__Impl(); + rule__ExportModel__Group__2(); state._fsp--; if (state.failed) return ; @@ -16940,30 +18165,33 @@ public final void rule__IfExpressionTri__Group_1__4() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__4" + // $ANTLR end "rule__ExportModel__Group__1" - // $ANTLR start "rule__IfExpressionTri__Group_1__4__Impl" - // InternalExport.g:5000:1: rule__IfExpressionTri__Group_1__4__Impl : ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ; - public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__1__Impl" + // InternalExport.g:4869:1: rule__ExportModel__Group__1__Impl : ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) ; + public final void rule__ExportModel__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5004:1: ( ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ) - // InternalExport.g:5005:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) + // InternalExport.g:4873:1: ( ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) ) + // InternalExport.g:4874:1: ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) { - // InternalExport.g:5005:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) - // InternalExport.g:5006:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) + // InternalExport.g:4874:1: ( ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) ) + // InternalExport.g:4875:2: ( ( rule__ExportModel__ImportsAssignment_1 ) ) ( ( rule__ExportModel__ImportsAssignment_1 )* ) + { + // InternalExport.g:4875:2: ( ( rule__ExportModel__ImportsAssignment_1 ) ) + // InternalExport.g:4876:3: ( rule__ExportModel__ImportsAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } - // InternalExport.g:5007:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) - // InternalExport.g:5007:3: rule__IfExpressionTri__ElsePartAssignment_1_4 + // InternalExport.g:4877:3: ( rule__ExportModel__ImportsAssignment_1 ) + // InternalExport.g:4877:4: rule__ExportModel__ImportsAssignment_1 { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__ElsePartAssignment_1_4(); + pushFollow(FOLLOW_6); + rule__ExportModel__ImportsAssignment_1(); state._fsp--; if (state.failed) return ; @@ -16971,12 +18199,56 @@ public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); } } - + // InternalExport.g:4880:2: ( ( rule__ExportModel__ImportsAssignment_1 )* ) + // InternalExport.g:4881:3: ( rule__ExportModel__ImportsAssignment_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getImportsAssignment_1()); + } + // InternalExport.g:4882:3: ( rule__ExportModel__ImportsAssignment_1 )* + loop61: + do { + int alt61=2; + int LA61_0 = input.LA(1); + + if ( (LA61_0==62) ) { + alt61=1; + } + + + switch (alt61) { + case 1 : + // InternalExport.g:4882:4: rule__ExportModel__ImportsAssignment_1 + { + pushFollow(FOLLOW_6); + rule__ExportModel__ImportsAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop61; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getImportsAssignment_1()); + } + + } + + + } + + } } @@ -16991,26 +18263,26 @@ public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__4__Impl" + // $ANTLR end "rule__ExportModel__Group__1__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__0" - // InternalExport.g:5016:1: rule__IfExpressionKw__Group__0 : rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ; - public final void rule__IfExpressionKw__Group__0() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__2" + // InternalExport.g:4891:1: rule__ExportModel__Group__2 : rule__ExportModel__Group__2__Impl rule__ExportModel__Group__3 ; + public final void rule__ExportModel__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5020:1: ( rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ) - // InternalExport.g:5021:2: rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 + // InternalExport.g:4895:1: ( rule__ExportModel__Group__2__Impl rule__ExportModel__Group__3 ) + // InternalExport.g:4896:2: rule__ExportModel__Group__2__Impl rule__ExportModel__Group__3 { - pushFollow(FOLLOW_18); - rule__IfExpressionKw__Group__0__Impl(); + pushFollow(FOLLOW_5); + rule__ExportModel__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__1(); + rule__ExportModel__Group__3(); state._fsp--; if (state.failed) return ; @@ -17029,28 +18301,56 @@ public final void rule__IfExpressionKw__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__0" + // $ANTLR end "rule__ExportModel__Group__2" - // $ANTLR start "rule__IfExpressionKw__Group__0__Impl" - // InternalExport.g:5028:1: rule__IfExpressionKw__Group__0__Impl : ( 'if' ) ; - public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__2__Impl" + // InternalExport.g:4903:1: rule__ExportModel__Group__2__Impl : ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) ; + public final void rule__ExportModel__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5032:1: ( ( 'if' ) ) - // InternalExport.g:5033:1: ( 'if' ) + // InternalExport.g:4907:1: ( ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) ) + // InternalExport.g:4908:1: ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) { - // InternalExport.g:5033:1: ( 'if' ) - // InternalExport.g:5034:2: 'if' + // InternalExport.g:4908:1: ( ( rule__ExportModel__ExtensionsAssignment_2 )* ) + // InternalExport.g:4909:2: ( rule__ExportModel__ExtensionsAssignment_2 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + before(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); } - match(input,62,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:4910:2: ( rule__ExportModel__ExtensionsAssignment_2 )* + loop62: + do { + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==63) ) { + alt62=1; + } + + + switch (alt62) { + case 1 : + // InternalExport.g:4910:3: rule__ExportModel__ExtensionsAssignment_2 + { + pushFollow(FOLLOW_7); + rule__ExportModel__ExtensionsAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop62; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + after(grammarAccess.getExportModelAccess().getExtensionsAssignment_2()); } } @@ -17070,26 +18370,26 @@ public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__0__Impl" + // $ANTLR end "rule__ExportModel__Group__2__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__1" - // InternalExport.g:5043:1: rule__IfExpressionKw__Group__1 : rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ; - public final void rule__IfExpressionKw__Group__1() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__3" + // InternalExport.g:4918:1: rule__ExportModel__Group__3 : rule__ExportModel__Group__3__Impl rule__ExportModel__Group__4 ; + public final void rule__ExportModel__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5047:1: ( rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ) - // InternalExport.g:5048:2: rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 + // InternalExport.g:4922:1: ( rule__ExportModel__Group__3__Impl rule__ExportModel__Group__4 ) + // InternalExport.g:4923:2: rule__ExportModel__Group__3__Impl rule__ExportModel__Group__4 { - pushFollow(FOLLOW_44); - rule__IfExpressionKw__Group__1__Impl(); + pushFollow(FOLLOW_5); + rule__ExportModel__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__2(); + rule__ExportModel__Group__4(); state._fsp--; if (state.failed) return ; @@ -17108,38 +18408,49 @@ public final void rule__IfExpressionKw__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__1" + // $ANTLR end "rule__ExportModel__Group__3" - // $ANTLR start "rule__IfExpressionKw__Group__1__Impl" - // InternalExport.g:5055:1: rule__IfExpressionKw__Group__1__Impl : ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ; - public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__3__Impl" + // InternalExport.g:4930:1: rule__ExportModel__Group__3__Impl : ( ( rule__ExportModel__Group_3__0 )? ) ; + public final void rule__ExportModel__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5059:1: ( ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ) - // InternalExport.g:5060:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) + // InternalExport.g:4934:1: ( ( ( rule__ExportModel__Group_3__0 )? ) ) + // InternalExport.g:4935:1: ( ( rule__ExportModel__Group_3__0 )? ) { - // InternalExport.g:5060:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) - // InternalExport.g:5061:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) + // InternalExport.g:4935:1: ( ( rule__ExportModel__Group_3__0 )? ) + // InternalExport.g:4936:2: ( rule__ExportModel__Group_3__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); + before(grammarAccess.getExportModelAccess().getGroup_3()); } - // InternalExport.g:5062:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) - // InternalExport.g:5062:3: rule__IfExpressionKw__ConditionAssignment_1 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__ConditionAssignment_1(); + // InternalExport.g:4937:2: ( rule__ExportModel__Group_3__0 )? + int alt63=2; + int LA63_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA63_0==67) ) { + alt63=1; + } + switch (alt63) { + case 1 : + // InternalExport.g:4937:3: rule__ExportModel__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__ExportModel__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); + after(grammarAccess.getExportModelAccess().getGroup_3()); } } @@ -17159,26 +18470,21 @@ public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__1__Impl" + // $ANTLR end "rule__ExportModel__Group__3__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__2" - // InternalExport.g:5070:1: rule__IfExpressionKw__Group__2 : rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ; - public final void rule__IfExpressionKw__Group__2() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__4" + // InternalExport.g:4945:1: rule__ExportModel__Group__4 : rule__ExportModel__Group__4__Impl ; + public final void rule__ExportModel__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5074:1: ( rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ) - // InternalExport.g:5075:2: rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 + // InternalExport.g:4949:1: ( rule__ExportModel__Group__4__Impl ) + // InternalExport.g:4950:2: rule__ExportModel__Group__4__Impl { - pushFollow(FOLLOW_18); - rule__IfExpressionKw__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__3(); + rule__ExportModel__Group__4__Impl(); state._fsp--; if (state.failed) return ; @@ -17197,28 +18503,82 @@ public final void rule__IfExpressionKw__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__2" + // $ANTLR end "rule__ExportModel__Group__4" - // $ANTLR start "rule__IfExpressionKw__Group__2__Impl" - // InternalExport.g:5082:1: rule__IfExpressionKw__Group__2__Impl : ( 'then' ) ; - public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group__4__Impl" + // InternalExport.g:4956:1: rule__ExportModel__Group__4__Impl : ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) ; + public final void rule__ExportModel__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5086:1: ( ( 'then' ) ) - // InternalExport.g:5087:1: ( 'then' ) + // InternalExport.g:4960:1: ( ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) ) + // InternalExport.g:4961:1: ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) { - // InternalExport.g:5087:1: ( 'then' ) - // InternalExport.g:5088:2: 'then' + // InternalExport.g:4961:1: ( ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) ) + // InternalExport.g:4962:2: ( ( rule__ExportModel__ExportsAssignment_4 ) ) ( ( rule__ExportModel__ExportsAssignment_4 )* ) + { + // InternalExport.g:4962:2: ( ( rule__ExportModel__ExportsAssignment_4 ) ) + // InternalExport.g:4963:3: ( rule__ExportModel__ExportsAssignment_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); + before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } - match(input,63,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:4964:3: ( rule__ExportModel__ExportsAssignment_4 ) + // InternalExport.g:4964:4: rule__ExportModel__ExportsAssignment_4 + { + pushFollow(FOLLOW_8); + rule__ExportModel__ExportsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); + after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); + } + + } + + // InternalExport.g:4967:2: ( ( rule__ExportModel__ExportsAssignment_4 )* ) + // InternalExport.g:4968:3: ( rule__ExportModel__ExportsAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getExportsAssignment_4()); + } + // InternalExport.g:4969:3: ( rule__ExportModel__ExportsAssignment_4 )* + loop64: + do { + int alt64=2; + int LA64_0 = input.LA(1); + + if ( (LA64_0==65) ) { + alt64=1; + } + + + switch (alt64) { + case 1 : + // InternalExport.g:4969:4: rule__ExportModel__ExportsAssignment_4 + { + pushFollow(FOLLOW_8); + rule__ExportModel__ExportsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop64; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getExportsAssignment_4()); } } @@ -17226,6 +18586,9 @@ public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionExcep } + + } + } catch (RecognitionException re) { reportError(re); @@ -17238,26 +18601,26 @@ public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__2__Impl" + // $ANTLR end "rule__ExportModel__Group__4__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__3" - // InternalExport.g:5097:1: rule__IfExpressionKw__Group__3 : rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ; - public final void rule__IfExpressionKw__Group__3() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__0" + // InternalExport.g:4979:1: rule__ExportModel__Group_0__0 : rule__ExportModel__Group_0__0__Impl rule__ExportModel__Group_0__1 ; + public final void rule__ExportModel__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5101:1: ( rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ) - // InternalExport.g:5102:2: rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 + // InternalExport.g:4983:1: ( rule__ExportModel__Group_0__0__Impl rule__ExportModel__Group_0__1 ) + // InternalExport.g:4984:2: rule__ExportModel__Group_0__0__Impl rule__ExportModel__Group_0__1 { - pushFollow(FOLLOW_45); - rule__IfExpressionKw__Group__3__Impl(); + pushFollow(FOLLOW_9); + rule__ExportModel__Group_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__4(); + rule__ExportModel__Group_0__1(); state._fsp--; if (state.failed) return ; @@ -17276,38 +18639,28 @@ public final void rule__IfExpressionKw__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__3" + // $ANTLR end "rule__ExportModel__Group_0__0" - // $ANTLR start "rule__IfExpressionKw__Group__3__Impl" - // InternalExport.g:5109:1: rule__IfExpressionKw__Group__3__Impl : ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ; - public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__0__Impl" + // InternalExport.g:4991:1: rule__ExportModel__Group_0__0__Impl : ( 'export' ) ; + public final void rule__ExportModel__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5113:1: ( ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ) - // InternalExport.g:5114:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) + // InternalExport.g:4995:1: ( ( 'export' ) ) + // InternalExport.g:4996:1: ( 'export' ) { - // InternalExport.g:5114:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) - // InternalExport.g:5115:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) + // InternalExport.g:4996:1: ( 'export' ) + // InternalExport.g:4997:2: 'export' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); - } - // InternalExport.g:5116:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) - // InternalExport.g:5116:3: rule__IfExpressionKw__ThenPartAssignment_3 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__ThenPartAssignment_3(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); } - + match(input,65,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); + after(grammarAccess.getExportModelAccess().getExportKeyword_0_0()); } } @@ -17327,21 +18680,26 @@ public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__3__Impl" + // $ANTLR end "rule__ExportModel__Group_0__0__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__4" - // InternalExport.g:5124:1: rule__IfExpressionKw__Group__4 : rule__IfExpressionKw__Group__4__Impl ; - public final void rule__IfExpressionKw__Group__4() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__1" + // InternalExport.g:5006:1: rule__ExportModel__Group_0__1 : rule__ExportModel__Group_0__1__Impl rule__ExportModel__Group_0__2 ; + public final void rule__ExportModel__Group_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5128:1: ( rule__IfExpressionKw__Group__4__Impl ) - // InternalExport.g:5129:2: rule__IfExpressionKw__Group__4__Impl + // InternalExport.g:5010:1: ( rule__ExportModel__Group_0__1__Impl rule__ExportModel__Group_0__2 ) + // InternalExport.g:5011:2: rule__ExportModel__Group_0__1__Impl rule__ExportModel__Group_0__2 { + pushFollow(FOLLOW_9); + rule__ExportModel__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__4__Impl(); + rule__ExportModel__Group_0__2(); state._fsp--; if (state.failed) return ; @@ -17360,42 +18718,38 @@ public final void rule__IfExpressionKw__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__4" + // $ANTLR end "rule__ExportModel__Group_0__1" - // $ANTLR start "rule__IfExpressionKw__Group__4__Impl" - // InternalExport.g:5135:1: rule__IfExpressionKw__Group__4__Impl : ( ( rule__IfExpressionKw__Group_4__0 )? ) ; - public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__1__Impl" + // InternalExport.g:5018:1: rule__ExportModel__Group_0__1__Impl : ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) ; + public final void rule__ExportModel__Group_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5139:1: ( ( ( rule__IfExpressionKw__Group_4__0 )? ) ) - // InternalExport.g:5140:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) + // InternalExport.g:5022:1: ( ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) ) + // InternalExport.g:5023:1: ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) { - // InternalExport.g:5140:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) - // InternalExport.g:5141:2: ( rule__IfExpressionKw__Group_4__0 )? + // InternalExport.g:5023:1: ( ( rule__ExportModel__ExtensionAssignment_0_1 )? ) + // InternalExport.g:5024:2: ( rule__ExportModel__ExtensionAssignment_0_1 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); + before(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); } - // InternalExport.g:5142:2: ( rule__IfExpressionKw__Group_4__0 )? - int alt49=2; - int LA49_0 = input.LA(1); - - if ( (LA49_0==64) ) { - int LA49_1 = input.LA(2); + // InternalExport.g:5025:2: ( rule__ExportModel__ExtensionAssignment_0_1 )? + int alt65=2; + int LA65_0 = input.LA(1); - if ( (synpred80_InternalExport()) ) { - alt49=1; - } + if ( (LA65_0==63) ) { + alt65=1; } - switch (alt49) { + switch (alt65) { case 1 : - // InternalExport.g:5142:3: rule__IfExpressionKw__Group_4__0 + // InternalExport.g:5025:3: rule__ExportModel__ExtensionAssignment_0_1 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0(); + rule__ExportModel__ExtensionAssignment_0_1(); state._fsp--; if (state.failed) return ; @@ -17406,7 +18760,7 @@ public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); + after(grammarAccess.getExportModelAccess().getExtensionAssignment_0_1()); } } @@ -17426,21 +18780,26 @@ public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__4__Impl" + // $ANTLR end "rule__ExportModel__Group_0__1__Impl" - // $ANTLR start "rule__IfExpressionKw__Group_4__0" - // InternalExport.g:5151:1: rule__IfExpressionKw__Group_4__0 : rule__IfExpressionKw__Group_4__0__Impl ; - public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__2" + // InternalExport.g:5033:1: rule__ExportModel__Group_0__2 : rule__ExportModel__Group_0__2__Impl rule__ExportModel__Group_0__3 ; + public final void rule__ExportModel__Group_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5155:1: ( rule__IfExpressionKw__Group_4__0__Impl ) - // InternalExport.g:5156:2: rule__IfExpressionKw__Group_4__0__Impl + // InternalExport.g:5037:1: ( rule__ExportModel__Group_0__2__Impl rule__ExportModel__Group_0__3 ) + // InternalExport.g:5038:2: rule__ExportModel__Group_0__2__Impl rule__ExportModel__Group_0__3 { + pushFollow(FOLLOW_10); + rule__ExportModel__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0__Impl(); + rule__ExportModel__Group_0__3(); state._fsp--; if (state.failed) return ; @@ -17459,30 +18818,30 @@ public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4__0" + // $ANTLR end "rule__ExportModel__Group_0__2" - // $ANTLR start "rule__IfExpressionKw__Group_4__0__Impl" - // InternalExport.g:5162:1: rule__IfExpressionKw__Group_4__0__Impl : ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ; - public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__2__Impl" + // InternalExport.g:5045:1: rule__ExportModel__Group_0__2__Impl : ( ( rule__ExportModel__NameAssignment_0_2 ) ) ; + public final void rule__ExportModel__Group_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5166:1: ( ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ) - // InternalExport.g:5167:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) + // InternalExport.g:5049:1: ( ( ( rule__ExportModel__NameAssignment_0_2 ) ) ) + // InternalExport.g:5050:1: ( ( rule__ExportModel__NameAssignment_0_2 ) ) { - // InternalExport.g:5167:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) - // InternalExport.g:5168:2: ( rule__IfExpressionKw__Group_4_0__0 ) + // InternalExport.g:5050:1: ( ( rule__ExportModel__NameAssignment_0_2 ) ) + // InternalExport.g:5051:2: ( rule__ExportModel__NameAssignment_0_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + before(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); } - // InternalExport.g:5169:2: ( rule__IfExpressionKw__Group_4_0__0 ) - // InternalExport.g:5169:3: rule__IfExpressionKw__Group_4_0__0 + // InternalExport.g:5052:2: ( rule__ExportModel__NameAssignment_0_2 ) + // InternalExport.g:5052:3: rule__ExportModel__NameAssignment_0_2 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__0(); + rule__ExportModel__NameAssignment_0_2(); state._fsp--; if (state.failed) return ; @@ -17490,7 +18849,7 @@ public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + after(grammarAccess.getExportModelAccess().getNameAssignment_0_2()); } } @@ -17510,26 +18869,26 @@ public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4__0__Impl" + // $ANTLR end "rule__ExportModel__Group_0__2__Impl" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__0" - // InternalExport.g:5178:1: rule__IfExpressionKw__Group_4_0__0 : rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ; - public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__3" + // InternalExport.g:5060:1: rule__ExportModel__Group_0__3 : rule__ExportModel__Group_0__3__Impl rule__ExportModel__Group_0__4 ; + public final void rule__ExportModel__Group_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5182:1: ( rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ) - // InternalExport.g:5183:2: rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 + // InternalExport.g:5064:1: ( rule__ExportModel__Group_0__3__Impl rule__ExportModel__Group_0__4 ) + // InternalExport.g:5065:2: rule__ExportModel__Group_0__3__Impl rule__ExportModel__Group_0__4 { - pushFollow(FOLLOW_18); - rule__IfExpressionKw__Group_4_0__0__Impl(); + pushFollow(FOLLOW_11); + rule__ExportModel__Group_0__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__1(); + rule__ExportModel__Group_0__4(); state._fsp--; if (state.failed) return ; @@ -17548,28 +18907,28 @@ public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__0" + // $ANTLR end "rule__ExportModel__Group_0__3" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__0__Impl" - // InternalExport.g:5190:1: rule__IfExpressionKw__Group_4_0__0__Impl : ( 'else' ) ; - public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__3__Impl" + // InternalExport.g:5072:1: rule__ExportModel__Group_0__3__Impl : ( 'for' ) ; + public final void rule__ExportModel__Group_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5194:1: ( ( 'else' ) ) - // InternalExport.g:5195:1: ( 'else' ) + // InternalExport.g:5076:1: ( ( 'for' ) ) + // InternalExport.g:5077:1: ( 'for' ) { - // InternalExport.g:5195:1: ( 'else' ) - // InternalExport.g:5196:2: 'else' + // InternalExport.g:5077:1: ( 'for' ) + // InternalExport.g:5078:2: 'for' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); + before(grammarAccess.getExportModelAccess().getForKeyword_0_3()); } - match(input,64,FOLLOW_2); if (state.failed) return ; + match(input,66,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); + after(grammarAccess.getExportModelAccess().getForKeyword_0_3()); } } @@ -17589,21 +18948,21 @@ public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__0__Impl" + // $ANTLR end "rule__ExportModel__Group_0__3__Impl" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__1" - // InternalExport.g:5205:1: rule__IfExpressionKw__Group_4_0__1 : rule__IfExpressionKw__Group_4_0__1__Impl ; - public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__4" + // InternalExport.g:5087:1: rule__ExportModel__Group_0__4 : rule__ExportModel__Group_0__4__Impl ; + public final void rule__ExportModel__Group_0__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5209:1: ( rule__IfExpressionKw__Group_4_0__1__Impl ) - // InternalExport.g:5210:2: rule__IfExpressionKw__Group_4_0__1__Impl + // InternalExport.g:5091:1: ( rule__ExportModel__Group_0__4__Impl ) + // InternalExport.g:5092:2: rule__ExportModel__Group_0__4__Impl { pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__1__Impl(); + rule__ExportModel__Group_0__4__Impl(); state._fsp--; if (state.failed) return ; @@ -17622,30 +18981,30 @@ public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__1" + // $ANTLR end "rule__ExportModel__Group_0__4" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__1__Impl" - // InternalExport.g:5216:1: rule__IfExpressionKw__Group_4_0__1__Impl : ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ; - public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_0__4__Impl" + // InternalExport.g:5098:1: rule__ExportModel__Group_0__4__Impl : ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) ; + public final void rule__ExportModel__Group_0__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5220:1: ( ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ) - // InternalExport.g:5221:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) + // InternalExport.g:5102:1: ( ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) ) + // InternalExport.g:5103:1: ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) { - // InternalExport.g:5221:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) - // InternalExport.g:5222:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) + // InternalExport.g:5103:1: ( ( rule__ExportModel__TargetGrammarAssignment_0_4 ) ) + // InternalExport.g:5104:2: ( rule__ExportModel__TargetGrammarAssignment_0_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); + before(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); } - // InternalExport.g:5223:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) - // InternalExport.g:5223:3: rule__IfExpressionKw__ElsePartAssignment_4_0_1 + // InternalExport.g:5105:2: ( rule__ExportModel__TargetGrammarAssignment_0_4 ) + // InternalExport.g:5105:3: rule__ExportModel__TargetGrammarAssignment_0_4 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__ElsePartAssignment_4_0_1(); + rule__ExportModel__TargetGrammarAssignment_0_4(); state._fsp--; if (state.failed) return ; @@ -17653,7 +19012,7 @@ public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionE } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); + after(grammarAccess.getExportModelAccess().getTargetGrammarAssignment_0_4()); } } @@ -17673,26 +19032,26 @@ public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__1__Impl" + // $ANTLR end "rule__ExportModel__Group_0__4__Impl" - // $ANTLR start "rule__SwitchExpression__Group__0" - // InternalExport.g:5232:1: rule__SwitchExpression__Group__0 : rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ; - public final void rule__SwitchExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__0" + // InternalExport.g:5114:1: rule__ExportModel__Group_3__0 : rule__ExportModel__Group_3__0__Impl rule__ExportModel__Group_3__1 ; + public final void rule__ExportModel__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5236:1: ( rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ) - // InternalExport.g:5237:2: rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 + // InternalExport.g:5118:1: ( rule__ExportModel__Group_3__0__Impl rule__ExportModel__Group_3__1 ) + // InternalExport.g:5119:2: rule__ExportModel__Group_3__0__Impl rule__ExportModel__Group_3__1 { - pushFollow(FOLLOW_46); - rule__SwitchExpression__Group__0__Impl(); + pushFollow(FOLLOW_12); + rule__ExportModel__Group_3__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__1(); + rule__ExportModel__Group_3__1(); state._fsp--; if (state.failed) return ; @@ -17711,28 +19070,28 @@ public final void rule__SwitchExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__0" + // $ANTLR end "rule__ExportModel__Group_3__0" - // $ANTLR start "rule__SwitchExpression__Group__0__Impl" - // InternalExport.g:5244:1: rule__SwitchExpression__Group__0__Impl : ( 'switch' ) ; - public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__0__Impl" + // InternalExport.g:5126:1: rule__ExportModel__Group_3__0__Impl : ( 'interface' ) ; + public final void rule__ExportModel__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5248:1: ( ( 'switch' ) ) - // InternalExport.g:5249:1: ( 'switch' ) + // InternalExport.g:5130:1: ( ( 'interface' ) ) + // InternalExport.g:5131:1: ( 'interface' ) { - // InternalExport.g:5249:1: ( 'switch' ) - // InternalExport.g:5250:2: 'switch' + // InternalExport.g:5131:1: ( 'interface' ) + // InternalExport.g:5132:2: 'interface' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); + before(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } - match(input,65,FOLLOW_2); if (state.failed) return ; + match(input,67,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); + after(grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } } @@ -17752,26 +19111,26 @@ public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__0__Impl" + // $ANTLR end "rule__ExportModel__Group_3__0__Impl" - // $ANTLR start "rule__SwitchExpression__Group__1" - // InternalExport.g:5259:1: rule__SwitchExpression__Group__1 : rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ; - public final void rule__SwitchExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__1" + // InternalExport.g:5141:1: rule__ExportModel__Group_3__1 : rule__ExportModel__Group_3__1__Impl rule__ExportModel__Group_3__2 ; + public final void rule__ExportModel__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5263:1: ( rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ) - // InternalExport.g:5264:2: rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 + // InternalExport.g:5145:1: ( rule__ExportModel__Group_3__1__Impl rule__ExportModel__Group_3__2 ) + // InternalExport.g:5146:2: rule__ExportModel__Group_3__1__Impl rule__ExportModel__Group_3__2 { - pushFollow(FOLLOW_46); - rule__SwitchExpression__Group__1__Impl(); + pushFollow(FOLLOW_11); + rule__ExportModel__Group_3__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__2(); + rule__ExportModel__Group_3__2(); state._fsp--; if (state.failed) return ; @@ -17790,49 +19149,28 @@ public final void rule__SwitchExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__1" + // $ANTLR end "rule__ExportModel__Group_3__1" - // $ANTLR start "rule__SwitchExpression__Group__1__Impl" - // InternalExport.g:5271:1: rule__SwitchExpression__Group__1__Impl : ( ( rule__SwitchExpression__Group_1__0 )? ) ; - public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__1__Impl" + // InternalExport.g:5153:1: rule__ExportModel__Group_3__1__Impl : ( '{' ) ; + public final void rule__ExportModel__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5275:1: ( ( ( rule__SwitchExpression__Group_1__0 )? ) ) - // InternalExport.g:5276:1: ( ( rule__SwitchExpression__Group_1__0 )? ) + // InternalExport.g:5157:1: ( ( '{' ) ) + // InternalExport.g:5158:1: ( '{' ) { - // InternalExport.g:5276:1: ( ( rule__SwitchExpression__Group_1__0 )? ) - // InternalExport.g:5277:2: ( rule__SwitchExpression__Group_1__0 )? + // InternalExport.g:5158:1: ( '{' ) + // InternalExport.g:5159:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); - } - // InternalExport.g:5278:2: ( rule__SwitchExpression__Group_1__0 )? - int alt50=2; - int LA50_0 = input.LA(1); - - if ( (LA50_0==51) ) { - alt50=1; - } - switch (alt50) { - case 1 : - // InternalExport.g:5278:3: rule__SwitchExpression__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); } - + match(input,68,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); + after(grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); } } @@ -17852,26 +19190,26 @@ public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__1__Impl" + // $ANTLR end "rule__ExportModel__Group_3__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group__2" - // InternalExport.g:5286:1: rule__SwitchExpression__Group__2 : rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ; - public final void rule__SwitchExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__2" + // InternalExport.g:5168:1: rule__ExportModel__Group_3__2 : rule__ExportModel__Group_3__2__Impl rule__ExportModel__Group_3__3 ; + public final void rule__ExportModel__Group_3__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5290:1: ( rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ) - // InternalExport.g:5291:2: rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 + // InternalExport.g:5172:1: ( rule__ExportModel__Group_3__2__Impl rule__ExportModel__Group_3__3 ) + // InternalExport.g:5173:2: rule__ExportModel__Group_3__2__Impl rule__ExportModel__Group_3__3 { - pushFollow(FOLLOW_47); - rule__SwitchExpression__Group__2__Impl(); + pushFollow(FOLLOW_13); + rule__ExportModel__Group_3__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__3(); + rule__ExportModel__Group_3__3(); state._fsp--; if (state.failed) return ; @@ -17890,121 +19228,68 @@ public final void rule__SwitchExpression__Group__2() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__2" + // $ANTLR end "rule__ExportModel__Group_3__2" - // $ANTLR start "rule__SwitchExpression__Group__2__Impl" - // InternalExport.g:5298:1: rule__SwitchExpression__Group__2__Impl : ( '{' ) ; - public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__2__Impl" + // InternalExport.g:5180:1: rule__ExportModel__Group_3__2__Impl : ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) ; + public final void rule__ExportModel__Group_3__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5302:1: ( ( '{' ) ) - // InternalExport.g:5303:1: ( '{' ) + // InternalExport.g:5184:1: ( ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) ) + // InternalExport.g:5185:1: ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) { - // InternalExport.g:5303:1: ( '{' ) - // InternalExport.g:5304:2: '{' + // InternalExport.g:5185:1: ( ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) ) + // InternalExport.g:5186:2: ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) + { + // InternalExport.g:5186:2: ( ( rule__ExportModel__InterfacesAssignment_3_2 ) ) + // InternalExport.g:5187:3: ( rule__ExportModel__InterfacesAssignment_3_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); - } - match(input,39,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); - } - - } - - + before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__SwitchExpression__Group__2__Impl" - - - // $ANTLR start "rule__SwitchExpression__Group__3" - // InternalExport.g:5313:1: rule__SwitchExpression__Group__3 : rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ; - public final void rule__SwitchExpression__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalExport.g:5317:1: ( rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ) - // InternalExport.g:5318:2: rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 + // InternalExport.g:5188:3: ( rule__ExportModel__InterfacesAssignment_3_2 ) + // InternalExport.g:5188:4: rule__ExportModel__InterfacesAssignment_3_2 { - pushFollow(FOLLOW_47); - rule__SwitchExpression__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__4(); + pushFollow(FOLLOW_3); + rule__ExportModel__InterfacesAssignment_3_2(); state._fsp--; if (state.failed) return ; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__SwitchExpression__Group__3" - + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); + } - // $ANTLR start "rule__SwitchExpression__Group__3__Impl" - // InternalExport.g:5325:1: rule__SwitchExpression__Group__3__Impl : ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ; - public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExport.g:5329:1: ( ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ) - // InternalExport.g:5330:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) - { - // InternalExport.g:5330:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) - // InternalExport.g:5331:2: ( rule__SwitchExpression__CaseAssignment_3 )* + // InternalExport.g:5191:2: ( ( rule__ExportModel__InterfacesAssignment_3_2 )* ) + // InternalExport.g:5192:3: ( rule__ExportModel__InterfacesAssignment_3_2 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); + before(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); } - // InternalExport.g:5332:2: ( rule__SwitchExpression__CaseAssignment_3 )* - loop51: + // InternalExport.g:5193:3: ( rule__ExportModel__InterfacesAssignment_3_2 )* + loop66: do { - int alt51=2; - int LA51_0 = input.LA(1); + int alt66=2; + int LA66_0 = input.LA(1); - if ( (LA51_0==67) ) { - alt51=1; + if ( (LA66_0==RULE_ID) ) { + alt66=1; } - switch (alt51) { + switch (alt66) { case 1 : - // InternalExport.g:5332:3: rule__SwitchExpression__CaseAssignment_3 + // InternalExport.g:5193:4: rule__ExportModel__InterfacesAssignment_3_2 { - pushFollow(FOLLOW_48); - rule__SwitchExpression__CaseAssignment_3(); + pushFollow(FOLLOW_3); + rule__ExportModel__InterfacesAssignment_3_2(); state._fsp--; if (state.failed) return ; @@ -18013,14 +19298,17 @@ public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionExc break; default : - break loop51; + break loop66; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); + after(grammarAccess.getExportModelAccess().getInterfacesAssignment_3_2()); + } + } + } @@ -18038,26 +19326,21 @@ public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__3__Impl" + // $ANTLR end "rule__ExportModel__Group_3__2__Impl" - // $ANTLR start "rule__SwitchExpression__Group__4" - // InternalExport.g:5340:1: rule__SwitchExpression__Group__4 : rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ; - public final void rule__SwitchExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__3" + // InternalExport.g:5202:1: rule__ExportModel__Group_3__3 : rule__ExportModel__Group_3__3__Impl ; + public final void rule__ExportModel__Group_3__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5344:1: ( rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ) - // InternalExport.g:5345:2: rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 + // InternalExport.g:5206:1: ( rule__ExportModel__Group_3__3__Impl ) + // InternalExport.g:5207:2: rule__ExportModel__Group_3__3__Impl { - pushFollow(FOLLOW_39); - rule__SwitchExpression__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__5(); + rule__ExportModel__Group_3__3__Impl(); state._fsp--; if (state.failed) return ; @@ -18076,28 +19359,28 @@ public final void rule__SwitchExpression__Group__4() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__4" + // $ANTLR end "rule__ExportModel__Group_3__3" - // $ANTLR start "rule__SwitchExpression__Group__4__Impl" - // InternalExport.g:5352:1: rule__SwitchExpression__Group__4__Impl : ( 'default' ) ; - public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ExportModel__Group_3__3__Impl" + // InternalExport.g:5213:1: rule__ExportModel__Group_3__3__Impl : ( '}' ) ; + public final void rule__ExportModel__Group_3__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5356:1: ( ( 'default' ) ) - // InternalExport.g:5357:1: ( 'default' ) + // InternalExport.g:5217:1: ( ( '}' ) ) + // InternalExport.g:5218:1: ( '}' ) { - // InternalExport.g:5357:1: ( 'default' ) - // InternalExport.g:5358:2: 'default' + // InternalExport.g:5218:1: ( '}' ) + // InternalExport.g:5219:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); + before(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); } - match(input,66,FOLLOW_2); if (state.failed) return ; + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); + after(grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); } } @@ -18117,26 +19400,26 @@ public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__4__Impl" + // $ANTLR end "rule__ExportModel__Group_3__3__Impl" - // $ANTLR start "rule__SwitchExpression__Group__5" - // InternalExport.g:5367:1: rule__SwitchExpression__Group__5 : rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ; - public final void rule__SwitchExpression__Group__5() throws RecognitionException { + // $ANTLR start "rule__Import__Group__0" + // InternalExport.g:5229:1: rule__Import__Group__0 : rule__Import__Group__0__Impl rule__Import__Group__1 ; + public final void rule__Import__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5371:1: ( rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ) - // InternalExport.g:5372:2: rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 + // InternalExport.g:5233:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 ) + // InternalExport.g:5234:2: rule__Import__Group__0__Impl rule__Import__Group__1 { - pushFollow(FOLLOW_49); - rule__SwitchExpression__Group__5__Impl(); + pushFollow(FOLLOW_14); + rule__Import__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__6(); + rule__Import__Group__1(); state._fsp--; if (state.failed) return ; @@ -18155,28 +19438,28 @@ public final void rule__SwitchExpression__Group__5() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__5" - + // $ANTLR end "rule__Import__Group__0" - // $ANTLR start "rule__SwitchExpression__Group__5__Impl" - // InternalExport.g:5379:1: rule__SwitchExpression__Group__5__Impl : ( ':' ) ; - public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionException { + + // $ANTLR start "rule__Import__Group__0__Impl" + // InternalExport.g:5241:1: rule__Import__Group__0__Impl : ( 'import' ) ; + public final void rule__Import__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5383:1: ( ( ':' ) ) - // InternalExport.g:5384:1: ( ':' ) + // InternalExport.g:5245:1: ( ( 'import' ) ) + // InternalExport.g:5246:1: ( 'import' ) { - // InternalExport.g:5384:1: ( ':' ) - // InternalExport.g:5385:2: ':' + // InternalExport.g:5246:1: ( 'import' ) + // InternalExport.g:5247:2: 'import' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); + before(grammarAccess.getImportAccess().getImportKeyword_0()); } - match(input,59,FOLLOW_2); if (state.failed) return ; + match(input,62,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); + after(grammarAccess.getImportAccess().getImportKeyword_0()); } } @@ -18196,26 +19479,26 @@ public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__5__Impl" + // $ANTLR end "rule__Import__Group__0__Impl" - // $ANTLR start "rule__SwitchExpression__Group__6" - // InternalExport.g:5394:1: rule__SwitchExpression__Group__6 : rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ; - public final void rule__SwitchExpression__Group__6() throws RecognitionException { + // $ANTLR start "rule__Import__Group__1" + // InternalExport.g:5256:1: rule__Import__Group__1 : rule__Import__Group__1__Impl rule__Import__Group__2 ; + public final void rule__Import__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5398:1: ( rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ) - // InternalExport.g:5399:2: rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 + // InternalExport.g:5260:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 ) + // InternalExport.g:5261:2: rule__Import__Group__1__Impl rule__Import__Group__2 { - pushFollow(FOLLOW_12); - rule__SwitchExpression__Group__6__Impl(); + pushFollow(FOLLOW_15); + rule__Import__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__7(); + rule__Import__Group__2(); state._fsp--; if (state.failed) return ; @@ -18234,30 +19517,30 @@ public final void rule__SwitchExpression__Group__6() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__6" + // $ANTLR end "rule__Import__Group__1" - // $ANTLR start "rule__SwitchExpression__Group__6__Impl" - // InternalExport.g:5406:1: rule__SwitchExpression__Group__6__Impl : ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ; - public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group__1__Impl" + // InternalExport.g:5268:1: rule__Import__Group__1__Impl : ( ( rule__Import__PackageAssignment_1 ) ) ; + public final void rule__Import__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5410:1: ( ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ) - // InternalExport.g:5411:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) + // InternalExport.g:5272:1: ( ( ( rule__Import__PackageAssignment_1 ) ) ) + // InternalExport.g:5273:1: ( ( rule__Import__PackageAssignment_1 ) ) { - // InternalExport.g:5411:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) - // InternalExport.g:5412:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) + // InternalExport.g:5273:1: ( ( rule__Import__PackageAssignment_1 ) ) + // InternalExport.g:5274:2: ( rule__Import__PackageAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + before(grammarAccess.getImportAccess().getPackageAssignment_1()); } - // InternalExport.g:5413:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) - // InternalExport.g:5413:3: rule__SwitchExpression__DefaultExprAssignment_6 + // InternalExport.g:5275:2: ( rule__Import__PackageAssignment_1 ) + // InternalExport.g:5275:3: rule__Import__PackageAssignment_1 { pushFollow(FOLLOW_2); - rule__SwitchExpression__DefaultExprAssignment_6(); + rule__Import__PackageAssignment_1(); state._fsp--; if (state.failed) return ; @@ -18265,7 +19548,7 @@ public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + after(grammarAccess.getImportAccess().getPackageAssignment_1()); } } @@ -18285,21 +19568,21 @@ public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__6__Impl" + // $ANTLR end "rule__Import__Group__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group__7" - // InternalExport.g:5421:1: rule__SwitchExpression__Group__7 : rule__SwitchExpression__Group__7__Impl ; - public final void rule__SwitchExpression__Group__7() throws RecognitionException { + // $ANTLR start "rule__Import__Group__2" + // InternalExport.g:5283:1: rule__Import__Group__2 : rule__Import__Group__2__Impl ; + public final void rule__Import__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5425:1: ( rule__SwitchExpression__Group__7__Impl ) - // InternalExport.g:5426:2: rule__SwitchExpression__Group__7__Impl + // InternalExport.g:5287:1: ( rule__Import__Group__2__Impl ) + // InternalExport.g:5288:2: rule__Import__Group__2__Impl { pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__7__Impl(); + rule__Import__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -18318,28 +19601,49 @@ public final void rule__SwitchExpression__Group__7() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__7" + // $ANTLR end "rule__Import__Group__2" - // $ANTLR start "rule__SwitchExpression__Group__7__Impl" - // InternalExport.g:5432:1: rule__SwitchExpression__Group__7__Impl : ( '}' ) ; - public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group__2__Impl" + // InternalExport.g:5294:1: rule__Import__Group__2__Impl : ( ( rule__Import__Group_2__0 )? ) ; + public final void rule__Import__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5436:1: ( ( '}' ) ) - // InternalExport.g:5437:1: ( '}' ) + // InternalExport.g:5298:1: ( ( ( rule__Import__Group_2__0 )? ) ) + // InternalExport.g:5299:1: ( ( rule__Import__Group_2__0 )? ) { - // InternalExport.g:5437:1: ( '}' ) - // InternalExport.g:5438:2: '}' + // InternalExport.g:5299:1: ( ( rule__Import__Group_2__0 )? ) + // InternalExport.g:5300:2: ( rule__Import__Group_2__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getImportAccess().getGroup_2()); } - match(input,40,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:5301:2: ( rule__Import__Group_2__0 )? + int alt67=2; + int LA67_0 = input.LA(1); + + if ( (LA67_0==70) ) { + alt67=1; + } + switch (alt67) { + case 1 : + // InternalExport.g:5301:3: rule__Import__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__Import__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); + after(grammarAccess.getImportAccess().getGroup_2()); } } @@ -18359,26 +19663,26 @@ public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__7__Impl" + // $ANTLR end "rule__Import__Group__2__Impl" - // $ANTLR start "rule__SwitchExpression__Group_1__0" - // InternalExport.g:5448:1: rule__SwitchExpression__Group_1__0 : rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ; - public final void rule__SwitchExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__0" + // InternalExport.g:5310:1: rule__Import__Group_2__0 : rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ; + public final void rule__Import__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5452:1: ( rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ) - // InternalExport.g:5453:2: rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 + // InternalExport.g:5314:1: ( rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ) + // InternalExport.g:5315:2: rule__Import__Group_2__0__Impl rule__Import__Group_2__1 { - pushFollow(FOLLOW_49); - rule__SwitchExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_11); + rule__Import__Group_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__1(); + rule__Import__Group_2__1(); state._fsp--; if (state.failed) return ; @@ -18397,28 +19701,28 @@ public final void rule__SwitchExpression__Group_1__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__0" + // $ANTLR end "rule__Import__Group_2__0" - // $ANTLR start "rule__SwitchExpression__Group_1__0__Impl" - // InternalExport.g:5460:1: rule__SwitchExpression__Group_1__0__Impl : ( '(' ) ; - public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__0__Impl" + // InternalExport.g:5322:1: rule__Import__Group_2__0__Impl : ( 'as' ) ; + public final void rule__Import__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5464:1: ( ( '(' ) ) - // InternalExport.g:5465:1: ( '(' ) + // InternalExport.g:5326:1: ( ( 'as' ) ) + // InternalExport.g:5327:1: ( 'as' ) { - // InternalExport.g:5465:1: ( '(' ) - // InternalExport.g:5466:2: '(' + // InternalExport.g:5327:1: ( 'as' ) + // InternalExport.g:5328:2: 'as' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); + before(grammarAccess.getImportAccess().getAsKeyword_2_0()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + match(input,70,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); + after(grammarAccess.getImportAccess().getAsKeyword_2_0()); } } @@ -18438,26 +19742,21 @@ public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__0__Impl" + // $ANTLR end "rule__Import__Group_2__0__Impl" - // $ANTLR start "rule__SwitchExpression__Group_1__1" - // InternalExport.g:5475:1: rule__SwitchExpression__Group_1__1 : rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ; - public final void rule__SwitchExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__1" + // InternalExport.g:5337:1: rule__Import__Group_2__1 : rule__Import__Group_2__1__Impl ; + public final void rule__Import__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5479:1: ( rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ) - // InternalExport.g:5480:2: rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 + // InternalExport.g:5341:1: ( rule__Import__Group_2__1__Impl ) + // InternalExport.g:5342:2: rule__Import__Group_2__1__Impl { - pushFollow(FOLLOW_25); - rule__SwitchExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__2(); + rule__Import__Group_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -18476,30 +19775,30 @@ public final void rule__SwitchExpression__Group_1__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__1" + // $ANTLR end "rule__Import__Group_2__1" - // $ANTLR start "rule__SwitchExpression__Group_1__1__Impl" - // InternalExport.g:5487:1: rule__SwitchExpression__Group_1__1__Impl : ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ; - public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__1__Impl" + // InternalExport.g:5348:1: rule__Import__Group_2__1__Impl : ( ( rule__Import__NameAssignment_2_1 ) ) ; + public final void rule__Import__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5491:1: ( ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ) - // InternalExport.g:5492:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) + // InternalExport.g:5352:1: ( ( ( rule__Import__NameAssignment_2_1 ) ) ) + // InternalExport.g:5353:1: ( ( rule__Import__NameAssignment_2_1 ) ) { - // InternalExport.g:5492:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) - // InternalExport.g:5493:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) + // InternalExport.g:5353:1: ( ( rule__Import__NameAssignment_2_1 ) ) + // InternalExport.g:5354:2: ( rule__Import__NameAssignment_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); + before(grammarAccess.getImportAccess().getNameAssignment_2_1()); } - // InternalExport.g:5494:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) - // InternalExport.g:5494:3: rule__SwitchExpression__SwitchExprAssignment_1_1 + // InternalExport.g:5355:2: ( rule__Import__NameAssignment_2_1 ) + // InternalExport.g:5355:3: rule__Import__NameAssignment_2_1 { pushFollow(FOLLOW_2); - rule__SwitchExpression__SwitchExprAssignment_1_1(); + rule__Import__NameAssignment_2_1(); state._fsp--; if (state.failed) return ; @@ -18507,7 +19806,7 @@ public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionE } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); + after(grammarAccess.getImportAccess().getNameAssignment_2_1()); } } @@ -18527,21 +19826,26 @@ public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__1__Impl" + // $ANTLR end "rule__Import__Group_2__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group_1__2" - // InternalExport.g:5502:1: rule__SwitchExpression__Group_1__2 : rule__SwitchExpression__Group_1__2__Impl ; - public final void rule__SwitchExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__0" + // InternalExport.g:5364:1: rule__Extension__Group__0 : rule__Extension__Group__0__Impl rule__Extension__Group__1 ; + public final void rule__Extension__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5506:1: ( rule__SwitchExpression__Group_1__2__Impl ) - // InternalExport.g:5507:2: rule__SwitchExpression__Group_1__2__Impl + // InternalExport.g:5368:1: ( rule__Extension__Group__0__Impl rule__Extension__Group__1 ) + // InternalExport.g:5369:2: rule__Extension__Group__0__Impl rule__Extension__Group__1 { + pushFollow(FOLLOW_11); + rule__Extension__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__2__Impl(); + rule__Extension__Group__1(); state._fsp--; if (state.failed) return ; @@ -18560,28 +19864,28 @@ public final void rule__SwitchExpression__Group_1__2() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__2" + // $ANTLR end "rule__Extension__Group__0" - // $ANTLR start "rule__SwitchExpression__Group_1__2__Impl" - // InternalExport.g:5513:1: rule__SwitchExpression__Group_1__2__Impl : ( ')' ) ; - public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__0__Impl" + // InternalExport.g:5376:1: rule__Extension__Group__0__Impl : ( 'extension' ) ; + public final void rule__Extension__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5517:1: ( ( ')' ) ) - // InternalExport.g:5518:1: ( ')' ) + // InternalExport.g:5380:1: ( ( 'extension' ) ) + // InternalExport.g:5381:1: ( 'extension' ) { - // InternalExport.g:5518:1: ( ')' ) - // InternalExport.g:5519:2: ')' + // InternalExport.g:5381:1: ( 'extension' ) + // InternalExport.g:5382:2: 'extension' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); + before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,63,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); + after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } } @@ -18601,26 +19905,21 @@ public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__2__Impl" + // $ANTLR end "rule__Extension__Group__0__Impl" - // $ANTLR start "rule__Case__Group__0" - // InternalExport.g:5529:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; - public final void rule__Case__Group__0() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__1" + // InternalExport.g:5391:1: rule__Extension__Group__1 : rule__Extension__Group__1__Impl ; + public final void rule__Extension__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5533:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) - // InternalExport.g:5534:2: rule__Case__Group__0__Impl rule__Case__Group__1 + // InternalExport.g:5395:1: ( rule__Extension__Group__1__Impl ) + // InternalExport.g:5396:2: rule__Extension__Group__1__Impl { - pushFollow(FOLLOW_49); - rule__Case__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__1(); + rule__Extension__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -18639,28 +19938,38 @@ public final void rule__Case__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__0" + // $ANTLR end "rule__Extension__Group__1" - // $ANTLR start "rule__Case__Group__0__Impl" - // InternalExport.g:5541:1: rule__Case__Group__0__Impl : ( 'case' ) ; - public final void rule__Case__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__1__Impl" + // InternalExport.g:5402:1: rule__Extension__Group__1__Impl : ( ( rule__Extension__ExtensionAssignment_1 ) ) ; + public final void rule__Extension__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5545:1: ( ( 'case' ) ) - // InternalExport.g:5546:1: ( 'case' ) + // InternalExport.g:5406:1: ( ( ( rule__Extension__ExtensionAssignment_1 ) ) ) + // InternalExport.g:5407:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) { - // InternalExport.g:5546:1: ( 'case' ) - // InternalExport.g:5547:2: 'case' + // InternalExport.g:5407:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) + // InternalExport.g:5408:2: ( rule__Extension__ExtensionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getCaseKeyword_0()); + before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } - match(input,67,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:5409:2: ( rule__Extension__ExtensionAssignment_1 ) + // InternalExport.g:5409:3: rule__Extension__ExtensionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Extension__ExtensionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getCaseKeyword_0()); + after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } } @@ -18680,26 +19989,26 @@ public final void rule__Case__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__0__Impl" + // $ANTLR end "rule__Extension__Group__1__Impl" - // $ANTLR start "rule__Case__Group__1" - // InternalExport.g:5556:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; - public final void rule__Case__Group__1() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__0" + // InternalExport.g:5418:1: rule__Interface__Group__0 : rule__Interface__Group__0__Impl rule__Interface__Group__1 ; + public final void rule__Interface__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5560:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) - // InternalExport.g:5561:2: rule__Case__Group__1__Impl rule__Case__Group__2 + // InternalExport.g:5422:1: ( rule__Interface__Group__0__Impl rule__Interface__Group__1 ) + // InternalExport.g:5423:2: rule__Interface__Group__0__Impl rule__Interface__Group__1 { - pushFollow(FOLLOW_39); - rule__Case__Group__1__Impl(); + pushFollow(FOLLOW_16); + rule__Interface__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__2(); + rule__Interface__Group__1(); state._fsp--; if (state.failed) return ; @@ -18718,30 +20027,30 @@ public final void rule__Case__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__1" + // $ANTLR end "rule__Interface__Group__0" - // $ANTLR start "rule__Case__Group__1__Impl" - // InternalExport.g:5568:1: rule__Case__Group__1__Impl : ( ( rule__Case__ConditionAssignment_1 ) ) ; - public final void rule__Case__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__0__Impl" + // InternalExport.g:5430:1: rule__Interface__Group__0__Impl : ( ( rule__Interface__TypeAssignment_0 ) ) ; + public final void rule__Interface__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5572:1: ( ( ( rule__Case__ConditionAssignment_1 ) ) ) - // InternalExport.g:5573:1: ( ( rule__Case__ConditionAssignment_1 ) ) + // InternalExport.g:5434:1: ( ( ( rule__Interface__TypeAssignment_0 ) ) ) + // InternalExport.g:5435:1: ( ( rule__Interface__TypeAssignment_0 ) ) { - // InternalExport.g:5573:1: ( ( rule__Case__ConditionAssignment_1 ) ) - // InternalExport.g:5574:2: ( rule__Case__ConditionAssignment_1 ) + // InternalExport.g:5435:1: ( ( rule__Interface__TypeAssignment_0 ) ) + // InternalExport.g:5436:2: ( rule__Interface__TypeAssignment_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getConditionAssignment_1()); + before(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); } - // InternalExport.g:5575:2: ( rule__Case__ConditionAssignment_1 ) - // InternalExport.g:5575:3: rule__Case__ConditionAssignment_1 + // InternalExport.g:5437:2: ( rule__Interface__TypeAssignment_0 ) + // InternalExport.g:5437:3: rule__Interface__TypeAssignment_0 { pushFollow(FOLLOW_2); - rule__Case__ConditionAssignment_1(); + rule__Interface__TypeAssignment_0(); state._fsp--; if (state.failed) return ; @@ -18749,7 +20058,7 @@ public final void rule__Case__Group__1__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getConditionAssignment_1()); + after(grammarAccess.getInterfaceAccess().getTypeAssignment_0()); } } @@ -18769,26 +20078,26 @@ public final void rule__Case__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__1__Impl" + // $ANTLR end "rule__Interface__Group__0__Impl" - // $ANTLR start "rule__Case__Group__2" - // InternalExport.g:5583:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ; - public final void rule__Case__Group__2() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__1" + // InternalExport.g:5445:1: rule__Interface__Group__1 : rule__Interface__Group__1__Impl rule__Interface__Group__2 ; + public final void rule__Interface__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5587:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 ) - // InternalExport.g:5588:2: rule__Case__Group__2__Impl rule__Case__Group__3 + // InternalExport.g:5449:1: ( rule__Interface__Group__1__Impl rule__Interface__Group__2 ) + // InternalExport.g:5450:2: rule__Interface__Group__1__Impl rule__Interface__Group__2 { - pushFollow(FOLLOW_49); - rule__Case__Group__2__Impl(); + pushFollow(FOLLOW_16); + rule__Interface__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__3(); + rule__Interface__Group__2(); state._fsp--; if (state.failed) return ; @@ -18807,28 +20116,49 @@ public final void rule__Case__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__2" + // $ANTLR end "rule__Interface__Group__1" - // $ANTLR start "rule__Case__Group__2__Impl" - // InternalExport.g:5595:1: rule__Case__Group__2__Impl : ( ':' ) ; - public final void rule__Case__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__1__Impl" + // InternalExport.g:5457:1: rule__Interface__Group__1__Impl : ( ( rule__Interface__Group_1__0 )? ) ; + public final void rule__Interface__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5599:1: ( ( ':' ) ) - // InternalExport.g:5600:1: ( ':' ) + // InternalExport.g:5461:1: ( ( ( rule__Interface__Group_1__0 )? ) ) + // InternalExport.g:5462:1: ( ( rule__Interface__Group_1__0 )? ) { - // InternalExport.g:5600:1: ( ':' ) - // InternalExport.g:5601:2: ':' + // InternalExport.g:5462:1: ( ( rule__Interface__Group_1__0 )? ) + // InternalExport.g:5463:2: ( rule__Interface__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getColonKeyword_2()); + before(grammarAccess.getInterfaceAccess().getGroup_1()); + } + // InternalExport.g:5464:2: ( rule__Interface__Group_1__0 )? + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==72) ) { + alt68=1; + } + switch (alt68) { + case 1 : + // InternalExport.g:5464:3: rule__Interface__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__Interface__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } - match(input,59,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getColonKeyword_2()); + after(grammarAccess.getInterfaceAccess().getGroup_1()); } } @@ -18848,21 +20178,26 @@ public final void rule__Case__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__2__Impl" + // $ANTLR end "rule__Interface__Group__1__Impl" - // $ANTLR start "rule__Case__Group__3" - // InternalExport.g:5610:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ; - public final void rule__Case__Group__3() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__2" + // InternalExport.g:5472:1: rule__Interface__Group__2 : rule__Interface__Group__2__Impl rule__Interface__Group__3 ; + public final void rule__Interface__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5614:1: ( rule__Case__Group__3__Impl ) - // InternalExport.g:5615:2: rule__Case__Group__3__Impl + // InternalExport.g:5476:1: ( rule__Interface__Group__2__Impl rule__Interface__Group__3 ) + // InternalExport.g:5477:2: rule__Interface__Group__2__Impl rule__Interface__Group__3 { + pushFollow(FOLLOW_16); + rule__Interface__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__3__Impl(); + rule__Interface__Group__3(); state._fsp--; if (state.failed) return ; @@ -18881,38 +20216,56 @@ public final void rule__Case__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__3" + // $ANTLR end "rule__Interface__Group__2" - // $ANTLR start "rule__Case__Group__3__Impl" - // InternalExport.g:5621:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenParAssignment_3 ) ) ; - public final void rule__Case__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__2__Impl" + // InternalExport.g:5484:1: rule__Interface__Group__2__Impl : ( ( rule__Interface__Group_2__0 )* ) ; + public final void rule__Interface__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5625:1: ( ( ( rule__Case__ThenParAssignment_3 ) ) ) - // InternalExport.g:5626:1: ( ( rule__Case__ThenParAssignment_3 ) ) + // InternalExport.g:5488:1: ( ( ( rule__Interface__Group_2__0 )* ) ) + // InternalExport.g:5489:1: ( ( rule__Interface__Group_2__0 )* ) { - // InternalExport.g:5626:1: ( ( rule__Case__ThenParAssignment_3 ) ) - // InternalExport.g:5627:2: ( rule__Case__ThenParAssignment_3 ) + // InternalExport.g:5489:1: ( ( rule__Interface__Group_2__0 )* ) + // InternalExport.g:5490:2: ( rule__Interface__Group_2__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getThenParAssignment_3()); + before(grammarAccess.getInterfaceAccess().getGroup_2()); } - // InternalExport.g:5628:2: ( rule__Case__ThenParAssignment_3 ) - // InternalExport.g:5628:3: rule__Case__ThenParAssignment_3 - { - pushFollow(FOLLOW_2); - rule__Case__ThenParAssignment_3(); + // InternalExport.g:5491:2: ( rule__Interface__Group_2__0 )* + loop69: + do { + int alt69=2; + int LA69_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA69_0==14) ) { + alt69=1; + } - } + + switch (alt69) { + case 1 : + // InternalExport.g:5491:3: rule__Interface__Group_2__0 + { + pushFollow(FOLLOW_17); + rule__Interface__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop69; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getThenParAssignment_3()); + after(grammarAccess.getInterfaceAccess().getGroup_2()); } } @@ -18932,26 +20285,21 @@ public final void rule__Case__Group__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__3__Impl" + // $ANTLR end "rule__Interface__Group__2__Impl" - // $ANTLR start "rule__OrExpression__Group__0" - // InternalExport.g:5637:1: rule__OrExpression__Group__0 : rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ; - public final void rule__OrExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__3" + // InternalExport.g:5499:1: rule__Interface__Group__3 : rule__Interface__Group__3__Impl ; + public final void rule__Interface__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5641:1: ( rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ) - // InternalExport.g:5642:2: rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 + // InternalExport.g:5503:1: ( rule__Interface__Group__3__Impl ) + // InternalExport.g:5504:2: rule__Interface__Group__3__Impl { - pushFollow(FOLLOW_50); - rule__OrExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group__1(); + rule__Interface__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -18970,32 +20318,28 @@ public final void rule__OrExpression__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group__0" + // $ANTLR end "rule__Interface__Group__3" - // $ANTLR start "rule__OrExpression__Group__0__Impl" - // InternalExport.g:5649:1: rule__OrExpression__Group__0__Impl : ( ruleAndExpression ) ; - public final void rule__OrExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group__3__Impl" + // InternalExport.g:5510:1: rule__Interface__Group__3__Impl : ( ';' ) ; + public final void rule__Interface__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5653:1: ( ( ruleAndExpression ) ) - // InternalExport.g:5654:1: ( ruleAndExpression ) + // InternalExport.g:5514:1: ( ( ';' ) ) + // InternalExport.g:5515:1: ( ';' ) { - // InternalExport.g:5654:1: ( ruleAndExpression ) - // InternalExport.g:5655:2: ruleAndExpression + // InternalExport.g:5515:1: ( ';' ) + // InternalExport.g:5516:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); + before(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); } - pushFollow(FOLLOW_2); - ruleAndExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); + after(grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); } } @@ -19015,21 +20359,26 @@ public final void rule__OrExpression__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__OrExpression__Group__0__Impl" + // $ANTLR end "rule__Interface__Group__3__Impl" - // $ANTLR start "rule__OrExpression__Group__1" - // InternalExport.g:5664:1: rule__OrExpression__Group__1 : rule__OrExpression__Group__1__Impl ; - public final void rule__OrExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_1__0" + // InternalExport.g:5526:1: rule__Interface__Group_1__0 : rule__Interface__Group_1__0__Impl rule__Interface__Group_1__1 ; + public final void rule__Interface__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5668:1: ( rule__OrExpression__Group__1__Impl ) - // InternalExport.g:5669:2: rule__OrExpression__Group__1__Impl + // InternalExport.g:5530:1: ( rule__Interface__Group_1__0__Impl rule__Interface__Group_1__1 ) + // InternalExport.g:5531:2: rule__Interface__Group_1__0__Impl rule__Interface__Group_1__1 { + pushFollow(FOLLOW_18); + rule__Interface__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group__1__Impl(); + rule__Interface__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -19048,56 +20397,28 @@ public final void rule__OrExpression__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group__1" + // $ANTLR end "rule__Interface__Group_1__0" - // $ANTLR start "rule__OrExpression__Group__1__Impl" - // InternalExport.g:5675:1: rule__OrExpression__Group__1__Impl : ( ( rule__OrExpression__Group_1__0 )* ) ; - public final void rule__OrExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_1__0__Impl" + // InternalExport.g:5538:1: rule__Interface__Group_1__0__Impl : ( '[' ) ; + public final void rule__Interface__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5679:1: ( ( ( rule__OrExpression__Group_1__0 )* ) ) - // InternalExport.g:5680:1: ( ( rule__OrExpression__Group_1__0 )* ) + // InternalExport.g:5542:1: ( ( '[' ) ) + // InternalExport.g:5543:1: ( '[' ) { - // InternalExport.g:5680:1: ( ( rule__OrExpression__Group_1__0 )* ) - // InternalExport.g:5681:2: ( rule__OrExpression__Group_1__0 )* + // InternalExport.g:5543:1: ( '[' ) + // InternalExport.g:5544:2: '[' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getGroup_1()); + before(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); } - // InternalExport.g:5682:2: ( rule__OrExpression__Group_1__0 )* - loop52: - do { - int alt52=2; - int LA52_0 = input.LA(1); - - if ( (LA52_0==77) ) { - alt52=1; - } - - - switch (alt52) { - case 1 : - // InternalExport.g:5682:3: rule__OrExpression__Group_1__0 - { - pushFollow(FOLLOW_51); - rule__OrExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop52; - } - } while (true); - + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getGroup_1()); + after(grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); } } @@ -19117,26 +20438,26 @@ public final void rule__OrExpression__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__OrExpression__Group__1__Impl" + // $ANTLR end "rule__Interface__Group_1__0__Impl" - // $ANTLR start "rule__OrExpression__Group_1__0" - // InternalExport.g:5691:1: rule__OrExpression__Group_1__0 : rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ; - public final void rule__OrExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_1__1" + // InternalExport.g:5553:1: rule__Interface__Group_1__1 : rule__Interface__Group_1__1__Impl rule__Interface__Group_1__2 ; + public final void rule__Interface__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5695:1: ( rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ) - // InternalExport.g:5696:2: rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 + // InternalExport.g:5557:1: ( rule__Interface__Group_1__1__Impl rule__Interface__Group_1__2 ) + // InternalExport.g:5558:2: rule__Interface__Group_1__1__Impl rule__Interface__Group_1__2 { - pushFollow(FOLLOW_50); - rule__OrExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_19); + rule__Interface__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__1(); + rule__Interface__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -19155,32 +20476,38 @@ public final void rule__OrExpression__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group_1__0" + // $ANTLR end "rule__Interface__Group_1__1" - // $ANTLR start "rule__OrExpression__Group_1__0__Impl" - // InternalExport.g:5703:1: rule__OrExpression__Group_1__0__Impl : ( () ) ; - public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_1__1__Impl" + // InternalExport.g:5565:1: rule__Interface__Group_1__1__Impl : ( ( rule__Interface__GuardAssignment_1_1 ) ) ; + public final void rule__Interface__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5707:1: ( ( () ) ) - // InternalExport.g:5708:1: ( () ) + // InternalExport.g:5569:1: ( ( ( rule__Interface__GuardAssignment_1_1 ) ) ) + // InternalExport.g:5570:1: ( ( rule__Interface__GuardAssignment_1_1 ) ) { - // InternalExport.g:5708:1: ( () ) - // InternalExport.g:5709:2: () + // InternalExport.g:5570:1: ( ( rule__Interface__GuardAssignment_1_1 ) ) + // InternalExport.g:5571:2: ( rule__Interface__GuardAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); } - // InternalExport.g:5710:2: () - // InternalExport.g:5710:3: + // InternalExport.g:5572:2: ( rule__Interface__GuardAssignment_1_1 ) + // InternalExport.g:5572:3: rule__Interface__GuardAssignment_1_1 { + pushFollow(FOLLOW_2); + rule__Interface__GuardAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getInterfaceAccess().getGuardAssignment_1_1()); } } @@ -19189,6 +20516,10 @@ public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionExcep } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -19196,26 +20527,21 @@ public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__0__Impl" + // $ANTLR end "rule__Interface__Group_1__1__Impl" - // $ANTLR start "rule__OrExpression__Group_1__1" - // InternalExport.g:5718:1: rule__OrExpression__Group_1__1 : rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ; - public final void rule__OrExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_1__2" + // InternalExport.g:5580:1: rule__Interface__Group_1__2 : rule__Interface__Group_1__2__Impl ; + public final void rule__Interface__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5722:1: ( rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ) - // InternalExport.g:5723:2: rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 + // InternalExport.g:5584:1: ( rule__Interface__Group_1__2__Impl ) + // InternalExport.g:5585:2: rule__Interface__Group_1__2__Impl { - pushFollow(FOLLOW_49); - rule__OrExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__2(); + rule__Interface__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -19234,38 +20560,28 @@ public final void rule__OrExpression__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group_1__1" + // $ANTLR end "rule__Interface__Group_1__2" - // $ANTLR start "rule__OrExpression__Group_1__1__Impl" - // InternalExport.g:5730:1: rule__OrExpression__Group_1__1__Impl : ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_1__2__Impl" + // InternalExport.g:5591:1: rule__Interface__Group_1__2__Impl : ( ']' ) ; + public final void rule__Interface__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5734:1: ( ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ) - // InternalExport.g:5735:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:5595:1: ( ( ']' ) ) + // InternalExport.g:5596:1: ( ']' ) { - // InternalExport.g:5735:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) - // InternalExport.g:5736:2: ( rule__OrExpression__OperatorAssignment_1_1 ) + // InternalExport.g:5596:1: ( ']' ) + // InternalExport.g:5597:2: ']' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalExport.g:5737:2: ( rule__OrExpression__OperatorAssignment_1_1 ) - // InternalExport.g:5737:3: rule__OrExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__OrExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); } - + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); } } @@ -19285,21 +20601,26 @@ public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__1__Impl" + // $ANTLR end "rule__Interface__Group_1__2__Impl" - // $ANTLR start "rule__OrExpression__Group_1__2" - // InternalExport.g:5745:1: rule__OrExpression__Group_1__2 : rule__OrExpression__Group_1__2__Impl ; - public final void rule__OrExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2__0" + // InternalExport.g:5607:1: rule__Interface__Group_2__0 : rule__Interface__Group_2__0__Impl rule__Interface__Group_2__1 ; + public final void rule__Interface__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5749:1: ( rule__OrExpression__Group_1__2__Impl ) - // InternalExport.g:5750:2: rule__OrExpression__Group_1__2__Impl + // InternalExport.g:5611:1: ( rule__Interface__Group_2__0__Impl rule__Interface__Group_2__1 ) + // InternalExport.g:5612:2: rule__Interface__Group_2__0__Impl rule__Interface__Group_2__1 { + pushFollow(FOLLOW_20); + rule__Interface__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__2__Impl(); + rule__Interface__Group_2__1(); state._fsp--; if (state.failed) return ; @@ -19318,38 +20639,28 @@ public final void rule__OrExpression__Group_1__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group_1__2" + // $ANTLR end "rule__Interface__Group_2__0" - // $ANTLR start "rule__OrExpression__Group_1__2__Impl" - // InternalExport.g:5756:1: rule__OrExpression__Group_1__2__Impl : ( ( rule__OrExpression__RightAssignment_1_2 ) ) ; - public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2__0__Impl" + // InternalExport.g:5619:1: rule__Interface__Group_2__0__Impl : ( '=' ) ; + public final void rule__Interface__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5760:1: ( ( ( rule__OrExpression__RightAssignment_1_2 ) ) ) - // InternalExport.g:5761:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) + // InternalExport.g:5623:1: ( ( '=' ) ) + // InternalExport.g:5624:1: ( '=' ) { - // InternalExport.g:5761:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) - // InternalExport.g:5762:2: ( rule__OrExpression__RightAssignment_1_2 ) + // InternalExport.g:5624:1: ( '=' ) + // InternalExport.g:5625:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); - } - // InternalExport.g:5763:2: ( rule__OrExpression__RightAssignment_1_2 ) - // InternalExport.g:5763:3: rule__OrExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__OrExpression__RightAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); } - + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); } } @@ -19369,26 +20680,26 @@ public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__2__Impl" + // $ANTLR end "rule__Interface__Group_2__0__Impl" - // $ANTLR start "rule__AndExpression__Group__0" - // InternalExport.g:5772:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ; - public final void rule__AndExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2__1" + // InternalExport.g:5634:1: rule__Interface__Group_2__1 : rule__Interface__Group_2__1__Impl rule__Interface__Group_2__2 ; + public final void rule__Interface__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5776:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ) - // InternalExport.g:5777:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 + // InternalExport.g:5638:1: ( rule__Interface__Group_2__1__Impl rule__Interface__Group_2__2 ) + // InternalExport.g:5639:2: rule__Interface__Group_2__1__Impl rule__Interface__Group_2__2 { - pushFollow(FOLLOW_52); - rule__AndExpression__Group__0__Impl(); + pushFollow(FOLLOW_21); + rule__Interface__Group_2__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group__1(); + rule__Interface__Group_2__2(); state._fsp--; if (state.failed) return ; @@ -19407,32 +20718,38 @@ public final void rule__AndExpression__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AndExpression__Group__0" + // $ANTLR end "rule__Interface__Group_2__1" - // $ANTLR start "rule__AndExpression__Group__0__Impl" - // InternalExport.g:5784:1: rule__AndExpression__Group__0__Impl : ( ruleImpliesExpression ) ; - public final void rule__AndExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2__1__Impl" + // InternalExport.g:5646:1: rule__Interface__Group_2__1__Impl : ( ( rule__Interface__ItemsAssignment_2_1 ) ) ; + public final void rule__Interface__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5788:1: ( ( ruleImpliesExpression ) ) - // InternalExport.g:5789:1: ( ruleImpliesExpression ) + // InternalExport.g:5650:1: ( ( ( rule__Interface__ItemsAssignment_2_1 ) ) ) + // InternalExport.g:5651:1: ( ( rule__Interface__ItemsAssignment_2_1 ) ) { - // InternalExport.g:5789:1: ( ruleImpliesExpression ) - // InternalExport.g:5790:2: ruleImpliesExpression + // InternalExport.g:5651:1: ( ( rule__Interface__ItemsAssignment_2_1 ) ) + // InternalExport.g:5652:2: ( rule__Interface__ItemsAssignment_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); + before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); } + // InternalExport.g:5653:2: ( rule__Interface__ItemsAssignment_2_1 ) + // InternalExport.g:5653:3: rule__Interface__ItemsAssignment_2_1 + { pushFollow(FOLLOW_2); - ruleImpliesExpression(); + rule__Interface__ItemsAssignment_2_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); + after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_1()); } } @@ -19452,21 +20769,21 @@ public final void rule__AndExpression__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__AndExpression__Group__0__Impl" + // $ANTLR end "rule__Interface__Group_2__1__Impl" - // $ANTLR start "rule__AndExpression__Group__1" - // InternalExport.g:5799:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ; - public final void rule__AndExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2__2" + // InternalExport.g:5661:1: rule__Interface__Group_2__2 : rule__Interface__Group_2__2__Impl ; + public final void rule__Interface__Group_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5803:1: ( rule__AndExpression__Group__1__Impl ) - // InternalExport.g:5804:2: rule__AndExpression__Group__1__Impl + // InternalExport.g:5665:1: ( rule__Interface__Group_2__2__Impl ) + // InternalExport.g:5666:2: rule__Interface__Group_2__2__Impl { pushFollow(FOLLOW_2); - rule__AndExpression__Group__1__Impl(); + rule__Interface__Group_2__2__Impl(); state._fsp--; if (state.failed) return ; @@ -19485,42 +20802,42 @@ public final void rule__AndExpression__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__AndExpression__Group__1" + // $ANTLR end "rule__Interface__Group_2__2" - // $ANTLR start "rule__AndExpression__Group__1__Impl" - // InternalExport.g:5810:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ; - public final void rule__AndExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2__2__Impl" + // InternalExport.g:5672:1: rule__Interface__Group_2__2__Impl : ( ( rule__Interface__Group_2_2__0 )* ) ; + public final void rule__Interface__Group_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5814:1: ( ( ( rule__AndExpression__Group_1__0 )* ) ) - // InternalExport.g:5815:1: ( ( rule__AndExpression__Group_1__0 )* ) + // InternalExport.g:5676:1: ( ( ( rule__Interface__Group_2_2__0 )* ) ) + // InternalExport.g:5677:1: ( ( rule__Interface__Group_2_2__0 )* ) { - // InternalExport.g:5815:1: ( ( rule__AndExpression__Group_1__0 )* ) - // InternalExport.g:5816:2: ( rule__AndExpression__Group_1__0 )* + // InternalExport.g:5677:1: ( ( rule__Interface__Group_2_2__0 )* ) + // InternalExport.g:5678:2: ( rule__Interface__Group_2_2__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getGroup_1()); + before(grammarAccess.getInterfaceAccess().getGroup_2_2()); } - // InternalExport.g:5817:2: ( rule__AndExpression__Group_1__0 )* - loop53: + // InternalExport.g:5679:2: ( rule__Interface__Group_2_2__0 )* + loop70: do { - int alt53=2; - int LA53_0 = input.LA(1); + int alt70=2; + int LA70_0 = input.LA(1); - if ( (LA53_0==78) ) { - alt53=1; + if ( (LA70_0==74) ) { + alt70=1; } - switch (alt53) { + switch (alt70) { case 1 : - // InternalExport.g:5817:3: rule__AndExpression__Group_1__0 + // InternalExport.g:5679:3: rule__Interface__Group_2_2__0 { - pushFollow(FOLLOW_53); - rule__AndExpression__Group_1__0(); + pushFollow(FOLLOW_22); + rule__Interface__Group_2_2__0(); state._fsp--; if (state.failed) return ; @@ -19529,12 +20846,12 @@ public final void rule__AndExpression__Group__1__Impl() throws RecognitionExcept break; default : - break loop53; + break loop70; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getGroup_1()); + after(grammarAccess.getInterfaceAccess().getGroup_2_2()); } } @@ -19554,26 +20871,26 @@ public final void rule__AndExpression__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__AndExpression__Group__1__Impl" + // $ANTLR end "rule__Interface__Group_2__2__Impl" - // $ANTLR start "rule__AndExpression__Group_1__0" - // InternalExport.g:5826:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ; - public final void rule__AndExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2_2__0" + // InternalExport.g:5688:1: rule__Interface__Group_2_2__0 : rule__Interface__Group_2_2__0__Impl rule__Interface__Group_2_2__1 ; + public final void rule__Interface__Group_2_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5830:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ) - // InternalExport.g:5831:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 + // InternalExport.g:5692:1: ( rule__Interface__Group_2_2__0__Impl rule__Interface__Group_2_2__1 ) + // InternalExport.g:5693:2: rule__Interface__Group_2_2__0__Impl rule__Interface__Group_2_2__1 { - pushFollow(FOLLOW_52); - rule__AndExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_20); + rule__Interface__Group_2_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__1(); + rule__Interface__Group_2_2__1(); state._fsp--; if (state.failed) return ; @@ -19592,32 +20909,28 @@ public final void rule__AndExpression__Group_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__AndExpression__Group_1__0" + // $ANTLR end "rule__Interface__Group_2_2__0" - // $ANTLR start "rule__AndExpression__Group_1__0__Impl" - // InternalExport.g:5838:1: rule__AndExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2_2__0__Impl" + // InternalExport.g:5700:1: rule__Interface__Group_2_2__0__Impl : ( ',' ) ; + public final void rule__Interface__Group_2_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5842:1: ( ( () ) ) - // InternalExport.g:5843:1: ( () ) + // InternalExport.g:5704:1: ( ( ',' ) ) + // InternalExport.g:5705:1: ( ',' ) { - // InternalExport.g:5843:1: ( () ) - // InternalExport.g:5844:2: () + // InternalExport.g:5705:1: ( ',' ) + // InternalExport.g:5706:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); - } - // InternalExport.g:5845:2: () - // InternalExport.g:5845:3: - { + before(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); } - + match(input,74,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); } } @@ -19626,6 +20939,10 @@ public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionExce } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -19633,26 +20950,21 @@ public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__0__Impl" + // $ANTLR end "rule__Interface__Group_2_2__0__Impl" - // $ANTLR start "rule__AndExpression__Group_1__1" - // InternalExport.g:5853:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ; - public final void rule__AndExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2_2__1" + // InternalExport.g:5715:1: rule__Interface__Group_2_2__1 : rule__Interface__Group_2_2__1__Impl ; + public final void rule__Interface__Group_2_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5857:1: ( rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ) - // InternalExport.g:5858:2: rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 + // InternalExport.g:5719:1: ( rule__Interface__Group_2_2__1__Impl ) + // InternalExport.g:5720:2: rule__Interface__Group_2_2__1__Impl { - pushFollow(FOLLOW_49); - rule__AndExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__2(); + rule__Interface__Group_2_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -19671,30 +20983,30 @@ public final void rule__AndExpression__Group_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__AndExpression__Group_1__1" + // $ANTLR end "rule__Interface__Group_2_2__1" - // $ANTLR start "rule__AndExpression__Group_1__1__Impl" - // InternalExport.g:5865:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Interface__Group_2_2__1__Impl" + // InternalExport.g:5726:1: rule__Interface__Group_2_2__1__Impl : ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) ; + public final void rule__Interface__Group_2_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5869:1: ( ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ) - // InternalExport.g:5870:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:5730:1: ( ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) ) + // InternalExport.g:5731:1: ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) { - // InternalExport.g:5870:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) - // InternalExport.g:5871:2: ( rule__AndExpression__OperatorAssignment_1_1 ) + // InternalExport.g:5731:1: ( ( rule__Interface__ItemsAssignment_2_2_1 ) ) + // InternalExport.g:5732:2: ( rule__Interface__ItemsAssignment_2_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); } - // InternalExport.g:5872:2: ( rule__AndExpression__OperatorAssignment_1_1 ) - // InternalExport.g:5872:3: rule__AndExpression__OperatorAssignment_1_1 + // InternalExport.g:5733:2: ( rule__Interface__ItemsAssignment_2_2_1 ) + // InternalExport.g:5733:3: rule__Interface__ItemsAssignment_2_2_1 { pushFollow(FOLLOW_2); - rule__AndExpression__OperatorAssignment_1_1(); + rule__Interface__ItemsAssignment_2_2_1(); state._fsp--; if (state.failed) return ; @@ -19702,7 +21014,7 @@ public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getInterfaceAccess().getItemsAssignment_2_2_1()); } } @@ -19722,21 +21034,26 @@ public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__1__Impl" + // $ANTLR end "rule__Interface__Group_2_2__1__Impl" - // $ANTLR start "rule__AndExpression__Group_1__2" - // InternalExport.g:5880:1: rule__AndExpression__Group_1__2 : rule__AndExpression__Group_1__2__Impl ; - public final void rule__AndExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__InterfaceField__Group__0" + // InternalExport.g:5742:1: rule__InterfaceField__Group__0 : rule__InterfaceField__Group__0__Impl rule__InterfaceField__Group__1 ; + public final void rule__InterfaceField__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5884:1: ( rule__AndExpression__Group_1__2__Impl ) - // InternalExport.g:5885:2: rule__AndExpression__Group_1__2__Impl + // InternalExport.g:5746:1: ( rule__InterfaceField__Group__0__Impl rule__InterfaceField__Group__1 ) + // InternalExport.g:5747:2: rule__InterfaceField__Group__0__Impl rule__InterfaceField__Group__1 { + pushFollow(FOLLOW_23); + rule__InterfaceField__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__2__Impl(); + rule__InterfaceField__Group__1(); state._fsp--; if (state.failed) return ; @@ -19755,38 +21072,49 @@ public final void rule__AndExpression__Group_1__2() throws RecognitionException } return ; } - // $ANTLR end "rule__AndExpression__Group_1__2" + // $ANTLR end "rule__InterfaceField__Group__0" - // $ANTLR start "rule__AndExpression__Group_1__2__Impl" - // InternalExport.g:5891:1: rule__AndExpression__Group_1__2__Impl : ( ( rule__AndExpression__RightAssignment_1_2 ) ) ; - public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceField__Group__0__Impl" + // InternalExport.g:5754:1: rule__InterfaceField__Group__0__Impl : ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) ; + public final void rule__InterfaceField__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5895:1: ( ( ( rule__AndExpression__RightAssignment_1_2 ) ) ) - // InternalExport.g:5896:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) + // InternalExport.g:5758:1: ( ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) ) + // InternalExport.g:5759:1: ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) { - // InternalExport.g:5896:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) - // InternalExport.g:5897:2: ( rule__AndExpression__RightAssignment_1_2 ) + // InternalExport.g:5759:1: ( ( rule__InterfaceField__UnorderedAssignment_0 )? ) + // InternalExport.g:5760:2: ( rule__InterfaceField__UnorderedAssignment_0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); } - // InternalExport.g:5898:2: ( rule__AndExpression__RightAssignment_1_2 ) - // InternalExport.g:5898:3: rule__AndExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__AndExpression__RightAssignment_1_2(); + // InternalExport.g:5761:2: ( rule__InterfaceField__UnorderedAssignment_0 )? + int alt71=2; + int LA71_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA71_0==23) ) { + alt71=1; + } + switch (alt71) { + case 1 : + // InternalExport.g:5761:3: rule__InterfaceField__UnorderedAssignment_0 + { + pushFollow(FOLLOW_2); + rule__InterfaceField__UnorderedAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getInterfaceFieldAccess().getUnorderedAssignment_0()); } } @@ -19806,26 +21134,21 @@ public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__2__Impl" + // $ANTLR end "rule__InterfaceField__Group__0__Impl" - // $ANTLR start "rule__ImpliesExpression__Group__0" - // InternalExport.g:5907:1: rule__ImpliesExpression__Group__0 : rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ; - public final void rule__ImpliesExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__InterfaceField__Group__1" + // InternalExport.g:5769:1: rule__InterfaceField__Group__1 : rule__InterfaceField__Group__1__Impl ; + public final void rule__InterfaceField__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5911:1: ( rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ) - // InternalExport.g:5912:2: rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 + // InternalExport.g:5773:1: ( rule__InterfaceField__Group__1__Impl ) + // InternalExport.g:5774:2: rule__InterfaceField__Group__1__Impl { - pushFollow(FOLLOW_54); - rule__ImpliesExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group__1(); + rule__InterfaceField__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -19844,32 +21167,38 @@ public final void rule__ImpliesExpression__Group__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__0" + // $ANTLR end "rule__InterfaceField__Group__1" - // $ANTLR start "rule__ImpliesExpression__Group__0__Impl" - // InternalExport.g:5919:1: rule__ImpliesExpression__Group__0__Impl : ( ruleRelationalExpression ) ; - public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceField__Group__1__Impl" + // InternalExport.g:5780:1: rule__InterfaceField__Group__1__Impl : ( ( rule__InterfaceField__FieldAssignment_1 ) ) ; + public final void rule__InterfaceField__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5923:1: ( ( ruleRelationalExpression ) ) - // InternalExport.g:5924:1: ( ruleRelationalExpression ) + // InternalExport.g:5784:1: ( ( ( rule__InterfaceField__FieldAssignment_1 ) ) ) + // InternalExport.g:5785:1: ( ( rule__InterfaceField__FieldAssignment_1 ) ) { - // InternalExport.g:5924:1: ( ruleRelationalExpression ) - // InternalExport.g:5925:2: ruleRelationalExpression + // InternalExport.g:5785:1: ( ( rule__InterfaceField__FieldAssignment_1 ) ) + // InternalExport.g:5786:2: ( rule__InterfaceField__FieldAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); + before(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); } + // InternalExport.g:5787:2: ( rule__InterfaceField__FieldAssignment_1 ) + // InternalExport.g:5787:3: rule__InterfaceField__FieldAssignment_1 + { pushFollow(FOLLOW_2); - ruleRelationalExpression(); + rule__InterfaceField__FieldAssignment_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); + after(grammarAccess.getInterfaceFieldAccess().getFieldAssignment_1()); } } @@ -19889,21 +21218,26 @@ public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__0__Impl" + // $ANTLR end "rule__InterfaceField__Group__1__Impl" - // $ANTLR start "rule__ImpliesExpression__Group__1" - // InternalExport.g:5934:1: rule__ImpliesExpression__Group__1 : rule__ImpliesExpression__Group__1__Impl ; - public final void rule__ImpliesExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__InterfaceNavigation__Group__0" + // InternalExport.g:5796:1: rule__InterfaceNavigation__Group__0 : rule__InterfaceNavigation__Group__0__Impl rule__InterfaceNavigation__Group__1 ; + public final void rule__InterfaceNavigation__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5938:1: ( rule__ImpliesExpression__Group__1__Impl ) - // InternalExport.g:5939:2: rule__ImpliesExpression__Group__1__Impl + // InternalExport.g:5800:1: ( rule__InterfaceNavigation__Group__0__Impl rule__InterfaceNavigation__Group__1 ) + // InternalExport.g:5801:2: rule__InterfaceNavigation__Group__0__Impl rule__InterfaceNavigation__Group__1 { + pushFollow(FOLLOW_23); + rule__InterfaceNavigation__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group__1__Impl(); + rule__InterfaceNavigation__Group__1(); state._fsp--; if (state.failed) return ; @@ -19922,56 +21256,28 @@ public final void rule__ImpliesExpression__Group__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__1" + // $ANTLR end "rule__InterfaceNavigation__Group__0" - // $ANTLR start "rule__ImpliesExpression__Group__1__Impl" - // InternalExport.g:5945:1: rule__ImpliesExpression__Group__1__Impl : ( ( rule__ImpliesExpression__Group_1__0 )* ) ; - public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceNavigation__Group__0__Impl" + // InternalExport.g:5808:1: rule__InterfaceNavigation__Group__0__Impl : ( '@' ) ; + public final void rule__InterfaceNavigation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5949:1: ( ( ( rule__ImpliesExpression__Group_1__0 )* ) ) - // InternalExport.g:5950:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) + // InternalExport.g:5812:1: ( ( '@' ) ) + // InternalExport.g:5813:1: ( '@' ) { - // InternalExport.g:5950:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) - // InternalExport.g:5951:2: ( rule__ImpliesExpression__Group_1__0 )* + // InternalExport.g:5813:1: ( '@' ) + // InternalExport.g:5814:2: '@' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); + before(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); } - // InternalExport.g:5952:2: ( rule__ImpliesExpression__Group_1__0 )* - loop54: - do { - int alt54=2; - int LA54_0 = input.LA(1); - - if ( (LA54_0==79) ) { - alt54=1; - } - - - switch (alt54) { - case 1 : - // InternalExport.g:5952:3: rule__ImpliesExpression__Group_1__0 - { - pushFollow(FOLLOW_55); - rule__ImpliesExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop54; - } - } while (true); - + match(input,75,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); + after(grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); } } @@ -19991,26 +21297,26 @@ public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__1__Impl" + // $ANTLR end "rule__InterfaceNavigation__Group__0__Impl" - // $ANTLR start "rule__ImpliesExpression__Group_1__0" - // InternalExport.g:5961:1: rule__ImpliesExpression__Group_1__0 : rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ; - public final void rule__ImpliesExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__InterfaceNavigation__Group__1" + // InternalExport.g:5823:1: rule__InterfaceNavigation__Group__1 : rule__InterfaceNavigation__Group__1__Impl rule__InterfaceNavigation__Group__2 ; + public final void rule__InterfaceNavigation__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5965:1: ( rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ) - // InternalExport.g:5966:2: rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 + // InternalExport.g:5827:1: ( rule__InterfaceNavigation__Group__1__Impl rule__InterfaceNavigation__Group__2 ) + // InternalExport.g:5828:2: rule__InterfaceNavigation__Group__1__Impl rule__InterfaceNavigation__Group__2 { - pushFollow(FOLLOW_54); - rule__ImpliesExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_23); + rule__InterfaceNavigation__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__1(); + rule__InterfaceNavigation__Group__2(); state._fsp--; if (state.failed) return ; @@ -20029,32 +21335,49 @@ public final void rule__ImpliesExpression__Group_1__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__0" + // $ANTLR end "rule__InterfaceNavigation__Group__1" - // $ANTLR start "rule__ImpliesExpression__Group_1__0__Impl" - // InternalExport.g:5973:1: rule__ImpliesExpression__Group_1__0__Impl : ( () ) ; - public final void rule__ImpliesExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceNavigation__Group__1__Impl" + // InternalExport.g:5835:1: rule__InterfaceNavigation__Group__1__Impl : ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) ; + public final void rule__InterfaceNavigation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5977:1: ( ( () ) ) - // InternalExport.g:5978:1: ( () ) + // InternalExport.g:5839:1: ( ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) ) + // InternalExport.g:5840:1: ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) { - // InternalExport.g:5978:1: ( () ) - // InternalExport.g:5979:2: () + // InternalExport.g:5840:1: ( ( rule__InterfaceNavigation__UnorderedAssignment_1 )? ) + // InternalExport.g:5841:2: ( rule__InterfaceNavigation__UnorderedAssignment_1 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); } - // InternalExport.g:5980:2: () - // InternalExport.g:5980:3: - { + // InternalExport.g:5842:2: ( rule__InterfaceNavigation__UnorderedAssignment_1 )? + int alt72=2; + int LA72_0 = input.LA(1); + + if ( (LA72_0==23) ) { + alt72=1; + } + switch (alt72) { + case 1 : + // InternalExport.g:5842:3: rule__InterfaceNavigation__UnorderedAssignment_1 + { + pushFollow(FOLLOW_2); + rule__InterfaceNavigation__UnorderedAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getInterfaceNavigationAccess().getUnorderedAssignment_1()); } } @@ -20063,6 +21386,10 @@ public final void rule__ImpliesExpression__Group_1__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -20070,26 +21397,21 @@ public final void rule__ImpliesExpression__Group_1__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__0__Impl" + // $ANTLR end "rule__InterfaceNavigation__Group__1__Impl" - // $ANTLR start "rule__ImpliesExpression__Group_1__1" - // InternalExport.g:5988:1: rule__ImpliesExpression__Group_1__1 : rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ; - public final void rule__ImpliesExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__InterfaceNavigation__Group__2" + // InternalExport.g:5850:1: rule__InterfaceNavigation__Group__2 : rule__InterfaceNavigation__Group__2__Impl ; + public final void rule__InterfaceNavigation__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:5992:1: ( rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ) - // InternalExport.g:5993:2: rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 + // InternalExport.g:5854:1: ( rule__InterfaceNavigation__Group__2__Impl ) + // InternalExport.g:5855:2: rule__InterfaceNavigation__Group__2__Impl { - pushFollow(FOLLOW_49); - rule__ImpliesExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__2(); + rule__InterfaceNavigation__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -20108,30 +21430,30 @@ public final void rule__ImpliesExpression__Group_1__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__1" + // $ANTLR end "rule__InterfaceNavigation__Group__2" - // $ANTLR start "rule__ImpliesExpression__Group_1__1__Impl" - // InternalExport.g:6000:1: rule__ImpliesExpression__Group_1__1__Impl : ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__ImpliesExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceNavigation__Group__2__Impl" + // InternalExport.g:5861:1: rule__InterfaceNavigation__Group__2__Impl : ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) ; + public final void rule__InterfaceNavigation__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6004:1: ( ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ) - // InternalExport.g:6005:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:5865:1: ( ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) ) + // InternalExport.g:5866:1: ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) { - // InternalExport.g:6005:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) - // InternalExport.g:6006:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) + // InternalExport.g:5866:1: ( ( rule__InterfaceNavigation__RefAssignment_2 ) ) + // InternalExport.g:5867:2: ( rule__InterfaceNavigation__RefAssignment_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); } - // InternalExport.g:6007:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) - // InternalExport.g:6007:3: rule__ImpliesExpression__OperatorAssignment_1_1 + // InternalExport.g:5868:2: ( rule__InterfaceNavigation__RefAssignment_2 ) + // InternalExport.g:5868:3: rule__InterfaceNavigation__RefAssignment_2 { pushFollow(FOLLOW_2); - rule__ImpliesExpression__OperatorAssignment_1_1(); + rule__InterfaceNavigation__RefAssignment_2(); state._fsp--; if (state.failed) return ; @@ -20139,7 +21461,7 @@ public final void rule__ImpliesExpression__Group_1__1__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getInterfaceNavigationAccess().getRefAssignment_2()); } } @@ -20159,21 +21481,26 @@ public final void rule__ImpliesExpression__Group_1__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__1__Impl" + // $ANTLR end "rule__InterfaceNavigation__Group__2__Impl" - // $ANTLR start "rule__ImpliesExpression__Group_1__2" - // InternalExport.g:6015:1: rule__ImpliesExpression__Group_1__2 : rule__ImpliesExpression__Group_1__2__Impl ; - public final void rule__ImpliesExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__InterfaceExpression__Group__0" + // InternalExport.g:5877:1: rule__InterfaceExpression__Group__0 : rule__InterfaceExpression__Group__0__Impl rule__InterfaceExpression__Group__1 ; + public final void rule__InterfaceExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6019:1: ( rule__ImpliesExpression__Group_1__2__Impl ) - // InternalExport.g:6020:2: rule__ImpliesExpression__Group_1__2__Impl + // InternalExport.g:5881:1: ( rule__InterfaceExpression__Group__0__Impl rule__InterfaceExpression__Group__1 ) + // InternalExport.g:5882:2: rule__InterfaceExpression__Group__0__Impl rule__InterfaceExpression__Group__1 { + pushFollow(FOLLOW_24); + rule__InterfaceExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__2__Impl(); + rule__InterfaceExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -20192,38 +21519,28 @@ public final void rule__ImpliesExpression__Group_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__2" + // $ANTLR end "rule__InterfaceExpression__Group__0" - // $ANTLR start "rule__ImpliesExpression__Group_1__2__Impl" - // InternalExport.g:6026:1: rule__ImpliesExpression__Group_1__2__Impl : ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ; - public final void rule__ImpliesExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceExpression__Group__0__Impl" + // InternalExport.g:5889:1: rule__InterfaceExpression__Group__0__Impl : ( 'eval' ) ; + public final void rule__InterfaceExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6030:1: ( ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ) - // InternalExport.g:6031:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) + // InternalExport.g:5893:1: ( ( 'eval' ) ) + // InternalExport.g:5894:1: ( 'eval' ) { - // InternalExport.g:6031:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) - // InternalExport.g:6032:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) + // InternalExport.g:5894:1: ( 'eval' ) + // InternalExport.g:5895:2: 'eval' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); - } - // InternalExport.g:6033:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) - // InternalExport.g:6033:3: rule__ImpliesExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__RightAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); } - + match(input,76,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); } } @@ -20243,26 +21560,26 @@ public final void rule__ImpliesExpression__Group_1__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__2__Impl" + // $ANTLR end "rule__InterfaceExpression__Group__0__Impl" - // $ANTLR start "rule__RelationalExpression__Group__0" - // InternalExport.g:6042: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__InterfaceExpression__Group__1" + // InternalExport.g:5904:1: rule__InterfaceExpression__Group__1 : rule__InterfaceExpression__Group__1__Impl rule__InterfaceExpression__Group__2 ; + public final void rule__InterfaceExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6046:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) - // InternalExport.g:6047:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 + // InternalExport.g:5908:1: ( rule__InterfaceExpression__Group__1__Impl rule__InterfaceExpression__Group__2 ) + // InternalExport.g:5909:2: rule__InterfaceExpression__Group__1__Impl rule__InterfaceExpression__Group__2 { - pushFollow(FOLLOW_56); - rule__RelationalExpression__Group__0__Impl(); + pushFollow(FOLLOW_24); + rule__InterfaceExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group__1(); + rule__InterfaceExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -20281,32 +21598,49 @@ public final void rule__RelationalExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0" + // $ANTLR end "rule__InterfaceExpression__Group__1" - // $ANTLR start "rule__RelationalExpression__Group__0__Impl" - // InternalExport.g:6054:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceExpression__Group__1__Impl" + // InternalExport.g:5916:1: rule__InterfaceExpression__Group__1__Impl : ( ( rule__InterfaceExpression__RefAssignment_1 )? ) ; + public final void rule__InterfaceExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6058:1: ( ( ruleAdditiveExpression ) ) - // InternalExport.g:6059:1: ( ruleAdditiveExpression ) + // InternalExport.g:5920:1: ( ( ( rule__InterfaceExpression__RefAssignment_1 )? ) ) + // InternalExport.g:5921:1: ( ( rule__InterfaceExpression__RefAssignment_1 )? ) { - // InternalExport.g:6059:1: ( ruleAdditiveExpression ) - // InternalExport.g:6060:2: ruleAdditiveExpression + // InternalExport.g:5921:1: ( ( rule__InterfaceExpression__RefAssignment_1 )? ) + // InternalExport.g:5922:2: ( rule__InterfaceExpression__RefAssignment_1 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); + before(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); + } + // InternalExport.g:5923:2: ( rule__InterfaceExpression__RefAssignment_1 )? + int alt73=2; + int LA73_0 = input.LA(1); + + if ( (LA73_0==75) ) { + alt73=1; + } + switch (alt73) { + case 1 : + // InternalExport.g:5923:3: rule__InterfaceExpression__RefAssignment_1 + { + pushFollow(FOLLOW_2); + rule__InterfaceExpression__RefAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } - pushFollow(FOLLOW_2); - ruleAdditiveExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); + after(grammarAccess.getInterfaceExpressionAccess().getRefAssignment_1()); } } @@ -20326,21 +21660,26 @@ public final void rule__RelationalExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0__Impl" + // $ANTLR end "rule__InterfaceExpression__Group__1__Impl" - // $ANTLR start "rule__RelationalExpression__Group__1" - // InternalExport.g:6069:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; - public final void rule__RelationalExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__InterfaceExpression__Group__2" + // InternalExport.g:5931:1: rule__InterfaceExpression__Group__2 : rule__InterfaceExpression__Group__2__Impl rule__InterfaceExpression__Group__3 ; + public final void rule__InterfaceExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6073:1: ( rule__RelationalExpression__Group__1__Impl ) - // InternalExport.g:6074:2: rule__RelationalExpression__Group__1__Impl + // InternalExport.g:5935:1: ( rule__InterfaceExpression__Group__2__Impl rule__InterfaceExpression__Group__3 ) + // InternalExport.g:5936:2: rule__InterfaceExpression__Group__2__Impl rule__InterfaceExpression__Group__3 { + pushFollow(FOLLOW_24); + rule__InterfaceExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group__1__Impl(); + rule__InterfaceExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -20359,56 +21698,49 @@ public final void rule__RelationalExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1" + // $ANTLR end "rule__InterfaceExpression__Group__2" - // $ANTLR start "rule__RelationalExpression__Group__1__Impl" - // InternalExport.g:6080:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )* ) ; - public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceExpression__Group__2__Impl" + // InternalExport.g:5943:1: rule__InterfaceExpression__Group__2__Impl : ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) ; + public final void rule__InterfaceExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6084:1: ( ( ( rule__RelationalExpression__Group_1__0 )* ) ) - // InternalExport.g:6085:1: ( ( rule__RelationalExpression__Group_1__0 )* ) + // InternalExport.g:5947:1: ( ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) ) + // InternalExport.g:5948:1: ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) { - // InternalExport.g:6085:1: ( ( rule__RelationalExpression__Group_1__0 )* ) - // InternalExport.g:6086:2: ( rule__RelationalExpression__Group_1__0 )* + // InternalExport.g:5948:1: ( ( rule__InterfaceExpression__UnorderedAssignment_2 )? ) + // InternalExport.g:5949:2: ( rule__InterfaceExpression__UnorderedAssignment_2 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + before(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); } - // InternalExport.g:6087:2: ( rule__RelationalExpression__Group_1__0 )* - loop55: - do { - int alt55=2; - int LA55_0 = input.LA(1); - - if ( ((LA55_0>=12 && LA55_0<=17)) ) { - alt55=1; - } - + // InternalExport.g:5950:2: ( rule__InterfaceExpression__UnorderedAssignment_2 )? + int alt74=2; + int LA74_0 = input.LA(1); - switch (alt55) { - case 1 : - // InternalExport.g:6087:3: rule__RelationalExpression__Group_1__0 - { - pushFollow(FOLLOW_57); - rule__RelationalExpression__Group_1__0(); + if ( (LA74_0==23) ) { + alt74=1; + } + switch (alt74) { + case 1 : + // InternalExport.g:5950:3: rule__InterfaceExpression__UnorderedAssignment_2 + { + pushFollow(FOLLOW_2); + rule__InterfaceExpression__UnorderedAssignment_2(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } + break; - default : - break loop55; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + after(grammarAccess.getInterfaceExpressionAccess().getUnorderedAssignment_2()); } } @@ -20428,26 +21760,26 @@ public final void rule__RelationalExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1__Impl" + // $ANTLR end "rule__InterfaceExpression__Group__2__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__0" - // InternalExport.g:6096: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__InterfaceExpression__Group__3" + // InternalExport.g:5958:1: rule__InterfaceExpression__Group__3 : rule__InterfaceExpression__Group__3__Impl rule__InterfaceExpression__Group__4 ; + public final void rule__InterfaceExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6100:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) - // InternalExport.g:6101:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 + // InternalExport.g:5962:1: ( rule__InterfaceExpression__Group__3__Impl rule__InterfaceExpression__Group__4 ) + // InternalExport.g:5963:2: rule__InterfaceExpression__Group__3__Impl rule__InterfaceExpression__Group__4 { - pushFollow(FOLLOW_56); - rule__RelationalExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_18); + rule__InterfaceExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__1(); + rule__InterfaceExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -20466,32 +21798,28 @@ public final void rule__RelationalExpression__Group_1__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__0" + // $ANTLR end "rule__InterfaceExpression__Group__3" - // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" - // InternalExport.g:6108:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; - public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__InterfaceExpression__Group__3__Impl" + // InternalExport.g:5970:1: rule__InterfaceExpression__Group__3__Impl : ( '(' ) ; + public final void rule__InterfaceExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6112:1: ( ( () ) ) - // InternalExport.g:6113:1: ( () ) + // InternalExport.g:5974:1: ( ( '(' ) ) + // InternalExport.g:5975:1: ( '(' ) { - // InternalExport.g:6113:1: ( () ) - // InternalExport.g:6114:2: () + // InternalExport.g:5975:1: ( '(' ) + // InternalExport.g:5976:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); - } - // InternalExport.g:6115:2: () - // InternalExport.g:6115:3: - { + before(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); } - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); } } @@ -20500,6 +21828,10 @@ public final void rule__RelationalExpression__Group_1__0__Impl() throws Recognit } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -20507,26 +21839,26 @@ public final void rule__RelationalExpression__Group_1__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" + // $ANTLR end "rule__InterfaceExpression__Group__3__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__1" - // InternalExport.g:6123: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__InterfaceExpression__Group__4" + // InternalExport.g:5985:1: rule__InterfaceExpression__Group__4 : rule__InterfaceExpression__Group__4__Impl rule__InterfaceExpression__Group__5 ; + public final void rule__InterfaceExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6127:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) - // InternalExport.g:6128:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 + // InternalExport.g:5989:1: ( rule__InterfaceExpression__Group__4__Impl rule__InterfaceExpression__Group__5 ) + // InternalExport.g:5990:2: rule__InterfaceExpression__Group__4__Impl rule__InterfaceExpression__Group__5 { - pushFollow(FOLLOW_49); - rule__RelationalExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_25); + rule__InterfaceExpression__Group__4__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__2(); + rule__InterfaceExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -20545,30 +21877,30 @@ public final void rule__RelationalExpression__Group_1__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1" + // $ANTLR end "rule__InterfaceExpression__Group__4" - // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" - // InternalExport.g:6135: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__InterfaceExpression__Group__4__Impl" + // InternalExport.g:5997:1: rule__InterfaceExpression__Group__4__Impl : ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) ; + public final void rule__InterfaceExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6139:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) - // InternalExport.g:6140:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:6001:1: ( ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) ) + // InternalExport.g:6002:1: ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) { - // InternalExport.g:6140:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) - // InternalExport.g:6141:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) + // InternalExport.g:6002:1: ( ( rule__InterfaceExpression__ExprAssignment_4 ) ) + // InternalExport.g:6003:2: ( rule__InterfaceExpression__ExprAssignment_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); } - // InternalExport.g:6142:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) - // InternalExport.g:6142:3: rule__RelationalExpression__OperatorAssignment_1_1 + // InternalExport.g:6004:2: ( rule__InterfaceExpression__ExprAssignment_4 ) + // InternalExport.g:6004:3: rule__InterfaceExpression__ExprAssignment_4 { pushFollow(FOLLOW_2); - rule__RelationalExpression__OperatorAssignment_1_1(); + rule__InterfaceExpression__ExprAssignment_4(); state._fsp--; if (state.failed) return ; @@ -20576,7 +21908,7 @@ public final void rule__RelationalExpression__Group_1__1__Impl() throws Recognit } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getInterfaceExpressionAccess().getExprAssignment_4()); } } @@ -20596,21 +21928,21 @@ public final void rule__RelationalExpression__Group_1__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" + // $ANTLR end "rule__InterfaceExpression__Group__4__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__2" - // InternalExport.g:6150: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__InterfaceExpression__Group__5" + // InternalExport.g:6012:1: rule__InterfaceExpression__Group__5 : rule__InterfaceExpression__Group__5__Impl ; + public final void rule__InterfaceExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6154:1: ( rule__RelationalExpression__Group_1__2__Impl ) - // InternalExport.g:6155:2: rule__RelationalExpression__Group_1__2__Impl + // InternalExport.g:6016:1: ( rule__InterfaceExpression__Group__5__Impl ) + // InternalExport.g:6017:2: rule__InterfaceExpression__Group__5__Impl { pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__2__Impl(); + rule__InterfaceExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -20629,38 +21961,28 @@ public final void rule__RelationalExpression__Group_1__2() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__2" + // $ANTLR end "rule__InterfaceExpression__Group__5" - // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" - // InternalExport.g:6161: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__InterfaceExpression__Group__5__Impl" + // InternalExport.g:6023:1: rule__InterfaceExpression__Group__5__Impl : ( ')' ) ; + public final void rule__InterfaceExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6165:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) - // InternalExport.g:6166:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) + // InternalExport.g:6027:1: ( ( ')' ) ) + // InternalExport.g:6028:1: ( ')' ) { - // InternalExport.g:6166:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) - // InternalExport.g:6167:2: ( rule__RelationalExpression__RightAssignment_1_2 ) + // InternalExport.g:6028:1: ( ')' ) + // InternalExport.g:6029:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); - } - // InternalExport.g:6168:2: ( rule__RelationalExpression__RightAssignment_1_2 ) - // InternalExport.g:6168:3: rule__RelationalExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__RightAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); } } @@ -20680,26 +22002,26 @@ public final void rule__RelationalExpression__Group_1__2__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" + // $ANTLR end "rule__InterfaceExpression__Group__5__Impl" - // $ANTLR start "rule__AdditiveExpression__Group__0" - // InternalExport.g:6177: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__Export__Group__0" + // InternalExport.g:6039:1: rule__Export__Group__0 : rule__Export__Group__0__Impl rule__Export__Group__1 ; + public final void rule__Export__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6181:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) - // InternalExport.g:6182:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 + // InternalExport.g:6043:1: ( rule__Export__Group__0__Impl rule__Export__Group__1 ) + // InternalExport.g:6044:2: rule__Export__Group__0__Impl rule__Export__Group__1 { - pushFollow(FOLLOW_58); - rule__AdditiveExpression__Group__0__Impl(); + pushFollow(FOLLOW_26); + rule__Export__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group__1(); + rule__Export__Group__1(); state._fsp--; if (state.failed) return ; @@ -20718,32 +22040,28 @@ public final void rule__AdditiveExpression__Group__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0" + // $ANTLR end "rule__Export__Group__0" - // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" - // InternalExport.g:6189:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__0__Impl" + // InternalExport.g:6051:1: rule__Export__Group__0__Impl : ( 'export' ) ; + public final void rule__Export__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6193:1: ( ( ruleMultiplicativeExpression ) ) - // InternalExport.g:6194:1: ( ruleMultiplicativeExpression ) + // InternalExport.g:6055:1: ( ( 'export' ) ) + // InternalExport.g:6056:1: ( 'export' ) { - // InternalExport.g:6194:1: ( ruleMultiplicativeExpression ) - // InternalExport.g:6195:2: ruleMultiplicativeExpression + // InternalExport.g:6056:1: ( 'export' ) + // InternalExport.g:6057:2: 'export' { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + before(grammarAccess.getExportAccess().getExportKeyword_0()); } - pushFollow(FOLLOW_2); - ruleMultiplicativeExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,65,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + after(grammarAccess.getExportAccess().getExportKeyword_0()); } } @@ -20763,21 +22081,26 @@ public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" + // $ANTLR end "rule__Export__Group__0__Impl" - // $ANTLR start "rule__AdditiveExpression__Group__1" - // InternalExport.g:6204:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; - public final void rule__AdditiveExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group__1" + // InternalExport.g:6066:1: rule__Export__Group__1 : rule__Export__Group__1__Impl rule__Export__Group__2 ; + public final void rule__Export__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6208:1: ( rule__AdditiveExpression__Group__1__Impl ) - // InternalExport.g:6209:2: rule__AdditiveExpression__Group__1__Impl + // InternalExport.g:6070:1: ( rule__Export__Group__1__Impl rule__Export__Group__2 ) + // InternalExport.g:6071:2: rule__Export__Group__1__Impl rule__Export__Group__2 { + pushFollow(FOLLOW_26); + rule__Export__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group__1__Impl(); + rule__Export__Group__2(); state._fsp--; if (state.failed) return ; @@ -20796,56 +22119,49 @@ public final void rule__AdditiveExpression__Group__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1" + // $ANTLR end "rule__Export__Group__1" - // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" - // InternalExport.g:6215:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; - public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__1__Impl" + // InternalExport.g:6078:1: rule__Export__Group__1__Impl : ( ( rule__Export__Group_1__0 )? ) ; + public final void rule__Export__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6219:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) - // InternalExport.g:6220:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) + // InternalExport.g:6082:1: ( ( ( rule__Export__Group_1__0 )? ) ) + // InternalExport.g:6083:1: ( ( rule__Export__Group_1__0 )? ) { - // InternalExport.g:6220:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) - // InternalExport.g:6221:2: ( rule__AdditiveExpression__Group_1__0 )* + // InternalExport.g:6083:1: ( ( rule__Export__Group_1__0 )? ) + // InternalExport.g:6084:2: ( rule__Export__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + before(grammarAccess.getExportAccess().getGroup_1()); } - // InternalExport.g:6222:2: ( rule__AdditiveExpression__Group_1__0 )* - loop56: - do { - int alt56=2; - int LA56_0 = input.LA(1); - - if ( ((LA56_0>=18 && LA56_0<=19)) ) { - alt56=1; - } - + // InternalExport.g:6085:2: ( rule__Export__Group_1__0 )? + int alt75=2; + int LA75_0 = input.LA(1); - switch (alt56) { - case 1 : - // InternalExport.g:6222:3: rule__AdditiveExpression__Group_1__0 - { - pushFollow(FOLLOW_59); - rule__AdditiveExpression__Group_1__0(); + if ( (LA75_0==109) ) { + alt75=1; + } + switch (alt75) { + case 1 : + // InternalExport.g:6085:3: rule__Export__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_1__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } + break; - default : - break loop56; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + after(grammarAccess.getExportAccess().getGroup_1()); } } @@ -20865,26 +22181,26 @@ public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" + // $ANTLR end "rule__Export__Group__1__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__0" - // InternalExport.g:6231: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__Export__Group__2" + // InternalExport.g:6093:1: rule__Export__Group__2 : rule__Export__Group__2__Impl rule__Export__Group__3 ; + public final void rule__Export__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6235:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) - // InternalExport.g:6236:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 + // InternalExport.g:6097:1: ( rule__Export__Group__2__Impl rule__Export__Group__3 ) + // InternalExport.g:6098:2: rule__Export__Group__2__Impl rule__Export__Group__3 { - pushFollow(FOLLOW_58); - rule__AdditiveExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_27); + rule__Export__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__1(); + rule__Export__Group__3(); state._fsp--; if (state.failed) return ; @@ -20903,32 +22219,38 @@ public final void rule__AdditiveExpression__Group_1__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0" + // $ANTLR end "rule__Export__Group__2" - // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" - // InternalExport.g:6243:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__2__Impl" + // InternalExport.g:6105:1: rule__Export__Group__2__Impl : ( ( rule__Export__TypeAssignment_2 ) ) ; + public final void rule__Export__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6247:1: ( ( () ) ) - // InternalExport.g:6248:1: ( () ) + // InternalExport.g:6109:1: ( ( ( rule__Export__TypeAssignment_2 ) ) ) + // InternalExport.g:6110:1: ( ( rule__Export__TypeAssignment_2 ) ) { - // InternalExport.g:6248:1: ( () ) - // InternalExport.g:6249:2: () + // InternalExport.g:6110:1: ( ( rule__Export__TypeAssignment_2 ) ) + // InternalExport.g:6111:2: ( rule__Export__TypeAssignment_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); + before(grammarAccess.getExportAccess().getTypeAssignment_2()); } - // InternalExport.g:6250:2: () - // InternalExport.g:6250:3: + // InternalExport.g:6112:2: ( rule__Export__TypeAssignment_2 ) + // InternalExport.g:6112:3: rule__Export__TypeAssignment_2 { + pushFollow(FOLLOW_2); + rule__Export__TypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); + after(grammarAccess.getExportAccess().getTypeAssignment_2()); } } @@ -20937,6 +22259,10 @@ public final void rule__AdditiveExpression__Group_1__0__Impl() throws Recognitio } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -20944,26 +22270,26 @@ public final void rule__AdditiveExpression__Group_1__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" + // $ANTLR end "rule__Export__Group__2__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__1" - // InternalExport.g:6258: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__Export__Group__3" + // InternalExport.g:6120:1: rule__Export__Group__3 : rule__Export__Group__3__Impl rule__Export__Group__4 ; + public final void rule__Export__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6262:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) - // InternalExport.g:6263:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 + // InternalExport.g:6124:1: ( rule__Export__Group__3__Impl rule__Export__Group__4 ) + // InternalExport.g:6125:2: rule__Export__Group__3__Impl rule__Export__Group__4 { - pushFollow(FOLLOW_49); - rule__AdditiveExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_27); + rule__Export__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__2(); + rule__Export__Group__4(); state._fsp--; if (state.failed) return ; @@ -20982,38 +22308,49 @@ public final void rule__AdditiveExpression__Group_1__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1" + // $ANTLR end "rule__Export__Group__3" - // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" - // InternalExport.g:6270:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ; - public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__3__Impl" + // InternalExport.g:6132:1: rule__Export__Group__3__Impl : ( ( rule__Export__Group_3__0 )? ) ; + public final void rule__Export__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6274:1: ( ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ) - // InternalExport.g:6275:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) + // InternalExport.g:6136:1: ( ( ( rule__Export__Group_3__0 )? ) ) + // InternalExport.g:6137:1: ( ( rule__Export__Group_3__0 )? ) { - // InternalExport.g:6275:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) - // InternalExport.g:6276:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) + // InternalExport.g:6137:1: ( ( rule__Export__Group_3__0 )? ) + // InternalExport.g:6138:2: ( rule__Export__Group_3__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); + before(grammarAccess.getExportAccess().getGroup_3()); } - // InternalExport.g:6277:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) - // InternalExport.g:6277:3: rule__AdditiveExpression__NameAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__NameAssignment_1_1(); + // InternalExport.g:6139:2: ( rule__Export__Group_3__0 )? + int alt76=2; + int LA76_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA76_0==70) ) { + alt76=1; + } + switch (alt76) { + case 1 : + // InternalExport.g:6139:3: rule__Export__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); + after(grammarAccess.getExportAccess().getGroup_3()); } } @@ -21033,21 +22370,26 @@ public final void rule__AdditiveExpression__Group_1__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" + // $ANTLR end "rule__Export__Group__3__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__2" - // InternalExport.g:6285: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__Export__Group__4" + // InternalExport.g:6147:1: rule__Export__Group__4 : rule__Export__Group__4__Impl rule__Export__Group__5 ; + public final void rule__Export__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6289:1: ( rule__AdditiveExpression__Group_1__2__Impl ) - // InternalExport.g:6290:2: rule__AdditiveExpression__Group_1__2__Impl + // InternalExport.g:6151:1: ( rule__Export__Group__4__Impl rule__Export__Group__5 ) + // InternalExport.g:6152:2: rule__Export__Group__4__Impl rule__Export__Group__5 { + pushFollow(FOLLOW_27); + rule__Export__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__2__Impl(); + rule__Export__Group__5(); state._fsp--; if (state.failed) return ; @@ -21066,38 +22408,49 @@ public final void rule__AdditiveExpression__Group_1__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2" + // $ANTLR end "rule__Export__Group__4" - // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" - // InternalExport.g:6296:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ; - public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__4__Impl" + // InternalExport.g:6159:1: rule__Export__Group__4__Impl : ( ( rule__Export__Group_4__0 )? ) ; + public final void rule__Export__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6300:1: ( ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ) - // InternalExport.g:6301:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) + // InternalExport.g:6163:1: ( ( ( rule__Export__Group_4__0 )? ) ) + // InternalExport.g:6164:1: ( ( rule__Export__Group_4__0 )? ) { - // InternalExport.g:6301:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) - // InternalExport.g:6302:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) + // InternalExport.g:6164:1: ( ( rule__Export__Group_4__0 )? ) + // InternalExport.g:6165:2: ( rule__Export__Group_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); + before(grammarAccess.getExportAccess().getGroup_4()); } - // InternalExport.g:6303:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) - // InternalExport.g:6303:3: rule__AdditiveExpression__ParamsAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__ParamsAssignment_1_2(); + // InternalExport.g:6166:2: ( rule__Export__Group_4__0 )? + int alt77=2; + int LA77_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA77_0==72) ) { + alt77=1; + } + switch (alt77) { + case 1 : + // InternalExport.g:6166:3: rule__Export__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); + after(grammarAccess.getExportAccess().getGroup_4()); } } @@ -21117,26 +22470,26 @@ public final void rule__AdditiveExpression__Group_1__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" + // $ANTLR end "rule__Export__Group__4__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group__0" - // InternalExport.g:6312: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__Export__Group__5" + // InternalExport.g:6174:1: rule__Export__Group__5 : rule__Export__Group__5__Impl rule__Export__Group__6 ; + public final void rule__Export__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6316:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) - // InternalExport.g:6317:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 + // InternalExport.g:6178:1: ( rule__Export__Group__5__Impl rule__Export__Group__6 ) + // InternalExport.g:6179:2: rule__Export__Group__5__Impl rule__Export__Group__6 { - pushFollow(FOLLOW_60); - rule__MultiplicativeExpression__Group__0__Impl(); + pushFollow(FOLLOW_28); + rule__Export__Group__5__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group__1(); + rule__Export__Group__6(); state._fsp--; if (state.failed) return ; @@ -21155,32 +22508,28 @@ public final void rule__MultiplicativeExpression__Group__0() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__0" + // $ANTLR end "rule__Export__Group__5" - // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" - // InternalExport.g:6324:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleUnaryOrInfixExpression ) ; - public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__5__Impl" + // InternalExport.g:6186:1: rule__Export__Group__5__Impl : ( '{' ) ; + public final void rule__Export__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6328:1: ( ( ruleUnaryOrInfixExpression ) ) - // InternalExport.g:6329:1: ( ruleUnaryOrInfixExpression ) + // InternalExport.g:6190:1: ( ( '{' ) ) + // InternalExport.g:6191:1: ( '{' ) { - // InternalExport.g:6329:1: ( ruleUnaryOrInfixExpression ) - // InternalExport.g:6330:2: ruleUnaryOrInfixExpression + // InternalExport.g:6191:1: ( '{' ) + // InternalExport.g:6192:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); + before(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); } - pushFollow(FOLLOW_2); - ruleUnaryOrInfixExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,68,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); + after(grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); } } @@ -21200,21 +22549,26 @@ public final void rule__MultiplicativeExpression__Group__0__Impl() throws Recogn } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" + // $ANTLR end "rule__Export__Group__5__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group__1" - // InternalExport.g:6339:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; - public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group__6" + // InternalExport.g:6201:1: rule__Export__Group__6 : rule__Export__Group__6__Impl rule__Export__Group__7 ; + public final void rule__Export__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6343:1: ( rule__MultiplicativeExpression__Group__1__Impl ) - // InternalExport.g:6344:2: rule__MultiplicativeExpression__Group__1__Impl + // InternalExport.g:6205:1: ( rule__Export__Group__6__Impl rule__Export__Group__7 ) + // InternalExport.g:6206:2: rule__Export__Group__6__Impl rule__Export__Group__7 { + pushFollow(FOLLOW_28); + rule__Export__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group__1__Impl(); + rule__Export__Group__7(); state._fsp--; if (state.failed) return ; @@ -21233,56 +22587,49 @@ public final void rule__MultiplicativeExpression__Group__1() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1" + // $ANTLR end "rule__Export__Group__6" - // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" - // InternalExport.g:6350:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; - public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__6__Impl" + // InternalExport.g:6213:1: rule__Export__Group__6__Impl : ( ( rule__Export__Group_6__0 )? ) ; + public final void rule__Export__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6354:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) - // InternalExport.g:6355:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) + // InternalExport.g:6217:1: ( ( ( rule__Export__Group_6__0 )? ) ) + // InternalExport.g:6218:1: ( ( rule__Export__Group_6__0 )? ) { - // InternalExport.g:6355:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) - // InternalExport.g:6356:2: ( rule__MultiplicativeExpression__Group_1__0 )* + // InternalExport.g:6218:1: ( ( rule__Export__Group_6__0 )? ) + // InternalExport.g:6219:2: ( rule__Export__Group_6__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + before(grammarAccess.getExportAccess().getGroup_6()); } - // InternalExport.g:6357:2: ( rule__MultiplicativeExpression__Group_1__0 )* - loop57: - do { - int alt57=2; - int LA57_0 = input.LA(1); + // InternalExport.g:6220:2: ( rule__Export__Group_6__0 )? + int alt78=2; + int LA78_0 = input.LA(1); - if ( ((LA57_0>=20 && LA57_0<=21)) ) { - alt57=1; - } - - - switch (alt57) { - case 1 : - // InternalExport.g:6357:3: rule__MultiplicativeExpression__Group_1__0 - { - pushFollow(FOLLOW_61); - rule__MultiplicativeExpression__Group_1__0(); + if ( (LA78_0==79) ) { + alt78=1; + } + switch (alt78) { + case 1 : + // InternalExport.g:6220:3: rule__Export__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_6__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } + break; - default : - break loop57; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + after(grammarAccess.getExportAccess().getGroup_6()); } } @@ -21302,26 +22649,26 @@ public final void rule__MultiplicativeExpression__Group__1__Impl() throws Recogn } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" + // $ANTLR end "rule__Export__Group__6__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" - // InternalExport.g:6366: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__Export__Group__7" + // InternalExport.g:6228:1: rule__Export__Group__7 : rule__Export__Group__7__Impl rule__Export__Group__8 ; + public final void rule__Export__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6370:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) - // InternalExport.g:6371:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 + // InternalExport.g:6232:1: ( rule__Export__Group__7__Impl rule__Export__Group__8 ) + // InternalExport.g:6233:2: rule__Export__Group__7__Impl rule__Export__Group__8 { - pushFollow(FOLLOW_60); - rule__MultiplicativeExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_28); + rule__Export__Group__7__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__1(); + rule__Export__Group__8(); state._fsp--; if (state.failed) return ; @@ -21340,32 +22687,49 @@ public final void rule__MultiplicativeExpression__Group_1__0() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" + // $ANTLR end "rule__Export__Group__7" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" - // InternalExport.g:6378:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; - public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__7__Impl" + // InternalExport.g:6240:1: rule__Export__Group__7__Impl : ( ( rule__Export__Group_7__0 )? ) ; + public final void rule__Export__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6382:1: ( ( () ) ) - // InternalExport.g:6383:1: ( () ) + // InternalExport.g:6244:1: ( ( ( rule__Export__Group_7__0 )? ) ) + // InternalExport.g:6245:1: ( ( rule__Export__Group_7__0 )? ) { - // InternalExport.g:6383:1: ( () ) - // InternalExport.g:6384:2: () + // InternalExport.g:6245:1: ( ( rule__Export__Group_7__0 )? ) + // InternalExport.g:6246:2: ( rule__Export__Group_7__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + before(grammarAccess.getExportAccess().getGroup_7()); } - // InternalExport.g:6385:2: () - // InternalExport.g:6385:3: - { + // InternalExport.g:6247:2: ( rule__Export__Group_7__0 )? + int alt79=2; + int LA79_0 = input.LA(1); + + if ( ((LA79_0>=112 && LA79_0<=113)) ) { + alt79=1; + } + switch (alt79) { + case 1 : + // InternalExport.g:6247:3: rule__Export__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_7__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + after(grammarAccess.getExportAccess().getGroup_7()); } } @@ -21374,6 +22738,10 @@ public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws Reco } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -21381,26 +22749,26 @@ public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" + // $ANTLR end "rule__Export__Group__7__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" - // InternalExport.g:6393: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__Export__Group__8" + // InternalExport.g:6255:1: rule__Export__Group__8 : rule__Export__Group__8__Impl rule__Export__Group__9 ; + public final void rule__Export__Group__8() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6397:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) - // InternalExport.g:6398:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 + // InternalExport.g:6259:1: ( rule__Export__Group__8__Impl rule__Export__Group__9 ) + // InternalExport.g:6260:2: rule__Export__Group__8__Impl rule__Export__Group__9 { - pushFollow(FOLLOW_49); - rule__MultiplicativeExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_28); + rule__Export__Group__8__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2(); + rule__Export__Group__9(); state._fsp--; if (state.failed) return ; @@ -21419,38 +22787,56 @@ public final void rule__MultiplicativeExpression__Group_1__1() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" + // $ANTLR end "rule__Export__Group__8" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" - // InternalExport.g:6405:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__8__Impl" + // InternalExport.g:6267:1: rule__Export__Group__8__Impl : ( ( rule__Export__Alternatives_8 )* ) ; + public final void rule__Export__Group__8__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6409:1: ( ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ) - // InternalExport.g:6410:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) + // InternalExport.g:6271:1: ( ( ( rule__Export__Alternatives_8 )* ) ) + // InternalExport.g:6272:1: ( ( rule__Export__Alternatives_8 )* ) { - // InternalExport.g:6410:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) - // InternalExport.g:6411:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) + // InternalExport.g:6272:1: ( ( rule__Export__Alternatives_8 )* ) + // InternalExport.g:6273:2: ( rule__Export__Alternatives_8 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + before(grammarAccess.getExportAccess().getAlternatives_8()); } - // InternalExport.g:6412:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) - // InternalExport.g:6412:3: rule__MultiplicativeExpression__NameAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__NameAssignment_1_1(); + // InternalExport.g:6274:2: ( rule__Export__Alternatives_8 )* + loop80: + do { + int alt80=2; + int LA80_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( ((LA80_0>=81 && LA80_0<=82)) ) { + alt80=1; + } - } + + switch (alt80) { + case 1 : + // InternalExport.g:6274:3: rule__Export__Alternatives_8 + { + pushFollow(FOLLOW_29); + rule__Export__Alternatives_8(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop80; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + after(grammarAccess.getExportAccess().getAlternatives_8()); } } @@ -21470,21 +22856,21 @@ public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" + // $ANTLR end "rule__Export__Group__8__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" - // InternalExport.g:6420: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__Export__Group__9" + // InternalExport.g:6282:1: rule__Export__Group__9 : rule__Export__Group__9__Impl ; + public final void rule__Export__Group__9() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6424:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) - // InternalExport.g:6425:2: rule__MultiplicativeExpression__Group_1__2__Impl + // InternalExport.g:6286:1: ( rule__Export__Group__9__Impl ) + // InternalExport.g:6287:2: rule__Export__Group__9__Impl { pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2__Impl(); + rule__Export__Group__9__Impl(); state._fsp--; if (state.failed) return ; @@ -21503,38 +22889,28 @@ public final void rule__MultiplicativeExpression__Group_1__2() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" + // $ANTLR end "rule__Export__Group__9" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" - // InternalExport.g:6431:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group__9__Impl" + // InternalExport.g:6293:1: rule__Export__Group__9__Impl : ( '}' ) ; + public final void rule__Export__Group__9__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6435:1: ( ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ) - // InternalExport.g:6436:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) + // InternalExport.g:6297:1: ( ( '}' ) ) + // InternalExport.g:6298:1: ( '}' ) { - // InternalExport.g:6436:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) - // InternalExport.g:6437:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) + // InternalExport.g:6298:1: ( '}' ) + // InternalExport.g:6299:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); - } - // InternalExport.g:6438:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) - // InternalExport.g:6438:3: rule__MultiplicativeExpression__ParamsAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__ParamsAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); } - + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); + after(grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); } } @@ -21554,26 +22930,26 @@ public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" + // $ANTLR end "rule__Export__Group__9__Impl" - // $ANTLR start "rule__UnaryExpression__Group__0" - // InternalExport.g:6447:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ; - public final void rule__UnaryExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1__0" + // InternalExport.g:6309:1: rule__Export__Group_1__0 : rule__Export__Group_1__0__Impl rule__Export__Group_1__1 ; + public final void rule__Export__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6451:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ) - // InternalExport.g:6452:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 + // InternalExport.g:6313:1: ( rule__Export__Group_1__0__Impl rule__Export__Group_1__1 ) + // InternalExport.g:6314:2: rule__Export__Group_1__0__Impl rule__Export__Group_1__1 { - pushFollow(FOLLOW_49); - rule__UnaryExpression__Group__0__Impl(); + pushFollow(FOLLOW_30); + rule__Export__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__UnaryExpression__Group__1(); + rule__Export__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -21592,30 +22968,30 @@ public final void rule__UnaryExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__UnaryExpression__Group__0" + // $ANTLR end "rule__Export__Group_1__0" - // $ANTLR start "rule__UnaryExpression__Group__0__Impl" - // InternalExport.g:6459:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__NameAssignment_0 ) ) ; - public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1__0__Impl" + // InternalExport.g:6321:1: rule__Export__Group_1__0__Impl : ( ( rule__Export__LookupAssignment_1_0 ) ) ; + public final void rule__Export__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6463:1: ( ( ( rule__UnaryExpression__NameAssignment_0 ) ) ) - // InternalExport.g:6464:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) + // InternalExport.g:6325:1: ( ( ( rule__Export__LookupAssignment_1_0 ) ) ) + // InternalExport.g:6326:1: ( ( rule__Export__LookupAssignment_1_0 ) ) { - // InternalExport.g:6464:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) - // InternalExport.g:6465:2: ( rule__UnaryExpression__NameAssignment_0 ) + // InternalExport.g:6326:1: ( ( rule__Export__LookupAssignment_1_0 ) ) + // InternalExport.g:6327:2: ( rule__Export__LookupAssignment_1_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); + before(grammarAccess.getExportAccess().getLookupAssignment_1_0()); } - // InternalExport.g:6466:2: ( rule__UnaryExpression__NameAssignment_0 ) - // InternalExport.g:6466:3: rule__UnaryExpression__NameAssignment_0 + // InternalExport.g:6328:2: ( rule__Export__LookupAssignment_1_0 ) + // InternalExport.g:6328:3: rule__Export__LookupAssignment_1_0 { pushFollow(FOLLOW_2); - rule__UnaryExpression__NameAssignment_0(); + rule__Export__LookupAssignment_1_0(); state._fsp--; if (state.failed) return ; @@ -21623,7 +22999,7 @@ public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getExportAccess().getLookupAssignment_1_0()); } } @@ -21643,21 +23019,21 @@ public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__UnaryExpression__Group__0__Impl" + // $ANTLR end "rule__Export__Group_1__0__Impl" - // $ANTLR start "rule__UnaryExpression__Group__1" - // InternalExport.g:6474:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ; - public final void rule__UnaryExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1__1" + // InternalExport.g:6336:1: rule__Export__Group_1__1 : rule__Export__Group_1__1__Impl ; + public final void rule__Export__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6478:1: ( rule__UnaryExpression__Group__1__Impl ) - // InternalExport.g:6479:2: rule__UnaryExpression__Group__1__Impl + // InternalExport.g:6340:1: ( rule__Export__Group_1__1__Impl ) + // InternalExport.g:6341:2: rule__Export__Group_1__1__Impl { pushFollow(FOLLOW_2); - rule__UnaryExpression__Group__1__Impl(); + rule__Export__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -21676,38 +23052,49 @@ public final void rule__UnaryExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__UnaryExpression__Group__1" + // $ANTLR end "rule__Export__Group_1__1" - // $ANTLR start "rule__UnaryExpression__Group__1__Impl" - // InternalExport.g:6485:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ; - public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1__1__Impl" + // InternalExport.g:6347:1: rule__Export__Group_1__1__Impl : ( ( rule__Export__Group_1_1__0 )? ) ; + public final void rule__Export__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6489:1: ( ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ) - // InternalExport.g:6490:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) + // InternalExport.g:6351:1: ( ( ( rule__Export__Group_1_1__0 )? ) ) + // InternalExport.g:6352:1: ( ( rule__Export__Group_1_1__0 )? ) { - // InternalExport.g:6490:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) - // InternalExport.g:6491:2: ( rule__UnaryExpression__ParamsAssignment_1 ) + // InternalExport.g:6352:1: ( ( rule__Export__Group_1_1__0 )? ) + // InternalExport.g:6353:2: ( rule__Export__Group_1_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); + before(grammarAccess.getExportAccess().getGroup_1_1()); } - // InternalExport.g:6492:2: ( rule__UnaryExpression__ParamsAssignment_1 ) - // InternalExport.g:6492:3: rule__UnaryExpression__ParamsAssignment_1 - { - pushFollow(FOLLOW_2); - rule__UnaryExpression__ParamsAssignment_1(); + // InternalExport.g:6354:2: ( rule__Export__Group_1_1__0 )? + int alt81=2; + int LA81_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA81_0==72) ) { + alt81=1; + } + switch (alt81) { + case 1 : + // InternalExport.g:6354:3: rule__Export__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__Export__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); + after(grammarAccess.getExportAccess().getGroup_1_1()); } } @@ -21727,26 +23114,26 @@ public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__UnaryExpression__Group__1__Impl" + // $ANTLR end "rule__Export__Group_1__1__Impl" - // $ANTLR start "rule__InfixExpression__Group__0" - // InternalExport.g:6501:1: rule__InfixExpression__Group__0 : rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ; - public final void rule__InfixExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1_1__0" + // InternalExport.g:6363:1: rule__Export__Group_1_1__0 : rule__Export__Group_1_1__0__Impl rule__Export__Group_1_1__1 ; + public final void rule__Export__Group_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6505:1: ( rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ) - // InternalExport.g:6506:2: rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 + // InternalExport.g:6367:1: ( rule__Export__Group_1_1__0__Impl rule__Export__Group_1_1__1 ) + // InternalExport.g:6368:2: rule__Export__Group_1_1__0__Impl rule__Export__Group_1_1__1 { - pushFollow(FOLLOW_62); - rule__InfixExpression__Group__0__Impl(); + pushFollow(FOLLOW_18); + rule__Export__Group_1_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group__1(); + rule__Export__Group_1_1__1(); state._fsp--; if (state.failed) return ; @@ -21765,32 +23152,28 @@ public final void rule__InfixExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__InfixExpression__Group__0" + // $ANTLR end "rule__Export__Group_1_1__0" - // $ANTLR start "rule__InfixExpression__Group__0__Impl" - // InternalExport.g:6513:1: rule__InfixExpression__Group__0__Impl : ( rulePrimaryExpression ) ; - public final void rule__InfixExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1_1__0__Impl" + // InternalExport.g:6375:1: rule__Export__Group_1_1__0__Impl : ( '[' ) ; + public final void rule__Export__Group_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6517:1: ( ( rulePrimaryExpression ) ) - // InternalExport.g:6518:1: ( rulePrimaryExpression ) + // InternalExport.g:6379:1: ( ( '[' ) ) + // InternalExport.g:6380:1: ( '[' ) { - // InternalExport.g:6518:1: ( rulePrimaryExpression ) - // InternalExport.g:6519:2: rulePrimaryExpression + // InternalExport.g:6380:1: ( '[' ) + // InternalExport.g:6381:2: '[' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); } - pushFollow(FOLLOW_2); - rulePrimaryExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); } } @@ -21810,21 +23193,26 @@ public final void rule__InfixExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group__0__Impl" + // $ANTLR end "rule__Export__Group_1_1__0__Impl" - // $ANTLR start "rule__InfixExpression__Group__1" - // InternalExport.g:6528:1: rule__InfixExpression__Group__1 : rule__InfixExpression__Group__1__Impl ; - public final void rule__InfixExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1_1__1" + // InternalExport.g:6390:1: rule__Export__Group_1_1__1 : rule__Export__Group_1_1__1__Impl rule__Export__Group_1_1__2 ; + public final void rule__Export__Group_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6532:1: ( rule__InfixExpression__Group__1__Impl ) - // InternalExport.g:6533:2: rule__InfixExpression__Group__1__Impl + // InternalExport.g:6394:1: ( rule__Export__Group_1_1__1__Impl rule__Export__Group_1_1__2 ) + // InternalExport.g:6395:2: rule__Export__Group_1_1__1__Impl rule__Export__Group_1_1__2 { + pushFollow(FOLLOW_19); + rule__Export__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group__1__Impl(); + rule__Export__Group_1_1__2(); state._fsp--; if (state.failed) return ; @@ -21843,56 +23231,38 @@ public final void rule__InfixExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__InfixExpression__Group__1" + // $ANTLR end "rule__Export__Group_1_1__1" - // $ANTLR start "rule__InfixExpression__Group__1__Impl" - // InternalExport.g:6539:1: rule__InfixExpression__Group__1__Impl : ( ( rule__InfixExpression__Alternatives_1 )* ) ; - public final void rule__InfixExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1_1__1__Impl" + // InternalExport.g:6402:1: rule__Export__Group_1_1__1__Impl : ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) ; + public final void rule__Export__Group_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6543:1: ( ( ( rule__InfixExpression__Alternatives_1 )* ) ) - // InternalExport.g:6544:1: ( ( rule__InfixExpression__Alternatives_1 )* ) + // InternalExport.g:6406:1: ( ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) ) + // InternalExport.g:6407:1: ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) { - // InternalExport.g:6544:1: ( ( rule__InfixExpression__Alternatives_1 )* ) - // InternalExport.g:6545:2: ( rule__InfixExpression__Alternatives_1 )* + // InternalExport.g:6407:1: ( ( rule__Export__LookupPredicateAssignment_1_1_1 ) ) + // InternalExport.g:6408:2: ( rule__Export__LookupPredicateAssignment_1_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + before(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); } - // InternalExport.g:6546:2: ( rule__InfixExpression__Alternatives_1 )* - loop58: - do { - int alt58=2; - int LA58_0 = input.LA(1); - - if ( (LA58_0==68) ) { - alt58=1; - } - - - switch (alt58) { - case 1 : - // InternalExport.g:6546:3: rule__InfixExpression__Alternatives_1 - { - pushFollow(FOLLOW_63); - rule__InfixExpression__Alternatives_1(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:6409:2: ( rule__Export__LookupPredicateAssignment_1_1_1 ) + // InternalExport.g:6409:3: rule__Export__LookupPredicateAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__Export__LookupPredicateAssignment_1_1_1(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop58; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + after(grammarAccess.getExportAccess().getLookupPredicateAssignment_1_1_1()); } } @@ -21912,26 +23282,21 @@ public final void rule__InfixExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group__1__Impl" + // $ANTLR end "rule__Export__Group_1_1__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__0" - // InternalExport.g:6555:1: rule__InfixExpression__Group_1_0__0 : rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ; - public final void rule__InfixExpression__Group_1_0__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1_1__2" + // InternalExport.g:6417:1: rule__Export__Group_1_1__2 : rule__Export__Group_1_1__2__Impl ; + public final void rule__Export__Group_1_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6559:1: ( rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ) - // InternalExport.g:6560:2: rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 + // InternalExport.g:6421:1: ( rule__Export__Group_1_1__2__Impl ) + // InternalExport.g:6422:2: rule__Export__Group_1_1__2__Impl { - pushFollow(FOLLOW_62); - rule__InfixExpression__Group_1_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__1(); + rule__Export__Group_1_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -21950,32 +23315,28 @@ public final void rule__InfixExpression__Group_1_0__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__0" + // $ANTLR end "rule__Export__Group_1_1__2" - // $ANTLR start "rule__InfixExpression__Group_1_0__0__Impl" - // InternalExport.g:6567:1: rule__InfixExpression__Group_1_0__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_1_1__2__Impl" + // InternalExport.g:6428:1: rule__Export__Group_1_1__2__Impl : ( ']' ) ; + public final void rule__Export__Group_1_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6571:1: ( ( () ) ) - // InternalExport.g:6572:1: ( () ) + // InternalExport.g:6432:1: ( ( ']' ) ) + // InternalExport.g:6433:1: ( ']' ) { - // InternalExport.g:6572:1: ( () ) - // InternalExport.g:6573:2: () + // InternalExport.g:6433:1: ( ']' ) + // InternalExport.g:6434:2: ']' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); - } - // InternalExport.g:6574:2: () - // InternalExport.g:6574:3: - { + before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); } - + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); } } @@ -21984,6 +23345,10 @@ public final void rule__InfixExpression__Group_1_0__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -21991,26 +23356,26 @@ public final void rule__InfixExpression__Group_1_0__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__0__Impl" + // $ANTLR end "rule__Export__Group_1_1__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__1" - // InternalExport.g:6582:1: rule__InfixExpression__Group_1_0__1 : rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ; - public final void rule__InfixExpression__Group_1_0__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_3__0" + // InternalExport.g:6444:1: rule__Export__Group_3__0 : rule__Export__Group_3__0__Impl rule__Export__Group_3__1 ; + public final void rule__Export__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6586:1: ( rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ) - // InternalExport.g:6587:2: rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 + // InternalExport.g:6448:1: ( rule__Export__Group_3__0__Impl rule__Export__Group_3__1 ) + // InternalExport.g:6449:2: rule__Export__Group_3__0__Impl rule__Export__Group_3__1 { - pushFollow(FOLLOW_10); - rule__InfixExpression__Group_1_0__1__Impl(); + pushFollow(FOLLOW_31); + rule__Export__Group_3__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__2(); + rule__Export__Group_3__1(); state._fsp--; if (state.failed) return ; @@ -22029,28 +23394,28 @@ public final void rule__InfixExpression__Group_1_0__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__1" + // $ANTLR end "rule__Export__Group_3__0" - // $ANTLR start "rule__InfixExpression__Group_1_0__1__Impl" - // InternalExport.g:6594:1: rule__InfixExpression__Group_1_0__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_3__0__Impl" + // InternalExport.g:6456:1: rule__Export__Group_3__0__Impl : ( 'as' ) ; + public final void rule__Export__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6598:1: ( ( '.' ) ) - // InternalExport.g:6599:1: ( '.' ) + // InternalExport.g:6460:1: ( ( 'as' ) ) + // InternalExport.g:6461:1: ( 'as' ) { - // InternalExport.g:6599:1: ( '.' ) - // InternalExport.g:6600:2: '.' + // InternalExport.g:6461:1: ( 'as' ) + // InternalExport.g:6462:2: 'as' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + before(grammarAccess.getExportAccess().getAsKeyword_3_0()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,70,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + after(grammarAccess.getExportAccess().getAsKeyword_3_0()); } } @@ -22070,26 +23435,26 @@ public final void rule__InfixExpression__Group_1_0__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__1__Impl" + // $ANTLR end "rule__Export__Group_3__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__2" - // InternalExport.g:6609:1: rule__InfixExpression__Group_1_0__2 : rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ; - public final void rule__InfixExpression__Group_1_0__2() throws RecognitionException { + // $ANTLR start "rule__Export__Group_3__1" + // InternalExport.g:6471:1: rule__Export__Group_3__1 : rule__Export__Group_3__1__Impl rule__Export__Group_3__2 ; + public final void rule__Export__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6613:1: ( rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ) - // InternalExport.g:6614:2: rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 + // InternalExport.g:6475:1: ( rule__Export__Group_3__1__Impl rule__Export__Group_3__2 ) + // InternalExport.g:6476:2: rule__Export__Group_3__1__Impl rule__Export__Group_3__2 { - pushFollow(FOLLOW_34); - rule__InfixExpression__Group_1_0__2__Impl(); + pushFollow(FOLLOW_31); + rule__Export__Group_3__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__3(); + rule__Export__Group_3__2(); state._fsp--; if (state.failed) return ; @@ -22108,38 +23473,49 @@ public final void rule__InfixExpression__Group_1_0__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__2" + // $ANTLR end "rule__Export__Group_3__1" - // $ANTLR start "rule__InfixExpression__Group_1_0__2__Impl" - // InternalExport.g:6621:1: rule__InfixExpression__Group_1_0__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ; - public final void rule__InfixExpression__Group_1_0__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_3__1__Impl" + // InternalExport.g:6483:1: rule__Export__Group_3__1__Impl : ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) ; + public final void rule__Export__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6625:1: ( ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ) - // InternalExport.g:6626:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) + // InternalExport.g:6487:1: ( ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) ) + // InternalExport.g:6488:1: ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) { - // InternalExport.g:6626:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) - // InternalExport.g:6627:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) + // InternalExport.g:6488:1: ( ( rule__Export__QualifiedNameAssignment_3_1 )? ) + // InternalExport.g:6489:2: ( rule__Export__QualifiedNameAssignment_3_1 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + before(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); } - // InternalExport.g:6628:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) - // InternalExport.g:6628:3: rule__InfixExpression__NameAssignment_1_0_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_0_2(); + // InternalExport.g:6490:2: ( rule__Export__QualifiedNameAssignment_3_1 )? + int alt82=2; + int LA82_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA82_0==110) ) { + alt82=1; + } + switch (alt82) { + case 1 : + // InternalExport.g:6490:3: rule__Export__QualifiedNameAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__Export__QualifiedNameAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + after(grammarAccess.getExportAccess().getQualifiedNameAssignment_3_1()); } } @@ -22159,26 +23535,21 @@ public final void rule__InfixExpression__Group_1_0__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__2__Impl" + // $ANTLR end "rule__Export__Group_3__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__3" - // InternalExport.g:6636:1: rule__InfixExpression__Group_1_0__3 : rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ; - public final void rule__InfixExpression__Group_1_0__3() throws RecognitionException { + // $ANTLR start "rule__Export__Group_3__2" + // InternalExport.g:6498:1: rule__Export__Group_3__2 : rule__Export__Group_3__2__Impl ; + public final void rule__Export__Group_3__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6640:1: ( rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ) - // InternalExport.g:6641:2: rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 + // InternalExport.g:6502:1: ( rule__Export__Group_3__2__Impl ) + // InternalExport.g:6503:2: rule__Export__Group_3__2__Impl { - pushFollow(FOLLOW_64); - rule__InfixExpression__Group_1_0__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__4(); + rule__Export__Group_3__2__Impl(); state._fsp--; if (state.failed) return ; @@ -22197,28 +23568,38 @@ public final void rule__InfixExpression__Group_1_0__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__3" + // $ANTLR end "rule__Export__Group_3__2" - // $ANTLR start "rule__InfixExpression__Group_1_0__3__Impl" - // InternalExport.g:6648:1: rule__InfixExpression__Group_1_0__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_0__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_3__2__Impl" + // InternalExport.g:6509:1: rule__Export__Group_3__2__Impl : ( ( rule__Export__NamingAssignment_3_2 ) ) ; + public final void rule__Export__Group_3__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6652:1: ( ( '(' ) ) - // InternalExport.g:6653:1: ( '(' ) + // InternalExport.g:6513:1: ( ( ( rule__Export__NamingAssignment_3_2 ) ) ) + // InternalExport.g:6514:1: ( ( rule__Export__NamingAssignment_3_2 ) ) { - // InternalExport.g:6653:1: ( '(' ) - // InternalExport.g:6654:2: '(' + // InternalExport.g:6514:1: ( ( rule__Export__NamingAssignment_3_2 ) ) + // InternalExport.g:6515:2: ( rule__Export__NamingAssignment_3_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + before(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:6516:2: ( rule__Export__NamingAssignment_3_2 ) + // InternalExport.g:6516:3: rule__Export__NamingAssignment_3_2 + { + pushFollow(FOLLOW_2); + rule__Export__NamingAssignment_3_2(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + after(grammarAccess.getExportAccess().getNamingAssignment_3_2()); } } @@ -22238,26 +23619,26 @@ public final void rule__InfixExpression__Group_1_0__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__3__Impl" + // $ANTLR end "rule__Export__Group_3__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__4" - // InternalExport.g:6663:1: rule__InfixExpression__Group_1_0__4 : rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ; - public final void rule__InfixExpression__Group_1_0__4() throws RecognitionException { + // $ANTLR start "rule__Export__Group_4__0" + // InternalExport.g:6525:1: rule__Export__Group_4__0 : rule__Export__Group_4__0__Impl rule__Export__Group_4__1 ; + public final void rule__Export__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6667:1: ( rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ) - // InternalExport.g:6668:2: rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 + // InternalExport.g:6529:1: ( rule__Export__Group_4__0__Impl rule__Export__Group_4__1 ) + // InternalExport.g:6530:2: rule__Export__Group_4__0__Impl rule__Export__Group_4__1 { - pushFollow(FOLLOW_64); - rule__InfixExpression__Group_1_0__4__Impl(); + pushFollow(FOLLOW_18); + rule__Export__Group_4__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__5(); + rule__Export__Group_4__1(); state._fsp--; if (state.failed) return ; @@ -22276,49 +23657,28 @@ public final void rule__InfixExpression__Group_1_0__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__4" + // $ANTLR end "rule__Export__Group_4__0" - // $ANTLR start "rule__InfixExpression__Group_1_0__4__Impl" - // InternalExport.g:6675:1: rule__InfixExpression__Group_1_0__4__Impl : ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ; - public final void rule__InfixExpression__Group_1_0__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_4__0__Impl" + // InternalExport.g:6537:1: rule__Export__Group_4__0__Impl : ( '[' ) ; + public final void rule__Export__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6679:1: ( ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ) - // InternalExport.g:6680:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) + // InternalExport.g:6541:1: ( ( '[' ) ) + // InternalExport.g:6542:1: ( '[' ) { - // InternalExport.g:6680:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) - // InternalExport.g:6681:2: ( rule__InfixExpression__Group_1_0_4__0 )? + // InternalExport.g:6542:1: ( '[' ) + // InternalExport.g:6543:2: '[' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); - } - // InternalExport.g:6682:2: ( rule__InfixExpression__Group_1_0_4__0 )? - int alt59=2; - int LA59_0 = input.LA(1); - - if ( ((LA59_0>=RULE_ID && LA59_0<=RULE_REAL)||LA59_0==19||(LA59_0>=22 && LA59_0<=35)||LA59_0==39||LA59_0==51||LA59_0==58||LA59_0==62||LA59_0==65||(LA59_0>=70 && LA59_0<=71)||(LA59_0>=80 && LA59_0<=81)) ) { - alt59=1; - } - switch (alt59) { - case 1 : - // InternalExport.g:6682:3: rule__InfixExpression__Group_1_0_4__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); } - + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + after(grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); } } @@ -22338,21 +23698,26 @@ public final void rule__InfixExpression__Group_1_0__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__4__Impl" + // $ANTLR end "rule__Export__Group_4__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__5" - // InternalExport.g:6690:1: rule__InfixExpression__Group_1_0__5 : rule__InfixExpression__Group_1_0__5__Impl ; - public final void rule__InfixExpression__Group_1_0__5() throws RecognitionException { + // $ANTLR start "rule__Export__Group_4__1" + // InternalExport.g:6552:1: rule__Export__Group_4__1 : rule__Export__Group_4__1__Impl rule__Export__Group_4__2 ; + public final void rule__Export__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6694:1: ( rule__InfixExpression__Group_1_0__5__Impl ) - // InternalExport.g:6695:2: rule__InfixExpression__Group_1_0__5__Impl + // InternalExport.g:6556:1: ( rule__Export__Group_4__1__Impl rule__Export__Group_4__2 ) + // InternalExport.g:6557:2: rule__Export__Group_4__1__Impl rule__Export__Group_4__2 { + pushFollow(FOLLOW_19); + rule__Export__Group_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__5__Impl(); + rule__Export__Group_4__2(); state._fsp--; if (state.failed) return ; @@ -22371,28 +23736,38 @@ public final void rule__InfixExpression__Group_1_0__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__5" + // $ANTLR end "rule__Export__Group_4__1" - // $ANTLR start "rule__InfixExpression__Group_1_0__5__Impl" - // InternalExport.g:6701:1: rule__InfixExpression__Group_1_0__5__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_0__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_4__1__Impl" + // InternalExport.g:6564:1: rule__Export__Group_4__1__Impl : ( ( rule__Export__GuardAssignment_4_1 ) ) ; + public final void rule__Export__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6705:1: ( ( ')' ) ) - // InternalExport.g:6706:1: ( ')' ) + // InternalExport.g:6568:1: ( ( ( rule__Export__GuardAssignment_4_1 ) ) ) + // InternalExport.g:6569:1: ( ( rule__Export__GuardAssignment_4_1 ) ) { - // InternalExport.g:6706:1: ( ')' ) - // InternalExport.g:6707:2: ')' + // InternalExport.g:6569:1: ( ( rule__Export__GuardAssignment_4_1 ) ) + // InternalExport.g:6570:2: ( rule__Export__GuardAssignment_4_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + before(grammarAccess.getExportAccess().getGuardAssignment_4_1()); + } + // InternalExport.g:6571:2: ( rule__Export__GuardAssignment_4_1 ) + // InternalExport.g:6571:3: rule__Export__GuardAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__Export__GuardAssignment_4_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + after(grammarAccess.getExportAccess().getGuardAssignment_4_1()); } } @@ -22412,26 +23787,21 @@ public final void rule__InfixExpression__Group_1_0__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__5__Impl" + // $ANTLR end "rule__Export__Group_4__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__0" - // InternalExport.g:6717:1: rule__InfixExpression__Group_1_0_4__0 : rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ; - public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_4__2" + // InternalExport.g:6579:1: rule__Export__Group_4__2 : rule__Export__Group_4__2__Impl ; + public final void rule__Export__Group_4__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6721:1: ( rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ) - // InternalExport.g:6722:2: rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 + // InternalExport.g:6583:1: ( rule__Export__Group_4__2__Impl ) + // InternalExport.g:6584:2: rule__Export__Group_4__2__Impl { - pushFollow(FOLLOW_21); - rule__InfixExpression__Group_1_0_4__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__1(); + rule__Export__Group_4__2__Impl(); state._fsp--; if (state.failed) return ; @@ -22450,38 +23820,28 @@ public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__0" + // $ANTLR end "rule__Export__Group_4__2" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__0__Impl" - // InternalExport.g:6729:1: rule__InfixExpression__Group_1_0_4__0__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ; - public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_4__2__Impl" + // InternalExport.g:6590:1: rule__Export__Group_4__2__Impl : ( ']' ) ; + public final void rule__Export__Group_4__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6733:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ) - // InternalExport.g:6734:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) + // InternalExport.g:6594:1: ( ( ']' ) ) + // InternalExport.g:6595:1: ( ']' ) { - // InternalExport.g:6734:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) - // InternalExport.g:6735:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) + // InternalExport.g:6595:1: ( ']' ) + // InternalExport.g:6596:2: ']' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); - } - // InternalExport.g:6736:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) - // InternalExport.g:6736:3: rule__InfixExpression__ParamsAssignment_1_0_4_0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__ParamsAssignment_1_0_4_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); } - + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); + after(grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); } } @@ -22501,21 +23861,26 @@ public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__0__Impl" + // $ANTLR end "rule__Export__Group_4__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__1" - // InternalExport.g:6744:1: rule__InfixExpression__Group_1_0_4__1 : rule__InfixExpression__Group_1_0_4__1__Impl ; - public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__0" + // InternalExport.g:6606:1: rule__Export__Group_6__0 : rule__Export__Group_6__0__Impl rule__Export__Group_6__1 ; + public final void rule__Export__Group_6__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6748:1: ( rule__InfixExpression__Group_1_0_4__1__Impl ) - // InternalExport.g:6749:2: rule__InfixExpression__Group_1_0_4__1__Impl + // InternalExport.g:6610:1: ( rule__Export__Group_6__0__Impl rule__Export__Group_6__1 ) + // InternalExport.g:6611:2: rule__Export__Group_6__0__Impl rule__Export__Group_6__1 { + pushFollow(FOLLOW_32); + rule__Export__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__1__Impl(); + rule__Export__Group_6__1(); state._fsp--; if (state.failed) return ; @@ -22534,56 +23899,28 @@ public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__1" + // $ANTLR end "rule__Export__Group_6__0" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__1__Impl" - // InternalExport.g:6755:1: rule__InfixExpression__Group_1_0_4__1__Impl : ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ; - public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__0__Impl" + // InternalExport.g:6618:1: rule__Export__Group_6__0__Impl : ( 'uri-fragment' ) ; + public final void rule__Export__Group_6__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6759:1: ( ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ) - // InternalExport.g:6760:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + // InternalExport.g:6622:1: ( ( 'uri-fragment' ) ) + // InternalExport.g:6623:1: ( 'uri-fragment' ) { - // InternalExport.g:6760:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) - // InternalExport.g:6761:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + // InternalExport.g:6623:1: ( 'uri-fragment' ) + // InternalExport.g:6624:2: 'uri-fragment' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + before(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } - // InternalExport.g:6762:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* - loop60: - do { - int alt60=2; - int LA60_0 = input.LA(1); - - if ( (LA60_0==48) ) { - alt60=1; - } - - - switch (alt60) { - case 1 : - // InternalExport.g:6762:3: rule__InfixExpression__Group_1_0_4_1__0 - { - pushFollow(FOLLOW_22); - rule__InfixExpression__Group_1_0_4_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop60; - } - } while (true); - + match(input,79,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + after(grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } } @@ -22603,26 +23940,26 @@ public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__1__Impl" + // $ANTLR end "rule__Export__Group_6__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0" - // InternalExport.g:6771:1: rule__InfixExpression__Group_1_0_4_1__0 : rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ; - public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__1" + // InternalExport.g:6633:1: rule__Export__Group_6__1 : rule__Export__Group_6__1__Impl rule__Export__Group_6__2 ; + public final void rule__Export__Group_6__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6775:1: ( rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ) - // InternalExport.g:6776:2: rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 + // InternalExport.g:6637:1: ( rule__Export__Group_6__1__Impl rule__Export__Group_6__2 ) + // InternalExport.g:6638:2: rule__Export__Group_6__1__Impl rule__Export__Group_6__2 { - pushFollow(FOLLOW_18); - rule__InfixExpression__Group_1_0_4_1__0__Impl(); + pushFollow(FOLLOW_33); + rule__Export__Group_6__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4_1__1(); + rule__Export__Group_6__2(); state._fsp--; if (state.failed) return ; @@ -22641,28 +23978,28 @@ public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0" + // $ANTLR end "rule__Export__Group_6__1" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0__Impl" - // InternalExport.g:6783:1: rule__InfixExpression__Group_1_0_4_1__0__Impl : ( ',' ) ; - public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__1__Impl" + // InternalExport.g:6645:1: rule__Export__Group_6__1__Impl : ( '=' ) ; + public final void rule__Export__Group_6__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6787:1: ( ( ',' ) ) - // InternalExport.g:6788:1: ( ',' ) + // InternalExport.g:6649:1: ( ( '=' ) ) + // InternalExport.g:6650:1: ( '=' ) { - // InternalExport.g:6788:1: ( ',' ) - // InternalExport.g:6789:2: ',' + // InternalExport.g:6650:1: ( '=' ) + // InternalExport.g:6651:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + before(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + after(grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); } } @@ -22682,21 +24019,26 @@ public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws Recogni } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0__Impl" + // $ANTLR end "rule__Export__Group_6__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1" - // InternalExport.g:6798:1: rule__InfixExpression__Group_1_0_4_1__1 : rule__InfixExpression__Group_1_0_4_1__1__Impl ; - public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__2" + // InternalExport.g:6660:1: rule__Export__Group_6__2 : rule__Export__Group_6__2__Impl rule__Export__Group_6__3 ; + public final void rule__Export__Group_6__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6802:1: ( rule__InfixExpression__Group_1_0_4_1__1__Impl ) - // InternalExport.g:6803:2: rule__InfixExpression__Group_1_0_4_1__1__Impl + // InternalExport.g:6664:1: ( rule__Export__Group_6__2__Impl rule__Export__Group_6__3 ) + // InternalExport.g:6665:2: rule__Export__Group_6__2__Impl rule__Export__Group_6__3 { + pushFollow(FOLLOW_33); + rule__Export__Group_6__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4_1__1__Impl(); + rule__Export__Group_6__3(); state._fsp--; if (state.failed) return ; @@ -22715,38 +24057,49 @@ public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1" + // $ANTLR end "rule__Export__Group_6__2" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1__Impl" - // InternalExport.g:6809:1: rule__InfixExpression__Group_1_0_4_1__1__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ; - public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__2__Impl" + // InternalExport.g:6672:1: rule__Export__Group_6__2__Impl : ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) ; + public final void rule__Export__Group_6__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6813:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ) - // InternalExport.g:6814:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + // InternalExport.g:6676:1: ( ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) ) + // InternalExport.g:6677:1: ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) { - // InternalExport.g:6814:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) - // InternalExport.g:6815:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + // InternalExport.g:6677:1: ( ( rule__Export__FragmentUniqueAssignment_6_2 )? ) + // InternalExport.g:6678:2: ( rule__Export__FragmentUniqueAssignment_6_2 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + before(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); } - // InternalExport.g:6816:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) - // InternalExport.g:6816:3: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__ParamsAssignment_1_0_4_1_1(); + // InternalExport.g:6679:2: ( rule__Export__FragmentUniqueAssignment_6_2 )? + int alt83=2; + int LA83_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA83_0==111) ) { + alt83=1; + } + switch (alt83) { + case 1 : + // InternalExport.g:6679:3: rule__Export__FragmentUniqueAssignment_6_2 + { + pushFollow(FOLLOW_2); + rule__Export__FragmentUniqueAssignment_6_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + after(grammarAccess.getExportAccess().getFragmentUniqueAssignment_6_2()); } } @@ -22766,26 +24119,26 @@ public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws Recogni } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1__Impl" + // $ANTLR end "rule__Export__Group_6__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_1__0" - // InternalExport.g:6825:1: rule__InfixExpression__Group_1_1__0 : rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ; - public final void rule__InfixExpression__Group_1_1__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__3" + // InternalExport.g:6687:1: rule__Export__Group_6__3 : rule__Export__Group_6__3__Impl rule__Export__Group_6__4 ; + public final void rule__Export__Group_6__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6829:1: ( rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ) - // InternalExport.g:6830:2: rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 + // InternalExport.g:6691:1: ( rule__Export__Group_6__3__Impl rule__Export__Group_6__4 ) + // InternalExport.g:6692:2: rule__Export__Group_6__3__Impl rule__Export__Group_6__4 { - pushFollow(FOLLOW_62); - rule__InfixExpression__Group_1_1__0__Impl(); + pushFollow(FOLLOW_34); + rule__Export__Group_6__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__1(); + rule__Export__Group_6__4(); state._fsp--; if (state.failed) return ; @@ -22804,32 +24157,28 @@ public final void rule__InfixExpression__Group_1_1__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__0" + // $ANTLR end "rule__Export__Group_6__3" - // $ANTLR start "rule__InfixExpression__Group_1_1__0__Impl" - // InternalExport.g:6837:1: rule__InfixExpression__Group_1_1__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__3__Impl" + // InternalExport.g:6699:1: rule__Export__Group_6__3__Impl : ( 'attribute' ) ; + public final void rule__Export__Group_6__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6841:1: ( ( () ) ) - // InternalExport.g:6842:1: ( () ) + // InternalExport.g:6703:1: ( ( 'attribute' ) ) + // InternalExport.g:6704:1: ( 'attribute' ) { - // InternalExport.g:6842:1: ( () ) - // InternalExport.g:6843:2: () + // InternalExport.g:6704:1: ( 'attribute' ) + // InternalExport.g:6705:2: 'attribute' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); - } - // InternalExport.g:6844:2: () - // InternalExport.g:6844:3: - { + before(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } - + match(input,80,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + after(grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } } @@ -22838,6 +24187,10 @@ public final void rule__InfixExpression__Group_1_1__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -22845,26 +24198,26 @@ public final void rule__InfixExpression__Group_1_1__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__0__Impl" + // $ANTLR end "rule__Export__Group_6__3__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_1__1" - // InternalExport.g:6852:1: rule__InfixExpression__Group_1_1__1 : rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ; - public final void rule__InfixExpression__Group_1_1__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__4" + // InternalExport.g:6714:1: rule__Export__Group_6__4 : rule__Export__Group_6__4__Impl rule__Export__Group_6__5 ; + public final void rule__Export__Group_6__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6856:1: ( rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ) - // InternalExport.g:6857:2: rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 + // InternalExport.g:6718:1: ( rule__Export__Group_6__4__Impl rule__Export__Group_6__5 ) + // InternalExport.g:6719:2: rule__Export__Group_6__4__Impl rule__Export__Group_6__5 { - pushFollow(FOLLOW_40); - rule__InfixExpression__Group_1_1__1__Impl(); + pushFollow(FOLLOW_11); + rule__Export__Group_6__4__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__2(); + rule__Export__Group_6__5(); state._fsp--; if (state.failed) return ; @@ -22883,28 +24236,28 @@ public final void rule__InfixExpression__Group_1_1__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__1" + // $ANTLR end "rule__Export__Group_6__4" - // $ANTLR start "rule__InfixExpression__Group_1_1__1__Impl" - // InternalExport.g:6864:1: rule__InfixExpression__Group_1_1__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__4__Impl" + // InternalExport.g:6726:1: rule__Export__Group_6__4__Impl : ( '(' ) ; + public final void rule__Export__Group_6__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6868:1: ( ( '.' ) ) - // InternalExport.g:6869:1: ( '.' ) + // InternalExport.g:6730:1: ( ( '(' ) ) + // InternalExport.g:6731:1: ( '(' ) { - // InternalExport.g:6869:1: ( '.' ) - // InternalExport.g:6870:2: '.' + // InternalExport.g:6731:1: ( '(' ) + // InternalExport.g:6732:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + before(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + after(grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); } } @@ -22924,21 +24277,26 @@ public final void rule__InfixExpression__Group_1_1__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__1__Impl" + // $ANTLR end "rule__Export__Group_6__4__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_1__2" - // InternalExport.g:6879:1: rule__InfixExpression__Group_1_1__2 : rule__InfixExpression__Group_1_1__2__Impl ; - public final void rule__InfixExpression__Group_1_1__2() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__5" + // InternalExport.g:6741:1: rule__Export__Group_6__5 : rule__Export__Group_6__5__Impl rule__Export__Group_6__6 ; + public final void rule__Export__Group_6__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6883:1: ( rule__InfixExpression__Group_1_1__2__Impl ) - // InternalExport.g:6884:2: rule__InfixExpression__Group_1_1__2__Impl + // InternalExport.g:6745:1: ( rule__Export__Group_6__5__Impl rule__Export__Group_6__6 ) + // InternalExport.g:6746:2: rule__Export__Group_6__5__Impl rule__Export__Group_6__6 { + pushFollow(FOLLOW_25); + rule__Export__Group_6__5__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__2__Impl(); + rule__Export__Group_6__6(); state._fsp--; if (state.failed) return ; @@ -22957,30 +24315,30 @@ public final void rule__InfixExpression__Group_1_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__2" + // $ANTLR end "rule__Export__Group_6__5" - // $ANTLR start "rule__InfixExpression__Group_1_1__2__Impl" - // InternalExport.g:6890:1: rule__InfixExpression__Group_1_1__2__Impl : ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ; - public final void rule__InfixExpression__Group_1_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__5__Impl" + // InternalExport.g:6753:1: rule__Export__Group_6__5__Impl : ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) ; + public final void rule__Export__Group_6__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6894:1: ( ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ) - // InternalExport.g:6895:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + // InternalExport.g:6757:1: ( ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) ) + // InternalExport.g:6758:1: ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) { - // InternalExport.g:6895:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) - // InternalExport.g:6896:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + // InternalExport.g:6758:1: ( ( rule__Export__FragmentAttributeAssignment_6_5 ) ) + // InternalExport.g:6759:2: ( rule__Export__FragmentAttributeAssignment_6_5 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + before(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); } - // InternalExport.g:6897:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) - // InternalExport.g:6897:3: rule__InfixExpression__TypeAssignment_1_1_2 + // InternalExport.g:6760:2: ( rule__Export__FragmentAttributeAssignment_6_5 ) + // InternalExport.g:6760:3: rule__Export__FragmentAttributeAssignment_6_5 { pushFollow(FOLLOW_2); - rule__InfixExpression__TypeAssignment_1_1_2(); + rule__Export__FragmentAttributeAssignment_6_5(); state._fsp--; if (state.failed) return ; @@ -22988,7 +24346,7 @@ public final void rule__InfixExpression__Group_1_1__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + after(grammarAccess.getExportAccess().getFragmentAttributeAssignment_6_5()); } } @@ -23008,26 +24366,26 @@ public final void rule__InfixExpression__Group_1_1__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__2__Impl" + // $ANTLR end "rule__Export__Group_6__5__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__0" - // InternalExport.g:6906:1: rule__InfixExpression__Group_1_2__0 : rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ; - public final void rule__InfixExpression__Group_1_2__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__6" + // InternalExport.g:6768:1: rule__Export__Group_6__6 : rule__Export__Group_6__6__Impl rule__Export__Group_6__7 ; + public final void rule__Export__Group_6__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6910:1: ( rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ) - // InternalExport.g:6911:2: rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 + // InternalExport.g:6772:1: ( rule__Export__Group_6__6__Impl rule__Export__Group_6__7 ) + // InternalExport.g:6773:2: rule__Export__Group_6__6__Impl rule__Export__Group_6__7 { - pushFollow(FOLLOW_62); - rule__InfixExpression__Group_1_2__0__Impl(); + pushFollow(FOLLOW_35); + rule__Export__Group_6__6__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__1(); + rule__Export__Group_6__7(); state._fsp--; if (state.failed) return ; @@ -23046,32 +24404,28 @@ public final void rule__InfixExpression__Group_1_2__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__0" + // $ANTLR end "rule__Export__Group_6__6" - // $ANTLR start "rule__InfixExpression__Group_1_2__0__Impl" - // InternalExport.g:6918:1: rule__InfixExpression__Group_1_2__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__6__Impl" + // InternalExport.g:6780:1: rule__Export__Group_6__6__Impl : ( ')' ) ; + public final void rule__Export__Group_6__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6922:1: ( ( () ) ) - // InternalExport.g:6923:1: ( () ) + // InternalExport.g:6784:1: ( ( ')' ) ) + // InternalExport.g:6785:1: ( ')' ) { - // InternalExport.g:6923:1: ( () ) - // InternalExport.g:6924:2: () + // InternalExport.g:6785:1: ( ')' ) + // InternalExport.g:6786:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); - } - // InternalExport.g:6925:2: () - // InternalExport.g:6925:3: - { + before(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + after(grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } } @@ -23080,6 +24434,10 @@ public final void rule__InfixExpression__Group_1_2__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -23087,26 +24445,21 @@ public final void rule__InfixExpression__Group_1_2__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__0__Impl" + // $ANTLR end "rule__Export__Group_6__6__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__1" - // InternalExport.g:6933:1: rule__InfixExpression__Group_1_2__1 : rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ; - public final void rule__InfixExpression__Group_1_2__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__7" + // InternalExport.g:6795:1: rule__Export__Group_6__7 : rule__Export__Group_6__7__Impl ; + public final void rule__Export__Group_6__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6937:1: ( rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ) - // InternalExport.g:6938:2: rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 + // InternalExport.g:6799:1: ( rule__Export__Group_6__7__Impl ) + // InternalExport.g:6800:2: rule__Export__Group_6__7__Impl { - pushFollow(FOLLOW_65); - rule__InfixExpression__Group_1_2__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__2(); + rule__Export__Group_6__7__Impl(); state._fsp--; if (state.failed) return ; @@ -23125,28 +24478,28 @@ public final void rule__InfixExpression__Group_1_2__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__1" + // $ANTLR end "rule__Export__Group_6__7" - // $ANTLR start "rule__InfixExpression__Group_1_2__1__Impl" - // InternalExport.g:6945:1: rule__InfixExpression__Group_1_2__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_6__7__Impl" + // InternalExport.g:6806:1: rule__Export__Group_6__7__Impl : ( ';' ) ; + public final void rule__Export__Group_6__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6949:1: ( ( '.' ) ) - // InternalExport.g:6950:1: ( '.' ) + // InternalExport.g:6810:1: ( ( ';' ) ) + // InternalExport.g:6811:1: ( ';' ) { - // InternalExport.g:6950:1: ( '.' ) - // InternalExport.g:6951:2: '.' + // InternalExport.g:6811:1: ( ';' ) + // InternalExport.g:6812:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + before(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + after(grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); } } @@ -23166,26 +24519,26 @@ public final void rule__InfixExpression__Group_1_2__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__1__Impl" + // $ANTLR end "rule__Export__Group_6__7__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__2" - // InternalExport.g:6960:1: rule__InfixExpression__Group_1_2__2 : rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ; - public final void rule__InfixExpression__Group_1_2__2() throws RecognitionException { + // $ANTLR start "rule__Export__Group_7__0" + // InternalExport.g:6822:1: rule__Export__Group_7__0 : rule__Export__Group_7__0__Impl rule__Export__Group_7__1 ; + public final void rule__Export__Group_7__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6964:1: ( rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ) - // InternalExport.g:6965:2: rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 + // InternalExport.g:6826:1: ( rule__Export__Group_7__0__Impl rule__Export__Group_7__1 ) + // InternalExport.g:6827:2: rule__Export__Group_7__0__Impl rule__Export__Group_7__1 { - pushFollow(FOLLOW_34); - rule__InfixExpression__Group_1_2__2__Impl(); + pushFollow(FOLLOW_35); + rule__Export__Group_7__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__3(); + rule__Export__Group_7__1(); state._fsp--; if (state.failed) return ; @@ -23204,30 +24557,30 @@ public final void rule__InfixExpression__Group_1_2__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__2" + // $ANTLR end "rule__Export__Group_7__0" - // $ANTLR start "rule__InfixExpression__Group_1_2__2__Impl" - // InternalExport.g:6972:1: rule__InfixExpression__Group_1_2__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ; - public final void rule__InfixExpression__Group_1_2__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_7__0__Impl" + // InternalExport.g:6834:1: rule__Export__Group_7__0__Impl : ( ( rule__Export__Alternatives_7_0 ) ) ; + public final void rule__Export__Group_7__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6976:1: ( ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ) - // InternalExport.g:6977:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + // InternalExport.g:6838:1: ( ( ( rule__Export__Alternatives_7_0 ) ) ) + // InternalExport.g:6839:1: ( ( rule__Export__Alternatives_7_0 ) ) { - // InternalExport.g:6977:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) - // InternalExport.g:6978:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + // InternalExport.g:6839:1: ( ( rule__Export__Alternatives_7_0 ) ) + // InternalExport.g:6840:2: ( rule__Export__Alternatives_7_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + before(grammarAccess.getExportAccess().getAlternatives_7_0()); } - // InternalExport.g:6979:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) - // InternalExport.g:6979:3: rule__InfixExpression__NameAssignment_1_2_2 + // InternalExport.g:6841:2: ( rule__Export__Alternatives_7_0 ) + // InternalExport.g:6841:3: rule__Export__Alternatives_7_0 { pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_2_2(); + rule__Export__Alternatives_7_0(); state._fsp--; if (state.failed) return ; @@ -23235,7 +24588,7 @@ public final void rule__InfixExpression__Group_1_2__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + after(grammarAccess.getExportAccess().getAlternatives_7_0()); } } @@ -23255,26 +24608,21 @@ public final void rule__InfixExpression__Group_1_2__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__2__Impl" + // $ANTLR end "rule__Export__Group_7__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__3" - // InternalExport.g:6987:1: rule__InfixExpression__Group_1_2__3 : rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ; - public final void rule__InfixExpression__Group_1_2__3() throws RecognitionException { + // $ANTLR start "rule__Export__Group_7__1" + // InternalExport.g:6849:1: rule__Export__Group_7__1 : rule__Export__Group_7__1__Impl ; + public final void rule__Export__Group_7__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:6991:1: ( rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ) - // InternalExport.g:6992:2: rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 + // InternalExport.g:6853:1: ( rule__Export__Group_7__1__Impl ) + // InternalExport.g:6854:2: rule__Export__Group_7__1__Impl { - pushFollow(FOLLOW_40); - rule__InfixExpression__Group_1_2__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__4(); + rule__Export__Group_7__1__Impl(); state._fsp--; if (state.failed) return ; @@ -23293,28 +24641,28 @@ public final void rule__InfixExpression__Group_1_2__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__3" + // $ANTLR end "rule__Export__Group_7__1" - // $ANTLR start "rule__InfixExpression__Group_1_2__3__Impl" - // InternalExport.g:6999:1: rule__InfixExpression__Group_1_2__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_2__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_7__1__Impl" + // InternalExport.g:6860:1: rule__Export__Group_7__1__Impl : ( ';' ) ; + public final void rule__Export__Group_7__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7003:1: ( ( '(' ) ) - // InternalExport.g:7004:1: ( '(' ) + // InternalExport.g:6864:1: ( ( ';' ) ) + // InternalExport.g:6865:1: ( ';' ) { - // InternalExport.g:7004:1: ( '(' ) - // InternalExport.g:7005:2: '(' + // InternalExport.g:6865:1: ( ';' ) + // InternalExport.g:6866:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + before(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + after(grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); } } @@ -23334,26 +24682,26 @@ public final void rule__InfixExpression__Group_1_2__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__3__Impl" + // $ANTLR end "rule__Export__Group_7__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__4" - // InternalExport.g:7014:1: rule__InfixExpression__Group_1_2__4 : rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ; - public final void rule__InfixExpression__Group_1_2__4() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__0" + // InternalExport.g:6876:1: rule__Export__Group_8_0__0 : rule__Export__Group_8_0__0__Impl rule__Export__Group_8_0__1 ; + public final void rule__Export__Group_8_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7018:1: ( rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ) - // InternalExport.g:7019:2: rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 + // InternalExport.g:6880:1: ( rule__Export__Group_8_0__0__Impl rule__Export__Group_8_0__1 ) + // InternalExport.g:6881:2: rule__Export__Group_8_0__0__Impl rule__Export__Group_8_0__1 { - pushFollow(FOLLOW_25); - rule__InfixExpression__Group_1_2__4__Impl(); + pushFollow(FOLLOW_11); + rule__Export__Group_8_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__5(); + rule__Export__Group_8_0__1(); state._fsp--; if (state.failed) return ; @@ -23372,38 +24720,28 @@ public final void rule__InfixExpression__Group_1_2__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__4" + // $ANTLR end "rule__Export__Group_8_0__0" - // $ANTLR start "rule__InfixExpression__Group_1_2__4__Impl" - // InternalExport.g:7026:1: rule__InfixExpression__Group_1_2__4__Impl : ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ; - public final void rule__InfixExpression__Group_1_2__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__0__Impl" + // InternalExport.g:6888:1: rule__Export__Group_8_0__0__Impl : ( 'field' ) ; + public final void rule__Export__Group_8_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7030:1: ( ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ) - // InternalExport.g:7031:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + // InternalExport.g:6892:1: ( ( 'field' ) ) + // InternalExport.g:6893:1: ( 'field' ) { - // InternalExport.g:7031:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) - // InternalExport.g:7032:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + // InternalExport.g:6893:1: ( 'field' ) + // InternalExport.g:6894:2: 'field' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); - } - // InternalExport.g:7033:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) - // InternalExport.g:7033:3: rule__InfixExpression__TypeAssignment_1_2_4 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__TypeAssignment_1_2_4(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); } - + match(input,81,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + after(grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); } } @@ -23423,21 +24761,26 @@ public final void rule__InfixExpression__Group_1_2__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__4__Impl" + // $ANTLR end "rule__Export__Group_8_0__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__5" - // InternalExport.g:7041:1: rule__InfixExpression__Group_1_2__5 : rule__InfixExpression__Group_1_2__5__Impl ; - public final void rule__InfixExpression__Group_1_2__5() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__1" + // InternalExport.g:6903:1: rule__Export__Group_8_0__1 : rule__Export__Group_8_0__1__Impl rule__Export__Group_8_0__2 ; + public final void rule__Export__Group_8_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7045:1: ( rule__InfixExpression__Group_1_2__5__Impl ) - // InternalExport.g:7046:2: rule__InfixExpression__Group_1_2__5__Impl + // InternalExport.g:6907:1: ( rule__Export__Group_8_0__1__Impl rule__Export__Group_8_0__2 ) + // InternalExport.g:6908:2: rule__Export__Group_8_0__1__Impl rule__Export__Group_8_0__2 { + pushFollow(FOLLOW_36); + rule__Export__Group_8_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__5__Impl(); + rule__Export__Group_8_0__2(); state._fsp--; if (state.failed) return ; @@ -23456,28 +24799,38 @@ public final void rule__InfixExpression__Group_1_2__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__5" + // $ANTLR end "rule__Export__Group_8_0__1" - // $ANTLR start "rule__InfixExpression__Group_1_2__5__Impl" - // InternalExport.g:7052:1: rule__InfixExpression__Group_1_2__5__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_2__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__1__Impl" + // InternalExport.g:6915:1: rule__Export__Group_8_0__1__Impl : ( ( rule__Export__AttributesAssignment_8_0_1 ) ) ; + public final void rule__Export__Group_8_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7056:1: ( ( ')' ) ) - // InternalExport.g:7057:1: ( ')' ) + // InternalExport.g:6919:1: ( ( ( rule__Export__AttributesAssignment_8_0_1 ) ) ) + // InternalExport.g:6920:1: ( ( rule__Export__AttributesAssignment_8_0_1 ) ) { - // InternalExport.g:7057:1: ( ')' ) - // InternalExport.g:7058:2: ')' + // InternalExport.g:6920:1: ( ( rule__Export__AttributesAssignment_8_0_1 ) ) + // InternalExport.g:6921:2: ( rule__Export__AttributesAssignment_8_0_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); + } + // InternalExport.g:6922:2: ( rule__Export__AttributesAssignment_8_0_1 ) + // InternalExport.g:6922:3: rule__Export__AttributesAssignment_8_0_1 + { + pushFollow(FOLLOW_2); + rule__Export__AttributesAssignment_8_0_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_1()); } } @@ -23497,26 +24850,26 @@ public final void rule__InfixExpression__Group_1_2__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__5__Impl" + // $ANTLR end "rule__Export__Group_8_0__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__0" - // InternalExport.g:7068:1: rule__InfixExpression__Group_1_3__0 : rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ; - public final void rule__InfixExpression__Group_1_3__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__2" + // InternalExport.g:6930:1: rule__Export__Group_8_0__2 : rule__Export__Group_8_0__2__Impl rule__Export__Group_8_0__3 ; + public final void rule__Export__Group_8_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7072:1: ( rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ) - // InternalExport.g:7073:2: rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 + // InternalExport.g:6934:1: ( rule__Export__Group_8_0__2__Impl rule__Export__Group_8_0__3 ) + // InternalExport.g:6935:2: rule__Export__Group_8_0__2__Impl rule__Export__Group_8_0__3 { - pushFollow(FOLLOW_62); - rule__InfixExpression__Group_1_3__0__Impl(); + pushFollow(FOLLOW_36); + rule__Export__Group_8_0__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__1(); + rule__Export__Group_8_0__3(); state._fsp--; if (state.failed) return ; @@ -23535,32 +24888,56 @@ public final void rule__InfixExpression__Group_1_3__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__0" + // $ANTLR end "rule__Export__Group_8_0__2" - // $ANTLR start "rule__InfixExpression__Group_1_3__0__Impl" - // InternalExport.g:7080:1: rule__InfixExpression__Group_1_3__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__2__Impl" + // InternalExport.g:6942:1: rule__Export__Group_8_0__2__Impl : ( ( rule__Export__Group_8_0_2__0 )* ) ; + public final void rule__Export__Group_8_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7084:1: ( ( () ) ) - // InternalExport.g:7085:1: ( () ) + // InternalExport.g:6946:1: ( ( ( rule__Export__Group_8_0_2__0 )* ) ) + // InternalExport.g:6947:1: ( ( rule__Export__Group_8_0_2__0 )* ) { - // InternalExport.g:7085:1: ( () ) - // InternalExport.g:7086:2: () + // InternalExport.g:6947:1: ( ( rule__Export__Group_8_0_2__0 )* ) + // InternalExport.g:6948:2: ( rule__Export__Group_8_0_2__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); - } - // InternalExport.g:7087:2: () - // InternalExport.g:7087:3: - { + before(grammarAccess.getExportAccess().getGroup_8_0_2()); } + // InternalExport.g:6949:2: ( rule__Export__Group_8_0_2__0 )* + loop84: + do { + int alt84=2; + int LA84_0 = input.LA(1); + + if ( (LA84_0==74) ) { + alt84=1; + } + + + switch (alt84) { + case 1 : + // InternalExport.g:6949:3: rule__Export__Group_8_0_2__0 + { + pushFollow(FOLLOW_22); + rule__Export__Group_8_0_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop84; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + after(grammarAccess.getExportAccess().getGroup_8_0_2()); } } @@ -23569,6 +24946,10 @@ public final void rule__InfixExpression__Group_1_3__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -23576,26 +24957,21 @@ public final void rule__InfixExpression__Group_1_3__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__0__Impl" + // $ANTLR end "rule__Export__Group_8_0__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__1" - // InternalExport.g:7095:1: rule__InfixExpression__Group_1_3__1 : rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ; - public final void rule__InfixExpression__Group_1_3__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__3" + // InternalExport.g:6957:1: rule__Export__Group_8_0__3 : rule__Export__Group_8_0__3__Impl ; + public final void rule__Export__Group_8_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7099:1: ( rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ) - // InternalExport.g:7100:2: rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 + // InternalExport.g:6961:1: ( rule__Export__Group_8_0__3__Impl ) + // InternalExport.g:6962:2: rule__Export__Group_8_0__3__Impl { - pushFollow(FOLLOW_66); - rule__InfixExpression__Group_1_3__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__2(); + rule__Export__Group_8_0__3__Impl(); state._fsp--; if (state.failed) return ; @@ -23614,28 +24990,28 @@ public final void rule__InfixExpression__Group_1_3__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__1" + // $ANTLR end "rule__Export__Group_8_0__3" - // $ANTLR start "rule__InfixExpression__Group_1_3__1__Impl" - // InternalExport.g:7107:1: rule__InfixExpression__Group_1_3__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0__3__Impl" + // InternalExport.g:6968:1: rule__Export__Group_8_0__3__Impl : ( ';' ) ; + public final void rule__Export__Group_8_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7111:1: ( ( '.' ) ) - // InternalExport.g:7112:1: ( '.' ) + // InternalExport.g:6972:1: ( ( ';' ) ) + // InternalExport.g:6973:1: ( ';' ) { - // InternalExport.g:7112:1: ( '.' ) - // InternalExport.g:7113:2: '.' + // InternalExport.g:6973:1: ( ';' ) + // InternalExport.g:6974:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + before(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + after(grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); } } @@ -23655,26 +25031,26 @@ public final void rule__InfixExpression__Group_1_3__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__1__Impl" + // $ANTLR end "rule__Export__Group_8_0__3__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__2" - // InternalExport.g:7122:1: rule__InfixExpression__Group_1_3__2 : rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ; - public final void rule__InfixExpression__Group_1_3__2() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0_2__0" + // InternalExport.g:6984:1: rule__Export__Group_8_0_2__0 : rule__Export__Group_8_0_2__0__Impl rule__Export__Group_8_0_2__1 ; + public final void rule__Export__Group_8_0_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7126:1: ( rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ) - // InternalExport.g:7127:2: rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 + // InternalExport.g:6988:1: ( rule__Export__Group_8_0_2__0__Impl rule__Export__Group_8_0_2__1 ) + // InternalExport.g:6989:2: rule__Export__Group_8_0_2__0__Impl rule__Export__Group_8_0_2__1 { - pushFollow(FOLLOW_34); - rule__InfixExpression__Group_1_3__2__Impl(); + pushFollow(FOLLOW_11); + rule__Export__Group_8_0_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__3(); + rule__Export__Group_8_0_2__1(); state._fsp--; if (state.failed) return ; @@ -23693,38 +25069,28 @@ public final void rule__InfixExpression__Group_1_3__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__2" + // $ANTLR end "rule__Export__Group_8_0_2__0" - // $ANTLR start "rule__InfixExpression__Group_1_3__2__Impl" - // InternalExport.g:7134:1: rule__InfixExpression__Group_1_3__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ; - public final void rule__InfixExpression__Group_1_3__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0_2__0__Impl" + // InternalExport.g:6996:1: rule__Export__Group_8_0_2__0__Impl : ( ',' ) ; + public final void rule__Export__Group_8_0_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7138:1: ( ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ) - // InternalExport.g:7139:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + // InternalExport.g:7000:1: ( ( ',' ) ) + // InternalExport.g:7001:1: ( ',' ) { - // InternalExport.g:7139:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) - // InternalExport.g:7140:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + // InternalExport.g:7001:1: ( ',' ) + // InternalExport.g:7002:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); - } - // InternalExport.g:7141:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) - // InternalExport.g:7141:3: rule__InfixExpression__NameAssignment_1_3_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_3_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); } - + match(input,74,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); + after(grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); } } @@ -23744,26 +25110,21 @@ public final void rule__InfixExpression__Group_1_3__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__2__Impl" + // $ANTLR end "rule__Export__Group_8_0_2__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__3" - // InternalExport.g:7149:1: rule__InfixExpression__Group_1_3__3 : rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ; - public final void rule__InfixExpression__Group_1_3__3() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0_2__1" + // InternalExport.g:7011:1: rule__Export__Group_8_0_2__1 : rule__Export__Group_8_0_2__1__Impl ; + public final void rule__Export__Group_8_0_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7153:1: ( rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ) - // InternalExport.g:7154:2: rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 + // InternalExport.g:7015:1: ( rule__Export__Group_8_0_2__1__Impl ) + // InternalExport.g:7016:2: rule__Export__Group_8_0_2__1__Impl { - pushFollow(FOLLOW_18); - rule__InfixExpression__Group_1_3__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__4(); + rule__Export__Group_8_0_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -23782,28 +25143,38 @@ public final void rule__InfixExpression__Group_1_3__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__3" + // $ANTLR end "rule__Export__Group_8_0_2__1" - // $ANTLR start "rule__InfixExpression__Group_1_3__3__Impl" - // InternalExport.g:7161:1: rule__InfixExpression__Group_1_3__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_3__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_0_2__1__Impl" + // InternalExport.g:7022:1: rule__Export__Group_8_0_2__1__Impl : ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) ; + public final void rule__Export__Group_8_0_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7165:1: ( ( '(' ) ) - // InternalExport.g:7166:1: ( '(' ) + // InternalExport.g:7026:1: ( ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) ) + // InternalExport.g:7027:1: ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) { - // InternalExport.g:7166:1: ( '(' ) - // InternalExport.g:7167:2: '(' + // InternalExport.g:7027:1: ( ( rule__Export__AttributesAssignment_8_0_2_1 ) ) + // InternalExport.g:7028:2: ( rule__Export__AttributesAssignment_8_0_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + before(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7029:2: ( rule__Export__AttributesAssignment_8_0_2_1 ) + // InternalExport.g:7029:3: rule__Export__AttributesAssignment_8_0_2_1 + { + pushFollow(FOLLOW_2); + rule__Export__AttributesAssignment_8_0_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + after(grammarAccess.getExportAccess().getAttributesAssignment_8_0_2_1()); } } @@ -23823,26 +25194,26 @@ public final void rule__InfixExpression__Group_1_3__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__3__Impl" + // $ANTLR end "rule__Export__Group_8_0_2__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__4" - // InternalExport.g:7176:1: rule__InfixExpression__Group_1_3__4 : rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ; - public final void rule__InfixExpression__Group_1_3__4() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__0" + // InternalExport.g:7038:1: rule__Export__Group_8_1__0 : rule__Export__Group_8_1__0__Impl rule__Export__Group_8_1__1 ; + public final void rule__Export__Group_8_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7180:1: ( rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ) - // InternalExport.g:7181:2: rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 + // InternalExport.g:7042:1: ( rule__Export__Group_8_1__0__Impl rule__Export__Group_8_1__1 ) + // InternalExport.g:7043:2: rule__Export__Group_8_1__0__Impl rule__Export__Group_8_1__1 { - pushFollow(FOLLOW_18); - rule__InfixExpression__Group_1_3__4__Impl(); + pushFollow(FOLLOW_11); + rule__Export__Group_8_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__5(); + rule__Export__Group_8_1__1(); state._fsp--; if (state.failed) return ; @@ -23861,53 +25232,28 @@ public final void rule__InfixExpression__Group_1_3__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__4" + // $ANTLR end "rule__Export__Group_8_1__0" - // $ANTLR start "rule__InfixExpression__Group_1_3__4__Impl" - // InternalExport.g:7188:1: rule__InfixExpression__Group_1_3__4__Impl : ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ; - public final void rule__InfixExpression__Group_1_3__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__0__Impl" + // InternalExport.g:7050:1: rule__Export__Group_8_1__0__Impl : ( 'data' ) ; + public final void rule__Export__Group_8_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7192:1: ( ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ) - // InternalExport.g:7193:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + // InternalExport.g:7054:1: ( ( 'data' ) ) + // InternalExport.g:7055:1: ( 'data' ) { - // InternalExport.g:7193:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) - // InternalExport.g:7194:2: ( rule__InfixExpression__Group_1_3_4__0 )? + // InternalExport.g:7055:1: ( 'data' ) + // InternalExport.g:7056:2: 'data' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); - } - // InternalExport.g:7195:2: ( rule__InfixExpression__Group_1_3_4__0 )? - int alt61=2; - int LA61_0 = input.LA(1); - - if ( (LA61_0==RULE_ID) ) { - int LA61_1 = input.LA(2); - - if ( (LA61_1==69) ) { - alt61=1; - } - } - switch (alt61) { - case 1 : - // InternalExport.g:7195:3: rule__InfixExpression__Group_1_3_4__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); } - + match(input,82,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + after(grammarAccess.getExportAccess().getDataKeyword_8_1_0()); } } @@ -23927,26 +25273,26 @@ public final void rule__InfixExpression__Group_1_3__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__4__Impl" + // $ANTLR end "rule__Export__Group_8_1__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__5" - // InternalExport.g:7203:1: rule__InfixExpression__Group_1_3__5 : rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ; - public final void rule__InfixExpression__Group_1_3__5() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__1" + // InternalExport.g:7065:1: rule__Export__Group_8_1__1 : rule__Export__Group_8_1__1__Impl rule__Export__Group_8_1__2 ; + public final void rule__Export__Group_8_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7207:1: ( rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ) - // InternalExport.g:7208:2: rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 + // InternalExport.g:7069:1: ( rule__Export__Group_8_1__1__Impl rule__Export__Group_8_1__2 ) + // InternalExport.g:7070:2: rule__Export__Group_8_1__1__Impl rule__Export__Group_8_1__2 { - pushFollow(FOLLOW_25); - rule__InfixExpression__Group_1_3__5__Impl(); + pushFollow(FOLLOW_36); + rule__Export__Group_8_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__6(); + rule__Export__Group_8_1__2(); state._fsp--; if (state.failed) return ; @@ -23965,30 +25311,30 @@ public final void rule__InfixExpression__Group_1_3__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__5" + // $ANTLR end "rule__Export__Group_8_1__1" - // $ANTLR start "rule__InfixExpression__Group_1_3__5__Impl" - // InternalExport.g:7215:1: rule__InfixExpression__Group_1_3__5__Impl : ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ; - public final void rule__InfixExpression__Group_1_3__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__1__Impl" + // InternalExport.g:7077:1: rule__Export__Group_8_1__1__Impl : ( ( rule__Export__UserDataAssignment_8_1_1 ) ) ; + public final void rule__Export__Group_8_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7219:1: ( ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ) - // InternalExport.g:7220:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + // InternalExport.g:7081:1: ( ( ( rule__Export__UserDataAssignment_8_1_1 ) ) ) + // InternalExport.g:7082:1: ( ( rule__Export__UserDataAssignment_8_1_1 ) ) { - // InternalExport.g:7220:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) - // InternalExport.g:7221:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + // InternalExport.g:7082:1: ( ( rule__Export__UserDataAssignment_8_1_1 ) ) + // InternalExport.g:7083:2: ( rule__Export__UserDataAssignment_8_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); } - // InternalExport.g:7222:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) - // InternalExport.g:7222:3: rule__InfixExpression__ExpAssignment_1_3_5 + // InternalExport.g:7084:2: ( rule__Export__UserDataAssignment_8_1_1 ) + // InternalExport.g:7084:3: rule__Export__UserDataAssignment_8_1_1 { pushFollow(FOLLOW_2); - rule__InfixExpression__ExpAssignment_1_3_5(); + rule__Export__UserDataAssignment_8_1_1(); state._fsp--; if (state.failed) return ; @@ -23996,7 +25342,7 @@ public final void rule__InfixExpression__Group_1_3__5__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_1()); } } @@ -24016,21 +25362,26 @@ public final void rule__InfixExpression__Group_1_3__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__5__Impl" + // $ANTLR end "rule__Export__Group_8_1__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__6" - // InternalExport.g:7230:1: rule__InfixExpression__Group_1_3__6 : rule__InfixExpression__Group_1_3__6__Impl ; - public final void rule__InfixExpression__Group_1_3__6() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__2" + // InternalExport.g:7092:1: rule__Export__Group_8_1__2 : rule__Export__Group_8_1__2__Impl rule__Export__Group_8_1__3 ; + public final void rule__Export__Group_8_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7234:1: ( rule__InfixExpression__Group_1_3__6__Impl ) - // InternalExport.g:7235:2: rule__InfixExpression__Group_1_3__6__Impl + // InternalExport.g:7096:1: ( rule__Export__Group_8_1__2__Impl rule__Export__Group_8_1__3 ) + // InternalExport.g:7097:2: rule__Export__Group_8_1__2__Impl rule__Export__Group_8_1__3 { + pushFollow(FOLLOW_36); + rule__Export__Group_8_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__6__Impl(); + rule__Export__Group_8_1__3(); state._fsp--; if (state.failed) return ; @@ -24049,28 +25400,56 @@ public final void rule__InfixExpression__Group_1_3__6() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__6" + // $ANTLR end "rule__Export__Group_8_1__2" - // $ANTLR start "rule__InfixExpression__Group_1_3__6__Impl" - // InternalExport.g:7241:1: rule__InfixExpression__Group_1_3__6__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_3__6__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__2__Impl" + // InternalExport.g:7104:1: rule__Export__Group_8_1__2__Impl : ( ( rule__Export__Group_8_1_2__0 )* ) ; + public final void rule__Export__Group_8_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7245:1: ( ( ')' ) ) - // InternalExport.g:7246:1: ( ')' ) + // InternalExport.g:7108:1: ( ( ( rule__Export__Group_8_1_2__0 )* ) ) + // InternalExport.g:7109:1: ( ( rule__Export__Group_8_1_2__0 )* ) { - // InternalExport.g:7246:1: ( ')' ) - // InternalExport.g:7247:2: ')' + // InternalExport.g:7109:1: ( ( rule__Export__Group_8_1_2__0 )* ) + // InternalExport.g:7110:2: ( rule__Export__Group_8_1_2__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + before(grammarAccess.getExportAccess().getGroup_8_1_2()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7111:2: ( rule__Export__Group_8_1_2__0 )* + loop85: + do { + int alt85=2; + int LA85_0 = input.LA(1); + + if ( (LA85_0==74) ) { + alt85=1; + } + + + switch (alt85) { + case 1 : + // InternalExport.g:7111:3: rule__Export__Group_8_1_2__0 + { + pushFollow(FOLLOW_22); + rule__Export__Group_8_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop85; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + after(grammarAccess.getExportAccess().getGroup_8_1_2()); } } @@ -24090,26 +25469,21 @@ public final void rule__InfixExpression__Group_1_3__6__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__6__Impl" + // $ANTLR end "rule__Export__Group_8_1__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__0" - // InternalExport.g:7257:1: rule__InfixExpression__Group_1_3_4__0 : rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ; - public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__3" + // InternalExport.g:7119:1: rule__Export__Group_8_1__3 : rule__Export__Group_8_1__3__Impl ; + public final void rule__Export__Group_8_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7261:1: ( rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ) - // InternalExport.g:7262:2: rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 + // InternalExport.g:7123:1: ( rule__Export__Group_8_1__3__Impl ) + // InternalExport.g:7124:2: rule__Export__Group_8_1__3__Impl { - pushFollow(FOLLOW_67); - rule__InfixExpression__Group_1_3_4__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__1(); + rule__Export__Group_8_1__3__Impl(); state._fsp--; if (state.failed) return ; @@ -24128,38 +25502,28 @@ public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__0" + // $ANTLR end "rule__Export__Group_8_1__3" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__0__Impl" - // InternalExport.g:7269:1: rule__InfixExpression__Group_1_3_4__0__Impl : ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ; - public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1__3__Impl" + // InternalExport.g:7130:1: rule__Export__Group_8_1__3__Impl : ( ';' ) ; + public final void rule__Export__Group_8_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7273:1: ( ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ) - // InternalExport.g:7274:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + // InternalExport.g:7134:1: ( ( ';' ) ) + // InternalExport.g:7135:1: ( ';' ) { - // InternalExport.g:7274:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) - // InternalExport.g:7275:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + // InternalExport.g:7135:1: ( ';' ) + // InternalExport.g:7136:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); - } - // InternalExport.g:7276:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) - // InternalExport.g:7276:3: rule__InfixExpression__VarAssignment_1_3_4_0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__VarAssignment_1_3_4_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); } - + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + after(grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); } } @@ -24179,21 +25543,26 @@ public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__0__Impl" + // $ANTLR end "rule__Export__Group_8_1__3__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__1" - // InternalExport.g:7284:1: rule__InfixExpression__Group_1_3_4__1 : rule__InfixExpression__Group_1_3_4__1__Impl ; - public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1_2__0" + // InternalExport.g:7146:1: rule__Export__Group_8_1_2__0 : rule__Export__Group_8_1_2__0__Impl rule__Export__Group_8_1_2__1 ; + public final void rule__Export__Group_8_1_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7288:1: ( rule__InfixExpression__Group_1_3_4__1__Impl ) - // InternalExport.g:7289:2: rule__InfixExpression__Group_1_3_4__1__Impl + // InternalExport.g:7150:1: ( rule__Export__Group_8_1_2__0__Impl rule__Export__Group_8_1_2__1 ) + // InternalExport.g:7151:2: rule__Export__Group_8_1_2__0__Impl rule__Export__Group_8_1_2__1 { + pushFollow(FOLLOW_11); + rule__Export__Group_8_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__1__Impl(); + rule__Export__Group_8_1_2__1(); state._fsp--; if (state.failed) return ; @@ -24212,28 +25581,28 @@ public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__1" + // $ANTLR end "rule__Export__Group_8_1_2__0" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__1__Impl" - // InternalExport.g:7295:1: rule__InfixExpression__Group_1_3_4__1__Impl : ( '|' ) ; - public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1_2__0__Impl" + // InternalExport.g:7158:1: rule__Export__Group_8_1_2__0__Impl : ( ',' ) ; + public final void rule__Export__Group_8_1_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7299:1: ( ( '|' ) ) - // InternalExport.g:7300:1: ( '|' ) + // InternalExport.g:7162:1: ( ( ',' ) ) + // InternalExport.g:7163:1: ( ',' ) { - // InternalExport.g:7300:1: ( '|' ) - // InternalExport.g:7301:2: '|' + // InternalExport.g:7163:1: ( ',' ) + // InternalExport.g:7164:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + before(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); } - match(input,69,FOLLOW_2); if (state.failed) return ; + match(input,74,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + after(grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); } } @@ -24253,26 +25622,21 @@ public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__1__Impl" + // $ANTLR end "rule__Export__Group_8_1_2__0__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__0" - // InternalExport.g:7311:1: rule__ParanthesizedExpression__Group__0 : rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ; - public final void rule__ParanthesizedExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1_2__1" + // InternalExport.g:7173:1: rule__Export__Group_8_1_2__1 : rule__Export__Group_8_1_2__1__Impl ; + public final void rule__Export__Group_8_1_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7315:1: ( rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ) - // InternalExport.g:7316:2: rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 + // InternalExport.g:7177:1: ( rule__Export__Group_8_1_2__1__Impl ) + // InternalExport.g:7178:2: rule__Export__Group_8_1_2__1__Impl { - pushFollow(FOLLOW_18); - rule__ParanthesizedExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__1(); + rule__Export__Group_8_1_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -24291,28 +25655,38 @@ public final void rule__ParanthesizedExpression__Group__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__0" + // $ANTLR end "rule__Export__Group_8_1_2__1" - // $ANTLR start "rule__ParanthesizedExpression__Group__0__Impl" - // InternalExport.g:7323:1: rule__ParanthesizedExpression__Group__0__Impl : ( '(' ) ; - public final void rule__ParanthesizedExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Export__Group_8_1_2__1__Impl" + // InternalExport.g:7184:1: rule__Export__Group_8_1_2__1__Impl : ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) ; + public final void rule__Export__Group_8_1_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7327:1: ( ( '(' ) ) - // InternalExport.g:7328:1: ( '(' ) + // InternalExport.g:7188:1: ( ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) ) + // InternalExport.g:7189:1: ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) { - // InternalExport.g:7328:1: ( '(' ) - // InternalExport.g:7329:2: '(' + // InternalExport.g:7189:1: ( ( rule__Export__UserDataAssignment_8_1_2_1 ) ) + // InternalExport.g:7190:2: ( rule__Export__UserDataAssignment_8_1_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + before(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7191:2: ( rule__Export__UserDataAssignment_8_1_2_1 ) + // InternalExport.g:7191:3: rule__Export__UserDataAssignment_8_1_2_1 + { + pushFollow(FOLLOW_2); + rule__Export__UserDataAssignment_8_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + after(grammarAccess.getExportAccess().getUserDataAssignment_8_1_2_1()); } } @@ -24332,26 +25706,26 @@ public final void rule__ParanthesizedExpression__Group__0__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__0__Impl" + // $ANTLR end "rule__Export__Group_8_1_2__1__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__1" - // InternalExport.g:7338:1: rule__ParanthesizedExpression__Group__1 : rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ; - public final void rule__ParanthesizedExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__UserData__Group__0" + // InternalExport.g:7200:1: rule__UserData__Group__0 : rule__UserData__Group__0__Impl rule__UserData__Group__1 ; + public final void rule__UserData__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7342:1: ( rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ) - // InternalExport.g:7343:2: rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 + // InternalExport.g:7204:1: ( rule__UserData__Group__0__Impl rule__UserData__Group__1 ) + // InternalExport.g:7205:2: rule__UserData__Group__0__Impl rule__UserData__Group__1 { - pushFollow(FOLLOW_25); - rule__ParanthesizedExpression__Group__1__Impl(); + pushFollow(FOLLOW_32); + rule__UserData__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__2(); + rule__UserData__Group__1(); state._fsp--; if (state.failed) return ; @@ -24370,32 +25744,38 @@ public final void rule__ParanthesizedExpression__Group__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__1" + // $ANTLR end "rule__UserData__Group__0" - // $ANTLR start "rule__ParanthesizedExpression__Group__1__Impl" - // InternalExport.g:7350:1: rule__ParanthesizedExpression__Group__1__Impl : ( ruleExpression ) ; - public final void rule__ParanthesizedExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__UserData__Group__0__Impl" + // InternalExport.g:7212:1: rule__UserData__Group__0__Impl : ( ( rule__UserData__NameAssignment_0 ) ) ; + public final void rule__UserData__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7354:1: ( ( ruleExpression ) ) - // InternalExport.g:7355:1: ( ruleExpression ) + // InternalExport.g:7216:1: ( ( ( rule__UserData__NameAssignment_0 ) ) ) + // InternalExport.g:7217:1: ( ( rule__UserData__NameAssignment_0 ) ) { - // InternalExport.g:7355:1: ( ruleExpression ) - // InternalExport.g:7356:2: ruleExpression + // InternalExport.g:7217:1: ( ( rule__UserData__NameAssignment_0 ) ) + // InternalExport.g:7218:2: ( rule__UserData__NameAssignment_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + before(grammarAccess.getUserDataAccess().getNameAssignment_0()); } + // InternalExport.g:7219:2: ( rule__UserData__NameAssignment_0 ) + // InternalExport.g:7219:3: rule__UserData__NameAssignment_0 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__UserData__NameAssignment_0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + after(grammarAccess.getUserDataAccess().getNameAssignment_0()); } } @@ -24415,21 +25795,26 @@ public final void rule__ParanthesizedExpression__Group__1__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__1__Impl" + // $ANTLR end "rule__UserData__Group__0__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__2" - // InternalExport.g:7365:1: rule__ParanthesizedExpression__Group__2 : rule__ParanthesizedExpression__Group__2__Impl ; - public final void rule__ParanthesizedExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__UserData__Group__1" + // InternalExport.g:7227:1: rule__UserData__Group__1 : rule__UserData__Group__1__Impl rule__UserData__Group__2 ; + public final void rule__UserData__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7369:1: ( rule__ParanthesizedExpression__Group__2__Impl ) - // InternalExport.g:7370:2: rule__ParanthesizedExpression__Group__2__Impl + // InternalExport.g:7231:1: ( rule__UserData__Group__1__Impl rule__UserData__Group__2 ) + // InternalExport.g:7232:2: rule__UserData__Group__1__Impl rule__UserData__Group__2 { + pushFollow(FOLLOW_18); + rule__UserData__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__2__Impl(); + rule__UserData__Group__2(); state._fsp--; if (state.failed) return ; @@ -24448,28 +25833,28 @@ public final void rule__ParanthesizedExpression__Group__2() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__2" + // $ANTLR end "rule__UserData__Group__1" - // $ANTLR start "rule__ParanthesizedExpression__Group__2__Impl" - // InternalExport.g:7376:1: rule__ParanthesizedExpression__Group__2__Impl : ( ')' ) ; - public final void rule__ParanthesizedExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__UserData__Group__1__Impl" + // InternalExport.g:7239:1: rule__UserData__Group__1__Impl : ( '=' ) ; + public final void rule__UserData__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7380:1: ( ( ')' ) ) - // InternalExport.g:7381:1: ( ')' ) + // InternalExport.g:7243:1: ( ( '=' ) ) + // InternalExport.g:7244:1: ( '=' ) { - // InternalExport.g:7381:1: ( ')' ) - // InternalExport.g:7382:2: ')' + // InternalExport.g:7244:1: ( '=' ) + // InternalExport.g:7245:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + before(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + after(grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); } } @@ -24489,26 +25874,21 @@ public final void rule__ParanthesizedExpression__Group__2__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__2__Impl" + // $ANTLR end "rule__UserData__Group__1__Impl" - // $ANTLR start "rule__GlobalVarExpression__Group__0" - // InternalExport.g:7392:1: rule__GlobalVarExpression__Group__0 : rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ; - public final void rule__GlobalVarExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__UserData__Group__2" + // InternalExport.g:7254:1: rule__UserData__Group__2 : rule__UserData__Group__2__Impl ; + public final void rule__UserData__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7396:1: ( rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ) - // InternalExport.g:7397:2: rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 + // InternalExport.g:7258:1: ( rule__UserData__Group__2__Impl ) + // InternalExport.g:7259:2: rule__UserData__Group__2__Impl { - pushFollow(FOLLOW_10); - rule__GlobalVarExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalVarExpression__Group__1(); + rule__UserData__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -24527,28 +25907,38 @@ public final void rule__GlobalVarExpression__Group__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__0" + // $ANTLR end "rule__UserData__Group__2" - // $ANTLR start "rule__GlobalVarExpression__Group__0__Impl" - // InternalExport.g:7404:1: rule__GlobalVarExpression__Group__0__Impl : ( 'GLOBALVAR' ) ; - public final void rule__GlobalVarExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__UserData__Group__2__Impl" + // InternalExport.g:7265:1: rule__UserData__Group__2__Impl : ( ( rule__UserData__ExprAssignment_2 ) ) ; + public final void rule__UserData__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7408:1: ( ( 'GLOBALVAR' ) ) - // InternalExport.g:7409:1: ( 'GLOBALVAR' ) + // InternalExport.g:7269:1: ( ( ( rule__UserData__ExprAssignment_2 ) ) ) + // InternalExport.g:7270:1: ( ( rule__UserData__ExprAssignment_2 ) ) { - // InternalExport.g:7409:1: ( 'GLOBALVAR' ) - // InternalExport.g:7410:2: 'GLOBALVAR' + // InternalExport.g:7270:1: ( ( rule__UserData__ExprAssignment_2 ) ) + // InternalExport.g:7271:2: ( rule__UserData__ExprAssignment_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + before(grammarAccess.getUserDataAccess().getExprAssignment_2()); } - match(input,70,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7272:2: ( rule__UserData__ExprAssignment_2 ) + // InternalExport.g:7272:3: rule__UserData__ExprAssignment_2 + { + pushFollow(FOLLOW_2); + rule__UserData__ExprAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + after(grammarAccess.getUserDataAccess().getExprAssignment_2()); } } @@ -24568,21 +25958,26 @@ public final void rule__GlobalVarExpression__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__0__Impl" + // $ANTLR end "rule__UserData__Group__2__Impl" - // $ANTLR start "rule__GlobalVarExpression__Group__1" - // InternalExport.g:7419:1: rule__GlobalVarExpression__Group__1 : rule__GlobalVarExpression__Group__1__Impl ; - public final void rule__GlobalVarExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__0" + // InternalExport.g:7281:1: rule__QualifiedID__Group__0 : rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ; + public final void rule__QualifiedID__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7423:1: ( rule__GlobalVarExpression__Group__1__Impl ) - // InternalExport.g:7424:2: rule__GlobalVarExpression__Group__1__Impl + // InternalExport.g:7285:1: ( rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ) + // InternalExport.g:7286:2: rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 { + pushFollow(FOLLOW_37); + rule__QualifiedID__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalVarExpression__Group__1__Impl(); + rule__QualifiedID__Group__1(); state._fsp--; if (state.failed) return ; @@ -24601,38 +25996,28 @@ public final void rule__GlobalVarExpression__Group__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__1" + // $ANTLR end "rule__QualifiedID__Group__0" - // $ANTLR start "rule__GlobalVarExpression__Group__1__Impl" - // InternalExport.g:7430:1: rule__GlobalVarExpression__Group__1__Impl : ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ; - public final void rule__GlobalVarExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__0__Impl" + // InternalExport.g:7293:1: rule__QualifiedID__Group__0__Impl : ( RULE_ID ) ; + public final void rule__QualifiedID__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7434:1: ( ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ) - // InternalExport.g:7435:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + // InternalExport.g:7297:1: ( ( RULE_ID ) ) + // InternalExport.g:7298:1: ( RULE_ID ) { - // InternalExport.g:7435:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) - // InternalExport.g:7436:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + // InternalExport.g:7298:1: ( RULE_ID ) + // InternalExport.g:7299:2: RULE_ID { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); - } - // InternalExport.g:7437:2: ( rule__GlobalVarExpression__NameAssignment_1 ) - // InternalExport.g:7437:3: rule__GlobalVarExpression__NameAssignment_1 - { - pushFollow(FOLLOW_2); - rule__GlobalVarExpression__NameAssignment_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); } - + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_0()); } } @@ -24652,26 +26037,21 @@ public final void rule__GlobalVarExpression__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__1__Impl" + // $ANTLR end "rule__QualifiedID__Group__0__Impl" - // $ANTLR start "rule__OperationCall__Group__0" - // InternalExport.g:7446:1: rule__OperationCall__Group__0 : rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ; - public final void rule__OperationCall__Group__0() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__1" + // InternalExport.g:7308:1: rule__QualifiedID__Group__1 : rule__QualifiedID__Group__1__Impl ; + public final void rule__QualifiedID__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7450:1: ( rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ) - // InternalExport.g:7451:2: rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 + // InternalExport.g:7312:1: ( rule__QualifiedID__Group__1__Impl ) + // InternalExport.g:7313:2: rule__QualifiedID__Group__1__Impl { - pushFollow(FOLLOW_34); - rule__OperationCall__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__1(); + rule__QualifiedID__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -24690,38 +26070,56 @@ public final void rule__OperationCall__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__0" + // $ANTLR end "rule__QualifiedID__Group__1" - // $ANTLR start "rule__OperationCall__Group__0__Impl" - // InternalExport.g:7458:1: rule__OperationCall__Group__0__Impl : ( ( rule__OperationCall__NameAssignment_0 ) ) ; - public final void rule__OperationCall__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__1__Impl" + // InternalExport.g:7319:1: rule__QualifiedID__Group__1__Impl : ( ( rule__QualifiedID__Group_1__0 )* ) ; + public final void rule__QualifiedID__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7462:1: ( ( ( rule__OperationCall__NameAssignment_0 ) ) ) - // InternalExport.g:7463:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + // InternalExport.g:7323:1: ( ( ( rule__QualifiedID__Group_1__0 )* ) ) + // InternalExport.g:7324:1: ( ( rule__QualifiedID__Group_1__0 )* ) { - // InternalExport.g:7463:1: ( ( rule__OperationCall__NameAssignment_0 ) ) - // InternalExport.g:7464:2: ( rule__OperationCall__NameAssignment_0 ) + // InternalExport.g:7324:1: ( ( rule__QualifiedID__Group_1__0 )* ) + // InternalExport.g:7325:2: ( rule__QualifiedID__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + before(grammarAccess.getQualifiedIDAccess().getGroup_1()); } - // InternalExport.g:7465:2: ( rule__OperationCall__NameAssignment_0 ) - // InternalExport.g:7465:3: rule__OperationCall__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__OperationCall__NameAssignment_0(); + // InternalExport.g:7326:2: ( rule__QualifiedID__Group_1__0 )* + loop86: + do { + int alt86=2; + int LA86_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA86_0==83) ) { + alt86=1; + } - } + + switch (alt86) { + case 1 : + // InternalExport.g:7326:3: rule__QualifiedID__Group_1__0 + { + pushFollow(FOLLOW_38); + rule__QualifiedID__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop86; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + after(grammarAccess.getQualifiedIDAccess().getGroup_1()); } } @@ -24741,26 +26139,26 @@ public final void rule__OperationCall__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__0__Impl" + // $ANTLR end "rule__QualifiedID__Group__1__Impl" - // $ANTLR start "rule__OperationCall__Group__1" - // InternalExport.g:7473:1: rule__OperationCall__Group__1 : rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ; - public final void rule__OperationCall__Group__1() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__0" + // InternalExport.g:7335:1: rule__QualifiedID__Group_1__0 : rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ; + public final void rule__QualifiedID__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7477:1: ( rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ) - // InternalExport.g:7478:2: rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 + // InternalExport.g:7339:1: ( rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ) + // InternalExport.g:7340:2: rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 { - pushFollow(FOLLOW_64); - rule__OperationCall__Group__1__Impl(); + pushFollow(FOLLOW_11); + rule__QualifiedID__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__2(); + rule__QualifiedID__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -24779,28 +26177,28 @@ public final void rule__OperationCall__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__1" + // $ANTLR end "rule__QualifiedID__Group_1__0" - // $ANTLR start "rule__OperationCall__Group__1__Impl" - // InternalExport.g:7485:1: rule__OperationCall__Group__1__Impl : ( '(' ) ; - public final void rule__OperationCall__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__0__Impl" + // InternalExport.g:7347:1: rule__QualifiedID__Group_1__0__Impl : ( '::' ) ; + public final void rule__QualifiedID__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7489:1: ( ( '(' ) ) - // InternalExport.g:7490:1: ( '(' ) + // InternalExport.g:7351:1: ( ( '::' ) ) + // InternalExport.g:7352:1: ( '::' ) { - // InternalExport.g:7490:1: ( '(' ) - // InternalExport.g:7491:2: '(' + // InternalExport.g:7352:1: ( '::' ) + // InternalExport.g:7353:2: '::' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + match(input,83,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } } @@ -24820,26 +26218,21 @@ public final void rule__OperationCall__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__1__Impl" + // $ANTLR end "rule__QualifiedID__Group_1__0__Impl" - // $ANTLR start "rule__OperationCall__Group__2" - // InternalExport.g:7500:1: rule__OperationCall__Group__2 : rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ; - public final void rule__OperationCall__Group__2() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__1" + // InternalExport.g:7362:1: rule__QualifiedID__Group_1__1 : rule__QualifiedID__Group_1__1__Impl ; + public final void rule__QualifiedID__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7504:1: ( rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ) - // InternalExport.g:7505:2: rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 + // InternalExport.g:7366:1: ( rule__QualifiedID__Group_1__1__Impl ) + // InternalExport.g:7367:2: rule__QualifiedID__Group_1__1__Impl { - pushFollow(FOLLOW_64); - rule__OperationCall__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__3(); + rule__QualifiedID__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -24858,49 +26251,28 @@ public final void rule__OperationCall__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__2" + // $ANTLR end "rule__QualifiedID__Group_1__1" - // $ANTLR start "rule__OperationCall__Group__2__Impl" - // InternalExport.g:7512:1: rule__OperationCall__Group__2__Impl : ( ( rule__OperationCall__Group_2__0 )? ) ; - public final void rule__OperationCall__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__1__Impl" + // InternalExport.g:7373:1: rule__QualifiedID__Group_1__1__Impl : ( RULE_ID ) ; + public final void rule__QualifiedID__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7516:1: ( ( ( rule__OperationCall__Group_2__0 )? ) ) - // InternalExport.g:7517:1: ( ( rule__OperationCall__Group_2__0 )? ) + // InternalExport.g:7377:1: ( ( RULE_ID ) ) + // InternalExport.g:7378:1: ( RULE_ID ) { - // InternalExport.g:7517:1: ( ( rule__OperationCall__Group_2__0 )? ) - // InternalExport.g:7518:2: ( rule__OperationCall__Group_2__0 )? + // InternalExport.g:7378:1: ( RULE_ID ) + // InternalExport.g:7379:2: RULE_ID { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getGroup_2()); - } - // InternalExport.g:7519:2: ( rule__OperationCall__Group_2__0 )? - int alt62=2; - int LA62_0 = input.LA(1); - - if ( ((LA62_0>=RULE_ID && LA62_0<=RULE_REAL)||LA62_0==19||(LA62_0>=22 && LA62_0<=35)||LA62_0==39||LA62_0==51||LA62_0==58||LA62_0==62||LA62_0==65||(LA62_0>=70 && LA62_0<=71)||(LA62_0>=80 && LA62_0<=81)) ) { - alt62=1; - } - switch (alt62) { - case 1 : - // InternalExport.g:7519:3: rule__OperationCall__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); } - + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getGroup_2()); + after(grammarAccess.getQualifiedIDAccess().getIDTerminalRuleCall_1_1()); } } @@ -24920,21 +26292,26 @@ public final void rule__OperationCall__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__2__Impl" + // $ANTLR end "rule__QualifiedID__Group_1__1__Impl" - // $ANTLR start "rule__OperationCall__Group__3" - // InternalExport.g:7527:1: rule__OperationCall__Group__3 : rule__OperationCall__Group__3__Impl ; - public final void rule__OperationCall__Group__3() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__0" + // InternalExport.g:7389:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ; + public final void rule__LetExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7531:1: ( rule__OperationCall__Group__3__Impl ) - // InternalExport.g:7532:2: rule__OperationCall__Group__3__Impl + // InternalExport.g:7393:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ) + // InternalExport.g:7394:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 { + pushFollow(FOLLOW_11); + rule__LetExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__3__Impl(); + rule__LetExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -24953,28 +26330,28 @@ public final void rule__OperationCall__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__3" + // $ANTLR end "rule__LetExpression__Group__0" - // $ANTLR start "rule__OperationCall__Group__3__Impl" - // InternalExport.g:7538:1: rule__OperationCall__Group__3__Impl : ( ')' ) ; - public final void rule__OperationCall__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__0__Impl" + // InternalExport.g:7401:1: rule__LetExpression__Group__0__Impl : ( 'let' ) ; + public final void rule__LetExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7542:1: ( ( ')' ) ) - // InternalExport.g:7543:1: ( ')' ) + // InternalExport.g:7405:1: ( ( 'let' ) ) + // InternalExport.g:7406:1: ( 'let' ) { - // InternalExport.g:7543:1: ( ')' ) - // InternalExport.g:7544:2: ')' + // InternalExport.g:7406:1: ( 'let' ) + // InternalExport.g:7407:2: 'let' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,84,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } } @@ -24994,26 +26371,26 @@ public final void rule__OperationCall__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__3__Impl" + // $ANTLR end "rule__LetExpression__Group__0__Impl" - // $ANTLR start "rule__OperationCall__Group_2__0" - // InternalExport.g:7554:1: rule__OperationCall__Group_2__0 : rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ; - public final void rule__OperationCall__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__1" + // InternalExport.g:7416:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ; + public final void rule__LetExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7558:1: ( rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ) - // InternalExport.g:7559:2: rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 + // InternalExport.g:7420:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ) + // InternalExport.g:7421:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 { - pushFollow(FOLLOW_21); - rule__OperationCall__Group_2__0__Impl(); + pushFollow(FOLLOW_32); + rule__LetExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__1(); + rule__LetExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -25032,30 +26409,30 @@ public final void rule__OperationCall__Group_2__0() throws RecognitionException } return ; } - // $ANTLR end "rule__OperationCall__Group_2__0" + // $ANTLR end "rule__LetExpression__Group__1" - // $ANTLR start "rule__OperationCall__Group_2__0__Impl" - // InternalExport.g:7566:1: rule__OperationCall__Group_2__0__Impl : ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ; - public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__1__Impl" + // InternalExport.g:7428:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ; + public final void rule__LetExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7570:1: ( ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ) - // InternalExport.g:7571:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + // InternalExport.g:7432:1: ( ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ) + // InternalExport.g:7433:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) { - // InternalExport.g:7571:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) - // InternalExport.g:7572:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + // InternalExport.g:7433:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) + // InternalExport.g:7434:2: ( rule__LetExpression__IdentifierAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } - // InternalExport.g:7573:2: ( rule__OperationCall__ParamsAssignment_2_0 ) - // InternalExport.g:7573:3: rule__OperationCall__ParamsAssignment_2_0 + // InternalExport.g:7435:2: ( rule__LetExpression__IdentifierAssignment_1 ) + // InternalExport.g:7435:3: rule__LetExpression__IdentifierAssignment_1 { pushFollow(FOLLOW_2); - rule__OperationCall__ParamsAssignment_2_0(); + rule__LetExpression__IdentifierAssignment_1(); state._fsp--; if (state.failed) return ; @@ -25063,7 +26440,7 @@ public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } } @@ -25083,21 +26460,26 @@ public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__Group_2__0__Impl" + // $ANTLR end "rule__LetExpression__Group__1__Impl" - // $ANTLR start "rule__OperationCall__Group_2__1" - // InternalExport.g:7581:1: rule__OperationCall__Group_2__1 : rule__OperationCall__Group_2__1__Impl ; - public final void rule__OperationCall__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__2" + // InternalExport.g:7443:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ; + public final void rule__LetExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7585:1: ( rule__OperationCall__Group_2__1__Impl ) - // InternalExport.g:7586:2: rule__OperationCall__Group_2__1__Impl + // InternalExport.g:7447:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ) + // InternalExport.g:7448:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 { + pushFollow(FOLLOW_18); + rule__LetExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__1__Impl(); + rule__LetExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -25116,56 +26498,28 @@ public final void rule__OperationCall__Group_2__1() throws RecognitionException } return ; } - // $ANTLR end "rule__OperationCall__Group_2__1" + // $ANTLR end "rule__LetExpression__Group__2" - // $ANTLR start "rule__OperationCall__Group_2__1__Impl" - // InternalExport.g:7592:1: rule__OperationCall__Group_2__1__Impl : ( ( rule__OperationCall__Group_2_1__0 )* ) ; - public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__2__Impl" + // InternalExport.g:7455:1: rule__LetExpression__Group__2__Impl : ( '=' ) ; + public final void rule__LetExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7596:1: ( ( ( rule__OperationCall__Group_2_1__0 )* ) ) - // InternalExport.g:7597:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + // InternalExport.g:7459:1: ( ( '=' ) ) + // InternalExport.g:7460:1: ( '=' ) { - // InternalExport.g:7597:1: ( ( rule__OperationCall__Group_2_1__0 )* ) - // InternalExport.g:7598:2: ( rule__OperationCall__Group_2_1__0 )* + // InternalExport.g:7460:1: ( '=' ) + // InternalExport.g:7461:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getGroup_2_1()); + before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } - // InternalExport.g:7599:2: ( rule__OperationCall__Group_2_1__0 )* - loop63: - do { - int alt63=2; - int LA63_0 = input.LA(1); - - if ( (LA63_0==48) ) { - alt63=1; - } - - - switch (alt63) { - case 1 : - // InternalExport.g:7599:3: rule__OperationCall__Group_2_1__0 - { - pushFollow(FOLLOW_22); - rule__OperationCall__Group_2_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop63; - } - } while (true); - + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getGroup_2_1()); + after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } } @@ -25185,26 +26539,26 @@ public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__Group_2__1__Impl" + // $ANTLR end "rule__LetExpression__Group__2__Impl" - // $ANTLR start "rule__OperationCall__Group_2_1__0" - // InternalExport.g:7608:1: rule__OperationCall__Group_2_1__0 : rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ; - public final void rule__OperationCall__Group_2_1__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__3" + // InternalExport.g:7470:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ; + public final void rule__LetExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7612:1: ( rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ) - // InternalExport.g:7613:2: rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 + // InternalExport.g:7474:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ) + // InternalExport.g:7475:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 { - pushFollow(FOLLOW_18); - rule__OperationCall__Group_2_1__0__Impl(); + pushFollow(FOLLOW_39); + rule__LetExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2_1__1(); + rule__LetExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -25223,28 +26577,38 @@ public final void rule__OperationCall__Group_2_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__0" + // $ANTLR end "rule__LetExpression__Group__3" - // $ANTLR start "rule__OperationCall__Group_2_1__0__Impl" - // InternalExport.g:7620:1: rule__OperationCall__Group_2_1__0__Impl : ( ',' ) ; - public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__3__Impl" + // InternalExport.g:7482:1: rule__LetExpression__Group__3__Impl : ( ( rule__LetExpression__VarExprAssignment_3 ) ) ; + public final void rule__LetExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7624:1: ( ( ',' ) ) - // InternalExport.g:7625:1: ( ',' ) + // InternalExport.g:7486:1: ( ( ( rule__LetExpression__VarExprAssignment_3 ) ) ) + // InternalExport.g:7487:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) { - // InternalExport.g:7625:1: ( ',' ) - // InternalExport.g:7626:2: ',' + // InternalExport.g:7487:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) + // InternalExport.g:7488:2: ( rule__LetExpression__VarExprAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7489:2: ( rule__LetExpression__VarExprAssignment_3 ) + // InternalExport.g:7489:3: rule__LetExpression__VarExprAssignment_3 + { + pushFollow(FOLLOW_2); + rule__LetExpression__VarExprAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } } @@ -25264,21 +26628,26 @@ public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__0__Impl" + // $ANTLR end "rule__LetExpression__Group__3__Impl" - // $ANTLR start "rule__OperationCall__Group_2_1__1" - // InternalExport.g:7635:1: rule__OperationCall__Group_2_1__1 : rule__OperationCall__Group_2_1__1__Impl ; - public final void rule__OperationCall__Group_2_1__1() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__4" + // InternalExport.g:7497:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ; + public final void rule__LetExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7639:1: ( rule__OperationCall__Group_2_1__1__Impl ) - // InternalExport.g:7640:2: rule__OperationCall__Group_2_1__1__Impl + // InternalExport.g:7501:1: ( rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ) + // InternalExport.g:7502:2: rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 { + pushFollow(FOLLOW_18); + rule__LetExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2_1__1__Impl(); + rule__LetExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -25297,38 +26666,28 @@ public final void rule__OperationCall__Group_2_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__1" + // $ANTLR end "rule__LetExpression__Group__4" - // $ANTLR start "rule__OperationCall__Group_2_1__1__Impl" - // InternalExport.g:7646:1: rule__OperationCall__Group_2_1__1__Impl : ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ; - public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__4__Impl" + // InternalExport.g:7509:1: rule__LetExpression__Group__4__Impl : ( ':' ) ; + public final void rule__LetExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7650:1: ( ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ) - // InternalExport.g:7651:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + // InternalExport.g:7513:1: ( ( ':' ) ) + // InternalExport.g:7514:1: ( ':' ) { - // InternalExport.g:7651:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) - // InternalExport.g:7652:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + // InternalExport.g:7514:1: ( ':' ) + // InternalExport.g:7515:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); - } - // InternalExport.g:7653:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) - // InternalExport.g:7653:3: rule__OperationCall__ParamsAssignment_2_1_1 - { - pushFollow(FOLLOW_2); - rule__OperationCall__ParamsAssignment_2_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } - + match(input,85,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } } @@ -25348,26 +26707,21 @@ public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__1__Impl" + // $ANTLR end "rule__LetExpression__Group__4__Impl" - // $ANTLR start "rule__ListLiteral__Group__0" - // InternalExport.g:7662:1: rule__ListLiteral__Group__0 : rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ; - public final void rule__ListLiteral__Group__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__5" + // InternalExport.g:7524:1: rule__LetExpression__Group__5 : rule__LetExpression__Group__5__Impl ; + public final void rule__LetExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7666:1: ( rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ) - // InternalExport.g:7667:2: rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 + // InternalExport.g:7528:1: ( rule__LetExpression__Group__5__Impl ) + // InternalExport.g:7529:2: rule__LetExpression__Group__5__Impl { - pushFollow(FOLLOW_11); - rule__ListLiteral__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__1(); + rule__LetExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -25386,32 +26740,38 @@ public final void rule__ListLiteral__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__0" + // $ANTLR end "rule__LetExpression__Group__5" - // $ANTLR start "rule__ListLiteral__Group__0__Impl" - // InternalExport.g:7674:1: rule__ListLiteral__Group__0__Impl : ( () ) ; - public final void rule__ListLiteral__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__5__Impl" + // InternalExport.g:7535:1: rule__LetExpression__Group__5__Impl : ( ( rule__LetExpression__TargetAssignment_5 ) ) ; + public final void rule__LetExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7678:1: ( ( () ) ) - // InternalExport.g:7679:1: ( () ) + // InternalExport.g:7539:1: ( ( ( rule__LetExpression__TargetAssignment_5 ) ) ) + // InternalExport.g:7540:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) { - // InternalExport.g:7679:1: ( () ) - // InternalExport.g:7680:2: () + // InternalExport.g:7540:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) + // InternalExport.g:7541:2: ( rule__LetExpression__TargetAssignment_5 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } - // InternalExport.g:7681:2: () - // InternalExport.g:7681:3: + // InternalExport.g:7542:2: ( rule__LetExpression__TargetAssignment_5 ) + // InternalExport.g:7542:3: rule__LetExpression__TargetAssignment_5 { + pushFollow(FOLLOW_2); + rule__LetExpression__TargetAssignment_5(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } } @@ -25420,6 +26780,10 @@ public final void rule__ListLiteral__Group__0__Impl() throws RecognitionExceptio } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -25427,26 +26791,26 @@ public final void rule__ListLiteral__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__0__Impl" + // $ANTLR end "rule__LetExpression__Group__5__Impl" - // $ANTLR start "rule__ListLiteral__Group__1" - // InternalExport.g:7689:1: rule__ListLiteral__Group__1 : rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ; - public final void rule__ListLiteral__Group__1() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__0" + // InternalExport.g:7551:1: rule__CastedExpression__Group__0 : rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ; + public final void rule__CastedExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7693:1: ( rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ) - // InternalExport.g:7694:2: rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 + // InternalExport.g:7555:1: ( rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ) + // InternalExport.g:7556:2: rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 { - pushFollow(FOLLOW_68); - rule__ListLiteral__Group__1__Impl(); + pushFollow(FOLLOW_40); + rule__CastedExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__2(); + rule__CastedExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -25465,28 +26829,28 @@ public final void rule__ListLiteral__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__1" + // $ANTLR end "rule__CastedExpression__Group__0" - // $ANTLR start "rule__ListLiteral__Group__1__Impl" - // InternalExport.g:7701:1: rule__ListLiteral__Group__1__Impl : ( '{' ) ; - public final void rule__ListLiteral__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__0__Impl" + // InternalExport.g:7563:1: rule__CastedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__CastedExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7705:1: ( ( '{' ) ) - // InternalExport.g:7706:1: ( '{' ) + // InternalExport.g:7567:1: ( ( '(' ) ) + // InternalExport.g:7568:1: ( '(' ) { - // InternalExport.g:7706:1: ( '{' ) - // InternalExport.g:7707:2: '{' + // InternalExport.g:7568:1: ( '(' ) + // InternalExport.g:7569:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } - match(input,39,FOLLOW_2); if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } } @@ -25506,26 +26870,26 @@ public final void rule__ListLiteral__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__1__Impl" + // $ANTLR end "rule__CastedExpression__Group__0__Impl" - // $ANTLR start "rule__ListLiteral__Group__2" - // InternalExport.g:7716:1: rule__ListLiteral__Group__2 : rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ; - public final void rule__ListLiteral__Group__2() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__1" + // InternalExport.g:7578:1: rule__CastedExpression__Group__1 : rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ; + public final void rule__CastedExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7720:1: ( rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ) - // InternalExport.g:7721:2: rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 + // InternalExport.g:7582:1: ( rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ) + // InternalExport.g:7583:2: rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 { - pushFollow(FOLLOW_68); - rule__ListLiteral__Group__2__Impl(); + pushFollow(FOLLOW_25); + rule__CastedExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__3(); + rule__CastedExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -25544,49 +26908,38 @@ public final void rule__ListLiteral__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__2" + // $ANTLR end "rule__CastedExpression__Group__1" - // $ANTLR start "rule__ListLiteral__Group__2__Impl" - // InternalExport.g:7728:1: rule__ListLiteral__Group__2__Impl : ( ( rule__ListLiteral__Group_2__0 )? ) ; - public final void rule__ListLiteral__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__1__Impl" + // InternalExport.g:7590:1: rule__CastedExpression__Group__1__Impl : ( ( rule__CastedExpression__TypeAssignment_1 ) ) ; + public final void rule__CastedExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7732:1: ( ( ( rule__ListLiteral__Group_2__0 )? ) ) - // InternalExport.g:7733:1: ( ( rule__ListLiteral__Group_2__0 )? ) + // InternalExport.g:7594:1: ( ( ( rule__CastedExpression__TypeAssignment_1 ) ) ) + // InternalExport.g:7595:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) { - // InternalExport.g:7733:1: ( ( rule__ListLiteral__Group_2__0 )? ) - // InternalExport.g:7734:2: ( rule__ListLiteral__Group_2__0 )? + // InternalExport.g:7595:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) + // InternalExport.g:7596:2: ( rule__CastedExpression__TypeAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getGroup_2()); - } - // InternalExport.g:7735:2: ( rule__ListLiteral__Group_2__0 )? - int alt64=2; - int LA64_0 = input.LA(1); - - if ( ((LA64_0>=RULE_ID && LA64_0<=RULE_REAL)||LA64_0==19||(LA64_0>=22 && LA64_0<=35)||LA64_0==39||LA64_0==51||LA64_0==58||LA64_0==62||LA64_0==65||(LA64_0>=70 && LA64_0<=71)||(LA64_0>=80 && LA64_0<=81)) ) { - alt64=1; + before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } - switch (alt64) { - case 1 : - // InternalExport.g:7735:3: rule__ListLiteral__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExport.g:7597:2: ( rule__CastedExpression__TypeAssignment_1 ) + // InternalExport.g:7597:3: rule__CastedExpression__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__CastedExpression__TypeAssignment_1(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getGroup_2()); + after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } } @@ -25606,21 +26959,26 @@ public final void rule__ListLiteral__Group__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__2__Impl" + // $ANTLR end "rule__CastedExpression__Group__1__Impl" - // $ANTLR start "rule__ListLiteral__Group__3" - // InternalExport.g:7743:1: rule__ListLiteral__Group__3 : rule__ListLiteral__Group__3__Impl ; - public final void rule__ListLiteral__Group__3() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__2" + // InternalExport.g:7605:1: rule__CastedExpression__Group__2 : rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ; + public final void rule__CastedExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7747:1: ( rule__ListLiteral__Group__3__Impl ) - // InternalExport.g:7748:2: rule__ListLiteral__Group__3__Impl + // InternalExport.g:7609:1: ( rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ) + // InternalExport.g:7610:2: rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 { + pushFollow(FOLLOW_18); + rule__CastedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__3__Impl(); + rule__CastedExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -25639,28 +26997,28 @@ public final void rule__ListLiteral__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__3" + // $ANTLR end "rule__CastedExpression__Group__2" - // $ANTLR start "rule__ListLiteral__Group__3__Impl" - // InternalExport.g:7754:1: rule__ListLiteral__Group__3__Impl : ( '}' ) ; - public final void rule__ListLiteral__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__2__Impl" + // InternalExport.g:7617:1: rule__CastedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__CastedExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7758:1: ( ( '}' ) ) - // InternalExport.g:7759:1: ( '}' ) + // InternalExport.g:7621:1: ( ( ')' ) ) + // InternalExport.g:7622:1: ( ')' ) { - // InternalExport.g:7759:1: ( '}' ) - // InternalExport.g:7760:2: '}' + // InternalExport.g:7622:1: ( ')' ) + // InternalExport.g:7623:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } - match(input,40,FOLLOW_2); if (state.failed) return ; + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } } @@ -25680,26 +27038,21 @@ public final void rule__ListLiteral__Group__3__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__3__Impl" + // $ANTLR end "rule__CastedExpression__Group__2__Impl" - // $ANTLR start "rule__ListLiteral__Group_2__0" - // InternalExport.g:7770:1: rule__ListLiteral__Group_2__0 : rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ; - public final void rule__ListLiteral__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__3" + // InternalExport.g:7632:1: rule__CastedExpression__Group__3 : rule__CastedExpression__Group__3__Impl ; + public final void rule__CastedExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7774:1: ( rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ) - // InternalExport.g:7775:2: rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 + // InternalExport.g:7636:1: ( rule__CastedExpression__Group__3__Impl ) + // InternalExport.g:7637:2: rule__CastedExpression__Group__3__Impl { - pushFollow(FOLLOW_21); - rule__ListLiteral__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__1(); + rule__CastedExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -25718,30 +27071,30 @@ public final void rule__ListLiteral__Group_2__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__0" + // $ANTLR end "rule__CastedExpression__Group__3" - // $ANTLR start "rule__ListLiteral__Group_2__0__Impl" - // InternalExport.g:7782:1: rule__ListLiteral__Group_2__0__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ; - public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__3__Impl" + // InternalExport.g:7643:1: rule__CastedExpression__Group__3__Impl : ( ( rule__CastedExpression__TargetAssignment_3 ) ) ; + public final void rule__CastedExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7786:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ) - // InternalExport.g:7787:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + // InternalExport.g:7647:1: ( ( ( rule__CastedExpression__TargetAssignment_3 ) ) ) + // InternalExport.g:7648:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) { - // InternalExport.g:7787:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) - // InternalExport.g:7788:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + // InternalExport.g:7648:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) + // InternalExport.g:7649:2: ( rule__CastedExpression__TargetAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } - // InternalExport.g:7789:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) - // InternalExport.g:7789:3: rule__ListLiteral__ElementsAssignment_2_0 + // InternalExport.g:7650:2: ( rule__CastedExpression__TargetAssignment_3 ) + // InternalExport.g:7650:3: rule__CastedExpression__TargetAssignment_3 { pushFollow(FOLLOW_2); - rule__ListLiteral__ElementsAssignment_2_0(); + rule__CastedExpression__TargetAssignment_3(); state._fsp--; if (state.failed) return ; @@ -25749,7 +27102,7 @@ public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } } @@ -25769,21 +27122,26 @@ public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__0__Impl" + // $ANTLR end "rule__CastedExpression__Group__3__Impl" - // $ANTLR start "rule__ListLiteral__Group_2__1" - // InternalExport.g:7797:1: rule__ListLiteral__Group_2__1 : rule__ListLiteral__Group_2__1__Impl ; - public final void rule__ListLiteral__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__0" + // InternalExport.g:7659:1: rule__ChainExpression__Group__0 : rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ; + public final void rule__ChainExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7801:1: ( rule__ListLiteral__Group_2__1__Impl ) - // InternalExport.g:7802:2: rule__ListLiteral__Group_2__1__Impl + // InternalExport.g:7663:1: ( rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ) + // InternalExport.g:7664:2: rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 { + pushFollow(FOLLOW_41); + rule__ChainExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__1__Impl(); + rule__ChainExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -25802,56 +27160,32 @@ public final void rule__ListLiteral__Group_2__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__1" + // $ANTLR end "rule__ChainExpression__Group__0" - // $ANTLR start "rule__ListLiteral__Group_2__1__Impl" - // InternalExport.g:7808:1: rule__ListLiteral__Group_2__1__Impl : ( ( rule__ListLiteral__Group_2_1__0 )* ) ; - public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__0__Impl" + // InternalExport.g:7671:1: rule__ChainExpression__Group__0__Impl : ( ruleChainedExpression ) ; + public final void rule__ChainExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7812:1: ( ( ( rule__ListLiteral__Group_2_1__0 )* ) ) - // InternalExport.g:7813:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + // InternalExport.g:7675:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:7676:1: ( ruleChainedExpression ) { - // InternalExport.g:7813:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) - // InternalExport.g:7814:2: ( rule__ListLiteral__Group_2_1__0 )* + // InternalExport.g:7676:1: ( ruleChainedExpression ) + // InternalExport.g:7677:2: ruleChainedExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getGroup_2_1()); + before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } - // InternalExport.g:7815:2: ( rule__ListLiteral__Group_2_1__0 )* - loop65: - do { - int alt65=2; - int LA65_0 = input.LA(1); - - if ( (LA65_0==48) ) { - alt65=1; - } - - - switch (alt65) { - case 1 : - // InternalExport.g:7815:3: rule__ListLiteral__Group_2_1__0 - { - pushFollow(FOLLOW_22); - rule__ListLiteral__Group_2_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop65; - } - } while (true); + pushFollow(FOLLOW_2); + ruleChainedExpression(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getGroup_2_1()); + after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } } @@ -25871,26 +27205,21 @@ public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__1__Impl" + // $ANTLR end "rule__ChainExpression__Group__0__Impl" - // $ANTLR start "rule__ListLiteral__Group_2_1__0" - // InternalExport.g:7824:1: rule__ListLiteral__Group_2_1__0 : rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ; - public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__1" + // InternalExport.g:7686:1: rule__ChainExpression__Group__1 : rule__ChainExpression__Group__1__Impl ; + public final void rule__ChainExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7828:1: ( rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ) - // InternalExport.g:7829:2: rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 + // InternalExport.g:7690:1: ( rule__ChainExpression__Group__1__Impl ) + // InternalExport.g:7691:2: rule__ChainExpression__Group__1__Impl { - pushFollow(FOLLOW_18); - rule__ListLiteral__Group_2_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2_1__1(); + rule__ChainExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -25909,28 +27238,56 @@ public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__0" + // $ANTLR end "rule__ChainExpression__Group__1" - // $ANTLR start "rule__ListLiteral__Group_2_1__0__Impl" - // InternalExport.g:7836:1: rule__ListLiteral__Group_2_1__0__Impl : ( ',' ) ; - public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__1__Impl" + // InternalExport.g:7697:1: rule__ChainExpression__Group__1__Impl : ( ( rule__ChainExpression__Group_1__0 )* ) ; + public final void rule__ChainExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7840:1: ( ( ',' ) ) - // InternalExport.g:7841:1: ( ',' ) + // InternalExport.g:7701:1: ( ( ( rule__ChainExpression__Group_1__0 )* ) ) + // InternalExport.g:7702:1: ( ( rule__ChainExpression__Group_1__0 )* ) { - // InternalExport.g:7841:1: ( ',' ) - // InternalExport.g:7842:2: ',' + // InternalExport.g:7702:1: ( ( rule__ChainExpression__Group_1__0 )* ) + // InternalExport.g:7703:2: ( rule__ChainExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + before(grammarAccess.getChainExpressionAccess().getGroup_1()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7704:2: ( rule__ChainExpression__Group_1__0 )* + loop87: + do { + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==48) ) { + alt87=1; + } + + + switch (alt87) { + case 1 : + // InternalExport.g:7704:3: rule__ChainExpression__Group_1__0 + { + pushFollow(FOLLOW_42); + rule__ChainExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop87; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + after(grammarAccess.getChainExpressionAccess().getGroup_1()); } } @@ -25950,21 +27307,26 @@ public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__0__Impl" + // $ANTLR end "rule__ChainExpression__Group__1__Impl" - // $ANTLR start "rule__ListLiteral__Group_2_1__1" - // InternalExport.g:7851:1: rule__ListLiteral__Group_2_1__1 : rule__ListLiteral__Group_2_1__1__Impl ; - public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__0" + // InternalExport.g:7713:1: rule__ChainExpression__Group_1__0 : rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ; + public final void rule__ChainExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7855:1: ( rule__ListLiteral__Group_2_1__1__Impl ) - // InternalExport.g:7856:2: rule__ListLiteral__Group_2_1__1__Impl + // InternalExport.g:7717:1: ( rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ) + // InternalExport.g:7718:2: rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 { + pushFollow(FOLLOW_41); + rule__ChainExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2_1__1__Impl(); + rule__ChainExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -25983,38 +27345,32 @@ public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__1" + // $ANTLR end "rule__ChainExpression__Group_1__0" - // $ANTLR start "rule__ListLiteral__Group_2_1__1__Impl" - // InternalExport.g:7862:1: rule__ListLiteral__Group_2_1__1__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ; - public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__0__Impl" + // InternalExport.g:7725:1: rule__ChainExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7866:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ) - // InternalExport.g:7867:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + // InternalExport.g:7729:1: ( ( () ) ) + // InternalExport.g:7730:1: ( () ) { - // InternalExport.g:7867:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) - // InternalExport.g:7868:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + // InternalExport.g:7730:1: ( () ) + // InternalExport.g:7731:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } - // InternalExport.g:7869:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) - // InternalExport.g:7869:3: rule__ListLiteral__ElementsAssignment_2_1_1 + // InternalExport.g:7732:2: () + // InternalExport.g:7732:3: { - pushFollow(FOLLOW_2); - rule__ListLiteral__ElementsAssignment_2_1_1(); - - state._fsp--; - if (state.failed) return ; - } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } } @@ -26023,10 +27379,6 @@ public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionExce } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -26034,26 +27386,26 @@ public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__1__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__0__Impl" - // $ANTLR start "rule__ConstructorCallExpression__Group__0" - // InternalExport.g:7878:1: rule__ConstructorCallExpression__Group__0 : rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ; - public final void rule__ConstructorCallExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__1" + // InternalExport.g:7740:1: rule__ChainExpression__Group_1__1 : rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ; + public final void rule__ChainExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7882:1: ( rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ) - // InternalExport.g:7883:2: rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 + // InternalExport.g:7744:1: ( rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ) + // InternalExport.g:7745:2: rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 { - pushFollow(FOLLOW_40); - rule__ConstructorCallExpression__Group__0__Impl(); + pushFollow(FOLLOW_18); + rule__ChainExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__Group__1(); + rule__ChainExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -26072,28 +27424,28 @@ public final void rule__ConstructorCallExpression__Group__0() throws Recognition } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__0" + // $ANTLR end "rule__ChainExpression__Group_1__1" - // $ANTLR start "rule__ConstructorCallExpression__Group__0__Impl" - // InternalExport.g:7890:1: rule__ConstructorCallExpression__Group__0__Impl : ( 'new' ) ; - public final void rule__ConstructorCallExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__1__Impl" + // InternalExport.g:7752:1: rule__ChainExpression__Group_1__1__Impl : ( '->' ) ; + public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7894:1: ( ( 'new' ) ) - // InternalExport.g:7895:1: ( 'new' ) + // InternalExport.g:7756:1: ( ( '->' ) ) + // InternalExport.g:7757:1: ( '->' ) { - // InternalExport.g:7895:1: ( 'new' ) - // InternalExport.g:7896:2: 'new' + // InternalExport.g:7757:1: ( '->' ) + // InternalExport.g:7758:2: '->' { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } - match(input,71,FOLLOW_2); if (state.failed) return ; + match(input,48,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } } @@ -26113,21 +27465,21 @@ public final void rule__ConstructorCallExpression__Group__0__Impl() throws Recog } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__0__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__1__Impl" - // $ANTLR start "rule__ConstructorCallExpression__Group__1" - // InternalExport.g:7905:1: rule__ConstructorCallExpression__Group__1 : rule__ConstructorCallExpression__Group__1__Impl ; - public final void rule__ConstructorCallExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__2" + // InternalExport.g:7767:1: rule__ChainExpression__Group_1__2 : rule__ChainExpression__Group_1__2__Impl ; + public final void rule__ChainExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7909:1: ( rule__ConstructorCallExpression__Group__1__Impl ) - // InternalExport.g:7910:2: rule__ConstructorCallExpression__Group__1__Impl + // InternalExport.g:7771:1: ( rule__ChainExpression__Group_1__2__Impl ) + // InternalExport.g:7772:2: rule__ChainExpression__Group_1__2__Impl { pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__Group__1__Impl(); + rule__ChainExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -26146,30 +27498,30 @@ public final void rule__ConstructorCallExpression__Group__1() throws Recognition } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__1" + // $ANTLR end "rule__ChainExpression__Group_1__2" - // $ANTLR start "rule__ConstructorCallExpression__Group__1__Impl" - // InternalExport.g:7916:1: rule__ConstructorCallExpression__Group__1__Impl : ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ; - public final void rule__ConstructorCallExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__2__Impl" + // InternalExport.g:7778:1: rule__ChainExpression__Group_1__2__Impl : ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ; + public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7920:1: ( ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ) - // InternalExport.g:7921:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + // InternalExport.g:7782:1: ( ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ) + // InternalExport.g:7783:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) { - // InternalExport.g:7921:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) - // InternalExport.g:7922:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + // InternalExport.g:7783:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) + // InternalExport.g:7784:2: ( rule__ChainExpression__NextAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } - // InternalExport.g:7923:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) - // InternalExport.g:7923:3: rule__ConstructorCallExpression__TypeAssignment_1 + // InternalExport.g:7785:2: ( rule__ChainExpression__NextAssignment_1_2 ) + // InternalExport.g:7785:3: rule__ChainExpression__NextAssignment_1_2 { pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__TypeAssignment_1(); + rule__ChainExpression__NextAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -26177,7 +27529,7 @@ public final void rule__ConstructorCallExpression__Group__1__Impl() throws Recog } if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } } @@ -26197,26 +27549,26 @@ public final void rule__ConstructorCallExpression__Group__1__Impl() throws Recog } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__1__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__2__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__0" - // InternalExport.g:7932:1: rule__TypeSelectExpression__Group__0 : rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ; - public final void rule__TypeSelectExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__0" + // InternalExport.g:7794:1: rule__IfExpressionTri__Group__0 : rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ; + public final void rule__IfExpressionTri__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7936:1: ( rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ) - // InternalExport.g:7937:2: rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 + // InternalExport.g:7798:1: ( rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ) + // InternalExport.g:7799:2: rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 { - pushFollow(FOLLOW_34); - rule__TypeSelectExpression__Group__0__Impl(); + pushFollow(FOLLOW_43); + rule__IfExpressionTri__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__1(); + rule__IfExpressionTri__Group__1(); state._fsp--; if (state.failed) return ; @@ -26235,38 +27587,32 @@ public final void rule__TypeSelectExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__0" + // $ANTLR end "rule__IfExpressionTri__Group__0" - // $ANTLR start "rule__TypeSelectExpression__Group__0__Impl" - // InternalExport.g:7944:1: rule__TypeSelectExpression__Group__0__Impl : ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ; - public final void rule__TypeSelectExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__0__Impl" + // InternalExport.g:7806:1: rule__IfExpressionTri__Group__0__Impl : ( ruleOrExpression ) ; + public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7948:1: ( ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ) - // InternalExport.g:7949:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + // InternalExport.g:7810:1: ( ( ruleOrExpression ) ) + // InternalExport.g:7811:1: ( ruleOrExpression ) { - // InternalExport.g:7949:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) - // InternalExport.g:7950:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + // InternalExport.g:7811:1: ( ruleOrExpression ) + // InternalExport.g:7812:2: ruleOrExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } - // InternalExport.g:7951:2: ( rule__TypeSelectExpression__NameAssignment_0 ) - // InternalExport.g:7951:3: rule__TypeSelectExpression__NameAssignment_0 - { pushFollow(FOLLOW_2); - rule__TypeSelectExpression__NameAssignment_0(); + ruleOrExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } } @@ -26286,26 +27632,21 @@ public final void rule__TypeSelectExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionTri__Group__0__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__1" - // InternalExport.g:7959:1: rule__TypeSelectExpression__Group__1 : rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ; - public final void rule__TypeSelectExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__1" + // InternalExport.g:7821:1: rule__IfExpressionTri__Group__1 : rule__IfExpressionTri__Group__1__Impl ; + public final void rule__IfExpressionTri__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7963:1: ( rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ) - // InternalExport.g:7964:2: rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 + // InternalExport.g:7825:1: ( rule__IfExpressionTri__Group__1__Impl ) + // InternalExport.g:7826:2: rule__IfExpressionTri__Group__1__Impl { - pushFollow(FOLLOW_40); - rule__TypeSelectExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__2(); + rule__IfExpressionTri__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -26324,28 +27665,49 @@ public final void rule__TypeSelectExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__1" + // $ANTLR end "rule__IfExpressionTri__Group__1" - // $ANTLR start "rule__TypeSelectExpression__Group__1__Impl" - // InternalExport.g:7971:1: rule__TypeSelectExpression__Group__1__Impl : ( '(' ) ; - public final void rule__TypeSelectExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__1__Impl" + // InternalExport.g:7832:1: rule__IfExpressionTri__Group__1__Impl : ( ( rule__IfExpressionTri__Group_1__0 )? ) ; + public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7975:1: ( ( '(' ) ) - // InternalExport.g:7976:1: ( '(' ) + // InternalExport.g:7836:1: ( ( ( rule__IfExpressionTri__Group_1__0 )? ) ) + // InternalExport.g:7837:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) { - // InternalExport.g:7976:1: ( '(' ) - // InternalExport.g:7977:2: '(' + // InternalExport.g:7837:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) + // InternalExport.g:7838:2: ( rule__IfExpressionTri__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:7839:2: ( rule__IfExpressionTri__Group_1__0 )? + int alt88=2; + int LA88_0 = input.LA(1); + + if ( (LA88_0==86) ) { + alt88=1; + } + switch (alt88) { + case 1 : + // InternalExport.g:7839:3: rule__IfExpressionTri__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionTri__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } } @@ -26365,26 +27727,26 @@ public final void rule__TypeSelectExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group__1__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__2" - // InternalExport.g:7986:1: rule__TypeSelectExpression__Group__2 : rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ; - public final void rule__TypeSelectExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__0" + // InternalExport.g:7848:1: rule__IfExpressionTri__Group_1__0 : rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ; + public final void rule__IfExpressionTri__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:7990:1: ( rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ) - // InternalExport.g:7991:2: rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 + // InternalExport.g:7852:1: ( rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ) + // InternalExport.g:7853:2: rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 { - pushFollow(FOLLOW_25); - rule__TypeSelectExpression__Group__2__Impl(); + pushFollow(FOLLOW_43); + rule__IfExpressionTri__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__3(); + rule__IfExpressionTri__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -26403,38 +27765,32 @@ public final void rule__TypeSelectExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__2" + // $ANTLR end "rule__IfExpressionTri__Group_1__0" - // $ANTLR start "rule__TypeSelectExpression__Group__2__Impl" - // InternalExport.g:7998:1: rule__TypeSelectExpression__Group__2__Impl : ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ; - public final void rule__TypeSelectExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__0__Impl" + // InternalExport.g:7860:1: rule__IfExpressionTri__Group_1__0__Impl : ( () ) ; + public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8002:1: ( ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ) - // InternalExport.g:8003:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + // InternalExport.g:7864:1: ( ( () ) ) + // InternalExport.g:7865:1: ( () ) { - // InternalExport.g:8003:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) - // InternalExport.g:8004:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + // InternalExport.g:7865:1: ( () ) + // InternalExport.g:7866:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } - // InternalExport.g:8005:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) - // InternalExport.g:8005:3: rule__TypeSelectExpression__TypeAssignment_2 + // InternalExport.g:7867:2: () + // InternalExport.g:7867:3: { - pushFollow(FOLLOW_2); - rule__TypeSelectExpression__TypeAssignment_2(); - - state._fsp--; - if (state.failed) return ; - } if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } } @@ -26443,10 +27799,6 @@ public final void rule__TypeSelectExpression__Group__2__Impl() throws Recognitio } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -26454,21 +27806,26 @@ public final void rule__TypeSelectExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__2__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__0__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__3" - // InternalExport.g:8013:1: rule__TypeSelectExpression__Group__3 : rule__TypeSelectExpression__Group__3__Impl ; - public final void rule__TypeSelectExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__1" + // InternalExport.g:7875:1: rule__IfExpressionTri__Group_1__1 : rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ; + public final void rule__IfExpressionTri__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8017:1: ( rule__TypeSelectExpression__Group__3__Impl ) - // InternalExport.g:8018:2: rule__TypeSelectExpression__Group__3__Impl + // InternalExport.g:7879:1: ( rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ) + // InternalExport.g:7880:2: rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 { + pushFollow(FOLLOW_18); + rule__IfExpressionTri__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__3__Impl(); + rule__IfExpressionTri__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -26487,28 +27844,28 @@ public final void rule__TypeSelectExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__3" + // $ANTLR end "rule__IfExpressionTri__Group_1__1" - // $ANTLR start "rule__TypeSelectExpression__Group__3__Impl" - // InternalExport.g:8024:1: rule__TypeSelectExpression__Group__3__Impl : ( ')' ) ; - public final void rule__TypeSelectExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__1__Impl" + // InternalExport.g:7887:1: rule__IfExpressionTri__Group_1__1__Impl : ( '?' ) ; + public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8028:1: ( ( ')' ) ) - // InternalExport.g:8029:1: ( ')' ) + // InternalExport.g:7891:1: ( ( '?' ) ) + // InternalExport.g:7892:1: ( '?' ) { - // InternalExport.g:8029:1: ( ')' ) - // InternalExport.g:8030:2: ')' + // InternalExport.g:7892:1: ( '?' ) + // InternalExport.g:7893:2: '?' { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } } @@ -26528,26 +27885,26 @@ public final void rule__TypeSelectExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__3__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__1__Impl" - // $ANTLR start "rule__CollectionExpression__Group__0" - // InternalExport.g:8040:1: rule__CollectionExpression__Group__0 : rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ; - public final void rule__CollectionExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__2" + // InternalExport.g:7902:1: rule__IfExpressionTri__Group_1__2 : rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ; + public final void rule__IfExpressionTri__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8044:1: ( rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ) - // InternalExport.g:8045:2: rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 + // InternalExport.g:7906:1: ( rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ) + // InternalExport.g:7907:2: rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 { - pushFollow(FOLLOW_34); - rule__CollectionExpression__Group__0__Impl(); + pushFollow(FOLLOW_39); + rule__IfExpressionTri__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__1(); + rule__IfExpressionTri__Group_1__3(); state._fsp--; if (state.failed) return ; @@ -26566,30 +27923,30 @@ public final void rule__CollectionExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__0" + // $ANTLR end "rule__IfExpressionTri__Group_1__2" - // $ANTLR start "rule__CollectionExpression__Group__0__Impl" - // InternalExport.g:8052:1: rule__CollectionExpression__Group__0__Impl : ( ( rule__CollectionExpression__NameAssignment_0 ) ) ; - public final void rule__CollectionExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__2__Impl" + // InternalExport.g:7914:1: rule__IfExpressionTri__Group_1__2__Impl : ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ; + public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8056:1: ( ( ( rule__CollectionExpression__NameAssignment_0 ) ) ) - // InternalExport.g:8057:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + // InternalExport.g:7918:1: ( ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ) + // InternalExport.g:7919:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) { - // InternalExport.g:8057:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) - // InternalExport.g:8058:2: ( rule__CollectionExpression__NameAssignment_0 ) + // InternalExport.g:7919:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) + // InternalExport.g:7920:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } - // InternalExport.g:8059:2: ( rule__CollectionExpression__NameAssignment_0 ) - // InternalExport.g:8059:3: rule__CollectionExpression__NameAssignment_0 + // InternalExport.g:7921:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) + // InternalExport.g:7921:3: rule__IfExpressionTri__ThenPartAssignment_1_2 { pushFollow(FOLLOW_2); - rule__CollectionExpression__NameAssignment_0(); + rule__IfExpressionTri__ThenPartAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -26597,7 +27954,7 @@ public final void rule__CollectionExpression__Group__0__Impl() throws Recognitio } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } } @@ -26617,26 +27974,26 @@ public final void rule__CollectionExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__2__Impl" - // $ANTLR start "rule__CollectionExpression__Group__1" - // InternalExport.g:8067:1: rule__CollectionExpression__Group__1 : rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ; - public final void rule__CollectionExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__3" + // InternalExport.g:7929:1: rule__IfExpressionTri__Group_1__3 : rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ; + public final void rule__IfExpressionTri__Group_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8071:1: ( rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ) - // InternalExport.g:8072:2: rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 + // InternalExport.g:7933:1: ( rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ) + // InternalExport.g:7934:2: rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 { pushFollow(FOLLOW_18); - rule__CollectionExpression__Group__1__Impl(); + rule__IfExpressionTri__Group_1__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__2(); + rule__IfExpressionTri__Group_1__4(); state._fsp--; if (state.failed) return ; @@ -26655,28 +28012,28 @@ public final void rule__CollectionExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__1" + // $ANTLR end "rule__IfExpressionTri__Group_1__3" - // $ANTLR start "rule__CollectionExpression__Group__1__Impl" - // InternalExport.g:8079:1: rule__CollectionExpression__Group__1__Impl : ( '(' ) ; - public final void rule__CollectionExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__3__Impl" + // InternalExport.g:7941:1: rule__IfExpressionTri__Group_1__3__Impl : ( ':' ) ; + public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8083:1: ( ( '(' ) ) - // InternalExport.g:8084:1: ( '(' ) + // InternalExport.g:7945:1: ( ( ':' ) ) + // InternalExport.g:7946:1: ( ':' ) { - // InternalExport.g:8084:1: ( '(' ) - // InternalExport.g:8085:2: '(' + // InternalExport.g:7946:1: ( ':' ) + // InternalExport.g:7947:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + match(input,85,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } } @@ -26696,26 +28053,21 @@ public final void rule__CollectionExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__3__Impl" - // $ANTLR start "rule__CollectionExpression__Group__2" - // InternalExport.g:8094:1: rule__CollectionExpression__Group__2 : rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ; - public final void rule__CollectionExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__4" + // InternalExport.g:7956:1: rule__IfExpressionTri__Group_1__4 : rule__IfExpressionTri__Group_1__4__Impl ; + public final void rule__IfExpressionTri__Group_1__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8098:1: ( rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ) - // InternalExport.g:8099:2: rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 + // InternalExport.g:7960:1: ( rule__IfExpressionTri__Group_1__4__Impl ) + // InternalExport.g:7961:2: rule__IfExpressionTri__Group_1__4__Impl { - pushFollow(FOLLOW_18); - rule__CollectionExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__3(); + rule__IfExpressionTri__Group_1__4__Impl(); state._fsp--; if (state.failed) return ; @@ -26734,53 +28086,117 @@ public final void rule__CollectionExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__2" + // $ANTLR end "rule__IfExpressionTri__Group_1__4" - // $ANTLR start "rule__CollectionExpression__Group__2__Impl" - // InternalExport.g:8106:1: rule__CollectionExpression__Group__2__Impl : ( ( rule__CollectionExpression__Group_2__0 )? ) ; - public final void rule__CollectionExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__4__Impl" + // InternalExport.g:7967:1: rule__IfExpressionTri__Group_1__4__Impl : ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ; + public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8110:1: ( ( ( rule__CollectionExpression__Group_2__0 )? ) ) - // InternalExport.g:8111:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + // InternalExport.g:7971:1: ( ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ) + // InternalExport.g:7972:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) { - // InternalExport.g:8111:1: ( ( rule__CollectionExpression__Group_2__0 )? ) - // InternalExport.g:8112:2: ( rule__CollectionExpression__Group_2__0 )? + // InternalExport.g:7972:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) + // InternalExport.g:7973:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } - // InternalExport.g:8113:2: ( rule__CollectionExpression__Group_2__0 )? - int alt66=2; - int LA66_0 = input.LA(1); + // InternalExport.g:7974:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) + // InternalExport.g:7974:3: rule__IfExpressionTri__ElsePartAssignment_1_4 + { + pushFollow(FOLLOW_2); + rule__IfExpressionTri__ElsePartAssignment_1_4(); - if ( (LA66_0==RULE_ID) ) { - int LA66_1 = input.LA(2); + state._fsp--; + if (state.failed) return ; - if ( (LA66_1==69) ) { - alt66=1; - } } - switch (alt66) { - case 1 : - // InternalExport.g:8113:3: rule__CollectionExpression__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__0(); - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + } - } - break; + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__Group_1__4__Impl" + + + // $ANTLR start "rule__IfExpressionKw__Group__0" + // InternalExport.g:7983:1: rule__IfExpressionKw__Group__0 : rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ; + public final void rule__IfExpressionKw__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:7987:1: ( rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ) + // InternalExport.g:7988:2: rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 + { + pushFollow(FOLLOW_18); + rule__IfExpressionKw__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group__1(); + + state._fsp--; + if (state.failed) return ; } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__Group__0" + + + // $ANTLR start "rule__IfExpressionKw__Group__0__Impl" + // InternalExport.g:7995:1: rule__IfExpressionKw__Group__0__Impl : ( 'if' ) ; + public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:7999:1: ( ( 'if' ) ) + // InternalExport.g:8000:1: ( 'if' ) + { + // InternalExport.g:8000:1: ( 'if' ) + // InternalExport.g:8001:2: 'if' + { if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + } + match(input,87,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } } @@ -26800,26 +28216,26 @@ public final void rule__CollectionExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__2__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__0__Impl" - // $ANTLR start "rule__CollectionExpression__Group__3" - // InternalExport.g:8121:1: rule__CollectionExpression__Group__3 : rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ; - public final void rule__CollectionExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__1" + // InternalExport.g:8010:1: rule__IfExpressionKw__Group__1 : rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ; + public final void rule__IfExpressionKw__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8125:1: ( rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ) - // InternalExport.g:8126:2: rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 + // InternalExport.g:8014:1: ( rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ) + // InternalExport.g:8015:2: rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 { - pushFollow(FOLLOW_25); - rule__CollectionExpression__Group__3__Impl(); + pushFollow(FOLLOW_44); + rule__IfExpressionKw__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__4(); + rule__IfExpressionKw__Group__2(); state._fsp--; if (state.failed) return ; @@ -26838,30 +28254,30 @@ public final void rule__CollectionExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__3" + // $ANTLR end "rule__IfExpressionKw__Group__1" - // $ANTLR start "rule__CollectionExpression__Group__3__Impl" - // InternalExport.g:8133:1: rule__CollectionExpression__Group__3__Impl : ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ; - public final void rule__CollectionExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__1__Impl" + // InternalExport.g:8022:1: rule__IfExpressionKw__Group__1__Impl : ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ; + public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8137:1: ( ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ) - // InternalExport.g:8138:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + // InternalExport.g:8026:1: ( ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ) + // InternalExport.g:8027:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) { - // InternalExport.g:8138:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) - // InternalExport.g:8139:2: ( rule__CollectionExpression__ExpAssignment_3 ) + // InternalExport.g:8027:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) + // InternalExport.g:8028:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } - // InternalExport.g:8140:2: ( rule__CollectionExpression__ExpAssignment_3 ) - // InternalExport.g:8140:3: rule__CollectionExpression__ExpAssignment_3 + // InternalExport.g:8029:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) + // InternalExport.g:8029:3: rule__IfExpressionKw__ConditionAssignment_1 { pushFollow(FOLLOW_2); - rule__CollectionExpression__ExpAssignment_3(); + rule__IfExpressionKw__ConditionAssignment_1(); state._fsp--; if (state.failed) return ; @@ -26869,7 +28285,7 @@ public final void rule__CollectionExpression__Group__3__Impl() throws Recognitio } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } } @@ -26889,21 +28305,26 @@ public final void rule__CollectionExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__3__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__1__Impl" - // $ANTLR start "rule__CollectionExpression__Group__4" - // InternalExport.g:8148:1: rule__CollectionExpression__Group__4 : rule__CollectionExpression__Group__4__Impl ; - public final void rule__CollectionExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__2" + // InternalExport.g:8037:1: rule__IfExpressionKw__Group__2 : rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ; + public final void rule__IfExpressionKw__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8152:1: ( rule__CollectionExpression__Group__4__Impl ) - // InternalExport.g:8153:2: rule__CollectionExpression__Group__4__Impl + // InternalExport.g:8041:1: ( rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ) + // InternalExport.g:8042:2: rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 { + pushFollow(FOLLOW_18); + rule__IfExpressionKw__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__4__Impl(); + rule__IfExpressionKw__Group__3(); state._fsp--; if (state.failed) return ; @@ -26922,28 +28343,28 @@ public final void rule__CollectionExpression__Group__4() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__4" + // $ANTLR end "rule__IfExpressionKw__Group__2" - // $ANTLR start "rule__CollectionExpression__Group__4__Impl" - // InternalExport.g:8159:1: rule__CollectionExpression__Group__4__Impl : ( ')' ) ; - public final void rule__CollectionExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__2__Impl" + // InternalExport.g:8049:1: rule__IfExpressionKw__Group__2__Impl : ( 'then' ) ; + public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8163:1: ( ( ')' ) ) - // InternalExport.g:8164:1: ( ')' ) + // InternalExport.g:8053:1: ( ( 'then' ) ) + // InternalExport.g:8054:1: ( 'then' ) { - // InternalExport.g:8164:1: ( ')' ) - // InternalExport.g:8165:2: ')' + // InternalExport.g:8054:1: ( 'then' ) + // InternalExport.g:8055:2: 'then' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,88,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } } @@ -26963,26 +28384,26 @@ public final void rule__CollectionExpression__Group__4__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__4__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__2__Impl" - // $ANTLR start "rule__CollectionExpression__Group_2__0" - // InternalExport.g:8175:1: rule__CollectionExpression__Group_2__0 : rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ; - public final void rule__CollectionExpression__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__3" + // InternalExport.g:8064:1: rule__IfExpressionKw__Group__3 : rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ; + public final void rule__IfExpressionKw__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8179:1: ( rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ) - // InternalExport.g:8180:2: rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 + // InternalExport.g:8068:1: ( rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ) + // InternalExport.g:8069:2: rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 { - pushFollow(FOLLOW_67); - rule__CollectionExpression__Group_2__0__Impl(); + pushFollow(FOLLOW_45); + rule__IfExpressionKw__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__1(); + rule__IfExpressionKw__Group__4(); state._fsp--; if (state.failed) return ; @@ -27001,30 +28422,30 @@ public final void rule__CollectionExpression__Group_2__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__0" + // $ANTLR end "rule__IfExpressionKw__Group__3" - // $ANTLR start "rule__CollectionExpression__Group_2__0__Impl" - // InternalExport.g:8187:1: rule__CollectionExpression__Group_2__0__Impl : ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ; - public final void rule__CollectionExpression__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__3__Impl" + // InternalExport.g:8076:1: rule__IfExpressionKw__Group__3__Impl : ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ; + public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8191:1: ( ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ) - // InternalExport.g:8192:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + // InternalExport.g:8080:1: ( ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ) + // InternalExport.g:8081:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) { - // InternalExport.g:8192:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) - // InternalExport.g:8193:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + // InternalExport.g:8081:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) + // InternalExport.g:8082:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } - // InternalExport.g:8194:2: ( rule__CollectionExpression__VarAssignment_2_0 ) - // InternalExport.g:8194:3: rule__CollectionExpression__VarAssignment_2_0 + // InternalExport.g:8083:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) + // InternalExport.g:8083:3: rule__IfExpressionKw__ThenPartAssignment_3 { pushFollow(FOLLOW_2); - rule__CollectionExpression__VarAssignment_2_0(); + rule__IfExpressionKw__ThenPartAssignment_3(); state._fsp--; if (state.failed) return ; @@ -27032,7 +28453,7 @@ public final void rule__CollectionExpression__Group_2__0__Impl() throws Recognit } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } } @@ -27052,21 +28473,21 @@ public final void rule__CollectionExpression__Group_2__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__3__Impl" - // $ANTLR start "rule__CollectionExpression__Group_2__1" - // InternalExport.g:8202:1: rule__CollectionExpression__Group_2__1 : rule__CollectionExpression__Group_2__1__Impl ; - public final void rule__CollectionExpression__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__4" + // InternalExport.g:8091:1: rule__IfExpressionKw__Group__4 : rule__IfExpressionKw__Group__4__Impl ; + public final void rule__IfExpressionKw__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8206:1: ( rule__CollectionExpression__Group_2__1__Impl ) - // InternalExport.g:8207:2: rule__CollectionExpression__Group_2__1__Impl + // InternalExport.g:8095:1: ( rule__IfExpressionKw__Group__4__Impl ) + // InternalExport.g:8096:2: rule__IfExpressionKw__Group__4__Impl { pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__1__Impl(); + rule__IfExpressionKw__Group__4__Impl(); state._fsp--; if (state.failed) return ; @@ -27085,28 +28506,53 @@ public final void rule__CollectionExpression__Group_2__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__1" + // $ANTLR end "rule__IfExpressionKw__Group__4" - // $ANTLR start "rule__CollectionExpression__Group_2__1__Impl" - // InternalExport.g:8213:1: rule__CollectionExpression__Group_2__1__Impl : ( '|' ) ; - public final void rule__CollectionExpression__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__4__Impl" + // InternalExport.g:8102:1: rule__IfExpressionKw__Group__4__Impl : ( ( rule__IfExpressionKw__Group_4__0 )? ) ; + public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8217:1: ( ( '|' ) ) - // InternalExport.g:8218:1: ( '|' ) + // InternalExport.g:8106:1: ( ( ( rule__IfExpressionKw__Group_4__0 )? ) ) + // InternalExport.g:8107:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) { - // InternalExport.g:8218:1: ( '|' ) - // InternalExport.g:8219:2: '|' + // InternalExport.g:8107:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) + // InternalExport.g:8108:2: ( rule__IfExpressionKw__Group_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } - match(input,69,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:8109:2: ( rule__IfExpressionKw__Group_4__0 )? + int alt89=2; + int LA89_0 = input.LA(1); + + if ( (LA89_0==89) ) { + int LA89_1 = input.LA(2); + + if ( (synpred163_InternalExport()) ) { + alt89=1; + } + } + switch (alt89) { + case 1 : + // InternalExport.g:8109:3: rule__IfExpressionKw__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } } @@ -27126,26 +28572,21 @@ public final void rule__CollectionExpression__Group_2__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__4__Impl" - // $ANTLR start "rule__CollectionType__Group__0" - // InternalExport.g:8229:1: rule__CollectionType__Group__0 : rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ; - public final void rule__CollectionType__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4__0" + // InternalExport.g:8118:1: rule__IfExpressionKw__Group_4__0 : rule__IfExpressionKw__Group_4__0__Impl ; + public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8233:1: ( rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ) - // InternalExport.g:8234:2: rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 + // InternalExport.g:8122:1: ( rule__IfExpressionKw__Group_4__0__Impl ) + // InternalExport.g:8123:2: rule__IfExpressionKw__Group_4__0__Impl { - pushFollow(FOLLOW_30); - rule__CollectionType__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__1(); + rule__IfExpressionKw__Group_4__0__Impl(); state._fsp--; if (state.failed) return ; @@ -27164,30 +28605,30 @@ public final void rule__CollectionType__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__0" + // $ANTLR end "rule__IfExpressionKw__Group_4__0" - // $ANTLR start "rule__CollectionType__Group__0__Impl" - // InternalExport.g:8241:1: rule__CollectionType__Group__0__Impl : ( ( rule__CollectionType__ClAssignment_0 ) ) ; - public final void rule__CollectionType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4__0__Impl" + // InternalExport.g:8129:1: rule__IfExpressionKw__Group_4__0__Impl : ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ; + public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8245:1: ( ( ( rule__CollectionType__ClAssignment_0 ) ) ) - // InternalExport.g:8246:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + // InternalExport.g:8133:1: ( ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ) + // InternalExport.g:8134:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) { - // InternalExport.g:8246:1: ( ( rule__CollectionType__ClAssignment_0 ) ) - // InternalExport.g:8247:2: ( rule__CollectionType__ClAssignment_0 ) + // InternalExport.g:8134:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) + // InternalExport.g:8135:2: ( rule__IfExpressionKw__Group_4_0__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } - // InternalExport.g:8248:2: ( rule__CollectionType__ClAssignment_0 ) - // InternalExport.g:8248:3: rule__CollectionType__ClAssignment_0 + // InternalExport.g:8136:2: ( rule__IfExpressionKw__Group_4_0__0 ) + // InternalExport.g:8136:3: rule__IfExpressionKw__Group_4_0__0 { pushFollow(FOLLOW_2); - rule__CollectionType__ClAssignment_0(); + rule__IfExpressionKw__Group_4_0__0(); state._fsp--; if (state.failed) return ; @@ -27195,7 +28636,7 @@ public final void rule__CollectionType__Group__0__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } } @@ -27215,26 +28656,26 @@ public final void rule__CollectionType__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4__0__Impl" - // $ANTLR start "rule__CollectionType__Group__1" - // InternalExport.g:8256:1: rule__CollectionType__Group__1 : rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ; - public final void rule__CollectionType__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__0" + // InternalExport.g:8145:1: rule__IfExpressionKw__Group_4_0__0 : rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ; + public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8260:1: ( rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ) - // InternalExport.g:8261:2: rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 + // InternalExport.g:8149:1: ( rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ) + // InternalExport.g:8150:2: rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 { - pushFollow(FOLLOW_40); - rule__CollectionType__Group__1__Impl(); + pushFollow(FOLLOW_18); + rule__IfExpressionKw__Group_4_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__2(); + rule__IfExpressionKw__Group_4_0__1(); state._fsp--; if (state.failed) return ; @@ -27253,28 +28694,28 @@ public final void rule__CollectionType__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__1" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__0" - // $ANTLR start "rule__CollectionType__Group__1__Impl" - // InternalExport.g:8268:1: rule__CollectionType__Group__1__Impl : ( '[' ) ; - public final void rule__CollectionType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__0__Impl" + // InternalExport.g:8157:1: rule__IfExpressionKw__Group_4_0__0__Impl : ( 'else' ) ; + public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8272:1: ( ( '[' ) ) - // InternalExport.g:8273:1: ( '[' ) + // InternalExport.g:8161:1: ( ( 'else' ) ) + // InternalExport.g:8162:1: ( 'else' ) { - // InternalExport.g:8273:1: ( '[' ) - // InternalExport.g:8274:2: '[' + // InternalExport.g:8162:1: ( 'else' ) + // InternalExport.g:8163:2: 'else' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } - match(input,45,FOLLOW_2); if (state.failed) return ; + match(input,89,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } } @@ -27294,26 +28735,21 @@ public final void rule__CollectionType__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__0__Impl" - // $ANTLR start "rule__CollectionType__Group__2" - // InternalExport.g:8283:1: rule__CollectionType__Group__2 : rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ; - public final void rule__CollectionType__Group__2() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__1" + // InternalExport.g:8172:1: rule__IfExpressionKw__Group_4_0__1 : rule__IfExpressionKw__Group_4_0__1__Impl ; + public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8287:1: ( rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ) - // InternalExport.g:8288:2: rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 + // InternalExport.g:8176:1: ( rule__IfExpressionKw__Group_4_0__1__Impl ) + // InternalExport.g:8177:2: rule__IfExpressionKw__Group_4_0__1__Impl { - pushFollow(FOLLOW_19); - rule__CollectionType__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__3(); + rule__IfExpressionKw__Group_4_0__1__Impl(); state._fsp--; if (state.failed) return ; @@ -27332,30 +28768,30 @@ public final void rule__CollectionType__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__2" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__1" - // $ANTLR start "rule__CollectionType__Group__2__Impl" - // InternalExport.g:8295:1: rule__CollectionType__Group__2__Impl : ( ( rule__CollectionType__Id1Assignment_2 ) ) ; - public final void rule__CollectionType__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__1__Impl" + // InternalExport.g:8183:1: rule__IfExpressionKw__Group_4_0__1__Impl : ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ; + public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8299:1: ( ( ( rule__CollectionType__Id1Assignment_2 ) ) ) - // InternalExport.g:8300:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + // InternalExport.g:8187:1: ( ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ) + // InternalExport.g:8188:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) { - // InternalExport.g:8300:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) - // InternalExport.g:8301:2: ( rule__CollectionType__Id1Assignment_2 ) + // InternalExport.g:8188:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) + // InternalExport.g:8189:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } - // InternalExport.g:8302:2: ( rule__CollectionType__Id1Assignment_2 ) - // InternalExport.g:8302:3: rule__CollectionType__Id1Assignment_2 + // InternalExport.g:8190:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) + // InternalExport.g:8190:3: rule__IfExpressionKw__ElsePartAssignment_4_0_1 { pushFollow(FOLLOW_2); - rule__CollectionType__Id1Assignment_2(); + rule__IfExpressionKw__ElsePartAssignment_4_0_1(); state._fsp--; if (state.failed) return ; @@ -27363,7 +28799,7 @@ public final void rule__CollectionType__Group__2__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } } @@ -27383,21 +28819,26 @@ public final void rule__CollectionType__Group__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__2__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__1__Impl" - // $ANTLR start "rule__CollectionType__Group__3" - // InternalExport.g:8310:1: rule__CollectionType__Group__3 : rule__CollectionType__Group__3__Impl ; - public final void rule__CollectionType__Group__3() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__0" + // InternalExport.g:8199:1: rule__SwitchExpression__Group__0 : rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ; + public final void rule__SwitchExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8314:1: ( rule__CollectionType__Group__3__Impl ) - // InternalExport.g:8315:2: rule__CollectionType__Group__3__Impl + // InternalExport.g:8203:1: ( rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ) + // InternalExport.g:8204:2: rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 { + pushFollow(FOLLOW_46); + rule__SwitchExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__3__Impl(); + rule__SwitchExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -27416,28 +28857,28 @@ public final void rule__CollectionType__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__3" + // $ANTLR end "rule__SwitchExpression__Group__0" - // $ANTLR start "rule__CollectionType__Group__3__Impl" - // InternalExport.g:8321:1: rule__CollectionType__Group__3__Impl : ( ']' ) ; - public final void rule__CollectionType__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__0__Impl" + // InternalExport.g:8211:1: rule__SwitchExpression__Group__0__Impl : ( 'switch' ) ; + public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8325:1: ( ( ']' ) ) - // InternalExport.g:8326:1: ( ']' ) + // InternalExport.g:8215:1: ( ( 'switch' ) ) + // InternalExport.g:8216:1: ( 'switch' ) { - // InternalExport.g:8326:1: ( ']' ) - // InternalExport.g:8327:2: ']' + // InternalExport.g:8216:1: ( 'switch' ) + // InternalExport.g:8217:2: 'switch' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } - match(input,46,FOLLOW_2); if (state.failed) return ; + match(input,90,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } } @@ -27457,26 +28898,26 @@ public final void rule__CollectionType__Group__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__3__Impl" + // $ANTLR end "rule__SwitchExpression__Group__0__Impl" - // $ANTLR start "rule__SimpleType__Group__0" - // InternalExport.g:8337:1: rule__SimpleType__Group__0 : rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ; - public final void rule__SimpleType__Group__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__1" + // InternalExport.g:8226:1: rule__SwitchExpression__Group__1 : rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ; + public final void rule__SwitchExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8341:1: ( rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ) - // InternalExport.g:8342:2: rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 + // InternalExport.g:8230:1: ( rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ) + // InternalExport.g:8231:2: rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 { - pushFollow(FOLLOW_37); - rule__SimpleType__Group__0__Impl(); + pushFollow(FOLLOW_46); + rule__SwitchExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group__1(); + rule__SwitchExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -27495,38 +28936,49 @@ public final void rule__SimpleType__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group__0" + // $ANTLR end "rule__SwitchExpression__Group__1" - // $ANTLR start "rule__SimpleType__Group__0__Impl" - // InternalExport.g:8349:1: rule__SimpleType__Group__0__Impl : ( ( rule__SimpleType__IdAssignment_0 ) ) ; - public final void rule__SimpleType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__1__Impl" + // InternalExport.g:8238:1: rule__SwitchExpression__Group__1__Impl : ( ( rule__SwitchExpression__Group_1__0 )? ) ; + public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8353:1: ( ( ( rule__SimpleType__IdAssignment_0 ) ) ) - // InternalExport.g:8354:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + // InternalExport.g:8242:1: ( ( ( rule__SwitchExpression__Group_1__0 )? ) ) + // InternalExport.g:8243:1: ( ( rule__SwitchExpression__Group_1__0 )? ) { - // InternalExport.g:8354:1: ( ( rule__SimpleType__IdAssignment_0 ) ) - // InternalExport.g:8355:2: ( rule__SimpleType__IdAssignment_0 ) + // InternalExport.g:8243:1: ( ( rule__SwitchExpression__Group_1__0 )? ) + // InternalExport.g:8244:2: ( rule__SwitchExpression__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } - // InternalExport.g:8356:2: ( rule__SimpleType__IdAssignment_0 ) - // InternalExport.g:8356:3: rule__SimpleType__IdAssignment_0 - { - pushFollow(FOLLOW_2); - rule__SimpleType__IdAssignment_0(); + // InternalExport.g:8245:2: ( rule__SwitchExpression__Group_1__0 )? + int alt90=2; + int LA90_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA90_0==77) ) { + alt90=1; + } + switch (alt90) { + case 1 : + // InternalExport.g:8245:3: rule__SwitchExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } } @@ -27546,21 +28998,26 @@ public final void rule__SimpleType__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__SimpleType__Group__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group__1__Impl" - // $ANTLR start "rule__SimpleType__Group__1" - // InternalExport.g:8364:1: rule__SimpleType__Group__1 : rule__SimpleType__Group__1__Impl ; - public final void rule__SimpleType__Group__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__2" + // InternalExport.g:8253:1: rule__SwitchExpression__Group__2 : rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ; + public final void rule__SwitchExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8368:1: ( rule__SimpleType__Group__1__Impl ) - // InternalExport.g:8369:2: rule__SimpleType__Group__1__Impl + // InternalExport.g:8257:1: ( rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ) + // InternalExport.g:8258:2: rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 { + pushFollow(FOLLOW_47); + rule__SwitchExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group__1__Impl(); + rule__SwitchExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -27579,56 +29036,28 @@ public final void rule__SimpleType__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group__1" + // $ANTLR end "rule__SwitchExpression__Group__2" - // $ANTLR start "rule__SimpleType__Group__1__Impl" - // InternalExport.g:8375:1: rule__SimpleType__Group__1__Impl : ( ( rule__SimpleType__Group_1__0 )* ) ; - public final void rule__SimpleType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__2__Impl" + // InternalExport.g:8265:1: rule__SwitchExpression__Group__2__Impl : ( '{' ) ; + public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8379:1: ( ( ( rule__SimpleType__Group_1__0 )* ) ) - // InternalExport.g:8380:1: ( ( rule__SimpleType__Group_1__0 )* ) + // InternalExport.g:8269:1: ( ( '{' ) ) + // InternalExport.g:8270:1: ( '{' ) { - // InternalExport.g:8380:1: ( ( rule__SimpleType__Group_1__0 )* ) - // InternalExport.g:8381:2: ( rule__SimpleType__Group_1__0 )* + // InternalExport.g:8270:1: ( '{' ) + // InternalExport.g:8271:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getGroup_1()); + before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } - // InternalExport.g:8382:2: ( rule__SimpleType__Group_1__0 )* - loop67: - do { - int alt67=2; - int LA67_0 = input.LA(1); - - if ( (LA67_0==57) ) { - alt67=1; - } - - - switch (alt67) { - case 1 : - // InternalExport.g:8382:3: rule__SimpleType__Group_1__0 - { - pushFollow(FOLLOW_38); - rule__SimpleType__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop67; - } - } while (true); - + match(input,68,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getGroup_1()); + after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } } @@ -27648,26 +29077,26 @@ public final void rule__SimpleType__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__SimpleType__Group__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group__2__Impl" - // $ANTLR start "rule__SimpleType__Group_1__0" - // InternalExport.g:8391:1: rule__SimpleType__Group_1__0 : rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ; - public final void rule__SimpleType__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__3" + // InternalExport.g:8280:1: rule__SwitchExpression__Group__3 : rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ; + public final void rule__SwitchExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8395:1: ( rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ) - // InternalExport.g:8396:2: rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 + // InternalExport.g:8284:1: ( rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ) + // InternalExport.g:8285:2: rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 { - pushFollow(FOLLOW_10); - rule__SimpleType__Group_1__0__Impl(); + pushFollow(FOLLOW_47); + rule__SwitchExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group_1__1(); + rule__SwitchExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -27686,28 +29115,56 @@ public final void rule__SimpleType__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group_1__0" + // $ANTLR end "rule__SwitchExpression__Group__3" - // $ANTLR start "rule__SimpleType__Group_1__0__Impl" - // InternalExport.g:8403:1: rule__SimpleType__Group_1__0__Impl : ( '::' ) ; - public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__3__Impl" + // InternalExport.g:8292:1: rule__SwitchExpression__Group__3__Impl : ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ; + public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8407:1: ( ( '::' ) ) - // InternalExport.g:8408:1: ( '::' ) + // InternalExport.g:8296:1: ( ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ) + // InternalExport.g:8297:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) { - // InternalExport.g:8408:1: ( '::' ) - // InternalExport.g:8409:2: '::' + // InternalExport.g:8297:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) + // InternalExport.g:8298:2: ( rule__SwitchExpression__CaseAssignment_3 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } - match(input,57,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:8299:2: ( rule__SwitchExpression__CaseAssignment_3 )* + loop91: + do { + int alt91=2; + int LA91_0 = input.LA(1); + + if ( (LA91_0==92) ) { + alt91=1; + } + + + switch (alt91) { + case 1 : + // InternalExport.g:8299:3: rule__SwitchExpression__CaseAssignment_3 + { + pushFollow(FOLLOW_48); + rule__SwitchExpression__CaseAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop91; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } } @@ -27727,21 +29184,26 @@ public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SimpleType__Group_1__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group__3__Impl" - // $ANTLR start "rule__SimpleType__Group_1__1" - // InternalExport.g:8418:1: rule__SimpleType__Group_1__1 : rule__SimpleType__Group_1__1__Impl ; - public final void rule__SimpleType__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__4" + // InternalExport.g:8307:1: rule__SwitchExpression__Group__4 : rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ; + public final void rule__SwitchExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8422:1: ( rule__SimpleType__Group_1__1__Impl ) - // InternalExport.g:8423:2: rule__SimpleType__Group_1__1__Impl + // InternalExport.g:8311:1: ( rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ) + // InternalExport.g:8312:2: rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 { + pushFollow(FOLLOW_39); + rule__SwitchExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group_1__1__Impl(); + rule__SwitchExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -27760,38 +29222,28 @@ public final void rule__SimpleType__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group_1__1" + // $ANTLR end "rule__SwitchExpression__Group__4" - // $ANTLR start "rule__SimpleType__Group_1__1__Impl" - // InternalExport.g:8429:1: rule__SimpleType__Group_1__1__Impl : ( ( rule__SimpleType__IdAssignment_1_1 ) ) ; - public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__4__Impl" + // InternalExport.g:8319:1: rule__SwitchExpression__Group__4__Impl : ( 'default' ) ; + public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8433:1: ( ( ( rule__SimpleType__IdAssignment_1_1 ) ) ) - // InternalExport.g:8434:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + // InternalExport.g:8323:1: ( ( 'default' ) ) + // InternalExport.g:8324:1: ( 'default' ) { - // InternalExport.g:8434:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) - // InternalExport.g:8435:2: ( rule__SimpleType__IdAssignment_1_1 ) + // InternalExport.g:8324:1: ( 'default' ) + // InternalExport.g:8325:2: 'default' { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); - } - // InternalExport.g:8436:2: ( rule__SimpleType__IdAssignment_1_1 ) - // InternalExport.g:8436:3: rule__SimpleType__IdAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__SimpleType__IdAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - + match(input,91,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } } @@ -27811,44 +29263,29 @@ public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SimpleType__Group_1__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group__4__Impl" - // $ANTLR start "rule__ExportModel__ExtensionAssignment_0_1" - // InternalExport.g:8445:1: rule__ExportModel__ExtensionAssignment_0_1 : ( ( 'extension' ) ) ; - public final void rule__ExportModel__ExtensionAssignment_0_1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__5" + // InternalExport.g:8334:1: rule__SwitchExpression__Group__5 : rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ; + public final void rule__SwitchExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8449:1: ( ( ( 'extension' ) ) ) - // InternalExport.g:8450:2: ( ( 'extension' ) ) - { - // InternalExport.g:8450:2: ( ( 'extension' ) ) - // InternalExport.g:8451:3: ( 'extension' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); - } - // InternalExport.g:8452:3: ( 'extension' ) - // InternalExport.g:8453:4: 'extension' + // InternalExport.g:8338:1: ( rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ) + // InternalExport.g:8339:2: rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); - } - match(input,43,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); - } + pushFollow(FOLLOW_49); + rule__SwitchExpression__Group__5__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group__6(); + state._fsp--; + if (state.failed) return ; } @@ -27864,28 +29301,28 @@ public final void rule__ExportModel__ExtensionAssignment_0_1() throws Recognitio } return ; } - // $ANTLR end "rule__ExportModel__ExtensionAssignment_0_1" + // $ANTLR end "rule__SwitchExpression__Group__5" - // $ANTLR start "rule__ExportModel__NameAssignment_0_2" - // InternalExport.g:8464:1: rule__ExportModel__NameAssignment_0_2 : ( RULE_ID ) ; - public final void rule__ExportModel__NameAssignment_0_2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__5__Impl" + // InternalExport.g:8346:1: rule__SwitchExpression__Group__5__Impl : ( ':' ) ; + public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8468:1: ( ( RULE_ID ) ) - // InternalExport.g:8469:2: ( RULE_ID ) + // InternalExport.g:8350:1: ( ( ':' ) ) + // InternalExport.g:8351:1: ( ':' ) { - // InternalExport.g:8469:2: ( RULE_ID ) - // InternalExport.g:8470:3: RULE_ID + // InternalExport.g:8351:1: ( ':' ) + // InternalExport.g:8352:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); + before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + match(input,85,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); + after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } } @@ -27905,48 +29342,29 @@ public final void rule__ExportModel__NameAssignment_0_2() throws RecognitionExce } return ; } - // $ANTLR end "rule__ExportModel__NameAssignment_0_2" + // $ANTLR end "rule__SwitchExpression__Group__5__Impl" - // $ANTLR start "rule__ExportModel__TargetGrammarAssignment_0_4" - // InternalExport.g:8479:1: rule__ExportModel__TargetGrammarAssignment_0_4 : ( ( ruleQualifiedID ) ) ; - public final void rule__ExportModel__TargetGrammarAssignment_0_4() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__6" + // InternalExport.g:8361:1: rule__SwitchExpression__Group__6 : rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ; + public final void rule__SwitchExpression__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8483:1: ( ( ( ruleQualifiedID ) ) ) - // InternalExport.g:8484:2: ( ( ruleQualifiedID ) ) - { - // InternalExport.g:8484:2: ( ( ruleQualifiedID ) ) - // InternalExport.g:8485:3: ( ruleQualifiedID ) + // InternalExport.g:8365:1: ( rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ) + // InternalExport.g:8366:2: rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); - } - // InternalExport.g:8486:3: ( ruleQualifiedID ) - // InternalExport.g:8487:4: ruleQualifiedID - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); - } - pushFollow(FOLLOW_2); - ruleQualifiedID(); + pushFollow(FOLLOW_13); + rule__SwitchExpression__Group__6__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group__7(); + state._fsp--; + if (state.failed) return ; } @@ -27962,32 +29380,38 @@ public final void rule__ExportModel__TargetGrammarAssignment_0_4() throws Recogn } return ; } - // $ANTLR end "rule__ExportModel__TargetGrammarAssignment_0_4" + // $ANTLR end "rule__SwitchExpression__Group__6" - // $ANTLR start "rule__ExportModel__ImportsAssignment_1" - // InternalExport.g:8498:1: rule__ExportModel__ImportsAssignment_1 : ( ruleImport ) ; - public final void rule__ExportModel__ImportsAssignment_1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__6__Impl" + // InternalExport.g:8373:1: rule__SwitchExpression__Group__6__Impl : ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ; + public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8502:1: ( ( ruleImport ) ) - // InternalExport.g:8503:2: ( ruleImport ) + // InternalExport.g:8377:1: ( ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ) + // InternalExport.g:8378:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) { - // InternalExport.g:8503:2: ( ruleImport ) - // InternalExport.g:8504:3: ruleImport + // InternalExport.g:8378:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) + // InternalExport.g:8379:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); + before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + // InternalExport.g:8380:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) + // InternalExport.g:8380:3: rule__SwitchExpression__DefaultExprAssignment_6 + { pushFollow(FOLLOW_2); - ruleImport(); + rule__SwitchExpression__DefaultExprAssignment_6(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); + after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } } @@ -28007,36 +29431,24 @@ public final void rule__ExportModel__ImportsAssignment_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__ExportModel__ImportsAssignment_1" + // $ANTLR end "rule__SwitchExpression__Group__6__Impl" - // $ANTLR start "rule__ExportModel__ExtensionsAssignment_2" - // InternalExport.g:8513:1: rule__ExportModel__ExtensionsAssignment_2 : ( ruleExtension ) ; - public final void rule__ExportModel__ExtensionsAssignment_2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__7" + // InternalExport.g:8388:1: rule__SwitchExpression__Group__7 : rule__SwitchExpression__Group__7__Impl ; + public final void rule__SwitchExpression__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8517:1: ( ( ruleExtension ) ) - // InternalExport.g:8518:2: ( ruleExtension ) + // InternalExport.g:8392:1: ( rule__SwitchExpression__Group__7__Impl ) + // InternalExport.g:8393:2: rule__SwitchExpression__Group__7__Impl { - // InternalExport.g:8518:2: ( ruleExtension ) - // InternalExport.g:8519:3: ruleExtension - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); - } pushFollow(FOLLOW_2); - ruleExtension(); + rule__SwitchExpression__Group__7__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); - } - - } - } @@ -28052,32 +29464,28 @@ public final void rule__ExportModel__ExtensionsAssignment_2() throws Recognition } return ; } - // $ANTLR end "rule__ExportModel__ExtensionsAssignment_2" + // $ANTLR end "rule__SwitchExpression__Group__7" - // $ANTLR start "rule__ExportModel__InterfacesAssignment_3_2" - // InternalExport.g:8528:1: rule__ExportModel__InterfacesAssignment_3_2 : ( ruleInterface ) ; - public final void rule__ExportModel__InterfacesAssignment_3_2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__7__Impl" + // InternalExport.g:8399:1: rule__SwitchExpression__Group__7__Impl : ( '}' ) ; + public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8532:1: ( ( ruleInterface ) ) - // InternalExport.g:8533:2: ( ruleInterface ) + // InternalExport.g:8403:1: ( ( '}' ) ) + // InternalExport.g:8404:1: ( '}' ) { - // InternalExport.g:8533:2: ( ruleInterface ) - // InternalExport.g:8534:3: ruleInterface + // InternalExport.g:8404:1: ( '}' ) + // InternalExport.g:8405:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); + before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } - pushFollow(FOLLOW_2); - ruleInterface(); - - state._fsp--; - if (state.failed) return ; + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); + after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } } @@ -28097,36 +29505,29 @@ public final void rule__ExportModel__InterfacesAssignment_3_2() throws Recogniti } return ; } - // $ANTLR end "rule__ExportModel__InterfacesAssignment_3_2" + // $ANTLR end "rule__SwitchExpression__Group__7__Impl" - // $ANTLR start "rule__ExportModel__ExportsAssignment_4" - // InternalExport.g:8543:1: rule__ExportModel__ExportsAssignment_4 : ( ruleExport ) ; - public final void rule__ExportModel__ExportsAssignment_4() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__0" + // InternalExport.g:8415:1: rule__SwitchExpression__Group_1__0 : rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ; + public final void rule__SwitchExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8547:1: ( ( ruleExport ) ) - // InternalExport.g:8548:2: ( ruleExport ) + // InternalExport.g:8419:1: ( rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ) + // InternalExport.g:8420:2: rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 { - // InternalExport.g:8548:2: ( ruleExport ) - // InternalExport.g:8549:3: ruleExport - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); - } - pushFollow(FOLLOW_2); - ruleExport(); + pushFollow(FOLLOW_49); + rule__SwitchExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -28142,40 +29543,28 @@ public final void rule__ExportModel__ExportsAssignment_4() throws RecognitionExc } return ; } - // $ANTLR end "rule__ExportModel__ExportsAssignment_4" + // $ANTLR end "rule__SwitchExpression__Group_1__0" - // $ANTLR start "rule__Import__PackageAssignment_1" - // InternalExport.g:8558:1: rule__Import__PackageAssignment_1 : ( ( RULE_STRING ) ) ; - public final void rule__Import__PackageAssignment_1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__0__Impl" + // InternalExport.g:8427:1: rule__SwitchExpression__Group_1__0__Impl : ( '(' ) ; + public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8562:1: ( ( ( RULE_STRING ) ) ) - // InternalExport.g:8563:2: ( ( RULE_STRING ) ) - { - // InternalExport.g:8563:2: ( ( RULE_STRING ) ) - // InternalExport.g:8564:3: ( RULE_STRING ) + // InternalExport.g:8431:1: ( ( '(' ) ) + // InternalExport.g:8432:1: ( '(' ) { - if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); - } - // InternalExport.g:8565:3: ( RULE_STRING ) - // InternalExport.g:8566:4: RULE_STRING + // InternalExport.g:8432:1: ( '(' ) + // InternalExport.g:8433:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); - } - match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); - } - + before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); + after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } } @@ -28195,32 +29584,29 @@ public final void rule__Import__PackageAssignment_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Import__PackageAssignment_1" + // $ANTLR end "rule__SwitchExpression__Group_1__0__Impl" - // $ANTLR start "rule__Import__NameAssignment_2_1" - // InternalExport.g:8577:1: rule__Import__NameAssignment_2_1 : ( RULE_ID ) ; - public final void rule__Import__NameAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__1" + // InternalExport.g:8442:1: rule__SwitchExpression__Group_1__1 : rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ; + public final void rule__SwitchExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8581:1: ( ( RULE_ID ) ) - // InternalExport.g:8582:2: ( RULE_ID ) - { - // InternalExport.g:8582:2: ( RULE_ID ) - // InternalExport.g:8583:3: RULE_ID + // InternalExport.g:8446:1: ( rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ) + // InternalExport.g:8447:2: rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); - } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); - } + pushFollow(FOLLOW_25); + rule__SwitchExpression__Group_1__1__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -28236,32 +29622,38 @@ public final void rule__Import__NameAssignment_2_1() throws RecognitionException } return ; } - // $ANTLR end "rule__Import__NameAssignment_2_1" + // $ANTLR end "rule__SwitchExpression__Group_1__1" - // $ANTLR start "rule__Extension__ExtensionAssignment_1" - // InternalExport.g:8592:1: rule__Extension__ExtensionAssignment_1 : ( ruleQualifiedID ) ; - public final void rule__Extension__ExtensionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__1__Impl" + // InternalExport.g:8454:1: rule__SwitchExpression__Group_1__1__Impl : ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ; + public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8596:1: ( ( ruleQualifiedID ) ) - // InternalExport.g:8597:2: ( ruleQualifiedID ) + // InternalExport.g:8458:1: ( ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ) + // InternalExport.g:8459:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) { - // InternalExport.g:8597:2: ( ruleQualifiedID ) - // InternalExport.g:8598:3: ruleQualifiedID + // InternalExport.g:8459:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) + // InternalExport.g:8460:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + // InternalExport.g:8461:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) + // InternalExport.g:8461:3: rule__SwitchExpression__SwitchExprAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleQualifiedID(); + rule__SwitchExpression__SwitchExprAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } } @@ -28281,48 +29673,24 @@ public final void rule__Extension__ExtensionAssignment_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__Extension__ExtensionAssignment_1" + // $ANTLR end "rule__SwitchExpression__Group_1__1__Impl" - // $ANTLR start "rule__Interface__TypeAssignment_0" - // InternalExport.g:8607:1: rule__Interface__TypeAssignment_0 : ( ( ruleQualifiedID ) ) ; - public final void rule__Interface__TypeAssignment_0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__2" + // InternalExport.g:8469:1: rule__SwitchExpression__Group_1__2 : rule__SwitchExpression__Group_1__2__Impl ; + public final void rule__SwitchExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8611:1: ( ( ( ruleQualifiedID ) ) ) - // InternalExport.g:8612:2: ( ( ruleQualifiedID ) ) - { - // InternalExport.g:8612:2: ( ( ruleQualifiedID ) ) - // InternalExport.g:8613:3: ( ruleQualifiedID ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); - } - // InternalExport.g:8614:3: ( ruleQualifiedID ) - // InternalExport.g:8615:4: ruleQualifiedID + // InternalExport.g:8473:1: ( rule__SwitchExpression__Group_1__2__Impl ) + // InternalExport.g:8474:2: rule__SwitchExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); - } pushFollow(FOLLOW_2); - ruleQualifiedID(); + rule__SwitchExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); - } - - } - } @@ -28338,32 +29706,28 @@ public final void rule__Interface__TypeAssignment_0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Interface__TypeAssignment_0" + // $ANTLR end "rule__SwitchExpression__Group_1__2" - // $ANTLR start "rule__Interface__GuardAssignment_1_1" - // InternalExport.g:8626:1: rule__Interface__GuardAssignment_1_1 : ( ruleExpression ) ; - public final void rule__Interface__GuardAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__2__Impl" + // InternalExport.g:8480:1: rule__SwitchExpression__Group_1__2__Impl : ( ')' ) ; + public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8630:1: ( ( ruleExpression ) ) - // InternalExport.g:8631:2: ( ruleExpression ) + // InternalExport.g:8484:1: ( ( ')' ) ) + // InternalExport.g:8485:1: ( ')' ) { - // InternalExport.g:8631:2: ( ruleExpression ) - // InternalExport.g:8632:3: ruleExpression + // InternalExport.g:8485:1: ( ')' ) + // InternalExport.g:8486:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); + before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); + after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } } @@ -28383,36 +29747,29 @@ public final void rule__Interface__GuardAssignment_1_1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Interface__GuardAssignment_1_1" + // $ANTLR end "rule__SwitchExpression__Group_1__2__Impl" - // $ANTLR start "rule__Interface__ItemsAssignment_2_1" - // InternalExport.g:8641:1: rule__Interface__ItemsAssignment_2_1 : ( ruleInterfaceItem ) ; - public final void rule__Interface__ItemsAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__0" + // InternalExport.g:8496:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; + public final void rule__Case__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8645:1: ( ( ruleInterfaceItem ) ) - // InternalExport.g:8646:2: ( ruleInterfaceItem ) + // InternalExport.g:8500:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) + // InternalExport.g:8501:2: rule__Case__Group__0__Impl rule__Case__Group__1 { - // InternalExport.g:8646:2: ( ruleInterfaceItem ) - // InternalExport.g:8647:3: ruleInterfaceItem - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); - } - pushFollow(FOLLOW_2); - ruleInterfaceItem(); + pushFollow(FOLLOW_49); + rule__Case__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__Case__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -28428,32 +29785,28 @@ public final void rule__Interface__ItemsAssignment_2_1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Interface__ItemsAssignment_2_1" + // $ANTLR end "rule__Case__Group__0" - // $ANTLR start "rule__Interface__ItemsAssignment_2_2_1" - // InternalExport.g:8656:1: rule__Interface__ItemsAssignment_2_2_1 : ( ruleInterfaceItem ) ; - public final void rule__Interface__ItemsAssignment_2_2_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__0__Impl" + // InternalExport.g:8508:1: rule__Case__Group__0__Impl : ( 'case' ) ; + public final void rule__Case__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8660:1: ( ( ruleInterfaceItem ) ) - // InternalExport.g:8661:2: ( ruleInterfaceItem ) + // InternalExport.g:8512:1: ( ( 'case' ) ) + // InternalExport.g:8513:1: ( 'case' ) { - // InternalExport.g:8661:2: ( ruleInterfaceItem ) - // InternalExport.g:8662:3: ruleInterfaceItem + // InternalExport.g:8513:1: ( 'case' ) + // InternalExport.g:8514:2: 'case' { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); + before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } - pushFollow(FOLLOW_2); - ruleInterfaceItem(); - - state._fsp--; - if (state.failed) return ; + match(input,92,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); + after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } } @@ -28473,44 +29826,29 @@ public final void rule__Interface__ItemsAssignment_2_2_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__Interface__ItemsAssignment_2_2_1" + // $ANTLR end "rule__Case__Group__0__Impl" - // $ANTLR start "rule__InterfaceField__UnorderedAssignment_0" - // InternalExport.g:8671:1: rule__InterfaceField__UnorderedAssignment_0 : ( ( '+' ) ) ; - public final void rule__InterfaceField__UnorderedAssignment_0() throws RecognitionException { + // $ANTLR start "rule__Case__Group__1" + // InternalExport.g:8523:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; + public final void rule__Case__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8675:1: ( ( ( '+' ) ) ) - // InternalExport.g:8676:2: ( ( '+' ) ) + // InternalExport.g:8527:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) + // InternalExport.g:8528:2: rule__Case__Group__1__Impl rule__Case__Group__2 { - // InternalExport.g:8676:2: ( ( '+' ) ) - // InternalExport.g:8677:3: ( '+' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); - } - // InternalExport.g:8678:3: ( '+' ) - // InternalExport.g:8679:4: '+' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); - } - match(input,18,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); - } + pushFollow(FOLLOW_39); + rule__Case__Group__1__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Case__Group__2(); + state._fsp--; + if (state.failed) return ; } @@ -28526,40 +29864,38 @@ public final void rule__InterfaceField__UnorderedAssignment_0() throws Recogniti } return ; } - // $ANTLR end "rule__InterfaceField__UnorderedAssignment_0" + // $ANTLR end "rule__Case__Group__1" - // $ANTLR start "rule__InterfaceField__FieldAssignment_1" - // InternalExport.g:8690:1: rule__InterfaceField__FieldAssignment_1 : ( ( RULE_ID ) ) ; - public final void rule__InterfaceField__FieldAssignment_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__1__Impl" + // InternalExport.g:8535:1: rule__Case__Group__1__Impl : ( ( rule__Case__ConditionAssignment_1 ) ) ; + public final void rule__Case__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8694:1: ( ( ( RULE_ID ) ) ) - // InternalExport.g:8695:2: ( ( RULE_ID ) ) + // InternalExport.g:8539:1: ( ( ( rule__Case__ConditionAssignment_1 ) ) ) + // InternalExport.g:8540:1: ( ( rule__Case__ConditionAssignment_1 ) ) { - // InternalExport.g:8695:2: ( ( RULE_ID ) ) - // InternalExport.g:8696:3: ( RULE_ID ) + // InternalExport.g:8540:1: ( ( rule__Case__ConditionAssignment_1 ) ) + // InternalExport.g:8541:2: ( rule__Case__ConditionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); + before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } - // InternalExport.g:8697:3: ( RULE_ID ) - // InternalExport.g:8698:4: RULE_ID + // InternalExport.g:8542:2: ( rule__Case__ConditionAssignment_1 ) + // InternalExport.g:8542:3: rule__Case__ConditionAssignment_1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); - } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); - } + pushFollow(FOLLOW_2); + rule__Case__ConditionAssignment_1(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); + after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } } @@ -28579,44 +29915,29 @@ public final void rule__InterfaceField__FieldAssignment_1() throws RecognitionEx } return ; } - // $ANTLR end "rule__InterfaceField__FieldAssignment_1" + // $ANTLR end "rule__Case__Group__1__Impl" - // $ANTLR start "rule__InterfaceNavigation__UnorderedAssignment_1" - // InternalExport.g:8709:1: rule__InterfaceNavigation__UnorderedAssignment_1 : ( ( '+' ) ) ; - public final void rule__InterfaceNavigation__UnorderedAssignment_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__2" + // InternalExport.g:8550:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ; + public final void rule__Case__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8713:1: ( ( ( '+' ) ) ) - // InternalExport.g:8714:2: ( ( '+' ) ) - { - // InternalExport.g:8714:2: ( ( '+' ) ) - // InternalExport.g:8715:3: ( '+' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); - } - // InternalExport.g:8716:3: ( '+' ) - // InternalExport.g:8717:4: '+' + // InternalExport.g:8554:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 ) + // InternalExport.g:8555:2: rule__Case__Group__2__Impl rule__Case__Group__3 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); - } - match(input,18,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); - } + pushFollow(FOLLOW_49); + rule__Case__Group__2__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Case__Group__3(); + state._fsp--; + if (state.failed) return ; } @@ -28632,40 +29953,28 @@ public final void rule__InterfaceNavigation__UnorderedAssignment_1() throws Reco } return ; } - // $ANTLR end "rule__InterfaceNavigation__UnorderedAssignment_1" + // $ANTLR end "rule__Case__Group__2" - // $ANTLR start "rule__InterfaceNavigation__RefAssignment_2" - // InternalExport.g:8728:1: rule__InterfaceNavigation__RefAssignment_2 : ( ( RULE_ID ) ) ; - public final void rule__InterfaceNavigation__RefAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Case__Group__2__Impl" + // InternalExport.g:8562:1: rule__Case__Group__2__Impl : ( ':' ) ; + public final void rule__Case__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8732:1: ( ( ( RULE_ID ) ) ) - // InternalExport.g:8733:2: ( ( RULE_ID ) ) + // InternalExport.g:8566:1: ( ( ':' ) ) + // InternalExport.g:8567:1: ( ':' ) { - // InternalExport.g:8733:2: ( ( RULE_ID ) ) - // InternalExport.g:8734:3: ( RULE_ID ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); - } - // InternalExport.g:8735:3: ( RULE_ID ) - // InternalExport.g:8736:4: RULE_ID + // InternalExport.g:8567:1: ( ':' ) + // InternalExport.g:8568:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); - } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); - } - + before(grammarAccess.getCaseAccess().getColonKeyword_2()); } - + match(input,85,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); + after(grammarAccess.getCaseAccess().getColonKeyword_2()); } } @@ -28685,44 +29994,24 @@ public final void rule__InterfaceNavigation__RefAssignment_2() throws Recognitio } return ; } - // $ANTLR end "rule__InterfaceNavigation__RefAssignment_2" + // $ANTLR end "rule__Case__Group__2__Impl" - // $ANTLR start "rule__InterfaceExpression__RefAssignment_1" - // InternalExport.g:8747:1: rule__InterfaceExpression__RefAssignment_1 : ( ( '@' ) ) ; - public final void rule__InterfaceExpression__RefAssignment_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__3" + // InternalExport.g:8577:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ; + public final void rule__Case__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8751:1: ( ( ( '@' ) ) ) - // InternalExport.g:8752:2: ( ( '@' ) ) - { - // InternalExport.g:8752:2: ( ( '@' ) ) - // InternalExport.g:8753:3: ( '@' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); - } - // InternalExport.g:8754:3: ( '@' ) - // InternalExport.g:8755:4: '@' + // InternalExport.g:8581:1: ( rule__Case__Group__3__Impl ) + // InternalExport.g:8582:2: rule__Case__Group__3__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); - } - match(input,49,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__Case__Group__3__Impl(); + state._fsp--; + if (state.failed) return ; } @@ -28738,40 +30027,38 @@ public final void rule__InterfaceExpression__RefAssignment_1() throws Recognitio } return ; } - // $ANTLR end "rule__InterfaceExpression__RefAssignment_1" + // $ANTLR end "rule__Case__Group__3" - // $ANTLR start "rule__InterfaceExpression__UnorderedAssignment_2" - // InternalExport.g:8766:1: rule__InterfaceExpression__UnorderedAssignment_2 : ( ( '+' ) ) ; - public final void rule__InterfaceExpression__UnorderedAssignment_2() throws RecognitionException { + // $ANTLR start "rule__Case__Group__3__Impl" + // InternalExport.g:8588:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenParAssignment_3 ) ) ; + public final void rule__Case__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8770:1: ( ( ( '+' ) ) ) - // InternalExport.g:8771:2: ( ( '+' ) ) + // InternalExport.g:8592:1: ( ( ( rule__Case__ThenParAssignment_3 ) ) ) + // InternalExport.g:8593:1: ( ( rule__Case__ThenParAssignment_3 ) ) { - // InternalExport.g:8771:2: ( ( '+' ) ) - // InternalExport.g:8772:3: ( '+' ) + // InternalExport.g:8593:1: ( ( rule__Case__ThenParAssignment_3 ) ) + // InternalExport.g:8594:2: ( rule__Case__ThenParAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); + before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } - // InternalExport.g:8773:3: ( '+' ) - // InternalExport.g:8774:4: '+' + // InternalExport.g:8595:2: ( rule__Case__ThenParAssignment_3 ) + // InternalExport.g:8595:3: rule__Case__ThenParAssignment_3 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); - } - match(input,18,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); - } + pushFollow(FOLLOW_2); + rule__Case__ThenParAssignment_3(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); + after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } } @@ -28791,36 +30078,29 @@ public final void rule__InterfaceExpression__UnorderedAssignment_2() throws Reco } return ; } - // $ANTLR end "rule__InterfaceExpression__UnorderedAssignment_2" + // $ANTLR end "rule__Case__Group__3__Impl" - // $ANTLR start "rule__InterfaceExpression__ExprAssignment_4" - // InternalExport.g:8785:1: rule__InterfaceExpression__ExprAssignment_4 : ( ruleExpression ) ; - public final void rule__InterfaceExpression__ExprAssignment_4() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__0" + // InternalExport.g:8604:1: rule__OrExpression__Group__0 : rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ; + public final void rule__OrExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8789:1: ( ( ruleExpression ) ) - // InternalExport.g:8790:2: ( ruleExpression ) - { - // InternalExport.g:8790:2: ( ruleExpression ) - // InternalExport.g:8791:3: ruleExpression + // InternalExport.g:8608:1: ( rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ) + // InternalExport.g:8609:2: rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_50); + rule__OrExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -28836,40 +30116,32 @@ public final void rule__InterfaceExpression__ExprAssignment_4() throws Recogniti } return ; } - // $ANTLR end "rule__InterfaceExpression__ExprAssignment_4" + // $ANTLR end "rule__OrExpression__Group__0" - // $ANTLR start "rule__Export__LookupAssignment_1_0" - // InternalExport.g:8800:1: rule__Export__LookupAssignment_1_0 : ( ( 'lookup' ) ) ; - public final void rule__Export__LookupAssignment_1_0() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__0__Impl" + // InternalExport.g:8616:1: rule__OrExpression__Group__0__Impl : ( ruleAndExpression ) ; + public final void rule__OrExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8804:1: ( ( ( 'lookup' ) ) ) - // InternalExport.g:8805:2: ( ( 'lookup' ) ) + // InternalExport.g:8620:1: ( ( ruleAndExpression ) ) + // InternalExport.g:8621:1: ( ruleAndExpression ) { - // InternalExport.g:8805:2: ( ( 'lookup' ) ) - // InternalExport.g:8806:3: ( 'lookup' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); - } - // InternalExport.g:8807:3: ( 'lookup' ) - // InternalExport.g:8808:4: 'lookup' + // InternalExport.g:8621:1: ( ruleAndExpression ) + // InternalExport.g:8622:2: ruleAndExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); - } - match(input,72,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); - } - + before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + pushFollow(FOLLOW_2); + ruleAndExpression(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); + after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } } @@ -28889,36 +30161,24 @@ public final void rule__Export__LookupAssignment_1_0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Export__LookupAssignment_1_0" + // $ANTLR end "rule__OrExpression__Group__0__Impl" - // $ANTLR start "rule__Export__LookupPredicateAssignment_1_1_1" - // InternalExport.g:8819:1: rule__Export__LookupPredicateAssignment_1_1_1 : ( ruleExpression ) ; - public final void rule__Export__LookupPredicateAssignment_1_1_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__1" + // InternalExport.g:8631:1: rule__OrExpression__Group__1 : rule__OrExpression__Group__1__Impl ; + public final void rule__OrExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8823:1: ( ( ruleExpression ) ) - // InternalExport.g:8824:2: ( ruleExpression ) + // InternalExport.g:8635:1: ( rule__OrExpression__Group__1__Impl ) + // InternalExport.g:8636:2: rule__OrExpression__Group__1__Impl { - // InternalExport.g:8824:2: ( ruleExpression ) - // InternalExport.g:8825:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__OrExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); - } - - } - } @@ -28934,44 +30194,56 @@ public final void rule__Export__LookupPredicateAssignment_1_1_1() throws Recogni } return ; } - // $ANTLR end "rule__Export__LookupPredicateAssignment_1_1_1" + // $ANTLR end "rule__OrExpression__Group__1" - // $ANTLR start "rule__Export__TypeAssignment_2" - // InternalExport.g:8834:1: rule__Export__TypeAssignment_2 : ( ( ruleQualifiedID ) ) ; - public final void rule__Export__TypeAssignment_2() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__1__Impl" + // InternalExport.g:8642:1: rule__OrExpression__Group__1__Impl : ( ( rule__OrExpression__Group_1__0 )* ) ; + public final void rule__OrExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8838:1: ( ( ( ruleQualifiedID ) ) ) - // InternalExport.g:8839:2: ( ( ruleQualifiedID ) ) + // InternalExport.g:8646:1: ( ( ( rule__OrExpression__Group_1__0 )* ) ) + // InternalExport.g:8647:1: ( ( rule__OrExpression__Group_1__0 )* ) { - // InternalExport.g:8839:2: ( ( ruleQualifiedID ) ) - // InternalExport.g:8840:3: ( ruleQualifiedID ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); - } - // InternalExport.g:8841:3: ( ruleQualifiedID ) - // InternalExport.g:8842:4: ruleQualifiedID + // InternalExport.g:8647:1: ( ( rule__OrExpression__Group_1__0 )* ) + // InternalExport.g:8648:2: ( rule__OrExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); + before(grammarAccess.getOrExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleQualifiedID(); + // InternalExport.g:8649:2: ( rule__OrExpression__Group_1__0 )* + loop92: + do { + int alt92=2; + int LA92_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); - } + if ( (LA92_0==15) ) { + alt92=1; + } - } + + switch (alt92) { + case 1 : + // InternalExport.g:8649:3: rule__OrExpression__Group_1__0 + { + pushFollow(FOLLOW_51); + rule__OrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop92; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); + after(grammarAccess.getOrExpressionAccess().getGroup_1()); } } @@ -28991,44 +30263,29 @@ public final void rule__Export__TypeAssignment_2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Export__TypeAssignment_2" + // $ANTLR end "rule__OrExpression__Group__1__Impl" - // $ANTLR start "rule__Export__QualifiedNameAssignment_3_1" - // InternalExport.g:8853:1: rule__Export__QualifiedNameAssignment_3_1 : ( ( 'qualified' ) ) ; - public final void rule__Export__QualifiedNameAssignment_3_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__0" + // InternalExport.g:8658:1: rule__OrExpression__Group_1__0 : rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ; + public final void rule__OrExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8857:1: ( ( ( 'qualified' ) ) ) - // InternalExport.g:8858:2: ( ( 'qualified' ) ) - { - // InternalExport.g:8858:2: ( ( 'qualified' ) ) - // InternalExport.g:8859:3: ( 'qualified' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); - } - // InternalExport.g:8860:3: ( 'qualified' ) - // InternalExport.g:8861:4: 'qualified' + // InternalExport.g:8662:1: ( rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ) + // InternalExport.g:8663:2: rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); - } - match(input,73,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); - } + pushFollow(FOLLOW_50); + rule__OrExpression__Group_1__0__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -29044,32 +30301,32 @@ public final void rule__Export__QualifiedNameAssignment_3_1() throws Recognition } return ; } - // $ANTLR end "rule__Export__QualifiedNameAssignment_3_1" + // $ANTLR end "rule__OrExpression__Group_1__0" - // $ANTLR start "rule__Export__NamingAssignment_3_2" - // InternalExport.g:8872:1: rule__Export__NamingAssignment_3_2 : ( ruleExpression ) ; - public final void rule__Export__NamingAssignment_3_2() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__0__Impl" + // InternalExport.g:8670:1: rule__OrExpression__Group_1__0__Impl : ( () ) ; + public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8876:1: ( ( ruleExpression ) ) - // InternalExport.g:8877:2: ( ruleExpression ) + // InternalExport.g:8674:1: ( ( () ) ) + // InternalExport.g:8675:1: ( () ) { - // InternalExport.g:8877:2: ( ruleExpression ) - // InternalExport.g:8878:3: ruleExpression + // InternalExport.g:8675:1: ( () ) + // InternalExport.g:8676:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); + before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + // InternalExport.g:8677:2: () + // InternalExport.g:8677:3: + { } - pushFollow(FOLLOW_2); - ruleExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); + after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -29078,10 +30335,6 @@ public final void rule__Export__NamingAssignment_3_2() throws RecognitionExcepti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -29089,36 +30342,29 @@ public final void rule__Export__NamingAssignment_3_2() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Export__NamingAssignment_3_2" + // $ANTLR end "rule__OrExpression__Group_1__0__Impl" - // $ANTLR start "rule__Export__GuardAssignment_4_1" - // InternalExport.g:8887:1: rule__Export__GuardAssignment_4_1 : ( ruleExpression ) ; - public final void rule__Export__GuardAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__1" + // InternalExport.g:8685:1: rule__OrExpression__Group_1__1 : rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ; + public final void rule__OrExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8891:1: ( ( ruleExpression ) ) - // InternalExport.g:8892:2: ( ruleExpression ) + // InternalExport.g:8689:1: ( rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ) + // InternalExport.g:8690:2: rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 { - // InternalExport.g:8892:2: ( ruleExpression ) - // InternalExport.g:8893:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_49); + rule__OrExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -29134,40 +30380,38 @@ public final void rule__Export__GuardAssignment_4_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Export__GuardAssignment_4_1" + // $ANTLR end "rule__OrExpression__Group_1__1" - // $ANTLR start "rule__Export__FragmentUniqueAssignment_6_2" - // InternalExport.g:8902:1: rule__Export__FragmentUniqueAssignment_6_2 : ( ( 'unique' ) ) ; - public final void rule__Export__FragmentUniqueAssignment_6_2() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__1__Impl" + // InternalExport.g:8697:1: rule__OrExpression__Group_1__1__Impl : ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8906:1: ( ( ( 'unique' ) ) ) - // InternalExport.g:8907:2: ( ( 'unique' ) ) + // InternalExport.g:8701:1: ( ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ) + // InternalExport.g:8702:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) { - // InternalExport.g:8907:2: ( ( 'unique' ) ) - // InternalExport.g:8908:3: ( 'unique' ) + // InternalExport.g:8702:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:8703:2: ( rule__OrExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); + before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } - // InternalExport.g:8909:3: ( 'unique' ) - // InternalExport.g:8910:4: 'unique' + // InternalExport.g:8704:2: ( rule__OrExpression__OperatorAssignment_1_1 ) + // InternalExport.g:8704:3: rule__OrExpression__OperatorAssignment_1_1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); - } - match(input,74,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); - } + pushFollow(FOLLOW_2); + rule__OrExpression__OperatorAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); + after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } } @@ -29187,44 +30431,24 @@ public final void rule__Export__FragmentUniqueAssignment_6_2() throws Recognitio } return ; } - // $ANTLR end "rule__Export__FragmentUniqueAssignment_6_2" + // $ANTLR end "rule__OrExpression__Group_1__1__Impl" - // $ANTLR start "rule__Export__FragmentAttributeAssignment_6_5" - // InternalExport.g:8921:1: rule__Export__FragmentAttributeAssignment_6_5 : ( ( RULE_ID ) ) ; - public final void rule__Export__FragmentAttributeAssignment_6_5() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__2" + // InternalExport.g:8712:1: rule__OrExpression__Group_1__2 : rule__OrExpression__Group_1__2__Impl ; + public final void rule__OrExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8925:1: ( ( ( RULE_ID ) ) ) - // InternalExport.g:8926:2: ( ( RULE_ID ) ) - { - // InternalExport.g:8926:2: ( ( RULE_ID ) ) - // InternalExport.g:8927:3: ( RULE_ID ) + // InternalExport.g:8716:1: ( rule__OrExpression__Group_1__2__Impl ) + // InternalExport.g:8717:2: rule__OrExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); - } - // InternalExport.g:8928:3: ( RULE_ID ) - // InternalExport.g:8929:4: RULE_ID - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); - } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__2__Impl(); + state._fsp--; + if (state.failed) return ; } @@ -29240,40 +30464,38 @@ public final void rule__Export__FragmentAttributeAssignment_6_5() throws Recogni } return ; } - // $ANTLR end "rule__Export__FragmentAttributeAssignment_6_5" + // $ANTLR end "rule__OrExpression__Group_1__2" - // $ANTLR start "rule__Export__FingerprintAssignment_7_0_0" - // InternalExport.g:8940:1: rule__Export__FingerprintAssignment_7_0_0 : ( ( 'object-fingerprint' ) ) ; - public final void rule__Export__FingerprintAssignment_7_0_0() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__2__Impl" + // InternalExport.g:8723:1: rule__OrExpression__Group_1__2__Impl : ( ( rule__OrExpression__RightAssignment_1_2 ) ) ; + public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8944:1: ( ( ( 'object-fingerprint' ) ) ) - // InternalExport.g:8945:2: ( ( 'object-fingerprint' ) ) + // InternalExport.g:8727:1: ( ( ( rule__OrExpression__RightAssignment_1_2 ) ) ) + // InternalExport.g:8728:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) { - // InternalExport.g:8945:2: ( ( 'object-fingerprint' ) ) - // InternalExport.g:8946:3: ( 'object-fingerprint' ) + // InternalExport.g:8728:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) + // InternalExport.g:8729:2: ( rule__OrExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); + before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } - // InternalExport.g:8947:3: ( 'object-fingerprint' ) - // InternalExport.g:8948:4: 'object-fingerprint' + // InternalExport.g:8730:2: ( rule__OrExpression__RightAssignment_1_2 ) + // InternalExport.g:8730:3: rule__OrExpression__RightAssignment_1_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); - } - match(input,75,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); - } + pushFollow(FOLLOW_2); + rule__OrExpression__RightAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); + after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } } @@ -29293,44 +30515,29 @@ public final void rule__Export__FingerprintAssignment_7_0_0() throws Recognition } return ; } - // $ANTLR end "rule__Export__FingerprintAssignment_7_0_0" + // $ANTLR end "rule__OrExpression__Group_1__2__Impl" - // $ANTLR start "rule__Export__ResourceFingerprintAssignment_7_0_1" - // InternalExport.g:8959:1: rule__Export__ResourceFingerprintAssignment_7_0_1 : ( ( 'resource-fingerprint' ) ) ; - public final void rule__Export__ResourceFingerprintAssignment_7_0_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__0" + // InternalExport.g:8739:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ; + public final void rule__AndExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8963:1: ( ( ( 'resource-fingerprint' ) ) ) - // InternalExport.g:8964:2: ( ( 'resource-fingerprint' ) ) - { - // InternalExport.g:8964:2: ( ( 'resource-fingerprint' ) ) - // InternalExport.g:8965:3: ( 'resource-fingerprint' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); - } - // InternalExport.g:8966:3: ( 'resource-fingerprint' ) - // InternalExport.g:8967:4: 'resource-fingerprint' + // InternalExport.g:8743:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ) + // InternalExport.g:8744:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); - } - match(input,76,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); - } + pushFollow(FOLLOW_52); + rule__AndExpression__Group__0__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__AndExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -29346,32 +30553,32 @@ public final void rule__Export__ResourceFingerprintAssignment_7_0_1() throws Rec } return ; } - // $ANTLR end "rule__Export__ResourceFingerprintAssignment_7_0_1" + // $ANTLR end "rule__AndExpression__Group__0" - // $ANTLR start "rule__Export__AttributesAssignment_8_0_1" - // InternalExport.g:8978:1: rule__Export__AttributesAssignment_8_0_1 : ( ruleAttribute ) ; - public final void rule__Export__AttributesAssignment_8_0_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__0__Impl" + // InternalExport.g:8751:1: rule__AndExpression__Group__0__Impl : ( ruleImpliesExpression ) ; + public final void rule__AndExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8982:1: ( ( ruleAttribute ) ) - // InternalExport.g:8983:2: ( ruleAttribute ) + // InternalExport.g:8755:1: ( ( ruleImpliesExpression ) ) + // InternalExport.g:8756:1: ( ruleImpliesExpression ) { - // InternalExport.g:8983:2: ( ruleAttribute ) - // InternalExport.g:8984:3: ruleAttribute + // InternalExport.g:8756:1: ( ruleImpliesExpression ) + // InternalExport.g:8757:2: ruleImpliesExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); + before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleAttribute(); + ruleImpliesExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); + after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } } @@ -29391,36 +30598,24 @@ public final void rule__Export__AttributesAssignment_8_0_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Export__AttributesAssignment_8_0_1" + // $ANTLR end "rule__AndExpression__Group__0__Impl" - // $ANTLR start "rule__Export__AttributesAssignment_8_0_2_1" - // InternalExport.g:8993:1: rule__Export__AttributesAssignment_8_0_2_1 : ( ruleAttribute ) ; - public final void rule__Export__AttributesAssignment_8_0_2_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__1" + // InternalExport.g:8766:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ; + public final void rule__AndExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:8997:1: ( ( ruleAttribute ) ) - // InternalExport.g:8998:2: ( ruleAttribute ) + // InternalExport.g:8770:1: ( rule__AndExpression__Group__1__Impl ) + // InternalExport.g:8771:2: rule__AndExpression__Group__1__Impl { - // InternalExport.g:8998:2: ( ruleAttribute ) - // InternalExport.g:8999:3: ruleAttribute - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); - } pushFollow(FOLLOW_2); - ruleAttribute(); + rule__AndExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); - } - - } - } @@ -29436,32 +30631,56 @@ public final void rule__Export__AttributesAssignment_8_0_2_1() throws Recognitio } return ; } - // $ANTLR end "rule__Export__AttributesAssignment_8_0_2_1" + // $ANTLR end "rule__AndExpression__Group__1" - // $ANTLR start "rule__Export__UserDataAssignment_8_1_1" - // InternalExport.g:9008:1: rule__Export__UserDataAssignment_8_1_1 : ( ruleUserData ) ; - public final void rule__Export__UserDataAssignment_8_1_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__1__Impl" + // InternalExport.g:8777:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ; + public final void rule__AndExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9012:1: ( ( ruleUserData ) ) - // InternalExport.g:9013:2: ( ruleUserData ) + // InternalExport.g:8781:1: ( ( ( rule__AndExpression__Group_1__0 )* ) ) + // InternalExport.g:8782:1: ( ( rule__AndExpression__Group_1__0 )* ) { - // InternalExport.g:9013:2: ( ruleUserData ) - // InternalExport.g:9014:3: ruleUserData + // InternalExport.g:8782:1: ( ( rule__AndExpression__Group_1__0 )* ) + // InternalExport.g:8783:2: ( rule__AndExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); + before(grammarAccess.getAndExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleUserData(); + // InternalExport.g:8784:2: ( rule__AndExpression__Group_1__0 )* + loop93: + do { + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==16) ) { + alt93=1; + } + + + switch (alt93) { + case 1 : + // InternalExport.g:8784:3: rule__AndExpression__Group_1__0 + { + pushFollow(FOLLOW_53); + rule__AndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop93; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); + after(grammarAccess.getAndExpressionAccess().getGroup_1()); } } @@ -29481,36 +30700,29 @@ public final void rule__Export__UserDataAssignment_8_1_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__Export__UserDataAssignment_8_1_1" + // $ANTLR end "rule__AndExpression__Group__1__Impl" - // $ANTLR start "rule__Export__UserDataAssignment_8_1_2_1" - // InternalExport.g:9023:1: rule__Export__UserDataAssignment_8_1_2_1 : ( ruleUserData ) ; - public final void rule__Export__UserDataAssignment_8_1_2_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__0" + // InternalExport.g:8793:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ; + public final void rule__AndExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9027:1: ( ( ruleUserData ) ) - // InternalExport.g:9028:2: ( ruleUserData ) - { - // InternalExport.g:9028:2: ( ruleUserData ) - // InternalExport.g:9029:3: ruleUserData + // InternalExport.g:8797:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ) + // InternalExport.g:8798:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); - } - pushFollow(FOLLOW_2); - ruleUserData(); + pushFollow(FOLLOW_52); + rule__AndExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -29526,28 +30738,32 @@ public final void rule__Export__UserDataAssignment_8_1_2_1() throws RecognitionE } return ; } - // $ANTLR end "rule__Export__UserDataAssignment_8_1_2_1" + // $ANTLR end "rule__AndExpression__Group_1__0" - // $ANTLR start "rule__UserData__NameAssignment_0" - // InternalExport.g:9038:1: rule__UserData__NameAssignment_0 : ( RULE_ID ) ; - public final void rule__UserData__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__0__Impl" + // InternalExport.g:8805:1: rule__AndExpression__Group_1__0__Impl : ( () ) ; + public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9042:1: ( ( RULE_ID ) ) - // InternalExport.g:9043:2: ( RULE_ID ) + // InternalExport.g:8809:1: ( ( () ) ) + // InternalExport.g:8810:1: ( () ) { - // InternalExport.g:9043:2: ( RULE_ID ) - // InternalExport.g:9044:3: RULE_ID + // InternalExport.g:8810:1: ( () ) + // InternalExport.g:8811:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); + before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:8812:2: () + // InternalExport.g:8812:3: + { + } + if ( state.backtracking==0 ) { - after(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); + after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -29556,10 +30772,6 @@ public final void rule__UserData__NameAssignment_0() throws RecognitionException } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -29567,36 +30779,29 @@ public final void rule__UserData__NameAssignment_0() throws RecognitionException } return ; } - // $ANTLR end "rule__UserData__NameAssignment_0" + // $ANTLR end "rule__AndExpression__Group_1__0__Impl" - // $ANTLR start "rule__UserData__ExprAssignment_2" - // InternalExport.g:9053:1: rule__UserData__ExprAssignment_2 : ( ruleExpression ) ; - public final void rule__UserData__ExprAssignment_2() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__1" + // InternalExport.g:8820:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ; + public final void rule__AndExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9057:1: ( ( ruleExpression ) ) - // InternalExport.g:9058:2: ( ruleExpression ) + // InternalExport.g:8824:1: ( rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ) + // InternalExport.g:8825:2: rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 { - // InternalExport.g:9058:2: ( ruleExpression ) - // InternalExport.g:9059:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_49); + rule__AndExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -29612,40 +30817,38 @@ public final void rule__UserData__ExprAssignment_2() throws RecognitionException } return ; } - // $ANTLR end "rule__UserData__ExprAssignment_2" + // $ANTLR end "rule__AndExpression__Group_1__1" - // $ANTLR start "rule__Attribute__AttributeAssignment" - // InternalExport.g:9068:1: rule__Attribute__AttributeAssignment : ( ( RULE_ID ) ) ; - public final void rule__Attribute__AttributeAssignment() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__1__Impl" + // InternalExport.g:8832:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9072:1: ( ( ( RULE_ID ) ) ) - // InternalExport.g:9073:2: ( ( RULE_ID ) ) + // InternalExport.g:8836:1: ( ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ) + // InternalExport.g:8837:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) { - // InternalExport.g:9073:2: ( ( RULE_ID ) ) - // InternalExport.g:9074:3: ( RULE_ID ) + // InternalExport.g:8837:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:8838:2: ( rule__AndExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); + before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } - // InternalExport.g:9075:3: ( RULE_ID ) - // InternalExport.g:9076:4: RULE_ID + // InternalExport.g:8839:2: ( rule__AndExpression__OperatorAssignment_1_1 ) + // InternalExport.g:8839:3: rule__AndExpression__OperatorAssignment_1_1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); - } - match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); - } + pushFollow(FOLLOW_2); + rule__AndExpression__OperatorAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); + after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } } @@ -29665,36 +30868,24 @@ public final void rule__Attribute__AttributeAssignment() throws RecognitionExcep } return ; } - // $ANTLR end "rule__Attribute__AttributeAssignment" + // $ANTLR end "rule__AndExpression__Group_1__1__Impl" - // $ANTLR start "rule__LetExpression__IdentifierAssignment_1" - // InternalExport.g:9087:1: rule__LetExpression__IdentifierAssignment_1 : ( ruleIdentifier ) ; - public final void rule__LetExpression__IdentifierAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__2" + // InternalExport.g:8847:1: rule__AndExpression__Group_1__2 : rule__AndExpression__Group_1__2__Impl ; + public final void rule__AndExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9091:1: ( ( ruleIdentifier ) ) - // InternalExport.g:9092:2: ( ruleIdentifier ) - { - // InternalExport.g:9092:2: ( ruleIdentifier ) - // InternalExport.g:9093:3: ruleIdentifier + // InternalExport.g:8851:1: ( rule__AndExpression__Group_1__2__Impl ) + // InternalExport.g:8852:2: rule__AndExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); - } pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__AndExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); - } - - } - } @@ -29710,32 +30901,38 @@ public final void rule__LetExpression__IdentifierAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__LetExpression__IdentifierAssignment_1" + // $ANTLR end "rule__AndExpression__Group_1__2" - // $ANTLR start "rule__LetExpression__VarExprAssignment_3" - // InternalExport.g:9102:1: rule__LetExpression__VarExprAssignment_3 : ( ruleExpression ) ; - public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__2__Impl" + // InternalExport.g:8858:1: rule__AndExpression__Group_1__2__Impl : ( ( rule__AndExpression__RightAssignment_1_2 ) ) ; + public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9106:1: ( ( ruleExpression ) ) - // InternalExport.g:9107:2: ( ruleExpression ) + // InternalExport.g:8862:1: ( ( ( rule__AndExpression__RightAssignment_1_2 ) ) ) + // InternalExport.g:8863:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) { - // InternalExport.g:9107:2: ( ruleExpression ) - // InternalExport.g:9108:3: ruleExpression + // InternalExport.g:8863:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) + // InternalExport.g:8864:2: ( rule__AndExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + // InternalExport.g:8865:2: ( rule__AndExpression__RightAssignment_1_2 ) + // InternalExport.g:8865:3: rule__AndExpression__RightAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__AndExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } } @@ -29755,36 +30952,29 @@ public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionE } return ; } - // $ANTLR end "rule__LetExpression__VarExprAssignment_3" + // $ANTLR end "rule__AndExpression__Group_1__2__Impl" - // $ANTLR start "rule__LetExpression__TargetAssignment_5" - // InternalExport.g:9117:1: rule__LetExpression__TargetAssignment_5 : ( ruleExpression ) ; - public final void rule__LetExpression__TargetAssignment_5() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__0" + // InternalExport.g:8874:1: rule__ImpliesExpression__Group__0 : rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ; + public final void rule__ImpliesExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9121:1: ( ( ruleExpression ) ) - // InternalExport.g:9122:2: ( ruleExpression ) - { - // InternalExport.g:9122:2: ( ruleExpression ) - // InternalExport.g:9123:3: ruleExpression + // InternalExport.g:8878:1: ( rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ) + // InternalExport.g:8879:2: rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_54); + rule__ImpliesExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -29800,32 +30990,32 @@ public final void rule__LetExpression__TargetAssignment_5() throws RecognitionEx } return ; } - // $ANTLR end "rule__LetExpression__TargetAssignment_5" + // $ANTLR end "rule__ImpliesExpression__Group__0" - // $ANTLR start "rule__CastedExpression__TypeAssignment_1" - // InternalExport.g:9132:1: rule__CastedExpression__TypeAssignment_1 : ( ruleType ) ; - public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__0__Impl" + // InternalExport.g:8886:1: rule__ImpliesExpression__Group__0__Impl : ( ruleRelationalExpression ) ; + public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9136:1: ( ( ruleType ) ) - // InternalExport.g:9137:2: ( ruleType ) + // InternalExport.g:8890:1: ( ( ruleRelationalExpression ) ) + // InternalExport.g:8891:1: ( ruleRelationalExpression ) { - // InternalExport.g:9137:2: ( ruleType ) - // InternalExport.g:9138:3: ruleType + // InternalExport.g:8891:1: ( ruleRelationalExpression ) + // InternalExport.g:8892:2: ruleRelationalExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleType(); + ruleRelationalExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } } @@ -29845,36 +31035,24 @@ public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionE } return ; } - // $ANTLR end "rule__CastedExpression__TypeAssignment_1" + // $ANTLR end "rule__ImpliesExpression__Group__0__Impl" - // $ANTLR start "rule__CastedExpression__TargetAssignment_3" - // InternalExport.g:9147:1: rule__CastedExpression__TargetAssignment_3 : ( ruleExpression ) ; - public final void rule__CastedExpression__TargetAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__1" + // InternalExport.g:8901:1: rule__ImpliesExpression__Group__1 : rule__ImpliesExpression__Group__1__Impl ; + public final void rule__ImpliesExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9151:1: ( ( ruleExpression ) ) - // InternalExport.g:9152:2: ( ruleExpression ) + // InternalExport.g:8905:1: ( rule__ImpliesExpression__Group__1__Impl ) + // InternalExport.g:8906:2: rule__ImpliesExpression__Group__1__Impl { - // InternalExport.g:9152:2: ( ruleExpression ) - // InternalExport.g:9153:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__ImpliesExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); - } - - } - } @@ -29890,77 +31068,56 @@ public final void rule__CastedExpression__TargetAssignment_3() throws Recognitio } return ; } - // $ANTLR end "rule__CastedExpression__TargetAssignment_3" + // $ANTLR end "rule__ImpliesExpression__Group__1" - // $ANTLR start "rule__ChainExpression__NextAssignment_1_2" - // InternalExport.g:9162:1: rule__ChainExpression__NextAssignment_1_2 : ( ruleChainedExpression ) ; - public final void rule__ChainExpression__NextAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__1__Impl" + // InternalExport.g:8912:1: rule__ImpliesExpression__Group__1__Impl : ( ( rule__ImpliesExpression__Group_1__0 )* ) ; + public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9166:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:9167:2: ( ruleChainedExpression ) + // InternalExport.g:8916:1: ( ( ( rule__ImpliesExpression__Group_1__0 )* ) ) + // InternalExport.g:8917:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) { - // InternalExport.g:9167:2: ( ruleChainedExpression ) - // InternalExport.g:9168:3: ruleChainedExpression + // InternalExport.g:8917:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) + // InternalExport.g:8918:2: ( rule__ImpliesExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); - } - - } - - + before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + // InternalExport.g:8919:2: ( rule__ImpliesExpression__Group_1__0 )* + loop94: + do { + int alt94=2; + int LA94_0 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( (LA94_0==114) ) { + alt94=1; + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ChainExpression__NextAssignment_1_2" + switch (alt94) { + case 1 : + // InternalExport.g:8919:3: rule__ImpliesExpression__Group_1__0 + { + pushFollow(FOLLOW_55); + rule__ImpliesExpression__Group_1__0(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__IfExpressionTri__ThenPartAssignment_1_2" - // InternalExport.g:9177:1: rule__IfExpressionTri__ThenPartAssignment_1_2 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws RecognitionException { + } + break; - int stackSize = keepStackSize(); - - try { - // InternalExport.g:9181:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:9182:2: ( ruleChainedExpression ) - { - // InternalExport.g:9182:2: ( ruleChainedExpression ) - // InternalExport.g:9183:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + default : + break loop94; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } } @@ -29980,36 +31137,29 @@ public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws Recogni } return ; } - // $ANTLR end "rule__IfExpressionTri__ThenPartAssignment_1_2" + // $ANTLR end "rule__ImpliesExpression__Group__1__Impl" - // $ANTLR start "rule__IfExpressionTri__ElsePartAssignment_1_4" - // InternalExport.g:9192:1: rule__IfExpressionTri__ElsePartAssignment_1_4 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__0" + // InternalExport.g:8928:1: rule__ImpliesExpression__Group_1__0 : rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ; + public final void rule__ImpliesExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9196:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:9197:2: ( ruleChainedExpression ) - { - // InternalExport.g:9197:2: ( ruleChainedExpression ) - // InternalExport.g:9198:3: ruleChainedExpression + // InternalExport.g:8932:1: ( rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ) + // InternalExport.g:8933:2: rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + pushFollow(FOLLOW_54); + rule__ImpliesExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -30025,32 +31175,32 @@ public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws Recogni } return ; } - // $ANTLR end "rule__IfExpressionTri__ElsePartAssignment_1_4" + // $ANTLR end "rule__ImpliesExpression__Group_1__0" - // $ANTLR start "rule__IfExpressionKw__ConditionAssignment_1" - // InternalExport.g:9207:1: rule__IfExpressionKw__ConditionAssignment_1 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ConditionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__0__Impl" + // InternalExport.g:8940:1: rule__ImpliesExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ImpliesExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9211:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:9212:2: ( ruleChainedExpression ) + // InternalExport.g:8944:1: ( ( () ) ) + // InternalExport.g:8945:1: ( () ) { - // InternalExport.g:9212:2: ( ruleChainedExpression ) - // InternalExport.g:9213:3: ruleChainedExpression + // InternalExport.g:8945:1: ( () ) + // InternalExport.g:8946:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + // InternalExport.g:8947:2: () + // InternalExport.g:8947:3: + { } - pushFollow(FOLLOW_2); - ruleChainedExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -30059,10 +31209,6 @@ public final void rule__IfExpressionKw__ConditionAssignment_1() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -30070,36 +31216,29 @@ public final void rule__IfExpressionKw__ConditionAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__IfExpressionKw__ConditionAssignment_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__0__Impl" - // $ANTLR start "rule__IfExpressionKw__ThenPartAssignment_3" - // InternalExport.g:9222:1: rule__IfExpressionKw__ThenPartAssignment_3 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ThenPartAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__1" + // InternalExport.g:8955:1: rule__ImpliesExpression__Group_1__1 : rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ; + public final void rule__ImpliesExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9226:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:9227:2: ( ruleChainedExpression ) + // InternalExport.g:8959:1: ( rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ) + // InternalExport.g:8960:2: rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 { - // InternalExport.g:9227:2: ( ruleChainedExpression ) - // InternalExport.g:9228:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + pushFollow(FOLLOW_49); + rule__ImpliesExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -30115,32 +31254,38 @@ public final void rule__IfExpressionKw__ThenPartAssignment_3() throws Recognitio } return ; } - // $ANTLR end "rule__IfExpressionKw__ThenPartAssignment_3" + // $ANTLR end "rule__ImpliesExpression__Group_1__1" - // $ANTLR start "rule__IfExpressionKw__ElsePartAssignment_4_0_1" - // InternalExport.g:9237:1: rule__IfExpressionKw__ElsePartAssignment_4_0_1 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__1__Impl" + // InternalExport.g:8967:1: rule__ImpliesExpression__Group_1__1__Impl : ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__ImpliesExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9241:1: ( ( ruleChainedExpression ) ) - // InternalExport.g:9242:2: ( ruleChainedExpression ) + // InternalExport.g:8971:1: ( ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ) + // InternalExport.g:8972:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) { - // InternalExport.g:9242:2: ( ruleChainedExpression ) - // InternalExport.g:9243:3: ruleChainedExpression + // InternalExport.g:8972:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:8973:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + // InternalExport.g:8974:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) + // InternalExport.g:8974:3: rule__ImpliesExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleChainedExpression(); + rule__ImpliesExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } } @@ -30160,36 +31305,24 @@ public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws Recogn } return ; } - // $ANTLR end "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__1__Impl" - // $ANTLR start "rule__SwitchExpression__SwitchExprAssignment_1_1" - // InternalExport.g:9252:1: rule__SwitchExpression__SwitchExprAssignment_1_1 : ( ruleOrExpression ) ; - public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__2" + // InternalExport.g:8982:1: rule__ImpliesExpression__Group_1__2 : rule__ImpliesExpression__Group_1__2__Impl ; + public final void rule__ImpliesExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9256:1: ( ( ruleOrExpression ) ) - // InternalExport.g:9257:2: ( ruleOrExpression ) - { - // InternalExport.g:9257:2: ( ruleOrExpression ) - // InternalExport.g:9258:3: ruleOrExpression + // InternalExport.g:8986:1: ( rule__ImpliesExpression__Group_1__2__Impl ) + // InternalExport.g:8987:2: rule__ImpliesExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); - } pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__ImpliesExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); - } - - } - } @@ -30205,32 +31338,38 @@ public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws Reco } return ; } - // $ANTLR end "rule__SwitchExpression__SwitchExprAssignment_1_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__2" - // $ANTLR start "rule__SwitchExpression__CaseAssignment_3" - // InternalExport.g:9267:1: rule__SwitchExpression__CaseAssignment_3 : ( ruleCase ) ; - public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__2__Impl" + // InternalExport.g:8993:1: rule__ImpliesExpression__Group_1__2__Impl : ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ; + public final void rule__ImpliesExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9271:1: ( ( ruleCase ) ) - // InternalExport.g:9272:2: ( ruleCase ) + // InternalExport.g:8997:1: ( ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ) + // InternalExport.g:8998:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) { - // InternalExport.g:9272:2: ( ruleCase ) - // InternalExport.g:9273:3: ruleCase + // InternalExport.g:8998:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) + // InternalExport.g:8999:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + // InternalExport.g:9000:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) + // InternalExport.g:9000:3: rule__ImpliesExpression__RightAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleCase(); + rule__ImpliesExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } } @@ -30250,36 +31389,29 @@ public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__CaseAssignment_3" + // $ANTLR end "rule__ImpliesExpression__Group_1__2__Impl" - // $ANTLR start "rule__SwitchExpression__DefaultExprAssignment_6" - // InternalExport.g:9282:1: rule__SwitchExpression__DefaultExprAssignment_6 : ( ruleOrExpression ) ; - public final void rule__SwitchExpression__DefaultExprAssignment_6() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__0" + // InternalExport.g:9009:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ; + public final void rule__RelationalExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9286:1: ( ( ruleOrExpression ) ) - // InternalExport.g:9287:2: ( ruleOrExpression ) - { - // InternalExport.g:9287:2: ( ruleOrExpression ) - // InternalExport.g:9288:3: ruleOrExpression + // InternalExport.g:9013:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) + // InternalExport.g:9014:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); - } - pushFollow(FOLLOW_2); - ruleOrExpression(); + pushFollow(FOLLOW_56); + rule__RelationalExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); - } - - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -30295,32 +31427,32 @@ public final void rule__SwitchExpression__DefaultExprAssignment_6() throws Recog } return ; } - // $ANTLR end "rule__SwitchExpression__DefaultExprAssignment_6" + // $ANTLR end "rule__RelationalExpression__Group__0" - // $ANTLR start "rule__Case__ConditionAssignment_1" - // InternalExport.g:9297:1: rule__Case__ConditionAssignment_1 : ( ruleOrExpression ) ; - public final void rule__Case__ConditionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__0__Impl" + // InternalExport.g:9021:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; + public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9301:1: ( ( ruleOrExpression ) ) - // InternalExport.g:9302:2: ( ruleOrExpression ) + // InternalExport.g:9025:1: ( ( ruleAdditiveExpression ) ) + // InternalExport.g:9026:1: ( ruleAdditiveExpression ) { - // InternalExport.g:9302:2: ( ruleOrExpression ) - // InternalExport.g:9303:3: ruleOrExpression + // InternalExport.g:9026:1: ( ruleAdditiveExpression ) + // InternalExport.g:9027:2: ruleAdditiveExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleOrExpression(); + ruleAdditiveExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } } @@ -30340,36 +31472,24 @@ public final void rule__Case__ConditionAssignment_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Case__ConditionAssignment_1" + // $ANTLR end "rule__RelationalExpression__Group__0__Impl" - // $ANTLR start "rule__Case__ThenParAssignment_3" - // InternalExport.g:9312:1: rule__Case__ThenParAssignment_3 : ( ruleOrExpression ) ; - public final void rule__Case__ThenParAssignment_3() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__1" + // InternalExport.g:9036:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; + public final void rule__RelationalExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9316:1: ( ( ruleOrExpression ) ) - // InternalExport.g:9317:2: ( ruleOrExpression ) + // InternalExport.g:9040:1: ( rule__RelationalExpression__Group__1__Impl ) + // InternalExport.g:9041:2: rule__RelationalExpression__Group__1__Impl { - // InternalExport.g:9317:2: ( ruleOrExpression ) - // InternalExport.g:9318:3: ruleOrExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); - } pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__RelationalExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); - } - - } - } @@ -30385,40 +31505,56 @@ public final void rule__Case__ThenParAssignment_3() throws RecognitionException } return ; } - // $ANTLR end "rule__Case__ThenParAssignment_3" + // $ANTLR end "rule__RelationalExpression__Group__1" - // $ANTLR start "rule__OrExpression__OperatorAssignment_1_1" - // InternalExport.g:9327:1: rule__OrExpression__OperatorAssignment_1_1 : ( ( '||' ) ) ; - public final void rule__OrExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__1__Impl" + // InternalExport.g:9047:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )* ) ; + public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9331:1: ( ( ( '||' ) ) ) - // InternalExport.g:9332:2: ( ( '||' ) ) + // InternalExport.g:9051:1: ( ( ( rule__RelationalExpression__Group_1__0 )* ) ) + // InternalExport.g:9052:1: ( ( rule__RelationalExpression__Group_1__0 )* ) { - // InternalExport.g:9332:2: ( ( '||' ) ) - // InternalExport.g:9333:3: ( '||' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - // InternalExport.g:9334:3: ( '||' ) - // InternalExport.g:9335:4: '||' + // InternalExport.g:9052:1: ( ( rule__RelationalExpression__Group_1__0 )* ) + // InternalExport.g:9053:2: ( rule__RelationalExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - match(input,77,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + // InternalExport.g:9054:2: ( rule__RelationalExpression__Group_1__0 )* + loop95: + do { + int alt95=2; + int LA95_0 = input.LA(1); - } + if ( ((LA95_0>=17 && LA95_0<=22)) ) { + alt95=1; + } + + + switch (alt95) { + case 1 : + // InternalExport.g:9054:3: rule__RelationalExpression__Group_1__0 + { + pushFollow(FOLLOW_57); + rule__RelationalExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop95; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } } @@ -30438,36 +31574,29 @@ public final void rule__OrExpression__OperatorAssignment_1_1() throws Recognitio } return ; } - // $ANTLR end "rule__OrExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__RelationalExpression__Group__1__Impl" - // $ANTLR start "rule__OrExpression__RightAssignment_1_2" - // InternalExport.g:9346:1: rule__OrExpression__RightAssignment_1_2 : ( ruleAndExpression ) ; - public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__0" + // InternalExport.g:9063: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 { int stackSize = keepStackSize(); try { - // InternalExport.g:9350:1: ( ( ruleAndExpression ) ) - // InternalExport.g:9351:2: ( ruleAndExpression ) - { - // InternalExport.g:9351:2: ( ruleAndExpression ) - // InternalExport.g:9352:3: ruleAndExpression + // InternalExport.g:9067:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) + // InternalExport.g:9068:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleAndExpression(); + pushFollow(FOLLOW_56); + rule__RelationalExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -30483,40 +31612,32 @@ public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionEx } return ; } - // $ANTLR end "rule__OrExpression__RightAssignment_1_2" + // $ANTLR end "rule__RelationalExpression__Group_1__0" - // $ANTLR start "rule__AndExpression__OperatorAssignment_1_1" - // InternalExport.g:9361:1: rule__AndExpression__OperatorAssignment_1_1 : ( ( '&&' ) ) ; - public final void rule__AndExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" + // InternalExport.g:9075:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; + public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9365:1: ( ( ( '&&' ) ) ) - // InternalExport.g:9366:2: ( ( '&&' ) ) + // InternalExport.g:9079:1: ( ( () ) ) + // InternalExport.g:9080:1: ( () ) { - // InternalExport.g:9366:2: ( ( '&&' ) ) - // InternalExport.g:9367:3: ( '&&' ) + // InternalExport.g:9080:1: ( () ) + // InternalExport.g:9081:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } - // InternalExport.g:9368:3: ( '&&' ) - // InternalExport.g:9369:4: '&&' + // InternalExport.g:9082:2: () + // InternalExport.g:9082:3: { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); - } - match(input,78,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); - } - } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -30525,10 +31646,6 @@ public final void rule__AndExpression__OperatorAssignment_1_1() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -30536,36 +31653,29 @@ public final void rule__AndExpression__OperatorAssignment_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__AndExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" - // $ANTLR start "rule__AndExpression__RightAssignment_1_2" - // InternalExport.g:9380:1: rule__AndExpression__RightAssignment_1_2 : ( ruleImpliesExpression ) ; - public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__1" + // InternalExport.g:9090: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 { int stackSize = keepStackSize(); try { - // InternalExport.g:9384:1: ( ( ruleImpliesExpression ) ) - // InternalExport.g:9385:2: ( ruleImpliesExpression ) + // InternalExport.g:9094:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) + // InternalExport.g:9095:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 { - // InternalExport.g:9385:2: ( ruleImpliesExpression ) - // InternalExport.g:9386:3: ruleImpliesExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleImpliesExpression(); + pushFollow(FOLLOW_49); + rule__RelationalExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -30581,40 +31691,38 @@ public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionE } return ; } - // $ANTLR end "rule__AndExpression__RightAssignment_1_2" + // $ANTLR end "rule__RelationalExpression__Group_1__1" - // $ANTLR start "rule__ImpliesExpression__OperatorAssignment_1_1" - // InternalExport.g:9395:1: rule__ImpliesExpression__OperatorAssignment_1_1 : ( ( 'implies' ) ) ; - public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" + // InternalExport.g:9102:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__RelationalExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9399:1: ( ( ( 'implies' ) ) ) - // InternalExport.g:9400:2: ( ( 'implies' ) ) + // InternalExport.g:9106:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) + // InternalExport.g:9107:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) { - // InternalExport.g:9400:2: ( ( 'implies' ) ) - // InternalExport.g:9401:3: ( 'implies' ) + // InternalExport.g:9107:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) + // InternalExport.g:9108:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } - // InternalExport.g:9402:3: ( 'implies' ) - // InternalExport.g:9403:4: 'implies' + // InternalExport.g:9109:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) + // InternalExport.g:9109:3: rule__RelationalExpression__OperatorAssignment_1_1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } - match(input,79,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__OperatorAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } } @@ -30634,36 +31742,24 @@ public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws Recog } return ; } - // $ANTLR end "rule__ImpliesExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" - // $ANTLR start "rule__ImpliesExpression__RightAssignment_1_2" - // InternalExport.g:9414:1: rule__ImpliesExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; - public final void rule__ImpliesExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__2" + // InternalExport.g:9117:1: rule__RelationalExpression__Group_1__2 : rule__RelationalExpression__Group_1__2__Impl ; + public final void rule__RelationalExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9418:1: ( ( ruleRelationalExpression ) ) - // InternalExport.g:9419:2: ( ruleRelationalExpression ) - { - // InternalExport.g:9419:2: ( ruleRelationalExpression ) - // InternalExport.g:9420:3: ruleRelationalExpression + // InternalExport.g:9121:1: ( rule__RelationalExpression__Group_1__2__Impl ) + // InternalExport.g:9122:2: rule__RelationalExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleRelationalExpression(); + rule__RelationalExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -30679,30 +31775,30 @@ public final void rule__ImpliesExpression__RightAssignment_1_2() throws Recognit } return ; } - // $ANTLR end "rule__ImpliesExpression__RightAssignment_1_2" + // $ANTLR end "rule__RelationalExpression__Group_1__2" - // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" - // InternalExport.g:9429: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__RelationalExpression__Group_1__2__Impl" + // InternalExport.g:9128:1: rule__RelationalExpression__Group_1__2__Impl : ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ; + public final void rule__RelationalExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9433:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) - // InternalExport.g:9434:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalExport.g:9132:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) + // InternalExport.g:9133:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) { - // InternalExport.g:9434:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) - // InternalExport.g:9435:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalExport.g:9133:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) + // InternalExport.g:9134:2: ( rule__RelationalExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - // InternalExport.g:9436:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) - // InternalExport.g:9436:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 + // InternalExport.g:9135:2: ( rule__RelationalExpression__RightAssignment_1_2 ) + // InternalExport.g:9135:3: rule__RelationalExpression__RightAssignment_1_2 { pushFollow(FOLLOW_2); - rule__RelationalExpression__OperatorAlternatives_1_1_0(); + rule__RelationalExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -30710,7 +31806,7 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } } @@ -30730,36 +31826,29 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" - // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" - // InternalExport.g:9444:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__0" + // InternalExport.g:9144:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; + public final void rule__AdditiveExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9448:1: ( ( ruleAdditiveExpression ) ) - // InternalExport.g:9449:2: ( ruleAdditiveExpression ) - { - // InternalExport.g:9449:2: ( ruleAdditiveExpression ) - // InternalExport.g:9450:3: ruleAdditiveExpression + // InternalExport.g:9148:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) + // InternalExport.g:9149:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleAdditiveExpression(); + pushFollow(FOLLOW_58); + rule__AdditiveExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -30775,38 +31864,32 @@ public final void rule__RelationalExpression__RightAssignment_1_2() throws Recog } return ; } - // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + // $ANTLR end "rule__AdditiveExpression__Group__0" - // $ANTLR start "rule__AdditiveExpression__NameAssignment_1_1" - // InternalExport.g:9459:1: rule__AdditiveExpression__NameAssignment_1_1 : ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ; - public final void rule__AdditiveExpression__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" + // InternalExport.g:9156:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; + public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9463:1: ( ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ) - // InternalExport.g:9464:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + // InternalExport.g:9160:1: ( ( ruleMultiplicativeExpression ) ) + // InternalExport.g:9161:1: ( ruleMultiplicativeExpression ) { - // InternalExport.g:9464:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) - // InternalExport.g:9465:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + // InternalExport.g:9161:1: ( ruleMultiplicativeExpression ) + // InternalExport.g:9162:2: ruleMultiplicativeExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } - // InternalExport.g:9466:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) - // InternalExport.g:9466:4: rule__AdditiveExpression__NameAlternatives_1_1_0 - { pushFollow(FOLLOW_2); - rule__AdditiveExpression__NameAlternatives_1_1_0(); + ruleMultiplicativeExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } } @@ -30826,36 +31909,24 @@ public final void rule__AdditiveExpression__NameAssignment_1_1() throws Recognit } return ; } - // $ANTLR end "rule__AdditiveExpression__NameAssignment_1_1" + // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" - // $ANTLR start "rule__AdditiveExpression__ParamsAssignment_1_2" - // InternalExport.g:9474:1: rule__AdditiveExpression__ParamsAssignment_1_2 : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__1" + // InternalExport.g:9171:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; + public final void rule__AdditiveExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9478:1: ( ( ruleMultiplicativeExpression ) ) - // InternalExport.g:9479:2: ( ruleMultiplicativeExpression ) + // InternalExport.g:9175:1: ( rule__AdditiveExpression__Group__1__Impl ) + // InternalExport.g:9176:2: rule__AdditiveExpression__Group__1__Impl { - // InternalExport.g:9479:2: ( ruleMultiplicativeExpression ) - // InternalExport.g:9480:3: ruleMultiplicativeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleMultiplicativeExpression(); + rule__AdditiveExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -30871,41 +31942,59 @@ public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws Recogn } return ; } - // $ANTLR end "rule__AdditiveExpression__ParamsAssignment_1_2" + // $ANTLR end "rule__AdditiveExpression__Group__1" - // $ANTLR start "rule__MultiplicativeExpression__NameAssignment_1_1" - // InternalExport.g:9489:1: rule__MultiplicativeExpression__NameAssignment_1_1 : ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ; - public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" + // InternalExport.g:9182:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; + public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9493:1: ( ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ) - // InternalExport.g:9494:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + // InternalExport.g:9186:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) + // InternalExport.g:9187:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) { - // InternalExport.g:9494:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) - // InternalExport.g:9495:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + // InternalExport.g:9187:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) + // InternalExport.g:9188:2: ( rule__AdditiveExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - // InternalExport.g:9496:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) - // InternalExport.g:9496:4: rule__MultiplicativeExpression__NameAlternatives_1_1_0 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__NameAlternatives_1_1_0(); + // InternalExport.g:9189:2: ( rule__AdditiveExpression__Group_1__0 )* + loop96: + do { + int alt96=2; + int LA96_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( ((LA96_0>=23 && LA96_0<=24)) ) { + alt96=1; + } - } - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); - } + switch (alt96) { + case 1 : + // InternalExport.g:9189:3: rule__AdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_59); + rule__AdditiveExpression__Group_1__0(); - } + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop96; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + } + + } } @@ -30922,36 +32011,29 @@ public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__MultiplicativeExpression__NameAssignment_1_1" + // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" - // $ANTLR start "rule__MultiplicativeExpression__ParamsAssignment_1_2" - // InternalExport.g:9504:1: rule__MultiplicativeExpression__ParamsAssignment_1_2 : ( ruleUnaryOrInfixExpression ) ; - public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__0" + // InternalExport.g:9198: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 { int stackSize = keepStackSize(); try { - // InternalExport.g:9508:1: ( ( ruleUnaryOrInfixExpression ) ) - // InternalExport.g:9509:2: ( ruleUnaryOrInfixExpression ) - { - // InternalExport.g:9509:2: ( ruleUnaryOrInfixExpression ) - // InternalExport.g:9510:3: ruleUnaryOrInfixExpression + // InternalExport.g:9202:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) + // InternalExport.g:9203:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleUnaryOrInfixExpression(); + pushFollow(FOLLOW_58); + rule__AdditiveExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -30967,38 +32049,32 @@ public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws } return ; } - // $ANTLR end "rule__MultiplicativeExpression__ParamsAssignment_1_2" + // $ANTLR end "rule__AdditiveExpression__Group_1__0" - // $ANTLR start "rule__UnaryExpression__NameAssignment_0" - // InternalExport.g:9519:1: rule__UnaryExpression__NameAssignment_0 : ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ; - public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" + // InternalExport.g:9210:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; + public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9523:1: ( ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ) - // InternalExport.g:9524:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + // InternalExport.g:9214:1: ( ( () ) ) + // InternalExport.g:9215:1: ( () ) { - // InternalExport.g:9524:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) - // InternalExport.g:9525:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + // InternalExport.g:9215:1: ( () ) + // InternalExport.g:9216:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } - // InternalExport.g:9526:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) - // InternalExport.g:9526:4: rule__UnaryExpression__NameAlternatives_0_0 + // InternalExport.g:9217:2: () + // InternalExport.g:9217:3: { - pushFollow(FOLLOW_2); - rule__UnaryExpression__NameAlternatives_0_0(); - - state._fsp--; - if (state.failed) return ; - } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } } @@ -31007,10 +32083,6 @@ public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionEx } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -31018,36 +32090,29 @@ public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionEx } return ; } - // $ANTLR end "rule__UnaryExpression__NameAssignment_0" + // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" - // $ANTLR start "rule__UnaryExpression__ParamsAssignment_1" - // InternalExport.g:9534:1: rule__UnaryExpression__ParamsAssignment_1 : ( ruleInfixExpression ) ; - public final void rule__UnaryExpression__ParamsAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__1" + // InternalExport.g:9225: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 { int stackSize = keepStackSize(); try { - // InternalExport.g:9538:1: ( ( ruleInfixExpression ) ) - // InternalExport.g:9539:2: ( ruleInfixExpression ) + // InternalExport.g:9229:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) + // InternalExport.g:9230:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 { - // InternalExport.g:9539:2: ( ruleInfixExpression ) - // InternalExport.g:9540:3: ruleInfixExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleInfixExpression(); + pushFollow(FOLLOW_49); + rule__AdditiveExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -31063,32 +32128,38 @@ public final void rule__UnaryExpression__ParamsAssignment_1() throws Recognition } return ; } - // $ANTLR end "rule__UnaryExpression__ParamsAssignment_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__1" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_0_2" - // InternalExport.g:9549:1: rule__InfixExpression__NameAssignment_1_0_2 : ( ruleIdentifier ) ; - public final void rule__InfixExpression__NameAssignment_1_0_2() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" + // InternalExport.g:9237:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ; + public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9553:1: ( ( ruleIdentifier ) ) - // InternalExport.g:9554:2: ( ruleIdentifier ) + // InternalExport.g:9241:1: ( ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ) + // InternalExport.g:9242:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) { - // InternalExport.g:9554:2: ( ruleIdentifier ) - // InternalExport.g:9555:3: ruleIdentifier + // InternalExport.g:9242:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) + // InternalExport.g:9243:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + // InternalExport.g:9244:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) + // InternalExport.g:9244:3: rule__AdditiveExpression__NameAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__AdditiveExpression__NameAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } } @@ -31108,36 +32179,24 @@ public final void rule__InfixExpression__NameAssignment_1_0_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_0_2" + // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" - // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_0" - // InternalExport.g:9564:1: rule__InfixExpression__ParamsAssignment_1_0_4_0 : ( ruleExpression ) ; - public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__2" + // InternalExport.g:9252:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ; + public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9568:1: ( ( ruleExpression ) ) - // InternalExport.g:9569:2: ( ruleExpression ) - { - // InternalExport.g:9569:2: ( ruleExpression ) - // InternalExport.g:9570:3: ruleExpression + // InternalExport.g:9256:1: ( rule__AdditiveExpression__Group_1__2__Impl ) + // InternalExport.g:9257:2: rule__AdditiveExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__AdditiveExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); - } - - } - } @@ -31153,32 +32212,38 @@ public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws Recog } return ; } - // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_0" + // $ANTLR end "rule__AdditiveExpression__Group_1__2" - // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" - // InternalExport.g:9579:1: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 : ( ruleExpression ) ; - public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" + // InternalExport.g:9263:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ; + public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9583:1: ( ( ruleExpression ) ) - // InternalExport.g:9584:2: ( ruleExpression ) + // InternalExport.g:9267:1: ( ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ) + // InternalExport.g:9268:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) { - // InternalExport.g:9584:2: ( ruleExpression ) - // InternalExport.g:9585:3: ruleExpression + // InternalExport.g:9268:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) + // InternalExport.g:9269:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + // InternalExport.g:9270:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) + // InternalExport.g:9270:3: rule__AdditiveExpression__ParamsAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__AdditiveExpression__ParamsAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } } @@ -31198,36 +32263,29 @@ public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws Rec } return ; } - // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" - // $ANTLR start "rule__InfixExpression__TypeAssignment_1_1_2" - // InternalExport.g:9594:1: rule__InfixExpression__TypeAssignment_1_1_2 : ( ruleType ) ; - public final void rule__InfixExpression__TypeAssignment_1_1_2() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__0" + // InternalExport.g:9279:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; + public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9598:1: ( ( ruleType ) ) - // InternalExport.g:9599:2: ( ruleType ) - { - // InternalExport.g:9599:2: ( ruleType ) - // InternalExport.g:9600:3: ruleType + // InternalExport.g:9283:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) + // InternalExport.g:9284:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleType(); + pushFollow(FOLLOW_60); + rule__MultiplicativeExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -31243,40 +32301,32 @@ public final void rule__InfixExpression__TypeAssignment_1_1_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__TypeAssignment_1_1_2" + // $ANTLR end "rule__MultiplicativeExpression__Group__0" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_2_2" - // InternalExport.g:9609:1: rule__InfixExpression__NameAssignment_1_2_2 : ( ( 'typeSelect' ) ) ; - public final void rule__InfixExpression__NameAssignment_1_2_2() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" + // InternalExport.g:9291:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleUnaryOrInfixExpression ) ; + public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9613:1: ( ( ( 'typeSelect' ) ) ) - // InternalExport.g:9614:2: ( ( 'typeSelect' ) ) + // InternalExport.g:9295:1: ( ( ruleUnaryOrInfixExpression ) ) + // InternalExport.g:9296:1: ( ruleUnaryOrInfixExpression ) { - // InternalExport.g:9614:2: ( ( 'typeSelect' ) ) - // InternalExport.g:9615:3: ( 'typeSelect' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } - // InternalExport.g:9616:3: ( 'typeSelect' ) - // InternalExport.g:9617:4: 'typeSelect' + // InternalExport.g:9296:1: ( ruleUnaryOrInfixExpression ) + // InternalExport.g:9297:2: ruleUnaryOrInfixExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } - match(input,80,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } - + before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + pushFollow(FOLLOW_2); + ruleUnaryOrInfixExpression(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } } @@ -31296,36 +32346,24 @@ public final void rule__InfixExpression__NameAssignment_1_2_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_2_2" + // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__TypeAssignment_1_2_4" - // InternalExport.g:9628:1: rule__InfixExpression__TypeAssignment_1_2_4 : ( ruleType ) ; - public final void rule__InfixExpression__TypeAssignment_1_2_4() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__1" + // InternalExport.g:9306:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; + public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9632:1: ( ( ruleType ) ) - // InternalExport.g:9633:2: ( ruleType ) + // InternalExport.g:9310:1: ( rule__MultiplicativeExpression__Group__1__Impl ) + // InternalExport.g:9311:2: rule__MultiplicativeExpression__Group__1__Impl { - // InternalExport.g:9633:2: ( ruleType ) - // InternalExport.g:9634:3: ruleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); - } pushFollow(FOLLOW_2); - ruleType(); + rule__MultiplicativeExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); - } - - } - } @@ -31341,38 +32379,56 @@ public final void rule__InfixExpression__TypeAssignment_1_2_4() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__TypeAssignment_1_2_4" + // $ANTLR end "rule__MultiplicativeExpression__Group__1" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_3_2" - // InternalExport.g:9643:1: rule__InfixExpression__NameAssignment_1_3_2 : ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ; - public final void rule__InfixExpression__NameAssignment_1_3_2() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" + // InternalExport.g:9317:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; + public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9647:1: ( ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ) - // InternalExport.g:9648:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + // InternalExport.g:9321:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) + // InternalExport.g:9322:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) { - // InternalExport.g:9648:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) - // InternalExport.g:9649:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + // InternalExport.g:9322:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) + // InternalExport.g:9323:2: ( rule__MultiplicativeExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - // InternalExport.g:9650:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) - // InternalExport.g:9650:4: rule__InfixExpression__NameAlternatives_1_3_2_0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAlternatives_1_3_2_0(); + // InternalExport.g:9324:2: ( rule__MultiplicativeExpression__Group_1__0 )* + loop97: + do { + int alt97=2; + int LA97_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( ((LA97_0>=25 && LA97_0<=26)) ) { + alt97=1; + } - } + + switch (alt97) { + case 1 : + // InternalExport.g:9324:3: rule__MultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_61); + rule__MultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop97; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } } @@ -31392,36 +32448,29 @@ public final void rule__InfixExpression__NameAssignment_1_3_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_3_2" + // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" - // $ANTLR start "rule__InfixExpression__VarAssignment_1_3_4_0" - // InternalExport.g:9658:1: rule__InfixExpression__VarAssignment_1_3_4_0 : ( ruleIdentifier ) ; - public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" + // InternalExport.g:9333: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 { int stackSize = keepStackSize(); try { - // InternalExport.g:9662:1: ( ( ruleIdentifier ) ) - // InternalExport.g:9663:2: ( ruleIdentifier ) - { - // InternalExport.g:9663:2: ( ruleIdentifier ) - // InternalExport.g:9664:3: ruleIdentifier + // InternalExport.g:9337:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) + // InternalExport.g:9338:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_60); + rule__MultiplicativeExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -31437,32 +32486,32 @@ public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws Recognit } return ; } - // $ANTLR end "rule__InfixExpression__VarAssignment_1_3_4_0" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" - // $ANTLR start "rule__InfixExpression__ExpAssignment_1_3_5" - // InternalExport.g:9673:1: rule__InfixExpression__ExpAssignment_1_3_5 : ( ruleExpression ) ; - public final void rule__InfixExpression__ExpAssignment_1_3_5() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" + // InternalExport.g:9345:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; + public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9677:1: ( ( ruleExpression ) ) - // InternalExport.g:9678:2: ( ruleExpression ) + // InternalExport.g:9349:1: ( ( () ) ) + // InternalExport.g:9350:1: ( () ) { - // InternalExport.g:9678:2: ( ruleExpression ) - // InternalExport.g:9679:3: ruleExpression + // InternalExport.g:9350:1: ( () ) + // InternalExport.g:9351:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + } + // InternalExport.g:9352:2: () + // InternalExport.g:9352:3: + { } - pushFollow(FOLLOW_2); - ruleExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } } @@ -31471,10 +32520,6 @@ public final void rule__InfixExpression__ExpAssignment_1_3_5() throws Recognitio } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -31482,42 +32527,29 @@ public final void rule__InfixExpression__ExpAssignment_1_3_5() throws Recognitio } return ; } - // $ANTLR end "rule__InfixExpression__ExpAssignment_1_3_5" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" - // $ANTLR start "rule__BooleanLiteral__ValAssignment" - // InternalExport.g:9688:1: rule__BooleanLiteral__ValAssignment : ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ; - public final void rule__BooleanLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" + // InternalExport.g:9360: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 { int stackSize = keepStackSize(); try { - // InternalExport.g:9692:1: ( ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ) - // InternalExport.g:9693:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) - { - // InternalExport.g:9693:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) - // InternalExport.g:9694:3: ( rule__BooleanLiteral__ValAlternatives_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); - } - // InternalExport.g:9695:3: ( rule__BooleanLiteral__ValAlternatives_0 ) - // InternalExport.g:9695:4: rule__BooleanLiteral__ValAlternatives_0 + // InternalExport.g:9364:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) + // InternalExport.g:9365:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 { - pushFollow(FOLLOW_2); - rule__BooleanLiteral__ValAlternatives_0(); + pushFollow(FOLLOW_49); + rule__MultiplicativeExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__2(); - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); - } - - } - + state._fsp--; + if (state.failed) return ; } @@ -31533,28 +32565,38 @@ public final void rule__BooleanLiteral__ValAssignment() throws RecognitionExcept } return ; } - // $ANTLR end "rule__BooleanLiteral__ValAssignment" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" - // $ANTLR start "rule__IntegerLiteral__ValAssignment" - // InternalExport.g:9703:1: rule__IntegerLiteral__ValAssignment : ( RULE_INT ) ; - public final void rule__IntegerLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" + // InternalExport.g:9372:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ; + public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9707:1: ( ( RULE_INT ) ) - // InternalExport.g:9708:2: ( RULE_INT ) + // InternalExport.g:9376:1: ( ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ) + // InternalExport.g:9377:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) { - // InternalExport.g:9708:2: ( RULE_INT ) - // InternalExport.g:9709:3: RULE_INT + // InternalExport.g:9377:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) + // InternalExport.g:9378:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } - match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:9379:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) + // InternalExport.g:9379:3: rule__MultiplicativeExpression__NameAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__NameAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } } @@ -31574,44 +32616,24 @@ public final void rule__IntegerLiteral__ValAssignment() throws RecognitionExcept } return ; } - // $ANTLR end "rule__IntegerLiteral__ValAssignment" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" - // $ANTLR start "rule__NullLiteral__ValAssignment" - // InternalExport.g:9718:1: rule__NullLiteral__ValAssignment : ( ( 'null' ) ) ; - public final void rule__NullLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" + // InternalExport.g:9387:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; + public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9722:1: ( ( ( 'null' ) ) ) - // InternalExport.g:9723:2: ( ( 'null' ) ) - { - // InternalExport.g:9723:2: ( ( 'null' ) ) - // InternalExport.g:9724:3: ( 'null' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - // InternalExport.g:9725:3: ( 'null' ) - // InternalExport.g:9726:4: 'null' + // InternalExport.g:9391:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) + // InternalExport.g:9392:2: rule__MultiplicativeExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - match(input,81,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__2__Impl(); + state._fsp--; + if (state.failed) return ; } @@ -31627,28 +32649,38 @@ public final void rule__NullLiteral__ValAssignment() throws RecognitionException } return ; } - // $ANTLR end "rule__NullLiteral__ValAssignment" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" - // $ANTLR start "rule__RealLiteral__ValAssignment" - // InternalExport.g:9737:1: rule__RealLiteral__ValAssignment : ( RULE_REAL ) ; - public final void rule__RealLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" + // InternalExport.g:9398:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ; + public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9741:1: ( ( RULE_REAL ) ) - // InternalExport.g:9742:2: ( RULE_REAL ) + // InternalExport.g:9402:1: ( ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ) + // InternalExport.g:9403:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) { - // InternalExport.g:9742:2: ( RULE_REAL ) - // InternalExport.g:9743:3: RULE_REAL + // InternalExport.g:9403:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) + // InternalExport.g:9404:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } - match(input,RULE_REAL,FOLLOW_2); if (state.failed) return ; + // InternalExport.g:9405:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) + // InternalExport.g:9405:3: rule__MultiplicativeExpression__ParamsAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__ParamsAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } } @@ -31668,32 +32700,29 @@ public final void rule__RealLiteral__ValAssignment() throws RecognitionException } return ; } - // $ANTLR end "rule__RealLiteral__ValAssignment" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" - // $ANTLR start "rule__StringLiteral__ValAssignment" - // InternalExport.g:9752:1: rule__StringLiteral__ValAssignment : ( RULE_STRING ) ; - public final void rule__StringLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__0" + // InternalExport.g:9414:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ; + public final void rule__UnaryExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9756:1: ( ( RULE_STRING ) ) - // InternalExport.g:9757:2: ( RULE_STRING ) - { - // InternalExport.g:9757:2: ( RULE_STRING ) - // InternalExport.g:9758:3: RULE_STRING + // InternalExport.g:9418:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ) + // InternalExport.g:9419:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); - } - match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); - } + pushFollow(FOLLOW_49); + rule__UnaryExpression__Group__0__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__UnaryExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -31709,32 +32738,38 @@ public final void rule__StringLiteral__ValAssignment() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__StringLiteral__ValAssignment" + // $ANTLR end "rule__UnaryExpression__Group__0" - // $ANTLR start "rule__GlobalVarExpression__NameAssignment_1" - // InternalExport.g:9767:1: rule__GlobalVarExpression__NameAssignment_1 : ( ruleIdentifier ) ; - public final void rule__GlobalVarExpression__NameAssignment_1() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__0__Impl" + // InternalExport.g:9426:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__NameAssignment_0 ) ) ; + public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9771:1: ( ( ruleIdentifier ) ) - // InternalExport.g:9772:2: ( ruleIdentifier ) + // InternalExport.g:9430:1: ( ( ( rule__UnaryExpression__NameAssignment_0 ) ) ) + // InternalExport.g:9431:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) { - // InternalExport.g:9772:2: ( ruleIdentifier ) - // InternalExport.g:9773:3: ruleIdentifier + // InternalExport.g:9431:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) + // InternalExport.g:9432:2: ( rule__UnaryExpression__NameAssignment_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + // InternalExport.g:9433:2: ( rule__UnaryExpression__NameAssignment_0 ) + // InternalExport.g:9433:3: rule__UnaryExpression__NameAssignment_0 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__UnaryExpression__NameAssignment_0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } } @@ -31754,36 +32789,24 @@ public final void rule__GlobalVarExpression__NameAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalVarExpression__NameAssignment_1" + // $ANTLR end "rule__UnaryExpression__Group__0__Impl" - // $ANTLR start "rule__FeatureCall__TypeAssignment_1" - // InternalExport.g:9782:1: rule__FeatureCall__TypeAssignment_1 : ( ruleType ) ; - public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__1" + // InternalExport.g:9441:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ; + public final void rule__UnaryExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9786:1: ( ( ruleType ) ) - // InternalExport.g:9787:2: ( ruleType ) + // InternalExport.g:9445:1: ( rule__UnaryExpression__Group__1__Impl ) + // InternalExport.g:9446:2: rule__UnaryExpression__Group__1__Impl { - // InternalExport.g:9787:2: ( ruleType ) - // InternalExport.g:9788:3: ruleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); - } pushFollow(FOLLOW_2); - ruleType(); + rule__UnaryExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); - } - - } - } @@ -31799,32 +32822,38 @@ public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__FeatureCall__TypeAssignment_1" + // $ANTLR end "rule__UnaryExpression__Group__1" - // $ANTLR start "rule__OperationCall__NameAssignment_0" - // InternalExport.g:9797:1: rule__OperationCall__NameAssignment_0 : ( ruleIdentifier ) ; - public final void rule__OperationCall__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__1__Impl" + // InternalExport.g:9452:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ; + public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9801:1: ( ( ruleIdentifier ) ) - // InternalExport.g:9802:2: ( ruleIdentifier ) + // InternalExport.g:9456:1: ( ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ) + // InternalExport.g:9457:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) { - // InternalExport.g:9802:2: ( ruleIdentifier ) - // InternalExport.g:9803:3: ruleIdentifier + // InternalExport.g:9457:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) + // InternalExport.g:9458:2: ( rule__UnaryExpression__ParamsAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + // InternalExport.g:9459:2: ( rule__UnaryExpression__ParamsAssignment_1 ) + // InternalExport.g:9459:3: rule__UnaryExpression__ParamsAssignment_1 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__UnaryExpression__ParamsAssignment_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } } @@ -31844,36 +32873,29 @@ public final void rule__OperationCall__NameAssignment_0() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__NameAssignment_0" + // $ANTLR end "rule__UnaryExpression__Group__1__Impl" - // $ANTLR start "rule__OperationCall__ParamsAssignment_2_0" - // InternalExport.g:9812:1: rule__OperationCall__ParamsAssignment_2_0 : ( ruleExpression ) ; - public final void rule__OperationCall__ParamsAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__0" + // InternalExport.g:9468:1: rule__InfixExpression__Group__0 : rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ; + public final void rule__InfixExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9816:1: ( ( ruleExpression ) ) - // InternalExport.g:9817:2: ( ruleExpression ) + // InternalExport.g:9472:1: ( rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ) + // InternalExport.g:9473:2: rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 { - // InternalExport.g:9817:2: ( ruleExpression ) - // InternalExport.g:9818:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_62); + rule__InfixExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -31889,32 +32911,32 @@ public final void rule__OperationCall__ParamsAssignment_2_0() throws Recognition } return ; } - // $ANTLR end "rule__OperationCall__ParamsAssignment_2_0" + // $ANTLR end "rule__InfixExpression__Group__0" - // $ANTLR start "rule__OperationCall__ParamsAssignment_2_1_1" - // InternalExport.g:9827:1: rule__OperationCall__ParamsAssignment_2_1_1 : ( ruleExpression ) ; - public final void rule__OperationCall__ParamsAssignment_2_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__0__Impl" + // InternalExport.g:9480:1: rule__InfixExpression__Group__0__Impl : ( rulePrimaryExpression ) ; + public final void rule__InfixExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9831:1: ( ( ruleExpression ) ) - // InternalExport.g:9832:2: ( ruleExpression ) + // InternalExport.g:9484:1: ( ( rulePrimaryExpression ) ) + // InternalExport.g:9485:1: ( rulePrimaryExpression ) { - // InternalExport.g:9832:2: ( ruleExpression ) - // InternalExport.g:9833:3: ruleExpression + // InternalExport.g:9485:1: ( rulePrimaryExpression ) + // InternalExport.g:9486:2: rulePrimaryExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleExpression(); + rulePrimaryExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } } @@ -31934,36 +32956,24 @@ public final void rule__OperationCall__ParamsAssignment_2_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__OperationCall__ParamsAssignment_2_1_1" + // $ANTLR end "rule__InfixExpression__Group__0__Impl" - // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_0" - // InternalExport.g:9842:1: rule__ListLiteral__ElementsAssignment_2_0 : ( ruleExpression ) ; - public final void rule__ListLiteral__ElementsAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__1" + // InternalExport.g:9495:1: rule__InfixExpression__Group__1 : rule__InfixExpression__Group__1__Impl ; + public final void rule__InfixExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9846:1: ( ( ruleExpression ) ) - // InternalExport.g:9847:2: ( ruleExpression ) - { - // InternalExport.g:9847:2: ( ruleExpression ) - // InternalExport.g:9848:3: ruleExpression + // InternalExport.g:9499:1: ( rule__InfixExpression__Group__1__Impl ) + // InternalExport.g:9500:2: rule__InfixExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__InfixExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); - } - - } - } @@ -31979,35 +32989,59 @@ public final void rule__ListLiteral__ElementsAssignment_2_0() throws Recognition } return ; } - // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_0" + // $ANTLR end "rule__InfixExpression__Group__1" - // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_1_1" - // InternalExport.g:9857:1: rule__ListLiteral__ElementsAssignment_2_1_1 : ( ruleExpression ) ; - public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__1__Impl" + // InternalExport.g:9506:1: rule__InfixExpression__Group__1__Impl : ( ( rule__InfixExpression__Alternatives_1 )* ) ; + public final void rule__InfixExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9861:1: ( ( ruleExpression ) ) - // InternalExport.g:9862:2: ( ruleExpression ) + // InternalExport.g:9510:1: ( ( ( rule__InfixExpression__Alternatives_1 )* ) ) + // InternalExport.g:9511:1: ( ( rule__InfixExpression__Alternatives_1 )* ) { - // InternalExport.g:9862:2: ( ruleExpression ) - // InternalExport.g:9863:3: ruleExpression + // InternalExport.g:9511:1: ( ( rule__InfixExpression__Alternatives_1 )* ) + // InternalExport.g:9512:2: ( rule__InfixExpression__Alternatives_1 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + // InternalExport.g:9513:2: ( rule__InfixExpression__Alternatives_1 )* + loop98: + do { + int alt98=2; + int LA98_0 = input.LA(1); - } + if ( (LA98_0==58) ) { + alt98=1; + } + + + switch (alt98) { + case 1 : + // InternalExport.g:9513:3: rule__InfixExpression__Alternatives_1 + { + pushFollow(FOLLOW_63); + rule__InfixExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop98; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + } + + } } @@ -32024,32 +33058,145 @@ public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_1_1" + // $ANTLR end "rule__InfixExpression__Group__1__Impl" - // $ANTLR start "rule__ConstructorCallExpression__TypeAssignment_1" - // InternalExport.g:9872:1: rule__ConstructorCallExpression__TypeAssignment_1 : ( ruleSimpleType ) ; - public final void rule__ConstructorCallExpression__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__0" + // InternalExport.g:9522:1: rule__InfixExpression__Group_1_0__0 : rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ; + public final void rule__InfixExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9526:1: ( rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ) + // InternalExport.g:9527:2: rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 + { + pushFollow(FOLLOW_62); + rule__InfixExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__0__Impl" + // InternalExport.g:9534:1: rule__InfixExpression__Group_1_0__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9876:1: ( ( ruleSimpleType ) ) - // InternalExport.g:9877:2: ( ruleSimpleType ) + // InternalExport.g:9538:1: ( ( () ) ) + // InternalExport.g:9539:1: ( () ) { - // InternalExport.g:9877:2: ( ruleSimpleType ) - // InternalExport.g:9878:3: ruleSimpleType + // InternalExport.g:9539:1: ( () ) + // InternalExport.g:9540:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + } + // InternalExport.g:9541:2: () + // InternalExport.g:9541:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + } + + } + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__1" + // InternalExport.g:9549:1: rule__InfixExpression__Group_1_0__1 : rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ; + public final void rule__InfixExpression__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9553:1: ( rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ) + // InternalExport.g:9554:2: rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 + { + pushFollow(FOLLOW_11); + rule__InfixExpression__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - ruleSimpleType(); + rule__InfixExpression__Group_1_0__2(); state._fsp--; if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__1__Impl" + // InternalExport.g:9561:1: rule__InfixExpression__Group_1_0__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9565:1: ( ( '.' ) ) + // InternalExport.g:9566:1: ( '.' ) + { + // InternalExport.g:9566:1: ( '.' ) + // InternalExport.g:9567:2: '.' + { if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } } @@ -32069,40 +33216,155 @@ public final void rule__ConstructorCallExpression__TypeAssignment_1() throws Rec } return ; } - // $ANTLR end "rule__ConstructorCallExpression__TypeAssignment_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__1__Impl" - // $ANTLR start "rule__TypeSelectExpression__NameAssignment_0" - // InternalExport.g:9887:1: rule__TypeSelectExpression__NameAssignment_0 : ( ( 'typeSelect' ) ) ; - public final void rule__TypeSelectExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__2" + // InternalExport.g:9576:1: rule__InfixExpression__Group_1_0__2 : rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ; + public final void rule__InfixExpression__Group_1_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9580:1: ( rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ) + // InternalExport.g:9581:2: rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 + { + pushFollow(FOLLOW_34); + rule__InfixExpression__Group_1_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__2__Impl" + // InternalExport.g:9588:1: rule__InfixExpression__Group_1_0__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ; + public final void rule__InfixExpression__Group_1_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9891:1: ( ( ( 'typeSelect' ) ) ) - // InternalExport.g:9892:2: ( ( 'typeSelect' ) ) + // InternalExport.g:9592:1: ( ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ) + // InternalExport.g:9593:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) { - // InternalExport.g:9892:2: ( ( 'typeSelect' ) ) - // InternalExport.g:9893:3: ( 'typeSelect' ) + // InternalExport.g:9593:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) + // InternalExport.g:9594:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } - // InternalExport.g:9894:3: ( 'typeSelect' ) - // InternalExport.g:9895:4: 'typeSelect' + // InternalExport.g:9595:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) + // InternalExport.g:9595:3: rule__InfixExpression__NameAssignment_1_0_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_0_2(); + + state._fsp--; + if (state.failed) return ; + } - match(input,80,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + } + + } + + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__3" + // InternalExport.g:9603:1: rule__InfixExpression__Group_1_0__3 : rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ; + public final void rule__InfixExpression__Group_1_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9607:1: ( rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ) + // InternalExport.g:9608:2: rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 + { + pushFollow(FOLLOW_64); + rule__InfixExpression__Group_1_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__4(); + + state._fsp--; + if (state.failed) return ; + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__3" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__3__Impl" + // InternalExport.g:9615:1: rule__InfixExpression__Group_1_0__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9619:1: ( ( '(' ) ) + // InternalExport.g:9620:1: ( '(' ) + { + // InternalExport.g:9620:1: ( '(' ) + // InternalExport.g:9621:2: '(' + { if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } } @@ -32122,32 +33384,161 @@ public final void rule__TypeSelectExpression__NameAssignment_0() throws Recognit } return ; } - // $ANTLR end "rule__TypeSelectExpression__NameAssignment_0" + // $ANTLR end "rule__InfixExpression__Group_1_0__3__Impl" - // $ANTLR start "rule__TypeSelectExpression__TypeAssignment_2" - // InternalExport.g:9906:1: rule__TypeSelectExpression__TypeAssignment_2 : ( ruleType ) ; - public final void rule__TypeSelectExpression__TypeAssignment_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__4" + // InternalExport.g:9630:1: rule__InfixExpression__Group_1_0__4 : rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ; + public final void rule__InfixExpression__Group_1_0__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9634:1: ( rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ) + // InternalExport.g:9635:2: rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 + { + pushFollow(FOLLOW_64); + rule__InfixExpression__Group_1_0__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__4__Impl" + // InternalExport.g:9642:1: rule__InfixExpression__Group_1_0__4__Impl : ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ; + public final void rule__InfixExpression__Group_1_0__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9910:1: ( ( ruleType ) ) - // InternalExport.g:9911:2: ( ruleType ) + // InternalExport.g:9646:1: ( ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ) + // InternalExport.g:9647:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) { - // InternalExport.g:9911:2: ( ruleType ) - // InternalExport.g:9912:3: ruleType + // InternalExport.g:9647:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) + // InternalExport.g:9648:2: ( rule__InfixExpression__Group_1_0_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + } + // InternalExport.g:9649:2: ( rule__InfixExpression__Group_1_0_4__0 )? + int alt99=2; + int LA99_0 = input.LA(1); + + if ( (LA99_0==RULE_ID||LA99_0==RULE_INT||(LA99_0>=RULE_STRING && LA99_0<=RULE_REAL)||LA99_0==24||(LA99_0>=27 && LA99_0<=40)||LA99_0==68||LA99_0==77||LA99_0==84||LA99_0==87||LA99_0==90||(LA99_0>=94 && LA99_0<=95)||LA99_0==100||LA99_0==115) ) { + alt99=1; + } + switch (alt99) { + case 1 : + // InternalExport.g:9649:3: rule__InfixExpression__Group_1_0_4__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + } + + } + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__4__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__5" + // InternalExport.g:9657:1: rule__InfixExpression__Group_1_0__5 : rule__InfixExpression__Group_1_0__5__Impl ; + public final void rule__InfixExpression__Group_1_0__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9661:1: ( rule__InfixExpression__Group_1_0__5__Impl ) + // InternalExport.g:9662:2: rule__InfixExpression__Group_1_0__5__Impl + { pushFollow(FOLLOW_2); - ruleType(); + rule__InfixExpression__Group_1_0__5__Impl(); state._fsp--; if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__5__Impl" + // InternalExport.g:9668:1: rule__InfixExpression__Group_1_0__5__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_0__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9672:1: ( ( ')' ) ) + // InternalExport.g:9673:1: ( ')' ) + { + // InternalExport.g:9673:1: ( ')' ) + // InternalExport.g:9674:2: ')' + { if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } } @@ -32167,421 +33558,57439 @@ public final void rule__TypeSelectExpression__TypeAssignment_2() throws Recognit } return ; } - // $ANTLR end "rule__TypeSelectExpression__TypeAssignment_2" + // $ANTLR end "rule__InfixExpression__Group_1_0__5__Impl" - // $ANTLR start "rule__CollectionExpression__NameAssignment_0" - // InternalExport.g:9921:1: rule__CollectionExpression__NameAssignment_0 : ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ; - public final void rule__CollectionExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4__0" + // InternalExport.g:9684:1: rule__InfixExpression__Group_1_0_4__0 : rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ; + public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9688:1: ( rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ) + // InternalExport.g:9689:2: rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 + { + pushFollow(FOLLOW_21); + rule__InfixExpression__Group_1_0_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__0__Impl" + // InternalExport.g:9696:1: rule__InfixExpression__Group_1_0_4__0__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ; + public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExport.g:9925:1: ( ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ) - // InternalExport.g:9926:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + // InternalExport.g:9700:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ) + // InternalExport.g:9701:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) { - // InternalExport.g:9926:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) - // InternalExport.g:9927:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + // InternalExport.g:9701:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) + // InternalExport.g:9702:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } - // InternalExport.g:9928:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) - // InternalExport.g:9928:4: rule__CollectionExpression__NameAlternatives_0_0 + // InternalExport.g:9703:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) + // InternalExport.g:9703:3: rule__InfixExpression__ParamsAssignment_1_0_4_0 { pushFollow(FOLLOW_2); - rule__CollectionExpression__NameAlternatives_0_0(); + rule__InfixExpression__ParamsAssignment_1_0_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__1" + // InternalExport.g:9711:1: rule__InfixExpression__Group_1_0_4__1 : rule__InfixExpression__Group_1_0_4__1__Impl ; + public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9715:1: ( rule__InfixExpression__Group_1_0_4__1__Impl ) + // InternalExport.g:9716:2: rule__InfixExpression__Group_1_0_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__1__Impl(); state._fsp--; if (state.failed) return ; - } + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__1__Impl" + // InternalExport.g:9722:1: rule__InfixExpression__Group_1_0_4__1__Impl : ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ; + public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9726:1: ( ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ) + // InternalExport.g:9727:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + { + // InternalExport.g:9727:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + // InternalExport.g:9728:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + } + // InternalExport.g:9729:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + loop100: + do { + int alt100=2; + int LA100_0 = input.LA(1); + + if ( (LA100_0==74) ) { + alt100=1; + } + + + switch (alt100) { + case 1 : + // InternalExport.g:9729:3: rule__InfixExpression__Group_1_0_4_1__0 + { + pushFollow(FOLLOW_22); + rule__InfixExpression__Group_1_0_4_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop100; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0" + // InternalExport.g:9738:1: rule__InfixExpression__Group_1_0_4_1__0 : rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ; + public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9742:1: ( rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ) + // InternalExport.g:9743:2: rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 + { + pushFollow(FOLLOW_18); + rule__InfixExpression__Group_1_0_4_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0__Impl" + // InternalExport.g:9750:1: rule__InfixExpression__Group_1_0_4_1__0__Impl : ( ',' ) ; + public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9754:1: ( ( ',' ) ) + // InternalExport.g:9755:1: ( ',' ) + { + // InternalExport.g:9755:1: ( ',' ) + // InternalExport.g:9756:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1" + // InternalExport.g:9765:1: rule__InfixExpression__Group_1_0_4_1__1 : rule__InfixExpression__Group_1_0_4_1__1__Impl ; + public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9769:1: ( rule__InfixExpression__Group_1_0_4_1__1__Impl ) + // InternalExport.g:9770:2: rule__InfixExpression__Group_1_0_4_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1__Impl" + // InternalExport.g:9776:1: rule__InfixExpression__Group_1_0_4_1__1__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ; + public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9780:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ) + // InternalExport.g:9781:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + { + // InternalExport.g:9781:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + // InternalExport.g:9782:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + } + // InternalExport.g:9783:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + // InternalExport.g:9783:3: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__ParamsAssignment_1_0_4_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__0" + // InternalExport.g:9792:1: rule__InfixExpression__Group_1_1__0 : rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ; + public final void rule__InfixExpression__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9796:1: ( rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ) + // InternalExport.g:9797:2: rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 + { + pushFollow(FOLLOW_62); + rule__InfixExpression__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__0__Impl" + // InternalExport.g:9804:1: rule__InfixExpression__Group_1_1__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9808:1: ( ( () ) ) + // InternalExport.g:9809:1: ( () ) + { + // InternalExport.g:9809:1: ( () ) + // InternalExport.g:9810:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + } + // InternalExport.g:9811:2: () + // InternalExport.g:9811:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__1" + // InternalExport.g:9819:1: rule__InfixExpression__Group_1_1__1 : rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ; + public final void rule__InfixExpression__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9823:1: ( rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ) + // InternalExport.g:9824:2: rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 + { + pushFollow(FOLLOW_40); + rule__InfixExpression__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__1__Impl" + // InternalExport.g:9831:1: rule__InfixExpression__Group_1_1__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9835:1: ( ( '.' ) ) + // InternalExport.g:9836:1: ( '.' ) + { + // InternalExport.g:9836:1: ( '.' ) + // InternalExport.g:9837:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__2" + // InternalExport.g:9846:1: rule__InfixExpression__Group_1_1__2 : rule__InfixExpression__Group_1_1__2__Impl ; + public final void rule__InfixExpression__Group_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9850:1: ( rule__InfixExpression__Group_1_1__2__Impl ) + // InternalExport.g:9851:2: rule__InfixExpression__Group_1_1__2__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__2__Impl" + // InternalExport.g:9857:1: rule__InfixExpression__Group_1_1__2__Impl : ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ; + public final void rule__InfixExpression__Group_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9861:1: ( ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ) + // InternalExport.g:9862:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + { + // InternalExport.g:9862:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + // InternalExport.g:9863:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + } + // InternalExport.g:9864:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + // InternalExport.g:9864:3: rule__InfixExpression__TypeAssignment_1_1_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__TypeAssignment_1_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__0" + // InternalExport.g:9873:1: rule__InfixExpression__Group_1_2__0 : rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ; + public final void rule__InfixExpression__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9877:1: ( rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ) + // InternalExport.g:9878:2: rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 + { + pushFollow(FOLLOW_62); + rule__InfixExpression__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__0__Impl" + // InternalExport.g:9885:1: rule__InfixExpression__Group_1_2__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9889:1: ( ( () ) ) + // InternalExport.g:9890:1: ( () ) + { + // InternalExport.g:9890:1: ( () ) + // InternalExport.g:9891:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + } + // InternalExport.g:9892:2: () + // InternalExport.g:9892:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__1" + // InternalExport.g:9900:1: rule__InfixExpression__Group_1_2__1 : rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ; + public final void rule__InfixExpression__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9904:1: ( rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ) + // InternalExport.g:9905:2: rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 + { + pushFollow(FOLLOW_65); + rule__InfixExpression__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__1__Impl" + // InternalExport.g:9912:1: rule__InfixExpression__Group_1_2__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9916:1: ( ( '.' ) ) + // InternalExport.g:9917:1: ( '.' ) + { + // InternalExport.g:9917:1: ( '.' ) + // InternalExport.g:9918:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__2" + // InternalExport.g:9927:1: rule__InfixExpression__Group_1_2__2 : rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ; + public final void rule__InfixExpression__Group_1_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9931:1: ( rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ) + // InternalExport.g:9932:2: rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 + { + pushFollow(FOLLOW_34); + rule__InfixExpression__Group_1_2__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__2__Impl" + // InternalExport.g:9939:1: rule__InfixExpression__Group_1_2__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ; + public final void rule__InfixExpression__Group_1_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9943:1: ( ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ) + // InternalExport.g:9944:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + { + // InternalExport.g:9944:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + // InternalExport.g:9945:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + } + // InternalExport.g:9946:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + // InternalExport.g:9946:3: rule__InfixExpression__NameAssignment_1_2_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_2_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__3" + // InternalExport.g:9954:1: rule__InfixExpression__Group_1_2__3 : rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ; + public final void rule__InfixExpression__Group_1_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9958:1: ( rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ) + // InternalExport.g:9959:2: rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 + { + pushFollow(FOLLOW_40); + rule__InfixExpression__Group_1_2__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__3" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__3__Impl" + // InternalExport.g:9966:1: rule__InfixExpression__Group_1_2__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9970:1: ( ( '(' ) ) + // InternalExport.g:9971:1: ( '(' ) + { + // InternalExport.g:9971:1: ( '(' ) + // InternalExport.g:9972:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__3__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__4" + // InternalExport.g:9981:1: rule__InfixExpression__Group_1_2__4 : rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ; + public final void rule__InfixExpression__Group_1_2__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9985:1: ( rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ) + // InternalExport.g:9986:2: rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 + { + pushFollow(FOLLOW_25); + rule__InfixExpression__Group_1_2__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__4__Impl" + // InternalExport.g:9993:1: rule__InfixExpression__Group_1_2__4__Impl : ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ; + public final void rule__InfixExpression__Group_1_2__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:9997:1: ( ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ) + // InternalExport.g:9998:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + { + // InternalExport.g:9998:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + // InternalExport.g:9999:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + } + // InternalExport.g:10000:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + // InternalExport.g:10000:3: rule__InfixExpression__TypeAssignment_1_2_4 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__TypeAssignment_1_2_4(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__4__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__5" + // InternalExport.g:10008:1: rule__InfixExpression__Group_1_2__5 : rule__InfixExpression__Group_1_2__5__Impl ; + public final void rule__InfixExpression__Group_1_2__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10012:1: ( rule__InfixExpression__Group_1_2__5__Impl ) + // InternalExport.g:10013:2: rule__InfixExpression__Group_1_2__5__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__5__Impl" + // InternalExport.g:10019:1: rule__InfixExpression__Group_1_2__5__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_2__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10023:1: ( ( ')' ) ) + // InternalExport.g:10024:1: ( ')' ) + { + // InternalExport.g:10024:1: ( ')' ) + // InternalExport.g:10025:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__5__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__0" + // InternalExport.g:10035:1: rule__InfixExpression__Group_1_3__0 : rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ; + public final void rule__InfixExpression__Group_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10039:1: ( rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ) + // InternalExport.g:10040:2: rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 + { + pushFollow(FOLLOW_62); + rule__InfixExpression__Group_1_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__0__Impl" + // InternalExport.g:10047:1: rule__InfixExpression__Group_1_3__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10051:1: ( ( () ) ) + // InternalExport.g:10052:1: ( () ) + { + // InternalExport.g:10052:1: ( () ) + // InternalExport.g:10053:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + } + // InternalExport.g:10054:2: () + // InternalExport.g:10054:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__1" + // InternalExport.g:10062:1: rule__InfixExpression__Group_1_3__1 : rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ; + public final void rule__InfixExpression__Group_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10066:1: ( rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ) + // InternalExport.g:10067:2: rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 + { + pushFollow(FOLLOW_66); + rule__InfixExpression__Group_1_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__1__Impl" + // InternalExport.g:10074:1: rule__InfixExpression__Group_1_3__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10078:1: ( ( '.' ) ) + // InternalExport.g:10079:1: ( '.' ) + { + // InternalExport.g:10079:1: ( '.' ) + // InternalExport.g:10080:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__2" + // InternalExport.g:10089:1: rule__InfixExpression__Group_1_3__2 : rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ; + public final void rule__InfixExpression__Group_1_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10093:1: ( rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ) + // InternalExport.g:10094:2: rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 + { + pushFollow(FOLLOW_34); + rule__InfixExpression__Group_1_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__2__Impl" + // InternalExport.g:10101:1: rule__InfixExpression__Group_1_3__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ; + public final void rule__InfixExpression__Group_1_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10105:1: ( ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ) + // InternalExport.g:10106:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + { + // InternalExport.g:10106:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + // InternalExport.g:10107:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); + } + // InternalExport.g:10108:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + // InternalExport.g:10108:3: rule__InfixExpression__NameAssignment_1_3_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_3_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__3" + // InternalExport.g:10116:1: rule__InfixExpression__Group_1_3__3 : rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ; + public final void rule__InfixExpression__Group_1_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10120:1: ( rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ) + // InternalExport.g:10121:2: rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 + { + pushFollow(FOLLOW_18); + rule__InfixExpression__Group_1_3__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__3" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__3__Impl" + // InternalExport.g:10128:1: rule__InfixExpression__Group_1_3__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10132:1: ( ( '(' ) ) + // InternalExport.g:10133:1: ( '(' ) + { + // InternalExport.g:10133:1: ( '(' ) + // InternalExport.g:10134:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__3__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__4" + // InternalExport.g:10143:1: rule__InfixExpression__Group_1_3__4 : rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ; + public final void rule__InfixExpression__Group_1_3__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10147:1: ( rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ) + // InternalExport.g:10148:2: rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 + { + pushFollow(FOLLOW_18); + rule__InfixExpression__Group_1_3__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__4__Impl" + // InternalExport.g:10155:1: rule__InfixExpression__Group_1_3__4__Impl : ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ; + public final void rule__InfixExpression__Group_1_3__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10159:1: ( ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ) + // InternalExport.g:10160:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + { + // InternalExport.g:10160:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + // InternalExport.g:10161:2: ( rule__InfixExpression__Group_1_3_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + } + // InternalExport.g:10162:2: ( rule__InfixExpression__Group_1_3_4__0 )? + int alt101=2; + int LA101_0 = input.LA(1); + + if ( (LA101_0==RULE_ID) ) { + int LA101_1 = input.LA(2); + + if ( (LA101_1==93) ) { + alt101=1; + } + } + switch (alt101) { + case 1 : + // InternalExport.g:10162:3: rule__InfixExpression__Group_1_3_4__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__4__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__5" + // InternalExport.g:10170:1: rule__InfixExpression__Group_1_3__5 : rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ; + public final void rule__InfixExpression__Group_1_3__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10174:1: ( rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ) + // InternalExport.g:10175:2: rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 + { + pushFollow(FOLLOW_25); + rule__InfixExpression__Group_1_3__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__5__Impl" + // InternalExport.g:10182:1: rule__InfixExpression__Group_1_3__5__Impl : ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ; + public final void rule__InfixExpression__Group_1_3__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10186:1: ( ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ) + // InternalExport.g:10187:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + { + // InternalExport.g:10187:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + // InternalExport.g:10188:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + } + // InternalExport.g:10189:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + // InternalExport.g:10189:3: rule__InfixExpression__ExpAssignment_1_3_5 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__ExpAssignment_1_3_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__5__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__6" + // InternalExport.g:10197:1: rule__InfixExpression__Group_1_3__6 : rule__InfixExpression__Group_1_3__6__Impl ; + public final void rule__InfixExpression__Group_1_3__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10201:1: ( rule__InfixExpression__Group_1_3__6__Impl ) + // InternalExport.g:10202:2: rule__InfixExpression__Group_1_3__6__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__6" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__6__Impl" + // InternalExport.g:10208:1: rule__InfixExpression__Group_1_3__6__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_3__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10212:1: ( ( ')' ) ) + // InternalExport.g:10213:1: ( ')' ) + { + // InternalExport.g:10213:1: ( ')' ) + // InternalExport.g:10214:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__6__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__0" + // InternalExport.g:10224:1: rule__InfixExpression__Group_1_3_4__0 : rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ; + public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10228:1: ( rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ) + // InternalExport.g:10229:2: rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 + { + pushFollow(FOLLOW_67); + rule__InfixExpression__Group_1_3_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__0__Impl" + // InternalExport.g:10236:1: rule__InfixExpression__Group_1_3_4__0__Impl : ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ; + public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10240:1: ( ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ) + // InternalExport.g:10241:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + { + // InternalExport.g:10241:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + // InternalExport.g:10242:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + } + // InternalExport.g:10243:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + // InternalExport.g:10243:3: rule__InfixExpression__VarAssignment_1_3_4_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__VarAssignment_1_3_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__1" + // InternalExport.g:10251:1: rule__InfixExpression__Group_1_3_4__1 : rule__InfixExpression__Group_1_3_4__1__Impl ; + public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10255:1: ( rule__InfixExpression__Group_1_3_4__1__Impl ) + // InternalExport.g:10256:2: rule__InfixExpression__Group_1_3_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__1__Impl" + // InternalExport.g:10262:1: rule__InfixExpression__Group_1_3_4__1__Impl : ( '|' ) ; + public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10266:1: ( ( '|' ) ) + // InternalExport.g:10267:1: ( '|' ) + { + // InternalExport.g:10267:1: ( '|' ) + // InternalExport.g:10268:2: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__1__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__0" + // InternalExport.g:10278:1: rule__ParanthesizedExpression__Group__0 : rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ; + public final void rule__ParanthesizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10282:1: ( rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ) + // InternalExport.g:10283:2: rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 + { + pushFollow(FOLLOW_18); + rule__ParanthesizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__0" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__0__Impl" + // InternalExport.g:10290:1: rule__ParanthesizedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__ParanthesizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10294:1: ( ( '(' ) ) + // InternalExport.g:10295:1: ( '(' ) + { + // InternalExport.g:10295:1: ( '(' ) + // InternalExport.g:10296:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__1" + // InternalExport.g:10305:1: rule__ParanthesizedExpression__Group__1 : rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ; + public final void rule__ParanthesizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10309:1: ( rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ) + // InternalExport.g:10310:2: rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 + { + pushFollow(FOLLOW_25); + rule__ParanthesizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__1" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__1__Impl" + // InternalExport.g:10317:1: rule__ParanthesizedExpression__Group__1__Impl : ( ruleExpression ) ; + public final void rule__ParanthesizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10321:1: ( ( ruleExpression ) ) + // InternalExport.g:10322:1: ( ruleExpression ) + { + // InternalExport.g:10322:1: ( ruleExpression ) + // InternalExport.g:10323:2: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__2" + // InternalExport.g:10332:1: rule__ParanthesizedExpression__Group__2 : rule__ParanthesizedExpression__Group__2__Impl ; + public final void rule__ParanthesizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10336:1: ( rule__ParanthesizedExpression__Group__2__Impl ) + // InternalExport.g:10337:2: rule__ParanthesizedExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__2" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__2__Impl" + // InternalExport.g:10343:1: rule__ParanthesizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__ParanthesizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10347:1: ( ( ')' ) ) + // InternalExport.g:10348:1: ( ')' ) + { + // InternalExport.g:10348:1: ( ')' ) + // InternalExport.g:10349:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__GlobalVarExpression__Group__0" + // InternalExport.g:10359:1: rule__GlobalVarExpression__Group__0 : rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ; + public final void rule__GlobalVarExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10363:1: ( rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ) + // InternalExport.g:10364:2: rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 + { + pushFollow(FOLLOW_11); + rule__GlobalVarExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__0" + + + // $ANTLR start "rule__GlobalVarExpression__Group__0__Impl" + // InternalExport.g:10371:1: rule__GlobalVarExpression__Group__0__Impl : ( 'GLOBALVAR' ) ; + public final void rule__GlobalVarExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10375:1: ( ( 'GLOBALVAR' ) ) + // InternalExport.g:10376:1: ( 'GLOBALVAR' ) + { + // InternalExport.g:10376:1: ( 'GLOBALVAR' ) + // InternalExport.g:10377:2: 'GLOBALVAR' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + } + match(input,94,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__0__Impl" + + + // $ANTLR start "rule__GlobalVarExpression__Group__1" + // InternalExport.g:10386:1: rule__GlobalVarExpression__Group__1 : rule__GlobalVarExpression__Group__1__Impl ; + public final void rule__GlobalVarExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10390:1: ( rule__GlobalVarExpression__Group__1__Impl ) + // InternalExport.g:10391:2: rule__GlobalVarExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__1" + + + // $ANTLR start "rule__GlobalVarExpression__Group__1__Impl" + // InternalExport.g:10397:1: rule__GlobalVarExpression__Group__1__Impl : ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ; + public final void rule__GlobalVarExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10401:1: ( ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ) + // InternalExport.g:10402:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + { + // InternalExport.g:10402:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + // InternalExport.g:10403:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + } + // InternalExport.g:10404:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + // InternalExport.g:10404:3: rule__GlobalVarExpression__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group__0" + // InternalExport.g:10413:1: rule__OperationCall__Group__0 : rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ; + public final void rule__OperationCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10417:1: ( rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ) + // InternalExport.g:10418:2: rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 + { + pushFollow(FOLLOW_34); + rule__OperationCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__0" + + + // $ANTLR start "rule__OperationCall__Group__0__Impl" + // InternalExport.g:10425:1: rule__OperationCall__Group__0__Impl : ( ( rule__OperationCall__NameAssignment_0 ) ) ; + public final void rule__OperationCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10429:1: ( ( ( rule__OperationCall__NameAssignment_0 ) ) ) + // InternalExport.g:10430:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + { + // InternalExport.g:10430:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + // InternalExport.g:10431:2: ( rule__OperationCall__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + } + // InternalExport.g:10432:2: ( rule__OperationCall__NameAssignment_0 ) + // InternalExport.g:10432:3: rule__OperationCall__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group__1" + // InternalExport.g:10440:1: rule__OperationCall__Group__1 : rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ; + public final void rule__OperationCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10444:1: ( rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ) + // InternalExport.g:10445:2: rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 + { + pushFollow(FOLLOW_64); + rule__OperationCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__1" + + + // $ANTLR start "rule__OperationCall__Group__1__Impl" + // InternalExport.g:10452:1: rule__OperationCall__Group__1__Impl : ( '(' ) ; + public final void rule__OperationCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10456:1: ( ( '(' ) ) + // InternalExport.g:10457:1: ( '(' ) + { + // InternalExport.g:10457:1: ( '(' ) + // InternalExport.g:10458:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group__2" + // InternalExport.g:10467:1: rule__OperationCall__Group__2 : rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ; + public final void rule__OperationCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10471:1: ( rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ) + // InternalExport.g:10472:2: rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 + { + pushFollow(FOLLOW_64); + rule__OperationCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__2" + + + // $ANTLR start "rule__OperationCall__Group__2__Impl" + // InternalExport.g:10479:1: rule__OperationCall__Group__2__Impl : ( ( rule__OperationCall__Group_2__0 )? ) ; + public final void rule__OperationCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10483:1: ( ( ( rule__OperationCall__Group_2__0 )? ) ) + // InternalExport.g:10484:1: ( ( rule__OperationCall__Group_2__0 )? ) + { + // InternalExport.g:10484:1: ( ( rule__OperationCall__Group_2__0 )? ) + // InternalExport.g:10485:2: ( rule__OperationCall__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getGroup_2()); + } + // InternalExport.g:10486:2: ( rule__OperationCall__Group_2__0 )? + int alt102=2; + int LA102_0 = input.LA(1); + + if ( (LA102_0==RULE_ID||LA102_0==RULE_INT||(LA102_0>=RULE_STRING && LA102_0<=RULE_REAL)||LA102_0==24||(LA102_0>=27 && LA102_0<=40)||LA102_0==68||LA102_0==77||LA102_0==84||LA102_0==87||LA102_0==90||(LA102_0>=94 && LA102_0<=95)||LA102_0==100||LA102_0==115) ) { + alt102=1; + } + switch (alt102) { + case 1 : + // InternalExport.g:10486:3: rule__OperationCall__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__2__Impl" + + + // $ANTLR start "rule__OperationCall__Group__3" + // InternalExport.g:10494:1: rule__OperationCall__Group__3 : rule__OperationCall__Group__3__Impl ; + public final void rule__OperationCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10498:1: ( rule__OperationCall__Group__3__Impl ) + // InternalExport.g:10499:2: rule__OperationCall__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__3" + + + // $ANTLR start "rule__OperationCall__Group__3__Impl" + // InternalExport.g:10505:1: rule__OperationCall__Group__3__Impl : ( ')' ) ; + public final void rule__OperationCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10509:1: ( ( ')' ) ) + // InternalExport.g:10510:1: ( ')' ) + { + // InternalExport.g:10510:1: ( ')' ) + // InternalExport.g:10511:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__3__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2__0" + // InternalExport.g:10521:1: rule__OperationCall__Group_2__0 : rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ; + public final void rule__OperationCall__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10525:1: ( rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ) + // InternalExport.g:10526:2: rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 + { + pushFollow(FOLLOW_21); + rule__OperationCall__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__0" + + + // $ANTLR start "rule__OperationCall__Group_2__0__Impl" + // InternalExport.g:10533:1: rule__OperationCall__Group_2__0__Impl : ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ; + public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10537:1: ( ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ) + // InternalExport.g:10538:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + { + // InternalExport.g:10538:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + // InternalExport.g:10539:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + } + // InternalExport.g:10540:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + // InternalExport.g:10540:3: rule__OperationCall__ParamsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__ParamsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2__1" + // InternalExport.g:10548:1: rule__OperationCall__Group_2__1 : rule__OperationCall__Group_2__1__Impl ; + public final void rule__OperationCall__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10552:1: ( rule__OperationCall__Group_2__1__Impl ) + // InternalExport.g:10553:2: rule__OperationCall__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__1" + + + // $ANTLR start "rule__OperationCall__Group_2__1__Impl" + // InternalExport.g:10559:1: rule__OperationCall__Group_2__1__Impl : ( ( rule__OperationCall__Group_2_1__0 )* ) ; + public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10563:1: ( ( ( rule__OperationCall__Group_2_1__0 )* ) ) + // InternalExport.g:10564:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + { + // InternalExport.g:10564:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + // InternalExport.g:10565:2: ( rule__OperationCall__Group_2_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getGroup_2_1()); + } + // InternalExport.g:10566:2: ( rule__OperationCall__Group_2_1__0 )* + loop103: + do { + int alt103=2; + int LA103_0 = input.LA(1); + + if ( (LA103_0==74) ) { + alt103=1; + } + + + switch (alt103) { + case 1 : + // InternalExport.g:10566:3: rule__OperationCall__Group_2_1__0 + { + pushFollow(FOLLOW_22); + rule__OperationCall__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop103; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getGroup_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2_1__0" + // InternalExport.g:10575:1: rule__OperationCall__Group_2_1__0 : rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ; + public final void rule__OperationCall__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10579:1: ( rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ) + // InternalExport.g:10580:2: rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 + { + pushFollow(FOLLOW_18); + rule__OperationCall__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__0" + + + // $ANTLR start "rule__OperationCall__Group_2_1__0__Impl" + // InternalExport.g:10587:1: rule__OperationCall__Group_2_1__0__Impl : ( ',' ) ; + public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10591:1: ( ( ',' ) ) + // InternalExport.g:10592:1: ( ',' ) + { + // InternalExport.g:10592:1: ( ',' ) + // InternalExport.g:10593:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2_1__1" + // InternalExport.g:10602:1: rule__OperationCall__Group_2_1__1 : rule__OperationCall__Group_2_1__1__Impl ; + public final void rule__OperationCall__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10606:1: ( rule__OperationCall__Group_2_1__1__Impl ) + // InternalExport.g:10607:2: rule__OperationCall__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__1" + + + // $ANTLR start "rule__OperationCall__Group_2_1__1__Impl" + // InternalExport.g:10613:1: rule__OperationCall__Group_2_1__1__Impl : ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ; + public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10617:1: ( ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ) + // InternalExport.g:10618:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + { + // InternalExport.g:10618:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + // InternalExport.g:10619:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + } + // InternalExport.g:10620:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + // InternalExport.g:10620:3: rule__OperationCall__ParamsAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__OperationCall__ParamsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__0" + // InternalExport.g:10629:1: rule__ListLiteral__Group__0 : rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ; + public final void rule__ListLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10633:1: ( rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ) + // InternalExport.g:10634:2: rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 + { + pushFollow(FOLLOW_12); + rule__ListLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__0" + + + // $ANTLR start "rule__ListLiteral__Group__0__Impl" + // InternalExport.g:10641:1: rule__ListLiteral__Group__0__Impl : ( () ) ; + public final void rule__ListLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10645:1: ( ( () ) ) + // InternalExport.g:10646:1: ( () ) + { + // InternalExport.g:10646:1: ( () ) + // InternalExport.g:10647:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + } + // InternalExport.g:10648:2: () + // InternalExport.g:10648:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__1" + // InternalExport.g:10656:1: rule__ListLiteral__Group__1 : rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ; + public final void rule__ListLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10660:1: ( rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ) + // InternalExport.g:10661:2: rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 + { + pushFollow(FOLLOW_68); + rule__ListLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__1" + + + // $ANTLR start "rule__ListLiteral__Group__1__Impl" + // InternalExport.g:10668:1: rule__ListLiteral__Group__1__Impl : ( '{' ) ; + public final void rule__ListLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10672:1: ( ( '{' ) ) + // InternalExport.g:10673:1: ( '{' ) + { + // InternalExport.g:10673:1: ( '{' ) + // InternalExport.g:10674:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__2" + // InternalExport.g:10683:1: rule__ListLiteral__Group__2 : rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ; + public final void rule__ListLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10687:1: ( rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ) + // InternalExport.g:10688:2: rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 + { + pushFollow(FOLLOW_68); + rule__ListLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__2" + + + // $ANTLR start "rule__ListLiteral__Group__2__Impl" + // InternalExport.g:10695:1: rule__ListLiteral__Group__2__Impl : ( ( rule__ListLiteral__Group_2__0 )? ) ; + public final void rule__ListLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10699:1: ( ( ( rule__ListLiteral__Group_2__0 )? ) ) + // InternalExport.g:10700:1: ( ( rule__ListLiteral__Group_2__0 )? ) + { + // InternalExport.g:10700:1: ( ( rule__ListLiteral__Group_2__0 )? ) + // InternalExport.g:10701:2: ( rule__ListLiteral__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getGroup_2()); + } + // InternalExport.g:10702:2: ( rule__ListLiteral__Group_2__0 )? + int alt104=2; + int LA104_0 = input.LA(1); + + if ( (LA104_0==RULE_ID||LA104_0==RULE_INT||(LA104_0>=RULE_STRING && LA104_0<=RULE_REAL)||LA104_0==24||(LA104_0>=27 && LA104_0<=40)||LA104_0==68||LA104_0==77||LA104_0==84||LA104_0==87||LA104_0==90||(LA104_0>=94 && LA104_0<=95)||LA104_0==100||LA104_0==115) ) { + alt104=1; + } + switch (alt104) { + case 1 : + // InternalExport.g:10702:3: rule__ListLiteral__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__2__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__3" + // InternalExport.g:10710:1: rule__ListLiteral__Group__3 : rule__ListLiteral__Group__3__Impl ; + public final void rule__ListLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10714:1: ( rule__ListLiteral__Group__3__Impl ) + // InternalExport.g:10715:2: rule__ListLiteral__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__3" + + + // $ANTLR start "rule__ListLiteral__Group__3__Impl" + // InternalExport.g:10721:1: rule__ListLiteral__Group__3__Impl : ( '}' ) ; + public final void rule__ListLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10725:1: ( ( '}' ) ) + // InternalExport.g:10726:1: ( '}' ) + { + // InternalExport.g:10726:1: ( '}' ) + // InternalExport.g:10727:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + } + match(input,69,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__3__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2__0" + // InternalExport.g:10737:1: rule__ListLiteral__Group_2__0 : rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ; + public final void rule__ListLiteral__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10741:1: ( rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ) + // InternalExport.g:10742:2: rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 + { + pushFollow(FOLLOW_21); + rule__ListLiteral__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__0" + + + // $ANTLR start "rule__ListLiteral__Group_2__0__Impl" + // InternalExport.g:10749:1: rule__ListLiteral__Group_2__0__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ; + public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10753:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ) + // InternalExport.g:10754:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + { + // InternalExport.g:10754:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + // InternalExport.g:10755:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + } + // InternalExport.g:10756:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + // InternalExport.g:10756:3: rule__ListLiteral__ElementsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__ElementsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2__1" + // InternalExport.g:10764:1: rule__ListLiteral__Group_2__1 : rule__ListLiteral__Group_2__1__Impl ; + public final void rule__ListLiteral__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10768:1: ( rule__ListLiteral__Group_2__1__Impl ) + // InternalExport.g:10769:2: rule__ListLiteral__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__1" + + + // $ANTLR start "rule__ListLiteral__Group_2__1__Impl" + // InternalExport.g:10775:1: rule__ListLiteral__Group_2__1__Impl : ( ( rule__ListLiteral__Group_2_1__0 )* ) ; + public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10779:1: ( ( ( rule__ListLiteral__Group_2_1__0 )* ) ) + // InternalExport.g:10780:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + { + // InternalExport.g:10780:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + // InternalExport.g:10781:2: ( rule__ListLiteral__Group_2_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getGroup_2_1()); + } + // InternalExport.g:10782:2: ( rule__ListLiteral__Group_2_1__0 )* + loop105: + do { + int alt105=2; + int LA105_0 = input.LA(1); + + if ( (LA105_0==74) ) { + alt105=1; + } + + + switch (alt105) { + case 1 : + // InternalExport.g:10782:3: rule__ListLiteral__Group_2_1__0 + { + pushFollow(FOLLOW_22); + rule__ListLiteral__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop105; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getGroup_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__0" + // InternalExport.g:10791:1: rule__ListLiteral__Group_2_1__0 : rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ; + public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10795:1: ( rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ) + // InternalExport.g:10796:2: rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 + { + pushFollow(FOLLOW_18); + rule__ListLiteral__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__0" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__0__Impl" + // InternalExport.g:10803:1: rule__ListLiteral__Group_2_1__0__Impl : ( ',' ) ; + public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10807:1: ( ( ',' ) ) + // InternalExport.g:10808:1: ( ',' ) + { + // InternalExport.g:10808:1: ( ',' ) + // InternalExport.g:10809:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__1" + // InternalExport.g:10818:1: rule__ListLiteral__Group_2_1__1 : rule__ListLiteral__Group_2_1__1__Impl ; + public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10822:1: ( rule__ListLiteral__Group_2_1__1__Impl ) + // InternalExport.g:10823:2: rule__ListLiteral__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__1" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__1__Impl" + // InternalExport.g:10829:1: rule__ListLiteral__Group_2_1__1__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ; + public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10833:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ) + // InternalExport.g:10834:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + { + // InternalExport.g:10834:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + // InternalExport.g:10835:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + } + // InternalExport.g:10836:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + // InternalExport.g:10836:3: rule__ListLiteral__ElementsAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__ElementsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__1__Impl" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__0" + // InternalExport.g:10845:1: rule__ConstructorCallExpression__Group__0 : rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ; + public final void rule__ConstructorCallExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10849:1: ( rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ) + // InternalExport.g:10850:2: rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 + { + pushFollow(FOLLOW_40); + rule__ConstructorCallExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__0" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__0__Impl" + // InternalExport.g:10857:1: rule__ConstructorCallExpression__Group__0__Impl : ( 'new' ) ; + public final void rule__ConstructorCallExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10861:1: ( ( 'new' ) ) + // InternalExport.g:10862:1: ( 'new' ) + { + // InternalExport.g:10862:1: ( 'new' ) + // InternalExport.g:10863:2: 'new' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__0__Impl" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__1" + // InternalExport.g:10872:1: rule__ConstructorCallExpression__Group__1 : rule__ConstructorCallExpression__Group__1__Impl ; + public final void rule__ConstructorCallExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10876:1: ( rule__ConstructorCallExpression__Group__1__Impl ) + // InternalExport.g:10877:2: rule__ConstructorCallExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__1" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__1__Impl" + // InternalExport.g:10883:1: rule__ConstructorCallExpression__Group__1__Impl : ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ; + public final void rule__ConstructorCallExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10887:1: ( ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ) + // InternalExport.g:10888:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + { + // InternalExport.g:10888:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + // InternalExport.g:10889:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + } + // InternalExport.g:10890:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + // InternalExport.g:10890:3: rule__ConstructorCallExpression__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__TypeAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__1__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__0" + // InternalExport.g:10899:1: rule__TypeSelectExpression__Group__0 : rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ; + public final void rule__TypeSelectExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10903:1: ( rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ) + // InternalExport.g:10904:2: rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 + { + pushFollow(FOLLOW_34); + rule__TypeSelectExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__0" + + + // $ANTLR start "rule__TypeSelectExpression__Group__0__Impl" + // InternalExport.g:10911:1: rule__TypeSelectExpression__Group__0__Impl : ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ; + public final void rule__TypeSelectExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10915:1: ( ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ) + // InternalExport.g:10916:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + { + // InternalExport.g:10916:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + // InternalExport.g:10917:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + } + // InternalExport.g:10918:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + // InternalExport.g:10918:3: rule__TypeSelectExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__0__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__1" + // InternalExport.g:10926:1: rule__TypeSelectExpression__Group__1 : rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ; + public final void rule__TypeSelectExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10930:1: ( rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ) + // InternalExport.g:10931:2: rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 + { + pushFollow(FOLLOW_40); + rule__TypeSelectExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__1" + + + // $ANTLR start "rule__TypeSelectExpression__Group__1__Impl" + // InternalExport.g:10938:1: rule__TypeSelectExpression__Group__1__Impl : ( '(' ) ; + public final void rule__TypeSelectExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10942:1: ( ( '(' ) ) + // InternalExport.g:10943:1: ( '(' ) + { + // InternalExport.g:10943:1: ( '(' ) + // InternalExport.g:10944:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__1__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__2" + // InternalExport.g:10953:1: rule__TypeSelectExpression__Group__2 : rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ; + public final void rule__TypeSelectExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10957:1: ( rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ) + // InternalExport.g:10958:2: rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 + { + pushFollow(FOLLOW_25); + rule__TypeSelectExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__2" + + + // $ANTLR start "rule__TypeSelectExpression__Group__2__Impl" + // InternalExport.g:10965:1: rule__TypeSelectExpression__Group__2__Impl : ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ; + public final void rule__TypeSelectExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10969:1: ( ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ) + // InternalExport.g:10970:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + { + // InternalExport.g:10970:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + // InternalExport.g:10971:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + } + // InternalExport.g:10972:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + // InternalExport.g:10972:3: rule__TypeSelectExpression__TypeAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__TypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__2__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__3" + // InternalExport.g:10980:1: rule__TypeSelectExpression__Group__3 : rule__TypeSelectExpression__Group__3__Impl ; + public final void rule__TypeSelectExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10984:1: ( rule__TypeSelectExpression__Group__3__Impl ) + // InternalExport.g:10985:2: rule__TypeSelectExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__3" + + + // $ANTLR start "rule__TypeSelectExpression__Group__3__Impl" + // InternalExport.g:10991:1: rule__TypeSelectExpression__Group__3__Impl : ( ')' ) ; + public final void rule__TypeSelectExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:10995:1: ( ( ')' ) ) + // InternalExport.g:10996:1: ( ')' ) + { + // InternalExport.g:10996:1: ( ')' ) + // InternalExport.g:10997:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__3__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__0" + // InternalExport.g:11007:1: rule__CollectionExpression__Group__0 : rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ; + public final void rule__CollectionExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11011:1: ( rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ) + // InternalExport.g:11012:2: rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 + { + pushFollow(FOLLOW_34); + rule__CollectionExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__0" + + + // $ANTLR start "rule__CollectionExpression__Group__0__Impl" + // InternalExport.g:11019:1: rule__CollectionExpression__Group__0__Impl : ( ( rule__CollectionExpression__NameAssignment_0 ) ) ; + public final void rule__CollectionExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11023:1: ( ( ( rule__CollectionExpression__NameAssignment_0 ) ) ) + // InternalExport.g:11024:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + { + // InternalExport.g:11024:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + // InternalExport.g:11025:2: ( rule__CollectionExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + } + // InternalExport.g:11026:2: ( rule__CollectionExpression__NameAssignment_0 ) + // InternalExport.g:11026:3: rule__CollectionExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__0__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__1" + // InternalExport.g:11034:1: rule__CollectionExpression__Group__1 : rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ; + public final void rule__CollectionExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11038:1: ( rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ) + // InternalExport.g:11039:2: rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 + { + pushFollow(FOLLOW_18); + rule__CollectionExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__1" + + + // $ANTLR start "rule__CollectionExpression__Group__1__Impl" + // InternalExport.g:11046:1: rule__CollectionExpression__Group__1__Impl : ( '(' ) ; + public final void rule__CollectionExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11050:1: ( ( '(' ) ) + // InternalExport.g:11051:1: ( '(' ) + { + // InternalExport.g:11051:1: ( '(' ) + // InternalExport.g:11052:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__1__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__2" + // InternalExport.g:11061:1: rule__CollectionExpression__Group__2 : rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ; + public final void rule__CollectionExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11065:1: ( rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ) + // InternalExport.g:11066:2: rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 + { + pushFollow(FOLLOW_18); + rule__CollectionExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__2" + + + // $ANTLR start "rule__CollectionExpression__Group__2__Impl" + // InternalExport.g:11073:1: rule__CollectionExpression__Group__2__Impl : ( ( rule__CollectionExpression__Group_2__0 )? ) ; + public final void rule__CollectionExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11077:1: ( ( ( rule__CollectionExpression__Group_2__0 )? ) ) + // InternalExport.g:11078:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + { + // InternalExport.g:11078:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + // InternalExport.g:11079:2: ( rule__CollectionExpression__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + } + // InternalExport.g:11080:2: ( rule__CollectionExpression__Group_2__0 )? + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==RULE_ID) ) { + int LA106_1 = input.LA(2); + + if ( (LA106_1==93) ) { + alt106=1; + } + } + switch (alt106) { + case 1 : + // InternalExport.g:11080:3: rule__CollectionExpression__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__2__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__3" + // InternalExport.g:11088:1: rule__CollectionExpression__Group__3 : rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ; + public final void rule__CollectionExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11092:1: ( rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ) + // InternalExport.g:11093:2: rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 + { + pushFollow(FOLLOW_25); + rule__CollectionExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__3" + + + // $ANTLR start "rule__CollectionExpression__Group__3__Impl" + // InternalExport.g:11100:1: rule__CollectionExpression__Group__3__Impl : ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ; + public final void rule__CollectionExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11104:1: ( ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ) + // InternalExport.g:11105:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + { + // InternalExport.g:11105:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + // InternalExport.g:11106:2: ( rule__CollectionExpression__ExpAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + } + // InternalExport.g:11107:2: ( rule__CollectionExpression__ExpAssignment_3 ) + // InternalExport.g:11107:3: rule__CollectionExpression__ExpAssignment_3 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__ExpAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__3__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__4" + // InternalExport.g:11115:1: rule__CollectionExpression__Group__4 : rule__CollectionExpression__Group__4__Impl ; + public final void rule__CollectionExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11119:1: ( rule__CollectionExpression__Group__4__Impl ) + // InternalExport.g:11120:2: rule__CollectionExpression__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__4" + + + // $ANTLR start "rule__CollectionExpression__Group__4__Impl" + // InternalExport.g:11126:1: rule__CollectionExpression__Group__4__Impl : ( ')' ) ; + public final void rule__CollectionExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11130:1: ( ( ')' ) ) + // InternalExport.g:11131:1: ( ')' ) + { + // InternalExport.g:11131:1: ( ')' ) + // InternalExport.g:11132:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__4__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group_2__0" + // InternalExport.g:11142:1: rule__CollectionExpression__Group_2__0 : rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ; + public final void rule__CollectionExpression__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11146:1: ( rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ) + // InternalExport.g:11147:2: rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 + { + pushFollow(FOLLOW_67); + rule__CollectionExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__0" + + + // $ANTLR start "rule__CollectionExpression__Group_2__0__Impl" + // InternalExport.g:11154:1: rule__CollectionExpression__Group_2__0__Impl : ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ; + public final void rule__CollectionExpression__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11158:1: ( ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ) + // InternalExport.g:11159:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + { + // InternalExport.g:11159:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + // InternalExport.g:11160:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + } + // InternalExport.g:11161:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + // InternalExport.g:11161:3: rule__CollectionExpression__VarAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__VarAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__0__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group_2__1" + // InternalExport.g:11169:1: rule__CollectionExpression__Group_2__1 : rule__CollectionExpression__Group_2__1__Impl ; + public final void rule__CollectionExpression__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11173:1: ( rule__CollectionExpression__Group_2__1__Impl ) + // InternalExport.g:11174:2: rule__CollectionExpression__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__1" + + + // $ANTLR start "rule__CollectionExpression__Group_2__1__Impl" + // InternalExport.g:11180:1: rule__CollectionExpression__Group_2__1__Impl : ( '|' ) ; + public final void rule__CollectionExpression__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11184:1: ( ( '|' ) ) + // InternalExport.g:11185:1: ( '|' ) + { + // InternalExport.g:11185:1: ( '|' ) + // InternalExport.g:11186:2: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__1__Impl" + + + // $ANTLR start "rule__CollectionType__Group__0" + // InternalExport.g:11196:1: rule__CollectionType__Group__0 : rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ; + public final void rule__CollectionType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11200:1: ( rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ) + // InternalExport.g:11201:2: rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 + { + pushFollow(FOLLOW_30); + rule__CollectionType__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__0" + + + // $ANTLR start "rule__CollectionType__Group__0__Impl" + // InternalExport.g:11208:1: rule__CollectionType__Group__0__Impl : ( ( rule__CollectionType__ClAssignment_0 ) ) ; + public final void rule__CollectionType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11212:1: ( ( ( rule__CollectionType__ClAssignment_0 ) ) ) + // InternalExport.g:11213:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + { + // InternalExport.g:11213:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + // InternalExport.g:11214:2: ( rule__CollectionType__ClAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + } + // InternalExport.g:11215:2: ( rule__CollectionType__ClAssignment_0 ) + // InternalExport.g:11215:3: rule__CollectionType__ClAssignment_0 + { + pushFollow(FOLLOW_2); + rule__CollectionType__ClAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__0__Impl" + + + // $ANTLR start "rule__CollectionType__Group__1" + // InternalExport.g:11223:1: rule__CollectionType__Group__1 : rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ; + public final void rule__CollectionType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11227:1: ( rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ) + // InternalExport.g:11228:2: rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 + { + pushFollow(FOLLOW_40); + rule__CollectionType__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__1" + + + // $ANTLR start "rule__CollectionType__Group__1__Impl" + // InternalExport.g:11235:1: rule__CollectionType__Group__1__Impl : ( '[' ) ; + public final void rule__CollectionType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11239:1: ( ( '[' ) ) + // InternalExport.g:11240:1: ( '[' ) + { + // InternalExport.g:11240:1: ( '[' ) + // InternalExport.g:11241:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__1__Impl" + + + // $ANTLR start "rule__CollectionType__Group__2" + // InternalExport.g:11250:1: rule__CollectionType__Group__2 : rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ; + public final void rule__CollectionType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11254:1: ( rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ) + // InternalExport.g:11255:2: rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 + { + pushFollow(FOLLOW_19); + rule__CollectionType__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__2" + + + // $ANTLR start "rule__CollectionType__Group__2__Impl" + // InternalExport.g:11262:1: rule__CollectionType__Group__2__Impl : ( ( rule__CollectionType__Id1Assignment_2 ) ) ; + public final void rule__CollectionType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11266:1: ( ( ( rule__CollectionType__Id1Assignment_2 ) ) ) + // InternalExport.g:11267:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + { + // InternalExport.g:11267:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + // InternalExport.g:11268:2: ( rule__CollectionType__Id1Assignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + } + // InternalExport.g:11269:2: ( rule__CollectionType__Id1Assignment_2 ) + // InternalExport.g:11269:3: rule__CollectionType__Id1Assignment_2 + { + pushFollow(FOLLOW_2); + rule__CollectionType__Id1Assignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__2__Impl" + + + // $ANTLR start "rule__CollectionType__Group__3" + // InternalExport.g:11277:1: rule__CollectionType__Group__3 : rule__CollectionType__Group__3__Impl ; + public final void rule__CollectionType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11281:1: ( rule__CollectionType__Group__3__Impl ) + // InternalExport.g:11282:2: rule__CollectionType__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionType__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__3" + + + // $ANTLR start "rule__CollectionType__Group__3__Impl" + // InternalExport.g:11288:1: rule__CollectionType__Group__3__Impl : ( ']' ) ; + public final void rule__CollectionType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11292:1: ( ( ']' ) ) + // InternalExport.g:11293:1: ( ']' ) + { + // InternalExport.g:11293:1: ( ']' ) + // InternalExport.g:11294:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__3__Impl" + + + // $ANTLR start "rule__SimpleType__Group__0" + // InternalExport.g:11304:1: rule__SimpleType__Group__0 : rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ; + public final void rule__SimpleType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11308:1: ( rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ) + // InternalExport.g:11309:2: rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 + { + pushFollow(FOLLOW_37); + rule__SimpleType__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SimpleType__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__0" + + + // $ANTLR start "rule__SimpleType__Group__0__Impl" + // InternalExport.g:11316:1: rule__SimpleType__Group__0__Impl : ( ( rule__SimpleType__IdAssignment_0 ) ) ; + public final void rule__SimpleType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11320:1: ( ( ( rule__SimpleType__IdAssignment_0 ) ) ) + // InternalExport.g:11321:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + { + // InternalExport.g:11321:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + // InternalExport.g:11322:2: ( rule__SimpleType__IdAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + } + // InternalExport.g:11323:2: ( rule__SimpleType__IdAssignment_0 ) + // InternalExport.g:11323:3: rule__SimpleType__IdAssignment_0 + { + pushFollow(FOLLOW_2); + rule__SimpleType__IdAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__0__Impl" + + + // $ANTLR start "rule__SimpleType__Group__1" + // InternalExport.g:11331:1: rule__SimpleType__Group__1 : rule__SimpleType__Group__1__Impl ; + public final void rule__SimpleType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11335:1: ( rule__SimpleType__Group__1__Impl ) + // InternalExport.g:11336:2: rule__SimpleType__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__SimpleType__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__1" + + + // $ANTLR start "rule__SimpleType__Group__1__Impl" + // InternalExport.g:11342:1: rule__SimpleType__Group__1__Impl : ( ( rule__SimpleType__Group_1__0 )* ) ; + public final void rule__SimpleType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11346:1: ( ( ( rule__SimpleType__Group_1__0 )* ) ) + // InternalExport.g:11347:1: ( ( rule__SimpleType__Group_1__0 )* ) + { + // InternalExport.g:11347:1: ( ( rule__SimpleType__Group_1__0 )* ) + // InternalExport.g:11348:2: ( rule__SimpleType__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getGroup_1()); + } + // InternalExport.g:11349:2: ( rule__SimpleType__Group_1__0 )* + loop107: + do { + int alt107=2; + int LA107_0 = input.LA(1); + + if ( (LA107_0==83) ) { + alt107=1; + } + + + switch (alt107) { + case 1 : + // InternalExport.g:11349:3: rule__SimpleType__Group_1__0 + { + pushFollow(FOLLOW_38); + rule__SimpleType__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop107; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__1__Impl" + + + // $ANTLR start "rule__SimpleType__Group_1__0" + // InternalExport.g:11358:1: rule__SimpleType__Group_1__0 : rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ; + public final void rule__SimpleType__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11362:1: ( rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ) + // InternalExport.g:11363:2: rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 + { + pushFollow(FOLLOW_11); + rule__SimpleType__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SimpleType__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__0" + + + // $ANTLR start "rule__SimpleType__Group_1__0__Impl" + // InternalExport.g:11370:1: rule__SimpleType__Group_1__0__Impl : ( '::' ) ; + public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11374:1: ( ( '::' ) ) + // InternalExport.g:11375:1: ( '::' ) + { + // InternalExport.g:11375:1: ( '::' ) + // InternalExport.g:11376:2: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__0__Impl" + + + // $ANTLR start "rule__SimpleType__Group_1__1" + // InternalExport.g:11385:1: rule__SimpleType__Group_1__1 : rule__SimpleType__Group_1__1__Impl ; + public final void rule__SimpleType__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11389:1: ( rule__SimpleType__Group_1__1__Impl ) + // InternalExport.g:11390:2: rule__SimpleType__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__SimpleType__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__1" + + + // $ANTLR start "rule__SimpleType__Group_1__1__Impl" + // InternalExport.g:11396:1: rule__SimpleType__Group_1__1__Impl : ( ( rule__SimpleType__IdAssignment_1_1 ) ) ; + public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11400:1: ( ( ( rule__SimpleType__IdAssignment_1_1 ) ) ) + // InternalExport.g:11401:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + { + // InternalExport.g:11401:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + // InternalExport.g:11402:2: ( rule__SimpleType__IdAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + } + // InternalExport.g:11403:2: ( rule__SimpleType__IdAssignment_1_1 ) + // InternalExport.g:11403:3: rule__SimpleType__IdAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__SimpleType__IdAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__0" + // InternalExport.g:11412:1: rule__XAssignment__Group_0__0 : rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ; + public final void rule__XAssignment__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11416:1: ( rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ) + // InternalExport.g:11417:2: rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 + { + pushFollow(FOLLOW_69); + rule__XAssignment__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__0" + + + // $ANTLR start "rule__XAssignment__Group_0__0__Impl" + // InternalExport.g:11424:1: rule__XAssignment__Group_0__0__Impl : ( () ) ; + public final void rule__XAssignment__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11428:1: ( ( () ) ) + // InternalExport.g:11429:1: ( () ) + { + // InternalExport.g:11429:1: ( () ) + // InternalExport.g:11430:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); + } + // InternalExport.g:11431:2: () + // InternalExport.g:11431:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__1" + // InternalExport.g:11439:1: rule__XAssignment__Group_0__1 : rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ; + public final void rule__XAssignment__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11443:1: ( rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ) + // InternalExport.g:11444:2: rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 + { + pushFollow(FOLLOW_32); + rule__XAssignment__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__1" + + + // $ANTLR start "rule__XAssignment__Group_0__1__Impl" + // InternalExport.g:11451:1: rule__XAssignment__Group_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ; + public final void rule__XAssignment__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11455:1: ( ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ) + // InternalExport.g:11456:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) + { + // InternalExport.g:11456:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) + // InternalExport.g:11457:2: ( rule__XAssignment__FeatureAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); + } + // InternalExport.g:11458:2: ( rule__XAssignment__FeatureAssignment_0_1 ) + // InternalExport.g:11458:3: rule__XAssignment__FeatureAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__FeatureAssignment_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__2" + // InternalExport.g:11466:1: rule__XAssignment__Group_0__2 : rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ; + public final void rule__XAssignment__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11470:1: ( rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ) + // InternalExport.g:11471:2: rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 + { + pushFollow(FOLLOW_70); + rule__XAssignment__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__2" + + + // $ANTLR start "rule__XAssignment__Group_0__2__Impl" + // InternalExport.g:11478:1: rule__XAssignment__Group_0__2__Impl : ( ruleOpSingleAssign ) ; + public final void rule__XAssignment__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11482:1: ( ( ruleOpSingleAssign ) ) + // InternalExport.g:11483:1: ( ruleOpSingleAssign ) + { + // InternalExport.g:11483:1: ( ruleOpSingleAssign ) + // InternalExport.g:11484:2: ruleOpSingleAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__2__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__3" + // InternalExport.g:11493:1: rule__XAssignment__Group_0__3 : rule__XAssignment__Group_0__3__Impl ; + public final void rule__XAssignment__Group_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11497:1: ( rule__XAssignment__Group_0__3__Impl ) + // InternalExport.g:11498:2: rule__XAssignment__Group_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__3" + + + // $ANTLR start "rule__XAssignment__Group_0__3__Impl" + // InternalExport.g:11504:1: rule__XAssignment__Group_0__3__Impl : ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ; + public final void rule__XAssignment__Group_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11508:1: ( ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ) + // InternalExport.g:11509:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) ) + { + // InternalExport.g:11509:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) ) + // InternalExport.g:11510:2: ( rule__XAssignment__ValueAssignment_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); + } + // InternalExport.g:11511:2: ( rule__XAssignment__ValueAssignment_0_3 ) + // InternalExport.g:11511:3: rule__XAssignment__ValueAssignment_0_3 + { + pushFollow(FOLLOW_2); + rule__XAssignment__ValueAssignment_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__3__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1__0" + // InternalExport.g:11520:1: rule__XAssignment__Group_1__0 : rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ; + public final void rule__XAssignment__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11524:1: ( rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ) + // InternalExport.g:11525:2: rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 + { + pushFollow(FOLLOW_71); + rule__XAssignment__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__0" + + + // $ANTLR start "rule__XAssignment__Group_1__0__Impl" + // InternalExport.g:11532:1: rule__XAssignment__Group_1__0__Impl : ( ruleXOrExpression ) ; + public final void rule__XAssignment__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11536:1: ( ( ruleXOrExpression ) ) + // InternalExport.g:11537:1: ( ruleXOrExpression ) + { + // InternalExport.g:11537:1: ( ruleXOrExpression ) + // InternalExport.g:11538:2: ruleXOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1__1" + // InternalExport.g:11547:1: rule__XAssignment__Group_1__1 : rule__XAssignment__Group_1__1__Impl ; + public final void rule__XAssignment__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11551:1: ( rule__XAssignment__Group_1__1__Impl ) + // InternalExport.g:11552:2: rule__XAssignment__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__1" + + + // $ANTLR start "rule__XAssignment__Group_1__1__Impl" + // InternalExport.g:11558:1: rule__XAssignment__Group_1__1__Impl : ( ( rule__XAssignment__Group_1_1__0 )? ) ; + public final void rule__XAssignment__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11562:1: ( ( ( rule__XAssignment__Group_1_1__0 )? ) ) + // InternalExport.g:11563:1: ( ( rule__XAssignment__Group_1_1__0 )? ) + { + // InternalExport.g:11563:1: ( ( rule__XAssignment__Group_1_1__0 )? ) + // InternalExport.g:11564:2: ( rule__XAssignment__Group_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); + } + // InternalExport.g:11565:2: ( rule__XAssignment__Group_1_1__0 )? + int alt108=2; + alt108 = dfa108.predict(input); + switch (alt108) { + case 1 : + // InternalExport.g:11565:3: rule__XAssignment__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1__0" + // InternalExport.g:11574:1: rule__XAssignment__Group_1_1__0 : rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ; + public final void rule__XAssignment__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11578:1: ( rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ) + // InternalExport.g:11579:2: rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 + { + pushFollow(FOLLOW_70); + rule__XAssignment__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1__0__Impl" + // InternalExport.g:11586:1: rule__XAssignment__Group_1_1__0__Impl : ( ( rule__XAssignment__Group_1_1_0__0 ) ) ; + public final void rule__XAssignment__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11590:1: ( ( ( rule__XAssignment__Group_1_1_0__0 ) ) ) + // InternalExport.g:11591:1: ( ( rule__XAssignment__Group_1_1_0__0 ) ) + { + // InternalExport.g:11591:1: ( ( rule__XAssignment__Group_1_1_0__0 ) ) + // InternalExport.g:11592:2: ( rule__XAssignment__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); + } + // InternalExport.g:11593:2: ( rule__XAssignment__Group_1_1_0__0 ) + // InternalExport.g:11593:3: rule__XAssignment__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1__1" + // InternalExport.g:11601:1: rule__XAssignment__Group_1_1__1 : rule__XAssignment__Group_1_1__1__Impl ; + public final void rule__XAssignment__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11605:1: ( rule__XAssignment__Group_1_1__1__Impl ) + // InternalExport.g:11606:2: rule__XAssignment__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__1" + + + // $ANTLR start "rule__XAssignment__Group_1_1__1__Impl" + // InternalExport.g:11612:1: rule__XAssignment__Group_1_1__1__Impl : ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ; + public final void rule__XAssignment__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11616:1: ( ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ) + // InternalExport.g:11617:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) + { + // InternalExport.g:11617:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) + // InternalExport.g:11618:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); + } + // InternalExport.g:11619:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 ) + // InternalExport.g:11619:3: rule__XAssignment__RightOperandAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__RightOperandAssignment_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0__0" + // InternalExport.g:11628:1: rule__XAssignment__Group_1_1_0__0 : rule__XAssignment__Group_1_1_0__0__Impl ; + public final void rule__XAssignment__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11632:1: ( rule__XAssignment__Group_1_1_0__0__Impl ) + // InternalExport.g:11633:2: rule__XAssignment__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0__0__Impl" + // InternalExport.g:11639:1: rule__XAssignment__Group_1_1_0__0__Impl : ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ; + public final void rule__XAssignment__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11643:1: ( ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ) + // InternalExport.g:11644:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) + { + // InternalExport.g:11644:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) + // InternalExport.g:11645:2: ( rule__XAssignment__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); + } + // InternalExport.g:11646:2: ( rule__XAssignment__Group_1_1_0_0__0 ) + // InternalExport.g:11646:3: rule__XAssignment__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0" + // InternalExport.g:11655:1: rule__XAssignment__Group_1_1_0_0__0 : rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ; + public final void rule__XAssignment__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11659:1: ( rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ) + // InternalExport.g:11660:2: rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_71); + rule__XAssignment__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0__Impl" + // InternalExport.g:11667:1: rule__XAssignment__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XAssignment__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11671:1: ( ( () ) ) + // InternalExport.g:11672:1: ( () ) + { + // InternalExport.g:11672:1: ( () ) + // InternalExport.g:11673:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + // InternalExport.g:11674:2: () + // InternalExport.g:11674:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1" + // InternalExport.g:11682:1: rule__XAssignment__Group_1_1_0_0__1 : rule__XAssignment__Group_1_1_0_0__1__Impl ; + public final void rule__XAssignment__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11686:1: ( rule__XAssignment__Group_1_1_0_0__1__Impl ) + // InternalExport.g:11687:2: rule__XAssignment__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1__Impl" + // InternalExport.g:11693:1: rule__XAssignment__Group_1_1_0_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ; + public final void rule__XAssignment__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11697:1: ( ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ) + // InternalExport.g:11698:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) + { + // InternalExport.g:11698:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) + // InternalExport.g:11699:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); + } + // InternalExport.g:11700:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) + // InternalExport.g:11700:3: rule__XAssignment__FeatureAssignment_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__FeatureAssignment_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__0" + // InternalExport.g:11709:1: rule__OpMultiAssign__Group_5__0 : rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ; + public final void rule__OpMultiAssign__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11713:1: ( rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ) + // InternalExport.g:11714:2: rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 + { + pushFollow(FOLLOW_72); + rule__OpMultiAssign__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__0" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__0__Impl" + // InternalExport.g:11721:1: rule__OpMultiAssign__Group_5__0__Impl : ( '<' ) ; + public final void rule__OpMultiAssign__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11725:1: ( ( '<' ) ) + // InternalExport.g:11726:1: ( '<' ) + { + // InternalExport.g:11726:1: ( '<' ) + // InternalExport.g:11727:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__0__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__1" + // InternalExport.g:11736:1: rule__OpMultiAssign__Group_5__1 : rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ; + public final void rule__OpMultiAssign__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11740:1: ( rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ) + // InternalExport.g:11741:2: rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 + { + pushFollow(FOLLOW_32); + rule__OpMultiAssign__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__1" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__1__Impl" + // InternalExport.g:11748:1: rule__OpMultiAssign__Group_5__1__Impl : ( '<' ) ; + public final void rule__OpMultiAssign__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11752:1: ( ( '<' ) ) + // InternalExport.g:11753:1: ( '<' ) + { + // InternalExport.g:11753:1: ( '<' ) + // InternalExport.g:11754:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__2" + // InternalExport.g:11763:1: rule__OpMultiAssign__Group_5__2 : rule__OpMultiAssign__Group_5__2__Impl ; + public final void rule__OpMultiAssign__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11767:1: ( rule__OpMultiAssign__Group_5__2__Impl ) + // InternalExport.g:11768:2: rule__OpMultiAssign__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__2" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__2__Impl" + // InternalExport.g:11774:1: rule__OpMultiAssign__Group_5__2__Impl : ( '=' ) ; + public final void rule__OpMultiAssign__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11778:1: ( ( '=' ) ) + // InternalExport.g:11779:1: ( '=' ) + { + // InternalExport.g:11779:1: ( '=' ) + // InternalExport.g:11780:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__2__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__0" + // InternalExport.g:11790:1: rule__OpMultiAssign__Group_6__0 : rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ; + public final void rule__OpMultiAssign__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11794:1: ( rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ) + // InternalExport.g:11795:2: rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 + { + pushFollow(FOLLOW_73); + rule__OpMultiAssign__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__0" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__0__Impl" + // InternalExport.g:11802:1: rule__OpMultiAssign__Group_6__0__Impl : ( '>' ) ; + public final void rule__OpMultiAssign__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11806:1: ( ( '>' ) ) + // InternalExport.g:11807:1: ( '>' ) + { + // InternalExport.g:11807:1: ( '>' ) + // InternalExport.g:11808:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__0__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__1" + // InternalExport.g:11817:1: rule__OpMultiAssign__Group_6__1 : rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ; + public final void rule__OpMultiAssign__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11821:1: ( rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ) + // InternalExport.g:11822:2: rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 + { + pushFollow(FOLLOW_73); + rule__OpMultiAssign__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__1" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__1__Impl" + // InternalExport.g:11829:1: rule__OpMultiAssign__Group_6__1__Impl : ( ( '>' )? ) ; + public final void rule__OpMultiAssign__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11833:1: ( ( ( '>' )? ) ) + // InternalExport.g:11834:1: ( ( '>' )? ) + { + // InternalExport.g:11834:1: ( ( '>' )? ) + // InternalExport.g:11835:2: ( '>' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + // InternalExport.g:11836:2: ( '>' )? + int alt109=2; + int LA109_0 = input.LA(1); + + if ( (LA109_0==21) ) { + alt109=1; + } + switch (alt109) { + case 1 : + // InternalExport.g:11836:3: '>' + { + match(input,21,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__2" + // InternalExport.g:11844:1: rule__OpMultiAssign__Group_6__2 : rule__OpMultiAssign__Group_6__2__Impl ; + public final void rule__OpMultiAssign__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11848:1: ( rule__OpMultiAssign__Group_6__2__Impl ) + // InternalExport.g:11849:2: rule__OpMultiAssign__Group_6__2__Impl + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__2" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__2__Impl" + // InternalExport.g:11855:1: rule__OpMultiAssign__Group_6__2__Impl : ( '>=' ) ; + public final void rule__OpMultiAssign__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11859:1: ( ( '>=' ) ) + // InternalExport.g:11860:1: ( '>=' ) + { + // InternalExport.g:11860:1: ( '>=' ) + // InternalExport.g:11861:2: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__2__Impl" + + + // $ANTLR start "rule__XOrExpression__Group__0" + // InternalExport.g:11871:1: rule__XOrExpression__Group__0 : rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ; + public final void rule__XOrExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11875:1: ( rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ) + // InternalExport.g:11876:2: rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 + { + pushFollow(FOLLOW_50); + rule__XOrExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__0" + + + // $ANTLR start "rule__XOrExpression__Group__0__Impl" + // InternalExport.g:11883:1: rule__XOrExpression__Group__0__Impl : ( ruleXAndExpression ) ; + public final void rule__XOrExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11887:1: ( ( ruleXAndExpression ) ) + // InternalExport.g:11888:1: ( ruleXAndExpression ) + { + // InternalExport.g:11888:1: ( ruleXAndExpression ) + // InternalExport.g:11889:2: ruleXAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group__1" + // InternalExport.g:11898:1: rule__XOrExpression__Group__1 : rule__XOrExpression__Group__1__Impl ; + public final void rule__XOrExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11902:1: ( rule__XOrExpression__Group__1__Impl ) + // InternalExport.g:11903:2: rule__XOrExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__1" + + + // $ANTLR start "rule__XOrExpression__Group__1__Impl" + // InternalExport.g:11909:1: rule__XOrExpression__Group__1__Impl : ( ( rule__XOrExpression__Group_1__0 )* ) ; + public final void rule__XOrExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11913:1: ( ( ( rule__XOrExpression__Group_1__0 )* ) ) + // InternalExport.g:11914:1: ( ( rule__XOrExpression__Group_1__0 )* ) + { + // InternalExport.g:11914:1: ( ( rule__XOrExpression__Group_1__0 )* ) + // InternalExport.g:11915:2: ( rule__XOrExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1()); + } + // InternalExport.g:11916:2: ( rule__XOrExpression__Group_1__0 )* + loop110: + do { + int alt110=2; + int LA110_0 = input.LA(1); + + if ( (LA110_0==15) ) { + int LA110_2 = input.LA(2); + + if ( (synpred184_InternalExport()) ) { + alt110=1; + } + + + } + + + switch (alt110) { + case 1 : + // InternalExport.g:11916:3: rule__XOrExpression__Group_1__0 + { + pushFollow(FOLLOW_51); + rule__XOrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop110; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__1__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1__0" + // InternalExport.g:11925:1: rule__XOrExpression__Group_1__0 : rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ; + public final void rule__XOrExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11929:1: ( rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ) + // InternalExport.g:11930:2: rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 + { + pushFollow(FOLLOW_70); + rule__XOrExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__0" + + + // $ANTLR start "rule__XOrExpression__Group_1__0__Impl" + // InternalExport.g:11937:1: rule__XOrExpression__Group_1__0__Impl : ( ( rule__XOrExpression__Group_1_0__0 ) ) ; + public final void rule__XOrExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11941:1: ( ( ( rule__XOrExpression__Group_1_0__0 ) ) ) + // InternalExport.g:11942:1: ( ( rule__XOrExpression__Group_1_0__0 ) ) + { + // InternalExport.g:11942:1: ( ( rule__XOrExpression__Group_1_0__0 ) ) + // InternalExport.g:11943:2: ( rule__XOrExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:11944:2: ( rule__XOrExpression__Group_1_0__0 ) + // InternalExport.g:11944:3: rule__XOrExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1__1" + // InternalExport.g:11952:1: rule__XOrExpression__Group_1__1 : rule__XOrExpression__Group_1__1__Impl ; + public final void rule__XOrExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11956:1: ( rule__XOrExpression__Group_1__1__Impl ) + // InternalExport.g:11957:2: rule__XOrExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__1" + + + // $ANTLR start "rule__XOrExpression__Group_1__1__Impl" + // InternalExport.g:11963:1: rule__XOrExpression__Group_1__1__Impl : ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XOrExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11967:1: ( ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExport.g:11968:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExport.g:11968:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) + // InternalExport.g:11969:2: ( rule__XOrExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExport.g:11970:2: ( rule__XOrExpression__RightOperandAssignment_1_1 ) + // InternalExport.g:11970:3: rule__XOrExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0__0" + // InternalExport.g:11979:1: rule__XOrExpression__Group_1_0__0 : rule__XOrExpression__Group_1_0__0__Impl ; + public final void rule__XOrExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11983:1: ( rule__XOrExpression__Group_1_0__0__Impl ) + // InternalExport.g:11984:2: rule__XOrExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0__0" + + + // $ANTLR start "rule__XOrExpression__Group_1_0__0__Impl" + // InternalExport.g:11990:1: rule__XOrExpression__Group_1_0__0__Impl : ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ; + public final void rule__XOrExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:11994:1: ( ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:11995:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:11995:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) ) + // InternalExport.g:11996:2: ( rule__XOrExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:11997:2: ( rule__XOrExpression__Group_1_0_0__0 ) + // InternalExport.g:11997:3: rule__XOrExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__0" + // InternalExport.g:12006:1: rule__XOrExpression__Group_1_0_0__0 : rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ; + public final void rule__XOrExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12010:1: ( rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ) + // InternalExport.g:12011:2: rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_50); + rule__XOrExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__0__Impl" + // InternalExport.g:12018:1: rule__XOrExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XOrExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12022:1: ( ( () ) ) + // InternalExport.g:12023:1: ( () ) + { + // InternalExport.g:12023:1: ( () ) + // InternalExport.g:12024:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExport.g:12025:2: () + // InternalExport.g:12025:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__1" + // InternalExport.g:12033:1: rule__XOrExpression__Group_1_0_0__1 : rule__XOrExpression__Group_1_0_0__1__Impl ; + public final void rule__XOrExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12037:1: ( rule__XOrExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:12038:2: rule__XOrExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__1__Impl" + // InternalExport.g:12044:1: rule__XOrExpression__Group_1_0_0__1__Impl : ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XOrExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12048:1: ( ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExport.g:12049:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExport.g:12049:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExport.g:12050:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExport.g:12051:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) + // InternalExport.g:12051:3: rule__XOrExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group__0" + // InternalExport.g:12060:1: rule__XAndExpression__Group__0 : rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ; + public final void rule__XAndExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12064:1: ( rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ) + // InternalExport.g:12065:2: rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 + { + pushFollow(FOLLOW_52); + rule__XAndExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__0" + + + // $ANTLR start "rule__XAndExpression__Group__0__Impl" + // InternalExport.g:12072:1: rule__XAndExpression__Group__0__Impl : ( ruleXEqualityExpression ) ; + public final void rule__XAndExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12076:1: ( ( ruleXEqualityExpression ) ) + // InternalExport.g:12077:1: ( ruleXEqualityExpression ) + { + // InternalExport.g:12077:1: ( ruleXEqualityExpression ) + // InternalExport.g:12078:2: ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group__1" + // InternalExport.g:12087:1: rule__XAndExpression__Group__1 : rule__XAndExpression__Group__1__Impl ; + public final void rule__XAndExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12091:1: ( rule__XAndExpression__Group__1__Impl ) + // InternalExport.g:12092:2: rule__XAndExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__1" + + + // $ANTLR start "rule__XAndExpression__Group__1__Impl" + // InternalExport.g:12098:1: rule__XAndExpression__Group__1__Impl : ( ( rule__XAndExpression__Group_1__0 )* ) ; + public final void rule__XAndExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12102:1: ( ( ( rule__XAndExpression__Group_1__0 )* ) ) + // InternalExport.g:12103:1: ( ( rule__XAndExpression__Group_1__0 )* ) + { + // InternalExport.g:12103:1: ( ( rule__XAndExpression__Group_1__0 )* ) + // InternalExport.g:12104:2: ( rule__XAndExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1()); + } + // InternalExport.g:12105:2: ( rule__XAndExpression__Group_1__0 )* + loop111: + do { + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==16) ) { + int LA111_2 = input.LA(2); + + if ( (synpred185_InternalExport()) ) { + alt111=1; + } + + + } + + + switch (alt111) { + case 1 : + // InternalExport.g:12105:3: rule__XAndExpression__Group_1__0 + { + pushFollow(FOLLOW_53); + rule__XAndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop111; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1__0" + // InternalExport.g:12114:1: rule__XAndExpression__Group_1__0 : rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ; + public final void rule__XAndExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12118:1: ( rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ) + // InternalExport.g:12119:2: rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 + { + pushFollow(FOLLOW_70); + rule__XAndExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__0" + + + // $ANTLR start "rule__XAndExpression__Group_1__0__Impl" + // InternalExport.g:12126:1: rule__XAndExpression__Group_1__0__Impl : ( ( rule__XAndExpression__Group_1_0__0 ) ) ; + public final void rule__XAndExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12130:1: ( ( ( rule__XAndExpression__Group_1_0__0 ) ) ) + // InternalExport.g:12131:1: ( ( rule__XAndExpression__Group_1_0__0 ) ) + { + // InternalExport.g:12131:1: ( ( rule__XAndExpression__Group_1_0__0 ) ) + // InternalExport.g:12132:2: ( rule__XAndExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:12133:2: ( rule__XAndExpression__Group_1_0__0 ) + // InternalExport.g:12133:3: rule__XAndExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1__1" + // InternalExport.g:12141:1: rule__XAndExpression__Group_1__1 : rule__XAndExpression__Group_1__1__Impl ; + public final void rule__XAndExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12145:1: ( rule__XAndExpression__Group_1__1__Impl ) + // InternalExport.g:12146:2: rule__XAndExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__1" + + + // $ANTLR start "rule__XAndExpression__Group_1__1__Impl" + // InternalExport.g:12152:1: rule__XAndExpression__Group_1__1__Impl : ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XAndExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12156:1: ( ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExport.g:12157:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExport.g:12157:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) + // InternalExport.g:12158:2: ( rule__XAndExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExport.g:12159:2: ( rule__XAndExpression__RightOperandAssignment_1_1 ) + // InternalExport.g:12159:3: rule__XAndExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0__0" + // InternalExport.g:12168:1: rule__XAndExpression__Group_1_0__0 : rule__XAndExpression__Group_1_0__0__Impl ; + public final void rule__XAndExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12172:1: ( rule__XAndExpression__Group_1_0__0__Impl ) + // InternalExport.g:12173:2: rule__XAndExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0__0" + + + // $ANTLR start "rule__XAndExpression__Group_1_0__0__Impl" + // InternalExport.g:12179:1: rule__XAndExpression__Group_1_0__0__Impl : ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ; + public final void rule__XAndExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12183:1: ( ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:12184:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:12184:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) ) + // InternalExport.g:12185:2: ( rule__XAndExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:12186:2: ( rule__XAndExpression__Group_1_0_0__0 ) + // InternalExport.g:12186:3: rule__XAndExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__0" + // InternalExport.g:12195:1: rule__XAndExpression__Group_1_0_0__0 : rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ; + public final void rule__XAndExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12199:1: ( rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ) + // InternalExport.g:12200:2: rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_52); + rule__XAndExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__0__Impl" + // InternalExport.g:12207:1: rule__XAndExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XAndExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12211:1: ( ( () ) ) + // InternalExport.g:12212:1: ( () ) + { + // InternalExport.g:12212:1: ( () ) + // InternalExport.g:12213:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExport.g:12214:2: () + // InternalExport.g:12214:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__1" + // InternalExport.g:12222:1: rule__XAndExpression__Group_1_0_0__1 : rule__XAndExpression__Group_1_0_0__1__Impl ; + public final void rule__XAndExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12226:1: ( rule__XAndExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:12227:2: rule__XAndExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__1__Impl" + // InternalExport.g:12233:1: rule__XAndExpression__Group_1_0_0__1__Impl : ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XAndExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12237:1: ( ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExport.g:12238:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExport.g:12238:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExport.g:12239:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExport.g:12240:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) + // InternalExport.g:12240:3: rule__XAndExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group__0" + // InternalExport.g:12249:1: rule__XEqualityExpression__Group__0 : rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ; + public final void rule__XEqualityExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12253:1: ( rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ) + // InternalExport.g:12254:2: rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 + { + pushFollow(FOLLOW_74); + rule__XEqualityExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__0" + + + // $ANTLR start "rule__XEqualityExpression__Group__0__Impl" + // InternalExport.g:12261:1: rule__XEqualityExpression__Group__0__Impl : ( ruleXRelationalExpression ) ; + public final void rule__XEqualityExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12265:1: ( ( ruleXRelationalExpression ) ) + // InternalExport.g:12266:1: ( ruleXRelationalExpression ) + { + // InternalExport.g:12266:1: ( ruleXRelationalExpression ) + // InternalExport.g:12267:2: ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group__1" + // InternalExport.g:12276:1: rule__XEqualityExpression__Group__1 : rule__XEqualityExpression__Group__1__Impl ; + public final void rule__XEqualityExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12280:1: ( rule__XEqualityExpression__Group__1__Impl ) + // InternalExport.g:12281:2: rule__XEqualityExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__1" + + + // $ANTLR start "rule__XEqualityExpression__Group__1__Impl" + // InternalExport.g:12287:1: rule__XEqualityExpression__Group__1__Impl : ( ( rule__XEqualityExpression__Group_1__0 )* ) ; + public final void rule__XEqualityExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12291:1: ( ( ( rule__XEqualityExpression__Group_1__0 )* ) ) + // InternalExport.g:12292:1: ( ( rule__XEqualityExpression__Group_1__0 )* ) + { + // InternalExport.g:12292:1: ( ( rule__XEqualityExpression__Group_1__0 )* ) + // InternalExport.g:12293:2: ( rule__XEqualityExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); + } + // InternalExport.g:12294:2: ( rule__XEqualityExpression__Group_1__0 )* + loop112: + do { + int alt112=2; + switch ( input.LA(1) ) { + case 17: + { + int LA112_2 = input.LA(2); + + if ( (synpred186_InternalExport()) ) { + alt112=1; + } + + + } + break; + case 18: + { + int LA112_3 = input.LA(2); + + if ( (synpred186_InternalExport()) ) { + alt112=1; + } + + + } + break; + case 46: + { + int LA112_4 = input.LA(2); + + if ( (synpred186_InternalExport()) ) { + alt112=1; + } + + + } + break; + case 47: + { + int LA112_5 = input.LA(2); + + if ( (synpred186_InternalExport()) ) { + alt112=1; + } + + + } + break; + + } + + switch (alt112) { + case 1 : + // InternalExport.g:12294:3: rule__XEqualityExpression__Group_1__0 + { + pushFollow(FOLLOW_75); + rule__XEqualityExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop112; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__0" + // InternalExport.g:12303:1: rule__XEqualityExpression__Group_1__0 : rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ; + public final void rule__XEqualityExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12307:1: ( rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ) + // InternalExport.g:12308:2: rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 + { + pushFollow(FOLLOW_70); + rule__XEqualityExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__0__Impl" + // InternalExport.g:12315:1: rule__XEqualityExpression__Group_1__0__Impl : ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ; + public final void rule__XEqualityExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12319:1: ( ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ) + // InternalExport.g:12320:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) ) + { + // InternalExport.g:12320:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) ) + // InternalExport.g:12321:2: ( rule__XEqualityExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:12322:2: ( rule__XEqualityExpression__Group_1_0__0 ) + // InternalExport.g:12322:3: rule__XEqualityExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__1" + // InternalExport.g:12330:1: rule__XEqualityExpression__Group_1__1 : rule__XEqualityExpression__Group_1__1__Impl ; + public final void rule__XEqualityExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12334:1: ( rule__XEqualityExpression__Group_1__1__Impl ) + // InternalExport.g:12335:2: rule__XEqualityExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__1" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__1__Impl" + // InternalExport.g:12341:1: rule__XEqualityExpression__Group_1__1__Impl : ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XEqualityExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12345:1: ( ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExport.g:12346:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExport.g:12346:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) + // InternalExport.g:12347:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExport.g:12348:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) + // InternalExport.g:12348:3: rule__XEqualityExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0__0" + // InternalExport.g:12357:1: rule__XEqualityExpression__Group_1_0__0 : rule__XEqualityExpression__Group_1_0__0__Impl ; + public final void rule__XEqualityExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12361:1: ( rule__XEqualityExpression__Group_1_0__0__Impl ) + // InternalExport.g:12362:2: rule__XEqualityExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0__0__Impl" + // InternalExport.g:12368:1: rule__XEqualityExpression__Group_1_0__0__Impl : ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ; + public final void rule__XEqualityExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12372:1: ( ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:12373:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:12373:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) + // InternalExport.g:12374:2: ( rule__XEqualityExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:12375:2: ( rule__XEqualityExpression__Group_1_0_0__0 ) + // InternalExport.g:12375:3: rule__XEqualityExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0" + // InternalExport.g:12384:1: rule__XEqualityExpression__Group_1_0_0__0 : rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ; + public final void rule__XEqualityExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12388:1: ( rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ) + // InternalExport.g:12389:2: rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_74); + rule__XEqualityExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0__Impl" + // InternalExport.g:12396:1: rule__XEqualityExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XEqualityExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12400:1: ( ( () ) ) + // InternalExport.g:12401:1: ( () ) + { + // InternalExport.g:12401:1: ( () ) + // InternalExport.g:12402:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExport.g:12403:2: () + // InternalExport.g:12403:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1" + // InternalExport.g:12411:1: rule__XEqualityExpression__Group_1_0_0__1 : rule__XEqualityExpression__Group_1_0_0__1__Impl ; + public final void rule__XEqualityExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12415:1: ( rule__XEqualityExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:12416:2: rule__XEqualityExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1__Impl" + // InternalExport.g:12422:1: rule__XEqualityExpression__Group_1_0_0__1__Impl : ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XEqualityExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12426:1: ( ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExport.g:12427:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExport.g:12427:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExport.g:12428:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExport.g:12429:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) + // InternalExport.g:12429:3: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group__0" + // InternalExport.g:12438:1: rule__XRelationalExpression__Group__0 : rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ; + public final void rule__XRelationalExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12442:1: ( rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ) + // InternalExport.g:12443:2: rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 + { + pushFollow(FOLLOW_76); + rule__XRelationalExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__0" + + + // $ANTLR start "rule__XRelationalExpression__Group__0__Impl" + // InternalExport.g:12450:1: rule__XRelationalExpression__Group__0__Impl : ( ruleXOtherOperatorExpression ) ; + public final void rule__XRelationalExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12454:1: ( ( ruleXOtherOperatorExpression ) ) + // InternalExport.g:12455:1: ( ruleXOtherOperatorExpression ) + { + // InternalExport.g:12455:1: ( ruleXOtherOperatorExpression ) + // InternalExport.g:12456:2: ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group__1" + // InternalExport.g:12465:1: rule__XRelationalExpression__Group__1 : rule__XRelationalExpression__Group__1__Impl ; + public final void rule__XRelationalExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12469:1: ( rule__XRelationalExpression__Group__1__Impl ) + // InternalExport.g:12470:2: rule__XRelationalExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__1" + + + // $ANTLR start "rule__XRelationalExpression__Group__1__Impl" + // InternalExport.g:12476:1: rule__XRelationalExpression__Group__1__Impl : ( ( rule__XRelationalExpression__Alternatives_1 )* ) ; + public final void rule__XRelationalExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12480:1: ( ( ( rule__XRelationalExpression__Alternatives_1 )* ) ) + // InternalExport.g:12481:1: ( ( rule__XRelationalExpression__Alternatives_1 )* ) + { + // InternalExport.g:12481:1: ( ( rule__XRelationalExpression__Alternatives_1 )* ) + // InternalExport.g:12482:2: ( rule__XRelationalExpression__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); + } + // InternalExport.g:12483:2: ( rule__XRelationalExpression__Alternatives_1 )* + loop113: + do { + int alt113=2; + switch ( input.LA(1) ) { + case 22: + { + int LA113_2 = input.LA(2); + + if ( (synpred187_InternalExport()) ) { + alt113=1; + } + + + } + break; + case 21: + { + int LA113_3 = input.LA(2); + + if ( (synpred187_InternalExport()) ) { + alt113=1; + } + + + } + break; + case 96: + { + int LA113_4 = input.LA(2); + + if ( (synpred187_InternalExport()) ) { + alt113=1; + } + + + } + break; + case 19: + { + int LA113_5 = input.LA(2); + + if ( (synpred187_InternalExport()) ) { + alt113=1; + } + + + } + break; + + } + + switch (alt113) { + case 1 : + // InternalExport.g:12483:3: rule__XRelationalExpression__Alternatives_1 + { + pushFollow(FOLLOW_77); + rule__XRelationalExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop113; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__0" + // InternalExport.g:12492:1: rule__XRelationalExpression__Group_1_0__0 : rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ; + public final void rule__XRelationalExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12496:1: ( rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ) + // InternalExport.g:12497:2: rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 + { + pushFollow(FOLLOW_78); + rule__XRelationalExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__0__Impl" + // InternalExport.g:12504:1: rule__XRelationalExpression__Group_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12508:1: ( ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:12509:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:12509:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) + // InternalExport.g:12510:2: ( rule__XRelationalExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:12511:2: ( rule__XRelationalExpression__Group_1_0_0__0 ) + // InternalExport.g:12511:3: rule__XRelationalExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__1" + // InternalExport.g:12519:1: rule__XRelationalExpression__Group_1_0__1 : rule__XRelationalExpression__Group_1_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12523:1: ( rule__XRelationalExpression__Group_1_0__1__Impl ) + // InternalExport.g:12524:2: rule__XRelationalExpression__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__1__Impl" + // InternalExport.g:12530:1: rule__XRelationalExpression__Group_1_0__1__Impl : ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12534:1: ( ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ) + // InternalExport.g:12535:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) + { + // InternalExport.g:12535:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) + // InternalExport.g:12536:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); + } + // InternalExport.g:12537:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) + // InternalExport.g:12537:3: rule__XRelationalExpression__TypeAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__TypeAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0" + // InternalExport.g:12546:1: rule__XRelationalExpression__Group_1_0_0__0 : rule__XRelationalExpression__Group_1_0_0__0__Impl ; + public final void rule__XRelationalExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12550:1: ( rule__XRelationalExpression__Group_1_0_0__0__Impl ) + // InternalExport.g:12551:2: rule__XRelationalExpression__Group_1_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0__Impl" + // InternalExport.g:12557:1: rule__XRelationalExpression__Group_1_0_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12561:1: ( ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ) + // InternalExport.g:12562:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) + { + // InternalExport.g:12562:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) + // InternalExport.g:12563:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); + } + // InternalExport.g:12564:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 ) + // InternalExport.g:12564:3: rule__XRelationalExpression__Group_1_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0" + // InternalExport.g:12573:1: rule__XRelationalExpression__Group_1_0_0_0__0 : rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ; + public final void rule__XRelationalExpression__Group_1_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12577:1: ( rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ) + // InternalExport.g:12578:2: rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 + { + pushFollow(FOLLOW_79); + rule__XRelationalExpression__Group_1_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0__Impl" + // InternalExport.g:12585:1: rule__XRelationalExpression__Group_1_0_0_0__0__Impl : ( () ) ; + public final void rule__XRelationalExpression__Group_1_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12589:1: ( ( () ) ) + // InternalExport.g:12590:1: ( () ) + { + // InternalExport.g:12590:1: ( () ) + // InternalExport.g:12591:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); + } + // InternalExport.g:12592:2: () + // InternalExport.g:12592:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1" + // InternalExport.g:12600:1: rule__XRelationalExpression__Group_1_0_0_0__1 : rule__XRelationalExpression__Group_1_0_0_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12604:1: ( rule__XRelationalExpression__Group_1_0_0_0__1__Impl ) + // InternalExport.g:12605:2: rule__XRelationalExpression__Group_1_0_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1__Impl" + // InternalExport.g:12611:1: rule__XRelationalExpression__Group_1_0_0_0__1__Impl : ( 'instanceof' ) ; + public final void rule__XRelationalExpression__Group_1_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12615:1: ( ( 'instanceof' ) ) + // InternalExport.g:12616:1: ( 'instanceof' ) + { + // InternalExport.g:12616:1: ( 'instanceof' ) + // InternalExport.g:12617:2: 'instanceof' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + match(input,96,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__0" + // InternalExport.g:12627:1: rule__XRelationalExpression__Group_1_1__0 : rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ; + public final void rule__XRelationalExpression__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12631:1: ( rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ) + // InternalExport.g:12632:2: rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 + { + pushFollow(FOLLOW_70); + rule__XRelationalExpression__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__0__Impl" + // InternalExport.g:12639:1: rule__XRelationalExpression__Group_1_1__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12643:1: ( ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ) + // InternalExport.g:12644:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) + { + // InternalExport.g:12644:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) + // InternalExport.g:12645:2: ( rule__XRelationalExpression__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); + } + // InternalExport.g:12646:2: ( rule__XRelationalExpression__Group_1_1_0__0 ) + // InternalExport.g:12646:3: rule__XRelationalExpression__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__1" + // InternalExport.g:12654:1: rule__XRelationalExpression__Group_1_1__1 : rule__XRelationalExpression__Group_1_1__1__Impl ; + public final void rule__XRelationalExpression__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12658:1: ( rule__XRelationalExpression__Group_1_1__1__Impl ) + // InternalExport.g:12659:2: rule__XRelationalExpression__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__1__Impl" + // InternalExport.g:12665:1: rule__XRelationalExpression__Group_1_1__1__Impl : ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12669:1: ( ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ) + // InternalExport.g:12670:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) + { + // InternalExport.g:12670:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) + // InternalExport.g:12671:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); + } + // InternalExport.g:12672:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) + // InternalExport.g:12672:3: rule__XRelationalExpression__RightOperandAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__RightOperandAssignment_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0" + // InternalExport.g:12681:1: rule__XRelationalExpression__Group_1_1_0__0 : rule__XRelationalExpression__Group_1_1_0__0__Impl ; + public final void rule__XRelationalExpression__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12685:1: ( rule__XRelationalExpression__Group_1_1_0__0__Impl ) + // InternalExport.g:12686:2: rule__XRelationalExpression__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0__Impl" + // InternalExport.g:12692:1: rule__XRelationalExpression__Group_1_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12696:1: ( ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ) + // InternalExport.g:12697:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) + { + // InternalExport.g:12697:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) + // InternalExport.g:12698:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); + } + // InternalExport.g:12699:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 ) + // InternalExport.g:12699:3: rule__XRelationalExpression__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0" + // InternalExport.g:12708:1: rule__XRelationalExpression__Group_1_1_0_0__0 : rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ; + public final void rule__XRelationalExpression__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12712:1: ( rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ) + // InternalExport.g:12713:2: rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_76); + rule__XRelationalExpression__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0__Impl" + // InternalExport.g:12720:1: rule__XRelationalExpression__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XRelationalExpression__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12724:1: ( ( () ) ) + // InternalExport.g:12725:1: ( () ) + { + // InternalExport.g:12725:1: ( () ) + // InternalExport.g:12726:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + // InternalExport.g:12727:2: () + // InternalExport.g:12727:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1" + // InternalExport.g:12735:1: rule__XRelationalExpression__Group_1_1_0_0__1 : rule__XRelationalExpression__Group_1_1_0_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12739:1: ( rule__XRelationalExpression__Group_1_1_0_0__1__Impl ) + // InternalExport.g:12740:2: rule__XRelationalExpression__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1__Impl" + // InternalExport.g:12746:1: rule__XRelationalExpression__Group_1_1_0_0__1__Impl : ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12750:1: ( ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ) + // InternalExport.g:12751:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) + { + // InternalExport.g:12751:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) + // InternalExport.g:12752:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); + } + // InternalExport.g:12753:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) + // InternalExport.g:12753:3: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpCompare__Group_1__0" + // InternalExport.g:12762:1: rule__OpCompare__Group_1__0 : rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ; + public final void rule__OpCompare__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12766:1: ( rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ) + // InternalExport.g:12767:2: rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 + { + pushFollow(FOLLOW_32); + rule__OpCompare__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__0" + + + // $ANTLR start "rule__OpCompare__Group_1__0__Impl" + // InternalExport.g:12774:1: rule__OpCompare__Group_1__0__Impl : ( '<' ) ; + public final void rule__OpCompare__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12778:1: ( ( '<' ) ) + // InternalExport.g:12779:1: ( '<' ) + { + // InternalExport.g:12779:1: ( '<' ) + // InternalExport.g:12780:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__0__Impl" + + + // $ANTLR start "rule__OpCompare__Group_1__1" + // InternalExport.g:12789:1: rule__OpCompare__Group_1__1 : rule__OpCompare__Group_1__1__Impl ; + public final void rule__OpCompare__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12793:1: ( rule__OpCompare__Group_1__1__Impl ) + // InternalExport.g:12794:2: rule__OpCompare__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__1" + + + // $ANTLR start "rule__OpCompare__Group_1__1__Impl" + // InternalExport.g:12800:1: rule__OpCompare__Group_1__1__Impl : ( '=' ) ; + public final void rule__OpCompare__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12804:1: ( ( '=' ) ) + // InternalExport.g:12805:1: ( '=' ) + { + // InternalExport.g:12805:1: ( '=' ) + // InternalExport.g:12806:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__0" + // InternalExport.g:12816:1: rule__XOtherOperatorExpression__Group__0 : rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ; + public final void rule__XOtherOperatorExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12820:1: ( rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ) + // InternalExport.g:12821:2: rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 + { + pushFollow(FOLLOW_80); + rule__XOtherOperatorExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__0__Impl" + // InternalExport.g:12828:1: rule__XOtherOperatorExpression__Group__0__Impl : ( ruleXAdditiveExpression ) ; + public final void rule__XOtherOperatorExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12832:1: ( ( ruleXAdditiveExpression ) ) + // InternalExport.g:12833:1: ( ruleXAdditiveExpression ) + { + // InternalExport.g:12833:1: ( ruleXAdditiveExpression ) + // InternalExport.g:12834:2: ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__1" + // InternalExport.g:12843:1: rule__XOtherOperatorExpression__Group__1 : rule__XOtherOperatorExpression__Group__1__Impl ; + public final void rule__XOtherOperatorExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12847:1: ( rule__XOtherOperatorExpression__Group__1__Impl ) + // InternalExport.g:12848:2: rule__XOtherOperatorExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__1__Impl" + // InternalExport.g:12854:1: rule__XOtherOperatorExpression__Group__1__Impl : ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ; + public final void rule__XOtherOperatorExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12858:1: ( ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ) + // InternalExport.g:12859:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) + { + // InternalExport.g:12859:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) + // InternalExport.g:12860:2: ( rule__XOtherOperatorExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); + } + // InternalExport.g:12861:2: ( rule__XOtherOperatorExpression__Group_1__0 )* + loop114: + do { + int alt114=2; + alt114 = dfa114.predict(input); + switch (alt114) { + case 1 : + // InternalExport.g:12861:3: rule__XOtherOperatorExpression__Group_1__0 + { + pushFollow(FOLLOW_81); + rule__XOtherOperatorExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop114; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0" + // InternalExport.g:12870:1: rule__XOtherOperatorExpression__Group_1__0 : rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ; + public final void rule__XOtherOperatorExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12874:1: ( rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ) + // InternalExport.g:12875:2: rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 + { + pushFollow(FOLLOW_70); + rule__XOtherOperatorExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0__Impl" + // InternalExport.g:12882:1: rule__XOtherOperatorExpression__Group_1__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12886:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ) + // InternalExport.g:12887:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) + { + // InternalExport.g:12887:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) + // InternalExport.g:12888:2: ( rule__XOtherOperatorExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:12889:2: ( rule__XOtherOperatorExpression__Group_1_0__0 ) + // InternalExport.g:12889:3: rule__XOtherOperatorExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1" + // InternalExport.g:12897:1: rule__XOtherOperatorExpression__Group_1__1 : rule__XOtherOperatorExpression__Group_1__1__Impl ; + public final void rule__XOtherOperatorExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12901:1: ( rule__XOtherOperatorExpression__Group_1__1__Impl ) + // InternalExport.g:12902:2: rule__XOtherOperatorExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1__Impl" + // InternalExport.g:12908:1: rule__XOtherOperatorExpression__Group_1__1__Impl : ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12912:1: ( ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExport.g:12913:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExport.g:12913:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) + // InternalExport.g:12914:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExport.g:12915:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) + // InternalExport.g:12915:3: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0" + // InternalExport.g:12924:1: rule__XOtherOperatorExpression__Group_1_0__0 : rule__XOtherOperatorExpression__Group_1_0__0__Impl ; + public final void rule__XOtherOperatorExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12928:1: ( rule__XOtherOperatorExpression__Group_1_0__0__Impl ) + // InternalExport.g:12929:2: rule__XOtherOperatorExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0__Impl" + // InternalExport.g:12935:1: rule__XOtherOperatorExpression__Group_1_0__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12939:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:12940:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:12940:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) + // InternalExport.g:12941:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:12942:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) + // InternalExport.g:12942:3: rule__XOtherOperatorExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0" + // InternalExport.g:12951:1: rule__XOtherOperatorExpression__Group_1_0_0__0 : rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12955:1: ( rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ) + // InternalExport.g:12956:2: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_80); + rule__XOtherOperatorExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl" + // InternalExport.g:12963:1: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12967:1: ( ( () ) ) + // InternalExport.g:12968:1: ( () ) + { + // InternalExport.g:12968:1: ( () ) + // InternalExport.g:12969:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExport.g:12970:2: () + // InternalExport.g:12970:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1" + // InternalExport.g:12978:1: rule__XOtherOperatorExpression__Group_1_0_0__1 : rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12982:1: ( rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:12983:2: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl" + // InternalExport.g:12989:1: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl : ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:12993:1: ( ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExport.g:12994:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExport.g:12994:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExport.g:12995:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExport.g:12996:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) + // InternalExport.g:12996:3: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_2__0" + // InternalExport.g:13005:1: rule__OpOther__Group_2__0 : rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ; + public final void rule__OpOther__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13009:1: ( rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ) + // InternalExport.g:13010:2: rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 + { + pushFollow(FOLLOW_82); + rule__OpOther__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__0" + + + // $ANTLR start "rule__OpOther__Group_2__0__Impl" + // InternalExport.g:13017:1: rule__OpOther__Group_2__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13021:1: ( ( '>' ) ) + // InternalExport.g:13022:1: ( '>' ) + { + // InternalExport.g:13022:1: ( '>' ) + // InternalExport.g:13023:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_2__1" + // InternalExport.g:13032:1: rule__OpOther__Group_2__1 : rule__OpOther__Group_2__1__Impl ; + public final void rule__OpOther__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13036:1: ( rule__OpOther__Group_2__1__Impl ) + // InternalExport.g:13037:2: rule__OpOther__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__1" + + + // $ANTLR start "rule__OpOther__Group_2__1__Impl" + // InternalExport.g:13043:1: rule__OpOther__Group_2__1__Impl : ( '..' ) ; + public final void rule__OpOther__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13047:1: ( ( '..' ) ) + // InternalExport.g:13048:1: ( '..' ) + { + // InternalExport.g:13048:1: ( '..' ) + // InternalExport.g:13049:2: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + match(input,50,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_5__0" + // InternalExport.g:13059:1: rule__OpOther__Group_5__0 : rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ; + public final void rule__OpOther__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13063:1: ( rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ) + // InternalExport.g:13064:2: rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 + { + pushFollow(FOLLOW_83); + rule__OpOther__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__0" + + + // $ANTLR start "rule__OpOther__Group_5__0__Impl" + // InternalExport.g:13071:1: rule__OpOther__Group_5__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13075:1: ( ( '>' ) ) + // InternalExport.g:13076:1: ( '>' ) + { + // InternalExport.g:13076:1: ( '>' ) + // InternalExport.g:13077:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5__1" + // InternalExport.g:13086:1: rule__OpOther__Group_5__1 : rule__OpOther__Group_5__1__Impl ; + public final void rule__OpOther__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13090:1: ( rule__OpOther__Group_5__1__Impl ) + // InternalExport.g:13091:2: rule__OpOther__Group_5__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__1" + + + // $ANTLR start "rule__OpOther__Group_5__1__Impl" + // InternalExport.g:13097:1: rule__OpOther__Group_5__1__Impl : ( ( rule__OpOther__Alternatives_5_1 ) ) ; + public final void rule__OpOther__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13101:1: ( ( ( rule__OpOther__Alternatives_5_1 ) ) ) + // InternalExport.g:13102:1: ( ( rule__OpOther__Alternatives_5_1 ) ) + { + // InternalExport.g:13102:1: ( ( rule__OpOther__Alternatives_5_1 ) ) + // InternalExport.g:13103:2: ( rule__OpOther__Alternatives_5_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); + } + // InternalExport.g:13104:2: ( rule__OpOther__Alternatives_5_1 ) + // InternalExport.g:13104:3: rule__OpOther__Alternatives_5_1 + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives_5_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0__0" + // InternalExport.g:13113:1: rule__OpOther__Group_5_1_0__0 : rule__OpOther__Group_5_1_0__0__Impl ; + public final void rule__OpOther__Group_5_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13117:1: ( rule__OpOther__Group_5_1_0__0__Impl ) + // InternalExport.g:13118:2: rule__OpOther__Group_5_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0__0" + + + // $ANTLR start "rule__OpOther__Group_5_1_0__0__Impl" + // InternalExport.g:13124:1: rule__OpOther__Group_5_1_0__0__Impl : ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ; + public final void rule__OpOther__Group_5_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13128:1: ( ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ) + // InternalExport.g:13129:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) ) + { + // InternalExport.g:13129:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) ) + // InternalExport.g:13130:2: ( rule__OpOther__Group_5_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); + } + // InternalExport.g:13131:2: ( rule__OpOther__Group_5_1_0_0__0 ) + // InternalExport.g:13131:3: rule__OpOther__Group_5_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__0" + // InternalExport.g:13140:1: rule__OpOther__Group_5_1_0_0__0 : rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ; + public final void rule__OpOther__Group_5_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13144:1: ( rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ) + // InternalExport.g:13145:2: rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 + { + pushFollow(FOLLOW_83); + rule__OpOther__Group_5_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__0" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__0__Impl" + // InternalExport.g:13152:1: rule__OpOther__Group_5_1_0_0__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13156:1: ( ( '>' ) ) + // InternalExport.g:13157:1: ( '>' ) + { + // InternalExport.g:13157:1: ( '>' ) + // InternalExport.g:13158:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__1" + // InternalExport.g:13167:1: rule__OpOther__Group_5_1_0_0__1 : rule__OpOther__Group_5_1_0_0__1__Impl ; + public final void rule__OpOther__Group_5_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13171:1: ( rule__OpOther__Group_5_1_0_0__1__Impl ) + // InternalExport.g:13172:2: rule__OpOther__Group_5_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__1" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__1__Impl" + // InternalExport.g:13178:1: rule__OpOther__Group_5_1_0_0__1__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13182:1: ( ( '>' ) ) + // InternalExport.g:13183:1: ( '>' ) + { + // InternalExport.g:13183:1: ( '>' ) + // InternalExport.g:13184:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_6__0" + // InternalExport.g:13194:1: rule__OpOther__Group_6__0 : rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ; + public final void rule__OpOther__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13198:1: ( rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ) + // InternalExport.g:13199:2: rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 + { + pushFollow(FOLLOW_84); + rule__OpOther__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__0" + + + // $ANTLR start "rule__OpOther__Group_6__0__Impl" + // InternalExport.g:13206:1: rule__OpOther__Group_6__0__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13210:1: ( ( '<' ) ) + // InternalExport.g:13211:1: ( '<' ) + { + // InternalExport.g:13211:1: ( '<' ) + // InternalExport.g:13212:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6__1" + // InternalExport.g:13221:1: rule__OpOther__Group_6__1 : rule__OpOther__Group_6__1__Impl ; + public final void rule__OpOther__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13225:1: ( rule__OpOther__Group_6__1__Impl ) + // InternalExport.g:13226:2: rule__OpOther__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__1" + + + // $ANTLR start "rule__OpOther__Group_6__1__Impl" + // InternalExport.g:13232:1: rule__OpOther__Group_6__1__Impl : ( ( rule__OpOther__Alternatives_6_1 ) ) ; + public final void rule__OpOther__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13236:1: ( ( ( rule__OpOther__Alternatives_6_1 ) ) ) + // InternalExport.g:13237:1: ( ( rule__OpOther__Alternatives_6_1 ) ) + { + // InternalExport.g:13237:1: ( ( rule__OpOther__Alternatives_6_1 ) ) + // InternalExport.g:13238:2: ( rule__OpOther__Alternatives_6_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); + } + // InternalExport.g:13239:2: ( rule__OpOther__Alternatives_6_1 ) + // InternalExport.g:13239:3: rule__OpOther__Alternatives_6_1 + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives_6_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0__0" + // InternalExport.g:13248:1: rule__OpOther__Group_6_1_0__0 : rule__OpOther__Group_6_1_0__0__Impl ; + public final void rule__OpOther__Group_6_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13252:1: ( rule__OpOther__Group_6_1_0__0__Impl ) + // InternalExport.g:13253:2: rule__OpOther__Group_6_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0__0" + + + // $ANTLR start "rule__OpOther__Group_6_1_0__0__Impl" + // InternalExport.g:13259:1: rule__OpOther__Group_6_1_0__0__Impl : ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ; + public final void rule__OpOther__Group_6_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13263:1: ( ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ) + // InternalExport.g:13264:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) ) + { + // InternalExport.g:13264:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) ) + // InternalExport.g:13265:2: ( rule__OpOther__Group_6_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); + } + // InternalExport.g:13266:2: ( rule__OpOther__Group_6_1_0_0__0 ) + // InternalExport.g:13266:3: rule__OpOther__Group_6_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__0" + // InternalExport.g:13275:1: rule__OpOther__Group_6_1_0_0__0 : rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ; + public final void rule__OpOther__Group_6_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13279:1: ( rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ) + // InternalExport.g:13280:2: rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 + { + pushFollow(FOLLOW_72); + rule__OpOther__Group_6_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__0" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__0__Impl" + // InternalExport.g:13287:1: rule__OpOther__Group_6_1_0_0__0__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13291:1: ( ( '<' ) ) + // InternalExport.g:13292:1: ( '<' ) + { + // InternalExport.g:13292:1: ( '<' ) + // InternalExport.g:13293:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__1" + // InternalExport.g:13302:1: rule__OpOther__Group_6_1_0_0__1 : rule__OpOther__Group_6_1_0_0__1__Impl ; + public final void rule__OpOther__Group_6_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13306:1: ( rule__OpOther__Group_6_1_0_0__1__Impl ) + // InternalExport.g:13307:2: rule__OpOther__Group_6_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__1" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__1__Impl" + // InternalExport.g:13313:1: rule__OpOther__Group_6_1_0_0__1__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13317:1: ( ( '<' ) ) + // InternalExport.g:13318:1: ( '<' ) + { + // InternalExport.g:13318:1: ( '<' ) + // InternalExport.g:13319:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group__0" + // InternalExport.g:13329:1: rule__XAdditiveExpression__Group__0 : rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ; + public final void rule__XAdditiveExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13333:1: ( rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ) + // InternalExport.g:13334:2: rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 + { + pushFollow(FOLLOW_58); + rule__XAdditiveExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group__0__Impl" + // InternalExport.g:13341:1: rule__XAdditiveExpression__Group__0__Impl : ( ruleXMultiplicativeExpression ) ; + public final void rule__XAdditiveExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13345:1: ( ( ruleXMultiplicativeExpression ) ) + // InternalExport.g:13346:1: ( ruleXMultiplicativeExpression ) + { + // InternalExport.g:13346:1: ( ruleXMultiplicativeExpression ) + // InternalExport.g:13347:2: ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group__1" + // InternalExport.g:13356:1: rule__XAdditiveExpression__Group__1 : rule__XAdditiveExpression__Group__1__Impl ; + public final void rule__XAdditiveExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13360:1: ( rule__XAdditiveExpression__Group__1__Impl ) + // InternalExport.g:13361:2: rule__XAdditiveExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group__1__Impl" + // InternalExport.g:13367:1: rule__XAdditiveExpression__Group__1__Impl : ( ( rule__XAdditiveExpression__Group_1__0 )* ) ; + public final void rule__XAdditiveExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13371:1: ( ( ( rule__XAdditiveExpression__Group_1__0 )* ) ) + // InternalExport.g:13372:1: ( ( rule__XAdditiveExpression__Group_1__0 )* ) + { + // InternalExport.g:13372:1: ( ( rule__XAdditiveExpression__Group_1__0 )* ) + // InternalExport.g:13373:2: ( rule__XAdditiveExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); + } + // InternalExport.g:13374:2: ( rule__XAdditiveExpression__Group_1__0 )* + loop115: + do { + int alt115=2; + int LA115_0 = input.LA(1); + + if ( (LA115_0==24) ) { + int LA115_2 = input.LA(2); + + if ( (synpred189_InternalExport()) ) { + alt115=1; + } + + + } + else if ( (LA115_0==23) ) { + int LA115_3 = input.LA(2); + + if ( (synpred189_InternalExport()) ) { + alt115=1; + } + + + } + + + switch (alt115) { + case 1 : + // InternalExport.g:13374:3: rule__XAdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_59); + rule__XAdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop115; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__0" + // InternalExport.g:13383:1: rule__XAdditiveExpression__Group_1__0 : rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ; + public final void rule__XAdditiveExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13387:1: ( rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ) + // InternalExport.g:13388:2: rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 + { + pushFollow(FOLLOW_70); + rule__XAdditiveExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__0__Impl" + // InternalExport.g:13395:1: rule__XAdditiveExpression__Group_1__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ; + public final void rule__XAdditiveExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13399:1: ( ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ) + // InternalExport.g:13400:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) + { + // InternalExport.g:13400:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) + // InternalExport.g:13401:2: ( rule__XAdditiveExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:13402:2: ( rule__XAdditiveExpression__Group_1_0__0 ) + // InternalExport.g:13402:3: rule__XAdditiveExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__1" + // InternalExport.g:13410:1: rule__XAdditiveExpression__Group_1__1 : rule__XAdditiveExpression__Group_1__1__Impl ; + public final void rule__XAdditiveExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13414:1: ( rule__XAdditiveExpression__Group_1__1__Impl ) + // InternalExport.g:13415:2: rule__XAdditiveExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__1__Impl" + // InternalExport.g:13421:1: rule__XAdditiveExpression__Group_1__1__Impl : ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XAdditiveExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13425:1: ( ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExport.g:13426:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExport.g:13426:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) + // InternalExport.g:13427:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExport.g:13428:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) + // InternalExport.g:13428:3: rule__XAdditiveExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0" + // InternalExport.g:13437:1: rule__XAdditiveExpression__Group_1_0__0 : rule__XAdditiveExpression__Group_1_0__0__Impl ; + public final void rule__XAdditiveExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13441:1: ( rule__XAdditiveExpression__Group_1_0__0__Impl ) + // InternalExport.g:13442:2: rule__XAdditiveExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0__Impl" + // InternalExport.g:13448:1: rule__XAdditiveExpression__Group_1_0__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ; + public final void rule__XAdditiveExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13452:1: ( ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:13453:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:13453:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) + // InternalExport.g:13454:2: ( rule__XAdditiveExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:13455:2: ( rule__XAdditiveExpression__Group_1_0_0__0 ) + // InternalExport.g:13455:3: rule__XAdditiveExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0" + // InternalExport.g:13464:1: rule__XAdditiveExpression__Group_1_0_0__0 : rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ; + public final void rule__XAdditiveExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13468:1: ( rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ) + // InternalExport.g:13469:2: rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_58); + rule__XAdditiveExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0__Impl" + // InternalExport.g:13476:1: rule__XAdditiveExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XAdditiveExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13480:1: ( ( () ) ) + // InternalExport.g:13481:1: ( () ) + { + // InternalExport.g:13481:1: ( () ) + // InternalExport.g:13482:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExport.g:13483:2: () + // InternalExport.g:13483:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1" + // InternalExport.g:13491:1: rule__XAdditiveExpression__Group_1_0_0__1 : rule__XAdditiveExpression__Group_1_0_0__1__Impl ; + public final void rule__XAdditiveExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13495:1: ( rule__XAdditiveExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:13496:2: rule__XAdditiveExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1__Impl" + // InternalExport.g:13502:1: rule__XAdditiveExpression__Group_1_0_0__1__Impl : ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XAdditiveExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13506:1: ( ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExport.g:13507:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExport.g:13507:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExport.g:13508:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExport.g:13509:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) + // InternalExport.g:13509:3: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__0" + // InternalExport.g:13518:1: rule__XMultiplicativeExpression__Group__0 : rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ; + public final void rule__XMultiplicativeExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13522:1: ( rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ) + // InternalExport.g:13523:2: rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 + { + pushFollow(FOLLOW_85); + rule__XMultiplicativeExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__0__Impl" + // InternalExport.g:13530:1: rule__XMultiplicativeExpression__Group__0__Impl : ( ruleXUnaryOperation ) ; + public final void rule__XMultiplicativeExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13534:1: ( ( ruleXUnaryOperation ) ) + // InternalExport.g:13535:1: ( ruleXUnaryOperation ) + { + // InternalExport.g:13535:1: ( ruleXUnaryOperation ) + // InternalExport.g:13536:2: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__1" + // InternalExport.g:13545:1: rule__XMultiplicativeExpression__Group__1 : rule__XMultiplicativeExpression__Group__1__Impl ; + public final void rule__XMultiplicativeExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13549:1: ( rule__XMultiplicativeExpression__Group__1__Impl ) + // InternalExport.g:13550:2: rule__XMultiplicativeExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__1__Impl" + // InternalExport.g:13556:1: rule__XMultiplicativeExpression__Group__1__Impl : ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ; + public final void rule__XMultiplicativeExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13560:1: ( ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ) + // InternalExport.g:13561:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) + { + // InternalExport.g:13561:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) + // InternalExport.g:13562:2: ( rule__XMultiplicativeExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); + } + // InternalExport.g:13563:2: ( rule__XMultiplicativeExpression__Group_1__0 )* + loop116: + do { + int alt116=2; + switch ( input.LA(1) ) { + case 25: + { + int LA116_2 = input.LA(2); + + if ( (synpred190_InternalExport()) ) { + alt116=1; + } + + + } + break; + case 54: + { + int LA116_3 = input.LA(2); + + if ( (synpred190_InternalExport()) ) { + alt116=1; + } + + + } + break; + case 26: + { + int LA116_4 = input.LA(2); + + if ( (synpred190_InternalExport()) ) { + alt116=1; + } + + + } + break; + case 55: + { + int LA116_5 = input.LA(2); + + if ( (synpred190_InternalExport()) ) { + alt116=1; + } + + + } + break; + + } + + switch (alt116) { + case 1 : + // InternalExport.g:13563:3: rule__XMultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_86); + rule__XMultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop116; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0" + // InternalExport.g:13572:1: rule__XMultiplicativeExpression__Group_1__0 : rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ; + public final void rule__XMultiplicativeExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13576:1: ( rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ) + // InternalExport.g:13577:2: rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 + { + pushFollow(FOLLOW_70); + rule__XMultiplicativeExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0__Impl" + // InternalExport.g:13584:1: rule__XMultiplicativeExpression__Group_1__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13588:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ) + // InternalExport.g:13589:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) + { + // InternalExport.g:13589:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) + // InternalExport.g:13590:2: ( rule__XMultiplicativeExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:13591:2: ( rule__XMultiplicativeExpression__Group_1_0__0 ) + // InternalExport.g:13591:3: rule__XMultiplicativeExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1" + // InternalExport.g:13599:1: rule__XMultiplicativeExpression__Group_1__1 : rule__XMultiplicativeExpression__Group_1__1__Impl ; + public final void rule__XMultiplicativeExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13603:1: ( rule__XMultiplicativeExpression__Group_1__1__Impl ) + // InternalExport.g:13604:2: rule__XMultiplicativeExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1__Impl" + // InternalExport.g:13610:1: rule__XMultiplicativeExpression__Group_1__1__Impl : ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13614:1: ( ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExport.g:13615:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExport.g:13615:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) + // InternalExport.g:13616:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExport.g:13617:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) + // InternalExport.g:13617:3: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0" + // InternalExport.g:13626:1: rule__XMultiplicativeExpression__Group_1_0__0 : rule__XMultiplicativeExpression__Group_1_0__0__Impl ; + public final void rule__XMultiplicativeExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13630:1: ( rule__XMultiplicativeExpression__Group_1_0__0__Impl ) + // InternalExport.g:13631:2: rule__XMultiplicativeExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0__Impl" + // InternalExport.g:13637:1: rule__XMultiplicativeExpression__Group_1_0__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13641:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:13642:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:13642:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) + // InternalExport.g:13643:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:13644:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) + // InternalExport.g:13644:3: rule__XMultiplicativeExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0" + // InternalExport.g:13653:1: rule__XMultiplicativeExpression__Group_1_0_0__0 : rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13657:1: ( rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ) + // InternalExport.g:13658:2: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_85); + rule__XMultiplicativeExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl" + // InternalExport.g:13665:1: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13669:1: ( ( () ) ) + // InternalExport.g:13670:1: ( () ) + { + // InternalExport.g:13670:1: ( () ) + // InternalExport.g:13671:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExport.g:13672:2: () + // InternalExport.g:13672:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1" + // InternalExport.g:13680:1: rule__XMultiplicativeExpression__Group_1_0_0__1 : rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13684:1: ( rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:13685:2: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl" + // InternalExport.g:13691:1: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl : ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13695:1: ( ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExport.g:13696:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExport.g:13696:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExport.g:13697:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExport.g:13698:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) + // InternalExport.g:13698:3: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__0" + // InternalExport.g:13707:1: rule__XUnaryOperation__Group_0__0 : rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ; + public final void rule__XUnaryOperation__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13711:1: ( rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ) + // InternalExport.g:13712:2: rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 + { + pushFollow(FOLLOW_87); + rule__XUnaryOperation__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__0" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__0__Impl" + // InternalExport.g:13719:1: rule__XUnaryOperation__Group_0__0__Impl : ( () ) ; + public final void rule__XUnaryOperation__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13723:1: ( ( () ) ) + // InternalExport.g:13724:1: ( () ) + { + // InternalExport.g:13724:1: ( () ) + // InternalExport.g:13725:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); + } + // InternalExport.g:13726:2: () + // InternalExport.g:13726:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__0__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__1" + // InternalExport.g:13734:1: rule__XUnaryOperation__Group_0__1 : rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ; + public final void rule__XUnaryOperation__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13738:1: ( rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ) + // InternalExport.g:13739:2: rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 + { + pushFollow(FOLLOW_70); + rule__XUnaryOperation__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__1" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__1__Impl" + // InternalExport.g:13746:1: rule__XUnaryOperation__Group_0__1__Impl : ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ; + public final void rule__XUnaryOperation__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13750:1: ( ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ) + // InternalExport.g:13751:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) + { + // InternalExport.g:13751:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) + // InternalExport.g:13752:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); + } + // InternalExport.g:13753:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 ) + // InternalExport.g:13753:3: rule__XUnaryOperation__FeatureAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__FeatureAssignment_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__1__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__2" + // InternalExport.g:13761:1: rule__XUnaryOperation__Group_0__2 : rule__XUnaryOperation__Group_0__2__Impl ; + public final void rule__XUnaryOperation__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13765:1: ( rule__XUnaryOperation__Group_0__2__Impl ) + // InternalExport.g:13766:2: rule__XUnaryOperation__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__2" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__2__Impl" + // InternalExport.g:13772:1: rule__XUnaryOperation__Group_0__2__Impl : ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ; + public final void rule__XUnaryOperation__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13776:1: ( ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ) + // InternalExport.g:13777:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) + { + // InternalExport.g:13777:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) + // InternalExport.g:13778:2: ( rule__XUnaryOperation__OperandAssignment_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); + } + // InternalExport.g:13779:2: ( rule__XUnaryOperation__OperandAssignment_0_2 ) + // InternalExport.g:13779:3: rule__XUnaryOperation__OperandAssignment_0_2 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__OperandAssignment_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__2__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group__0" + // InternalExport.g:13788:1: rule__XCastedExpression__Group__0 : rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ; + public final void rule__XCastedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13792:1: ( rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ) + // InternalExport.g:13793:2: rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 + { + pushFollow(FOLLOW_15); + rule__XCastedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__0" + + + // $ANTLR start "rule__XCastedExpression__Group__0__Impl" + // InternalExport.g:13800:1: rule__XCastedExpression__Group__0__Impl : ( ruleXPostfixOperation ) ; + public final void rule__XCastedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13804:1: ( ( ruleXPostfixOperation ) ) + // InternalExport.g:13805:1: ( ruleXPostfixOperation ) + { + // InternalExport.g:13805:1: ( ruleXPostfixOperation ) + // InternalExport.g:13806:2: ruleXPostfixOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group__1" + // InternalExport.g:13815:1: rule__XCastedExpression__Group__1 : rule__XCastedExpression__Group__1__Impl ; + public final void rule__XCastedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13819:1: ( rule__XCastedExpression__Group__1__Impl ) + // InternalExport.g:13820:2: rule__XCastedExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__1" + + + // $ANTLR start "rule__XCastedExpression__Group__1__Impl" + // InternalExport.g:13826:1: rule__XCastedExpression__Group__1__Impl : ( ( rule__XCastedExpression__Group_1__0 )* ) ; + public final void rule__XCastedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13830:1: ( ( ( rule__XCastedExpression__Group_1__0 )* ) ) + // InternalExport.g:13831:1: ( ( rule__XCastedExpression__Group_1__0 )* ) + { + // InternalExport.g:13831:1: ( ( rule__XCastedExpression__Group_1__0 )* ) + // InternalExport.g:13832:2: ( rule__XCastedExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); + } + // InternalExport.g:13833:2: ( rule__XCastedExpression__Group_1__0 )* + loop117: + do { + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==70) ) { + int LA117_2 = input.LA(2); + + if ( (synpred191_InternalExport()) ) { + alt117=1; + } + + + } + + + switch (alt117) { + case 1 : + // InternalExport.g:13833:3: rule__XCastedExpression__Group_1__0 + { + pushFollow(FOLLOW_88); + rule__XCastedExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop117; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1__0" + // InternalExport.g:13842:1: rule__XCastedExpression__Group_1__0 : rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ; + public final void rule__XCastedExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13846:1: ( rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ) + // InternalExport.g:13847:2: rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 + { + pushFollow(FOLLOW_78); + rule__XCastedExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1__0__Impl" + // InternalExport.g:13854:1: rule__XCastedExpression__Group_1__0__Impl : ( ( rule__XCastedExpression__Group_1_0__0 ) ) ; + public final void rule__XCastedExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13858:1: ( ( ( rule__XCastedExpression__Group_1_0__0 ) ) ) + // InternalExport.g:13859:1: ( ( rule__XCastedExpression__Group_1_0__0 ) ) + { + // InternalExport.g:13859:1: ( ( rule__XCastedExpression__Group_1_0__0 ) ) + // InternalExport.g:13860:2: ( rule__XCastedExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); + } + // InternalExport.g:13861:2: ( rule__XCastedExpression__Group_1_0__0 ) + // InternalExport.g:13861:3: rule__XCastedExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1__1" + // InternalExport.g:13869:1: rule__XCastedExpression__Group_1__1 : rule__XCastedExpression__Group_1__1__Impl ; + public final void rule__XCastedExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13873:1: ( rule__XCastedExpression__Group_1__1__Impl ) + // InternalExport.g:13874:2: rule__XCastedExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__1" + + + // $ANTLR start "rule__XCastedExpression__Group_1__1__Impl" + // InternalExport.g:13880:1: rule__XCastedExpression__Group_1__1__Impl : ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ; + public final void rule__XCastedExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13884:1: ( ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ) + // InternalExport.g:13885:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) + { + // InternalExport.g:13885:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) + // InternalExport.g:13886:2: ( rule__XCastedExpression__TypeAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); + } + // InternalExport.g:13887:2: ( rule__XCastedExpression__TypeAssignment_1_1 ) + // InternalExport.g:13887:3: rule__XCastedExpression__TypeAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__TypeAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0__0" + // InternalExport.g:13896:1: rule__XCastedExpression__Group_1_0__0 : rule__XCastedExpression__Group_1_0__0__Impl ; + public final void rule__XCastedExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13900:1: ( rule__XCastedExpression__Group_1_0__0__Impl ) + // InternalExport.g:13901:2: rule__XCastedExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0__0__Impl" + // InternalExport.g:13907:1: rule__XCastedExpression__Group_1_0__0__Impl : ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ; + public final void rule__XCastedExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13911:1: ( ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ) + // InternalExport.g:13912:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) + { + // InternalExport.g:13912:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) + // InternalExport.g:13913:2: ( rule__XCastedExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); + } + // InternalExport.g:13914:2: ( rule__XCastedExpression__Group_1_0_0__0 ) + // InternalExport.g:13914:3: rule__XCastedExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0" + // InternalExport.g:13923:1: rule__XCastedExpression__Group_1_0_0__0 : rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ; + public final void rule__XCastedExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13927:1: ( rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ) + // InternalExport.g:13928:2: rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_15); + rule__XCastedExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0__Impl" + // InternalExport.g:13935:1: rule__XCastedExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XCastedExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13939:1: ( ( () ) ) + // InternalExport.g:13940:1: ( () ) + { + // InternalExport.g:13940:1: ( () ) + // InternalExport.g:13941:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); + } + // InternalExport.g:13942:2: () + // InternalExport.g:13942:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1" + // InternalExport.g:13950:1: rule__XCastedExpression__Group_1_0_0__1 : rule__XCastedExpression__Group_1_0_0__1__Impl ; + public final void rule__XCastedExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13954:1: ( rule__XCastedExpression__Group_1_0_0__1__Impl ) + // InternalExport.g:13955:2: rule__XCastedExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1__Impl" + // InternalExport.g:13961:1: rule__XCastedExpression__Group_1_0_0__1__Impl : ( 'as' ) ; + public final void rule__XCastedExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13965:1: ( ( 'as' ) ) + // InternalExport.g:13966:1: ( 'as' ) + { + // InternalExport.g:13966:1: ( 'as' ) + // InternalExport.g:13967:2: 'as' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + match(input,70,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group__0" + // InternalExport.g:13977:1: rule__XPostfixOperation__Group__0 : rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ; + public final void rule__XPostfixOperation__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13981:1: ( rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ) + // InternalExport.g:13982:2: rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 + { + pushFollow(FOLLOW_89); + rule__XPostfixOperation__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__0" + + + // $ANTLR start "rule__XPostfixOperation__Group__0__Impl" + // InternalExport.g:13989:1: rule__XPostfixOperation__Group__0__Impl : ( ruleXMemberFeatureCall ) ; + public final void rule__XPostfixOperation__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:13993:1: ( ( ruleXMemberFeatureCall ) ) + // InternalExport.g:13994:1: ( ruleXMemberFeatureCall ) + { + // InternalExport.g:13994:1: ( ruleXMemberFeatureCall ) + // InternalExport.g:13995:2: ruleXMemberFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group__1" + // InternalExport.g:14004:1: rule__XPostfixOperation__Group__1 : rule__XPostfixOperation__Group__1__Impl ; + public final void rule__XPostfixOperation__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14008:1: ( rule__XPostfixOperation__Group__1__Impl ) + // InternalExport.g:14009:2: rule__XPostfixOperation__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__1" + + + // $ANTLR start "rule__XPostfixOperation__Group__1__Impl" + // InternalExport.g:14015:1: rule__XPostfixOperation__Group__1__Impl : ( ( rule__XPostfixOperation__Group_1__0 )? ) ; + public final void rule__XPostfixOperation__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14019:1: ( ( ( rule__XPostfixOperation__Group_1__0 )? ) ) + // InternalExport.g:14020:1: ( ( rule__XPostfixOperation__Group_1__0 )? ) + { + // InternalExport.g:14020:1: ( ( rule__XPostfixOperation__Group_1__0 )? ) + // InternalExport.g:14021:2: ( rule__XPostfixOperation__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); + } + // InternalExport.g:14022:2: ( rule__XPostfixOperation__Group_1__0 )? + int alt118=2; + int LA118_0 = input.LA(1); + + if ( (LA118_0==56) ) { + int LA118_1 = input.LA(2); + + if ( (synpred192_InternalExport()) ) { + alt118=1; + } + } + else if ( (LA118_0==57) ) { + int LA118_2 = input.LA(2); + + if ( (synpred192_InternalExport()) ) { + alt118=1; + } + } + switch (alt118) { + case 1 : + // InternalExport.g:14022:3: rule__XPostfixOperation__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__1__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1__0" + // InternalExport.g:14031:1: rule__XPostfixOperation__Group_1__0 : rule__XPostfixOperation__Group_1__0__Impl ; + public final void rule__XPostfixOperation__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14035:1: ( rule__XPostfixOperation__Group_1__0__Impl ) + // InternalExport.g:14036:2: rule__XPostfixOperation__Group_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1__0" + + + // $ANTLR start "rule__XPostfixOperation__Group_1__0__Impl" + // InternalExport.g:14042:1: rule__XPostfixOperation__Group_1__0__Impl : ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ; + public final void rule__XPostfixOperation__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14046:1: ( ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ) + // InternalExport.g:14047:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) ) + { + // InternalExport.g:14047:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) ) + // InternalExport.g:14048:2: ( rule__XPostfixOperation__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); + } + // InternalExport.g:14049:2: ( rule__XPostfixOperation__Group_1_0__0 ) + // InternalExport.g:14049:3: rule__XPostfixOperation__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__0" + // InternalExport.g:14058:1: rule__XPostfixOperation__Group_1_0__0 : rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ; + public final void rule__XPostfixOperation__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14062:1: ( rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ) + // InternalExport.g:14063:2: rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 + { + pushFollow(FOLLOW_89); + rule__XPostfixOperation__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__0" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__0__Impl" + // InternalExport.g:14070:1: rule__XPostfixOperation__Group_1_0__0__Impl : ( () ) ; + public final void rule__XPostfixOperation__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14074:1: ( ( () ) ) + // InternalExport.g:14075:1: ( () ) + { + // InternalExport.g:14075:1: ( () ) + // InternalExport.g:14076:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); + } + // InternalExport.g:14077:2: () + // InternalExport.g:14077:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__1" + // InternalExport.g:14085:1: rule__XPostfixOperation__Group_1_0__1 : rule__XPostfixOperation__Group_1_0__1__Impl ; + public final void rule__XPostfixOperation__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14089:1: ( rule__XPostfixOperation__Group_1_0__1__Impl ) + // InternalExport.g:14090:2: rule__XPostfixOperation__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__1" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__1__Impl" + // InternalExport.g:14096:1: rule__XPostfixOperation__Group_1_0__1__Impl : ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ; + public final void rule__XPostfixOperation__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14100:1: ( ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ) + // InternalExport.g:14101:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) + { + // InternalExport.g:14101:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) + // InternalExport.g:14102:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); + } + // InternalExport.g:14103:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) + // InternalExport.g:14103:3: rule__XPostfixOperation__FeatureAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__FeatureAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__0" + // InternalExport.g:14112:1: rule__XMemberFeatureCall__Group__0 : rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ; + public final void rule__XMemberFeatureCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14116:1: ( rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ) + // InternalExport.g:14117:2: rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 + { + pushFollow(FOLLOW_90); + rule__XMemberFeatureCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__0__Impl" + // InternalExport.g:14124:1: rule__XMemberFeatureCall__Group__0__Impl : ( ruleXPrimaryExpression ) ; + public final void rule__XMemberFeatureCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14128:1: ( ( ruleXPrimaryExpression ) ) + // InternalExport.g:14129:1: ( ruleXPrimaryExpression ) + { + // InternalExport.g:14129:1: ( ruleXPrimaryExpression ) + // InternalExport.g:14130:2: ruleXPrimaryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__1" + // InternalExport.g:14139:1: rule__XMemberFeatureCall__Group__1 : rule__XMemberFeatureCall__Group__1__Impl ; + public final void rule__XMemberFeatureCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14143:1: ( rule__XMemberFeatureCall__Group__1__Impl ) + // InternalExport.g:14144:2: rule__XMemberFeatureCall__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__1__Impl" + // InternalExport.g:14150:1: rule__XMemberFeatureCall__Group__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ; + public final void rule__XMemberFeatureCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14154:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ) + // InternalExport.g:14155:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) + { + // InternalExport.g:14155:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) + // InternalExport.g:14156:2: ( rule__XMemberFeatureCall__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); + } + // InternalExport.g:14157:2: ( rule__XMemberFeatureCall__Alternatives_1 )* + loop119: + do { + int alt119=2; + switch ( input.LA(1) ) { + case 58: + { + int LA119_2 = input.LA(2); + + if ( (synpred193_InternalExport()) ) { + alt119=1; + } + + + } + break; + case 83: + { + int LA119_3 = input.LA(2); + + if ( (synpred193_InternalExport()) ) { + alt119=1; + } + + + } + break; + case 116: + { + int LA119_4 = input.LA(2); + + if ( (synpred193_InternalExport()) ) { + alt119=1; + } + + + } + break; + + } + + switch (alt119) { + case 1 : + // InternalExport.g:14157:3: rule__XMemberFeatureCall__Alternatives_1 + { + pushFollow(FOLLOW_91); + rule__XMemberFeatureCall__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop119; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0" + // InternalExport.g:14166:1: rule__XMemberFeatureCall__Group_1_0__0 : rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14170:1: ( rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ) + // InternalExport.g:14171:2: rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 + { + pushFollow(FOLLOW_70); + rule__XMemberFeatureCall__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0__Impl" + // InternalExport.g:14178:1: rule__XMemberFeatureCall__Group_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14182:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ) + // InternalExport.g:14183:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) + { + // InternalExport.g:14183:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) + // InternalExport.g:14184:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); + } + // InternalExport.g:14185:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 ) + // InternalExport.g:14185:3: rule__XMemberFeatureCall__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1" + // InternalExport.g:14193:1: rule__XMemberFeatureCall__Group_1_0__1 : rule__XMemberFeatureCall__Group_1_0__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14197:1: ( rule__XMemberFeatureCall__Group_1_0__1__Impl ) + // InternalExport.g:14198:2: rule__XMemberFeatureCall__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1__Impl" + // InternalExport.g:14204:1: rule__XMemberFeatureCall__Group_1_0__1__Impl : ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14208:1: ( ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ) + // InternalExport.g:14209:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) + { + // InternalExport.g:14209:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) + // InternalExport.g:14210:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); + } + // InternalExport.g:14211:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) + // InternalExport.g:14211:3: rule__XMemberFeatureCall__ValueAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ValueAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0" + // InternalExport.g:14220:1: rule__XMemberFeatureCall__Group_1_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0__0__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14224:1: ( rule__XMemberFeatureCall__Group_1_0_0__0__Impl ) + // InternalExport.g:14225:2: rule__XMemberFeatureCall__Group_1_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0__Impl" + // InternalExport.g:14231:1: rule__XMemberFeatureCall__Group_1_0_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14235:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ) + // InternalExport.g:14236:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) + { + // InternalExport.g:14236:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) + // InternalExport.g:14237:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); + } + // InternalExport.g:14238:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) + // InternalExport.g:14238:3: rule__XMemberFeatureCall__Group_1_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0" + // InternalExport.g:14247:1: rule__XMemberFeatureCall__Group_1_0_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14251:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ) + // InternalExport.g:14252:2: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 + { + pushFollow(FOLLOW_92); + rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl" + // InternalExport.g:14259:1: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl : ( () ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14263:1: ( ( () ) ) + // InternalExport.g:14264:1: ( () ) + { + // InternalExport.g:14264:1: ( () ) + // InternalExport.g:14265:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); + } + // InternalExport.g:14266:2: () + // InternalExport.g:14266:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1" + // InternalExport.g:14274:1: rule__XMemberFeatureCall__Group_1_0_0_0__1 : rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14278:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ) + // InternalExport.g:14279:2: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 + { + pushFollow(FOLLOW_69); + rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl" + // InternalExport.g:14286:1: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14290:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ) + // InternalExport.g:14291:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) + { + // InternalExport.g:14291:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) + // InternalExport.g:14292:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); + } + // InternalExport.g:14293:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) + // InternalExport.g:14293:3: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_0_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2" + // InternalExport.g:14301:1: rule__XMemberFeatureCall__Group_1_0_0_0__2 : rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14305:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ) + // InternalExport.g:14306:2: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 + { + pushFollow(FOLLOW_32); + rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl" + // InternalExport.g:14313:1: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14317:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ) + // InternalExport.g:14318:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) + { + // InternalExport.g:14318:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) + // InternalExport.g:14319:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); + } + // InternalExport.g:14320:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) + // InternalExport.g:14320:3: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3" + // InternalExport.g:14328:1: rule__XMemberFeatureCall__Group_1_0_0_0__3 : rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14332:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ) + // InternalExport.g:14333:2: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl" + // InternalExport.g:14339:1: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl : ( ruleOpSingleAssign ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14343:1: ( ( ruleOpSingleAssign ) ) + // InternalExport.g:14344:1: ( ruleOpSingleAssign ) + { + // InternalExport.g:14344:1: ( ruleOpSingleAssign ) + // InternalExport.g:14345:2: ruleOpSingleAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0" + // InternalExport.g:14355:1: rule__XMemberFeatureCall__Group_1_1__0 : rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14359:1: ( rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ) + // InternalExport.g:14360:2: rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 + { + pushFollow(FOLLOW_93); + rule__XMemberFeatureCall__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0__Impl" + // InternalExport.g:14367:1: rule__XMemberFeatureCall__Group_1_1__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14371:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ) + // InternalExport.g:14372:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) + { + // InternalExport.g:14372:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) + // InternalExport.g:14373:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); + } + // InternalExport.g:14374:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 ) + // InternalExport.g:14374:3: rule__XMemberFeatureCall__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1" + // InternalExport.g:14382:1: rule__XMemberFeatureCall__Group_1_1__1 : rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ; + public final void rule__XMemberFeatureCall__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14386:1: ( rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ) + // InternalExport.g:14387:2: rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 + { + pushFollow(FOLLOW_93); + rule__XMemberFeatureCall__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1__Impl" + // InternalExport.g:14394:1: rule__XMemberFeatureCall__Group_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14398:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ) + // InternalExport.g:14399:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) + { + // InternalExport.g:14399:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) + // InternalExport.g:14400:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); + } + // InternalExport.g:14401:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )? + int alt120=2; + int LA120_0 = input.LA(1); + + if ( (LA120_0==22) ) { + alt120=1; + } + switch (alt120) { + case 1 : + // InternalExport.g:14401:3: rule__XMemberFeatureCall__Group_1_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2" + // InternalExport.g:14409:1: rule__XMemberFeatureCall__Group_1_1__2 : rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ; + public final void rule__XMemberFeatureCall__Group_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14413:1: ( rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ) + // InternalExport.g:14414:2: rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 + { + pushFollow(FOLLOW_94); + rule__XMemberFeatureCall__Group_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2__Impl" + // InternalExport.g:14421:1: rule__XMemberFeatureCall__Group_1_1__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14425:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ) + // InternalExport.g:14426:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) + { + // InternalExport.g:14426:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) + // InternalExport.g:14427:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); + } + // InternalExport.g:14428:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) + // InternalExport.g:14428:3: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__FeatureAssignment_1_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3" + // InternalExport.g:14436:1: rule__XMemberFeatureCall__Group_1_1__3 : rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ; + public final void rule__XMemberFeatureCall__Group_1_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14440:1: ( rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ) + // InternalExport.g:14441:2: rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 + { + pushFollow(FOLLOW_94); + rule__XMemberFeatureCall__Group_1_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3__Impl" + // InternalExport.g:14448:1: rule__XMemberFeatureCall__Group_1_1__3__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14452:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ) + // InternalExport.g:14453:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) + { + // InternalExport.g:14453:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) + // InternalExport.g:14454:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); + } + // InternalExport.g:14455:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )? + int alt121=2; + alt121 = dfa121.predict(input); + switch (alt121) { + case 1 : + // InternalExport.g:14455:3: rule__XMemberFeatureCall__Group_1_1_3__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4" + // InternalExport.g:14463:1: rule__XMemberFeatureCall__Group_1_1__4 : rule__XMemberFeatureCall__Group_1_1__4__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14467:1: ( rule__XMemberFeatureCall__Group_1_1__4__Impl ) + // InternalExport.g:14468:2: rule__XMemberFeatureCall__Group_1_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4__Impl" + // InternalExport.g:14474:1: rule__XMemberFeatureCall__Group_1_1__4__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14478:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ) + // InternalExport.g:14479:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) + { + // InternalExport.g:14479:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) + // InternalExport.g:14480:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); + } + // InternalExport.g:14481:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? + int alt122=2; + alt122 = dfa122.predict(input); + switch (alt122) { + case 1 : + // InternalExport.g:14481:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0" + // InternalExport.g:14490:1: rule__XMemberFeatureCall__Group_1_1_0__0 : rule__XMemberFeatureCall__Group_1_1_0__0__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14494:1: ( rule__XMemberFeatureCall__Group_1_1_0__0__Impl ) + // InternalExport.g:14495:2: rule__XMemberFeatureCall__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0__Impl" + // InternalExport.g:14501:1: rule__XMemberFeatureCall__Group_1_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14505:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ) + // InternalExport.g:14506:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) + { + // InternalExport.g:14506:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) + // InternalExport.g:14507:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); + } + // InternalExport.g:14508:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) + // InternalExport.g:14508:3: rule__XMemberFeatureCall__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0" + // InternalExport.g:14517:1: rule__XMemberFeatureCall__Group_1_1_0_0__0 : rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14521:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ) + // InternalExport.g:14522:2: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_90); + rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl" + // InternalExport.g:14529:1: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14533:1: ( ( () ) ) + // InternalExport.g:14534:1: ( () ) + { + // InternalExport.g:14534:1: ( () ) + // InternalExport.g:14535:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); + } + // InternalExport.g:14536:2: () + // InternalExport.g:14536:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1" + // InternalExport.g:14544:1: rule__XMemberFeatureCall__Group_1_1_0_0__1 : rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14548:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ) + // InternalExport.g:14549:2: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl" + // InternalExport.g:14555:1: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14559:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ) + // InternalExport.g:14560:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) + { + // InternalExport.g:14560:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) + // InternalExport.g:14561:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); + } + // InternalExport.g:14562:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) + // InternalExport.g:14562:3: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0" + // InternalExport.g:14571:1: rule__XMemberFeatureCall__Group_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14575:1: ( rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ) + // InternalExport.g:14576:2: rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 + { + pushFollow(FOLLOW_95); + rule__XMemberFeatureCall__Group_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0__Impl" + // InternalExport.g:14583:1: rule__XMemberFeatureCall__Group_1_1_1__0__Impl : ( '<' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14587:1: ( ( '<' ) ) + // InternalExport.g:14588:1: ( '<' ) + { + // InternalExport.g:14588:1: ( '<' ) + // InternalExport.g:14589:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1" + // InternalExport.g:14598:1: rule__XMemberFeatureCall__Group_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14602:1: ( rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ) + // InternalExport.g:14603:2: rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 + { + pushFollow(FOLLOW_96); + rule__XMemberFeatureCall__Group_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1__Impl" + // InternalExport.g:14610:1: rule__XMemberFeatureCall__Group_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14614:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ) + // InternalExport.g:14615:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) + { + // InternalExport.g:14615:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) + // InternalExport.g:14616:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); + } + // InternalExport.g:14617:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) + // InternalExport.g:14617:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2" + // InternalExport.g:14625:1: rule__XMemberFeatureCall__Group_1_1_1__2 : rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14629:1: ( rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ) + // InternalExport.g:14630:2: rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 + { + pushFollow(FOLLOW_96); + rule__XMemberFeatureCall__Group_1_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2__Impl" + // InternalExport.g:14637:1: rule__XMemberFeatureCall__Group_1_1_1__2__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14641:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ) + // InternalExport.g:14642:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) + { + // InternalExport.g:14642:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) + // InternalExport.g:14643:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); + } + // InternalExport.g:14644:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* + loop123: + do { + int alt123=2; + int LA123_0 = input.LA(1); + + if ( (LA123_0==74) ) { + alt123=1; + } + + + switch (alt123) { + case 1 : + // InternalExport.g:14644:3: rule__XMemberFeatureCall__Group_1_1_1_2__0 + { + pushFollow(FOLLOW_22); + rule__XMemberFeatureCall__Group_1_1_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop123; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3" + // InternalExport.g:14652:1: rule__XMemberFeatureCall__Group_1_1_1__3 : rule__XMemberFeatureCall__Group_1_1_1__3__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14656:1: ( rule__XMemberFeatureCall__Group_1_1_1__3__Impl ) + // InternalExport.g:14657:2: rule__XMemberFeatureCall__Group_1_1_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3__Impl" + // InternalExport.g:14663:1: rule__XMemberFeatureCall__Group_1_1_1__3__Impl : ( '>' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14667:1: ( ( '>' ) ) + // InternalExport.g:14668:1: ( '>' ) + { + // InternalExport.g:14668:1: ( '>' ) + // InternalExport.g:14669:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0" + // InternalExport.g:14679:1: rule__XMemberFeatureCall__Group_1_1_1_2__0 : rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14683:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ) + // InternalExport.g:14684:2: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 + { + pushFollow(FOLLOW_95); + rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl" + // InternalExport.g:14691:1: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl : ( ',' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14695:1: ( ( ',' ) ) + // InternalExport.g:14696:1: ( ',' ) + { + // InternalExport.g:14696:1: ( ',' ) + // InternalExport.g:14697:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1" + // InternalExport.g:14706:1: rule__XMemberFeatureCall__Group_1_1_1_2__1 : rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14710:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ) + // InternalExport.g:14711:2: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl" + // InternalExport.g:14717:1: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14721:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ) + // InternalExport.g:14722:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) + { + // InternalExport.g:14722:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) + // InternalExport.g:14723:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); + } + // InternalExport.g:14724:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) + // InternalExport.g:14724:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0" + // InternalExport.g:14733:1: rule__XMemberFeatureCall__Group_1_1_3__0 : rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14737:1: ( rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ) + // InternalExport.g:14738:2: rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 + { + pushFollow(FOLLOW_97); + rule__XMemberFeatureCall__Group_1_1_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0__Impl" + // InternalExport.g:14745:1: rule__XMemberFeatureCall__Group_1_1_3__0__Impl : ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14749:1: ( ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ) + // InternalExport.g:14750:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) + { + // InternalExport.g:14750:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) + // InternalExport.g:14751:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); + } + // InternalExport.g:14752:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) + // InternalExport.g:14752:3: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1" + // InternalExport.g:14760:1: rule__XMemberFeatureCall__Group_1_1_3__1 : rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ; + public final void rule__XMemberFeatureCall__Group_1_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14764:1: ( rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ) + // InternalExport.g:14765:2: rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 + { + pushFollow(FOLLOW_97); + rule__XMemberFeatureCall__Group_1_1_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1__Impl" + // InternalExport.g:14772:1: rule__XMemberFeatureCall__Group_1_1_3__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14776:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ) + // InternalExport.g:14777:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) + { + // InternalExport.g:14777:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) + // InternalExport.g:14778:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); + } + // InternalExport.g:14779:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? + int alt124=2; + int LA124_0 = input.LA(1); + + if ( ((LA124_0>=RULE_ID && LA124_0<=RULE_STRING)||(LA124_0>=22 && LA124_0<=24)||LA124_0==27||(LA124_0>=36 && LA124_0<=37)||LA124_0==51||(LA124_0>=60 && LA124_0<=64)||LA124_0==66||LA124_0==68||LA124_0==72||LA124_0==77||LA124_0==87||LA124_0==90||LA124_0==93||LA124_0==95||(LA124_0>=97 && LA124_0<=104)||LA124_0==106) ) { + alt124=1; + } + switch (alt124) { + case 1 : + // InternalExport.g:14779:3: rule__XMemberFeatureCall__Alternatives_1_1_3_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_1_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2" + // InternalExport.g:14787:1: rule__XMemberFeatureCall__Group_1_1_3__2 : rule__XMemberFeatureCall__Group_1_1_3__2__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14791:1: ( rule__XMemberFeatureCall__Group_1_1_3__2__Impl ) + // InternalExport.g:14792:2: rule__XMemberFeatureCall__Group_1_1_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2__Impl" + // InternalExport.g:14798:1: rule__XMemberFeatureCall__Group_1_1_3__2__Impl : ( ')' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14802:1: ( ( ')' ) ) + // InternalExport.g:14803:1: ( ')' ) + { + // InternalExport.g:14803:1: ( ')' ) + // InternalExport.g:14804:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0" + // InternalExport.g:14814:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14818:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ) + // InternalExport.g:14819:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 + { + pushFollow(FOLLOW_21); + rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl" + // InternalExport.g:14826:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14830:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ) + // InternalExport.g:14831:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) + { + // InternalExport.g:14831:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) + // InternalExport.g:14832:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); + } + // InternalExport.g:14833:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) + // InternalExport.g:14833:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1" + // InternalExport.g:14841:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14845:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ) + // InternalExport.g:14846:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl" + // InternalExport.g:14852:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14856:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ) + // InternalExport.g:14857:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) + { + // InternalExport.g:14857:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) + // InternalExport.g:14858:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); + } + // InternalExport.g:14859:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* + loop125: + do { + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==74) ) { + alt125=1; + } + + + switch (alt125) { + case 1 : + // InternalExport.g:14859:3: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 + { + pushFollow(FOLLOW_22); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop125; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0" + // InternalExport.g:14868:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14872:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ) + // InternalExport.g:14873:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 + { + pushFollow(FOLLOW_98); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl" + // InternalExport.g:14880:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14884:1: ( ( ',' ) ) + // InternalExport.g:14885:1: ( ',' ) + { + // InternalExport.g:14885:1: ( ',' ) + // InternalExport.g:14886:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1" + // InternalExport.g:14895:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14899:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ) + // InternalExport.g:14900:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl" + // InternalExport.g:14906:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14910:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ) + // InternalExport.g:14911:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) + { + // InternalExport.g:14911:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) + // InternalExport.g:14912:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); + } + // InternalExport.g:14913:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) + // InternalExport.g:14913:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__0" + // InternalExport.g:14922:1: rule__XSetLiteral__Group__0 : rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ; + public final void rule__XSetLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14926:1: ( rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ) + // InternalExport.g:14927:2: rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 + { + pushFollow(FOLLOW_99); + rule__XSetLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__0" + + + // $ANTLR start "rule__XSetLiteral__Group__0__Impl" + // InternalExport.g:14934:1: rule__XSetLiteral__Group__0__Impl : ( () ) ; + public final void rule__XSetLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14938:1: ( ( () ) ) + // InternalExport.g:14939:1: ( () ) + { + // InternalExport.g:14939:1: ( () ) + // InternalExport.g:14940:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); + } + // InternalExport.g:14941:2: () + // InternalExport.g:14941:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__1" + // InternalExport.g:14949:1: rule__XSetLiteral__Group__1 : rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ; + public final void rule__XSetLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14953:1: ( rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ) + // InternalExport.g:14954:2: rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 + { + pushFollow(FOLLOW_12); + rule__XSetLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__1" + + + // $ANTLR start "rule__XSetLiteral__Group__1__Impl" + // InternalExport.g:14961:1: rule__XSetLiteral__Group__1__Impl : ( '#' ) ; + public final void rule__XSetLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14965:1: ( ( '#' ) ) + // InternalExport.g:14966:1: ( '#' ) + { + // InternalExport.g:14966:1: ( '#' ) + // InternalExport.g:14967:2: '#' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + match(input,97,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__2" + // InternalExport.g:14976:1: rule__XSetLiteral__Group__2 : rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ; + public final void rule__XSetLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14980:1: ( rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ) + // InternalExport.g:14981:2: rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 + { + pushFollow(FOLLOW_100); + rule__XSetLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__2" + + + // $ANTLR start "rule__XSetLiteral__Group__2__Impl" + // InternalExport.g:14988:1: rule__XSetLiteral__Group__2__Impl : ( '{' ) ; + public final void rule__XSetLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:14992:1: ( ( '{' ) ) + // InternalExport.g:14993:1: ( '{' ) + { + // InternalExport.g:14993:1: ( '{' ) + // InternalExport.g:14994:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__3" + // InternalExport.g:15003:1: rule__XSetLiteral__Group__3 : rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ; + public final void rule__XSetLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15007:1: ( rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ) + // InternalExport.g:15008:2: rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 + { + pushFollow(FOLLOW_100); + rule__XSetLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__3" + + + // $ANTLR start "rule__XSetLiteral__Group__3__Impl" + // InternalExport.g:15015:1: rule__XSetLiteral__Group__3__Impl : ( ( rule__XSetLiteral__Group_3__0 )? ) ; + public final void rule__XSetLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15019:1: ( ( ( rule__XSetLiteral__Group_3__0 )? ) ) + // InternalExport.g:15020:1: ( ( rule__XSetLiteral__Group_3__0 )? ) + { + // InternalExport.g:15020:1: ( ( rule__XSetLiteral__Group_3__0 )? ) + // InternalExport.g:15021:2: ( rule__XSetLiteral__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup_3()); + } + // InternalExport.g:15022:2: ( rule__XSetLiteral__Group_3__0 )? + int alt126=2; + int LA126_0 = input.LA(1); + + if ( ((LA126_0>=RULE_ID && LA126_0<=RULE_STRING)||(LA126_0>=22 && LA126_0<=24)||LA126_0==27||(LA126_0>=36 && LA126_0<=37)||(LA126_0>=60 && LA126_0<=64)||LA126_0==66||LA126_0==68||LA126_0==72||LA126_0==77||LA126_0==87||LA126_0==90||LA126_0==95||(LA126_0>=97 && LA126_0<=104)||LA126_0==106) ) { + alt126=1; + } + switch (alt126) { + case 1 : + // InternalExport.g:15022:3: rule__XSetLiteral__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__4" + // InternalExport.g:15030:1: rule__XSetLiteral__Group__4 : rule__XSetLiteral__Group__4__Impl ; + public final void rule__XSetLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15034:1: ( rule__XSetLiteral__Group__4__Impl ) + // InternalExport.g:15035:2: rule__XSetLiteral__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__4" + + + // $ANTLR start "rule__XSetLiteral__Group__4__Impl" + // InternalExport.g:15041:1: rule__XSetLiteral__Group__4__Impl : ( '}' ) ; + public final void rule__XSetLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15045:1: ( ( '}' ) ) + // InternalExport.g:15046:1: ( '}' ) + { + // InternalExport.g:15046:1: ( '}' ) + // InternalExport.g:15047:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + match(input,69,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3__0" + // InternalExport.g:15057:1: rule__XSetLiteral__Group_3__0 : rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ; + public final void rule__XSetLiteral__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15061:1: ( rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ) + // InternalExport.g:15062:2: rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 + { + pushFollow(FOLLOW_21); + rule__XSetLiteral__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__0" + + + // $ANTLR start "rule__XSetLiteral__Group_3__0__Impl" + // InternalExport.g:15069:1: rule__XSetLiteral__Group_3__0__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ; + public final void rule__XSetLiteral__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15073:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ) + // InternalExport.g:15074:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) + { + // InternalExport.g:15074:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) + // InternalExport.g:15075:2: ( rule__XSetLiteral__ElementsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); + } + // InternalExport.g:15076:2: ( rule__XSetLiteral__ElementsAssignment_3_0 ) + // InternalExport.g:15076:3: rule__XSetLiteral__ElementsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__ElementsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3__1" + // InternalExport.g:15084:1: rule__XSetLiteral__Group_3__1 : rule__XSetLiteral__Group_3__1__Impl ; + public final void rule__XSetLiteral__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15088:1: ( rule__XSetLiteral__Group_3__1__Impl ) + // InternalExport.g:15089:2: rule__XSetLiteral__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__1" + + + // $ANTLR start "rule__XSetLiteral__Group_3__1__Impl" + // InternalExport.g:15095:1: rule__XSetLiteral__Group_3__1__Impl : ( ( rule__XSetLiteral__Group_3_1__0 )* ) ; + public final void rule__XSetLiteral__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15099:1: ( ( ( rule__XSetLiteral__Group_3_1__0 )* ) ) + // InternalExport.g:15100:1: ( ( rule__XSetLiteral__Group_3_1__0 )* ) + { + // InternalExport.g:15100:1: ( ( rule__XSetLiteral__Group_3_1__0 )* ) + // InternalExport.g:15101:2: ( rule__XSetLiteral__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); + } + // InternalExport.g:15102:2: ( rule__XSetLiteral__Group_3_1__0 )* + loop127: + do { + int alt127=2; + int LA127_0 = input.LA(1); + + if ( (LA127_0==74) ) { + alt127=1; + } + + + switch (alt127) { + case 1 : + // InternalExport.g:15102:3: rule__XSetLiteral__Group_3_1__0 + { + pushFollow(FOLLOW_22); + rule__XSetLiteral__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop127; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__0" + // InternalExport.g:15111:1: rule__XSetLiteral__Group_3_1__0 : rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ; + public final void rule__XSetLiteral__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15115:1: ( rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ) + // InternalExport.g:15116:2: rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 + { + pushFollow(FOLLOW_98); + rule__XSetLiteral__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__0" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__0__Impl" + // InternalExport.g:15123:1: rule__XSetLiteral__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XSetLiteral__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15127:1: ( ( ',' ) ) + // InternalExport.g:15128:1: ( ',' ) + { + // InternalExport.g:15128:1: ( ',' ) + // InternalExport.g:15129:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__1" + // InternalExport.g:15138:1: rule__XSetLiteral__Group_3_1__1 : rule__XSetLiteral__Group_3_1__1__Impl ; + public final void rule__XSetLiteral__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15142:1: ( rule__XSetLiteral__Group_3_1__1__Impl ) + // InternalExport.g:15143:2: rule__XSetLiteral__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__1" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__1__Impl" + // InternalExport.g:15149:1: rule__XSetLiteral__Group_3_1__1__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ; + public final void rule__XSetLiteral__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15153:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ) + // InternalExport.g:15154:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) + { + // InternalExport.g:15154:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) + // InternalExport.g:15155:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); + } + // InternalExport.g:15156:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) + // InternalExport.g:15156:3: rule__XSetLiteral__ElementsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__ElementsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__0" + // InternalExport.g:15165:1: rule__XListLiteral__Group__0 : rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ; + public final void rule__XListLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15169:1: ( rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ) + // InternalExport.g:15170:2: rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 + { + pushFollow(FOLLOW_99); + rule__XListLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__0" + + + // $ANTLR start "rule__XListLiteral__Group__0__Impl" + // InternalExport.g:15177:1: rule__XListLiteral__Group__0__Impl : ( () ) ; + public final void rule__XListLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15181:1: ( ( () ) ) + // InternalExport.g:15182:1: ( () ) + { + // InternalExport.g:15182:1: ( () ) + // InternalExport.g:15183:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); + } + // InternalExport.g:15184:2: () + // InternalExport.g:15184:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__1" + // InternalExport.g:15192:1: rule__XListLiteral__Group__1 : rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ; + public final void rule__XListLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15196:1: ( rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ) + // InternalExport.g:15197:2: rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 + { + pushFollow(FOLLOW_30); + rule__XListLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__1" + + + // $ANTLR start "rule__XListLiteral__Group__1__Impl" + // InternalExport.g:15204:1: rule__XListLiteral__Group__1__Impl : ( '#' ) ; + public final void rule__XListLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15208:1: ( ( '#' ) ) + // InternalExport.g:15209:1: ( '#' ) + { + // InternalExport.g:15209:1: ( '#' ) + // InternalExport.g:15210:2: '#' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + match(input,97,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__2" + // InternalExport.g:15219:1: rule__XListLiteral__Group__2 : rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ; + public final void rule__XListLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15223:1: ( rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ) + // InternalExport.g:15224:2: rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 + { + pushFollow(FOLLOW_101); + rule__XListLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__2" + + + // $ANTLR start "rule__XListLiteral__Group__2__Impl" + // InternalExport.g:15231:1: rule__XListLiteral__Group__2__Impl : ( '[' ) ; + public final void rule__XListLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15235:1: ( ( '[' ) ) + // InternalExport.g:15236:1: ( '[' ) + { + // InternalExport.g:15236:1: ( '[' ) + // InternalExport.g:15237:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__3" + // InternalExport.g:15246:1: rule__XListLiteral__Group__3 : rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ; + public final void rule__XListLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15250:1: ( rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ) + // InternalExport.g:15251:2: rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 + { + pushFollow(FOLLOW_101); + rule__XListLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__3" + + + // $ANTLR start "rule__XListLiteral__Group__3__Impl" + // InternalExport.g:15258:1: rule__XListLiteral__Group__3__Impl : ( ( rule__XListLiteral__Group_3__0 )? ) ; + public final void rule__XListLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15262:1: ( ( ( rule__XListLiteral__Group_3__0 )? ) ) + // InternalExport.g:15263:1: ( ( rule__XListLiteral__Group_3__0 )? ) + { + // InternalExport.g:15263:1: ( ( rule__XListLiteral__Group_3__0 )? ) + // InternalExport.g:15264:2: ( rule__XListLiteral__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup_3()); + } + // InternalExport.g:15265:2: ( rule__XListLiteral__Group_3__0 )? + int alt128=2; + int LA128_0 = input.LA(1); + + if ( ((LA128_0>=RULE_ID && LA128_0<=RULE_STRING)||(LA128_0>=22 && LA128_0<=24)||LA128_0==27||(LA128_0>=36 && LA128_0<=37)||(LA128_0>=60 && LA128_0<=64)||LA128_0==66||LA128_0==68||LA128_0==72||LA128_0==77||LA128_0==87||LA128_0==90||LA128_0==95||(LA128_0>=97 && LA128_0<=104)||LA128_0==106) ) { + alt128=1; + } + switch (alt128) { + case 1 : + // InternalExport.g:15265:3: rule__XListLiteral__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__4" + // InternalExport.g:15273:1: rule__XListLiteral__Group__4 : rule__XListLiteral__Group__4__Impl ; + public final void rule__XListLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15277:1: ( rule__XListLiteral__Group__4__Impl ) + // InternalExport.g:15278:2: rule__XListLiteral__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__4" + + + // $ANTLR start "rule__XListLiteral__Group__4__Impl" + // InternalExport.g:15284:1: rule__XListLiteral__Group__4__Impl : ( ']' ) ; + public final void rule__XListLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15288:1: ( ( ']' ) ) + // InternalExport.g:15289:1: ( ']' ) + { + // InternalExport.g:15289:1: ( ']' ) + // InternalExport.g:15290:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3__0" + // InternalExport.g:15300:1: rule__XListLiteral__Group_3__0 : rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ; + public final void rule__XListLiteral__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15304:1: ( rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ) + // InternalExport.g:15305:2: rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 + { + pushFollow(FOLLOW_21); + rule__XListLiteral__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__0" + + + // $ANTLR start "rule__XListLiteral__Group_3__0__Impl" + // InternalExport.g:15312:1: rule__XListLiteral__Group_3__0__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ; + public final void rule__XListLiteral__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15316:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ) + // InternalExport.g:15317:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) + { + // InternalExport.g:15317:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) + // InternalExport.g:15318:2: ( rule__XListLiteral__ElementsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); + } + // InternalExport.g:15319:2: ( rule__XListLiteral__ElementsAssignment_3_0 ) + // InternalExport.g:15319:3: rule__XListLiteral__ElementsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__ElementsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3__1" + // InternalExport.g:15327:1: rule__XListLiteral__Group_3__1 : rule__XListLiteral__Group_3__1__Impl ; + public final void rule__XListLiteral__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15331:1: ( rule__XListLiteral__Group_3__1__Impl ) + // InternalExport.g:15332:2: rule__XListLiteral__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__1" + + + // $ANTLR start "rule__XListLiteral__Group_3__1__Impl" + // InternalExport.g:15338:1: rule__XListLiteral__Group_3__1__Impl : ( ( rule__XListLiteral__Group_3_1__0 )* ) ; + public final void rule__XListLiteral__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15342:1: ( ( ( rule__XListLiteral__Group_3_1__0 )* ) ) + // InternalExport.g:15343:1: ( ( rule__XListLiteral__Group_3_1__0 )* ) + { + // InternalExport.g:15343:1: ( ( rule__XListLiteral__Group_3_1__0 )* ) + // InternalExport.g:15344:2: ( rule__XListLiteral__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); + } + // InternalExport.g:15345:2: ( rule__XListLiteral__Group_3_1__0 )* + loop129: + do { + int alt129=2; + int LA129_0 = input.LA(1); + + if ( (LA129_0==74) ) { + alt129=1; + } + + + switch (alt129) { + case 1 : + // InternalExport.g:15345:3: rule__XListLiteral__Group_3_1__0 + { + pushFollow(FOLLOW_22); + rule__XListLiteral__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop129; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__0" + // InternalExport.g:15354:1: rule__XListLiteral__Group_3_1__0 : rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ; + public final void rule__XListLiteral__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15358:1: ( rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ) + // InternalExport.g:15359:2: rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 + { + pushFollow(FOLLOW_98); + rule__XListLiteral__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__0" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__0__Impl" + // InternalExport.g:15366:1: rule__XListLiteral__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XListLiteral__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15370:1: ( ( ',' ) ) + // InternalExport.g:15371:1: ( ',' ) + { + // InternalExport.g:15371:1: ( ',' ) + // InternalExport.g:15372:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__1" + // InternalExport.g:15381:1: rule__XListLiteral__Group_3_1__1 : rule__XListLiteral__Group_3_1__1__Impl ; + public final void rule__XListLiteral__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15385:1: ( rule__XListLiteral__Group_3_1__1__Impl ) + // InternalExport.g:15386:2: rule__XListLiteral__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__1" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__1__Impl" + // InternalExport.g:15392:1: rule__XListLiteral__Group_3_1__1__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ; + public final void rule__XListLiteral__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15396:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ) + // InternalExport.g:15397:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) + { + // InternalExport.g:15397:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) + // InternalExport.g:15398:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); + } + // InternalExport.g:15399:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 ) + // InternalExport.g:15399:3: rule__XListLiteral__ElementsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__ElementsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XClosure__Group__0" + // InternalExport.g:15408:1: rule__XClosure__Group__0 : rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ; + public final void rule__XClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15412:1: ( rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ) + // InternalExport.g:15413:2: rule__XClosure__Group__0__Impl rule__XClosure__Group__1 + { + pushFollow(FOLLOW_102); + rule__XClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__0" + + + // $ANTLR start "rule__XClosure__Group__0__Impl" + // InternalExport.g:15420:1: rule__XClosure__Group__0__Impl : ( ( rule__XClosure__Group_0__0 ) ) ; + public final void rule__XClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15424:1: ( ( ( rule__XClosure__Group_0__0 ) ) ) + // InternalExport.g:15425:1: ( ( rule__XClosure__Group_0__0 ) ) + { + // InternalExport.g:15425:1: ( ( rule__XClosure__Group_0__0 ) ) + // InternalExport.g:15426:2: ( rule__XClosure__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_0()); + } + // InternalExport.g:15427:2: ( rule__XClosure__Group_0__0 ) + // InternalExport.g:15427:3: rule__XClosure__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__0__Impl" + + + // $ANTLR start "rule__XClosure__Group__1" + // InternalExport.g:15435:1: rule__XClosure__Group__1 : rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ; + public final void rule__XClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15439:1: ( rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ) + // InternalExport.g:15440:2: rule__XClosure__Group__1__Impl rule__XClosure__Group__2 + { + pushFollow(FOLLOW_102); + rule__XClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__1" + + + // $ANTLR start "rule__XClosure__Group__1__Impl" + // InternalExport.g:15447:1: rule__XClosure__Group__1__Impl : ( ( rule__XClosure__Group_1__0 )? ) ; + public final void rule__XClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15451:1: ( ( ( rule__XClosure__Group_1__0 )? ) ) + // InternalExport.g:15452:1: ( ( rule__XClosure__Group_1__0 )? ) + { + // InternalExport.g:15452:1: ( ( rule__XClosure__Group_1__0 )? ) + // InternalExport.g:15453:2: ( rule__XClosure__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1()); + } + // InternalExport.g:15454:2: ( rule__XClosure__Group_1__0 )? + int alt130=2; + alt130 = dfa130.predict(input); + switch (alt130) { + case 1 : + // InternalExport.g:15454:3: rule__XClosure__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__1__Impl" + + + // $ANTLR start "rule__XClosure__Group__2" + // InternalExport.g:15462:1: rule__XClosure__Group__2 : rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ; + public final void rule__XClosure__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15466:1: ( rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ) + // InternalExport.g:15467:2: rule__XClosure__Group__2__Impl rule__XClosure__Group__3 + { + pushFollow(FOLLOW_19); + rule__XClosure__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__2" + + + // $ANTLR start "rule__XClosure__Group__2__Impl" + // InternalExport.g:15474:1: rule__XClosure__Group__2__Impl : ( ( rule__XClosure__ExpressionAssignment_2 ) ) ; + public final void rule__XClosure__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15478:1: ( ( ( rule__XClosure__ExpressionAssignment_2 ) ) ) + // InternalExport.g:15479:1: ( ( rule__XClosure__ExpressionAssignment_2 ) ) + { + // InternalExport.g:15479:1: ( ( rule__XClosure__ExpressionAssignment_2 ) ) + // InternalExport.g:15480:2: ( rule__XClosure__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); + } + // InternalExport.g:15481:2: ( rule__XClosure__ExpressionAssignment_2 ) + // InternalExport.g:15481:3: rule__XClosure__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XClosure__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__2__Impl" + + + // $ANTLR start "rule__XClosure__Group__3" + // InternalExport.g:15489:1: rule__XClosure__Group__3 : rule__XClosure__Group__3__Impl ; + public final void rule__XClosure__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15493:1: ( rule__XClosure__Group__3__Impl ) + // InternalExport.g:15494:2: rule__XClosure__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__3" + + + // $ANTLR start "rule__XClosure__Group__3__Impl" + // InternalExport.g:15500:1: rule__XClosure__Group__3__Impl : ( ']' ) ; + public final void rule__XClosure__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15504:1: ( ( ']' ) ) + // InternalExport.g:15505:1: ( ']' ) + { + // InternalExport.g:15505:1: ( ']' ) + // InternalExport.g:15506:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__3__Impl" + + + // $ANTLR start "rule__XClosure__Group_0__0" + // InternalExport.g:15516:1: rule__XClosure__Group_0__0 : rule__XClosure__Group_0__0__Impl ; + public final void rule__XClosure__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15520:1: ( rule__XClosure__Group_0__0__Impl ) + // InternalExport.g:15521:2: rule__XClosure__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0__0" + + + // $ANTLR start "rule__XClosure__Group_0__0__Impl" + // InternalExport.g:15527:1: rule__XClosure__Group_0__0__Impl : ( ( rule__XClosure__Group_0_0__0 ) ) ; + public final void rule__XClosure__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15531:1: ( ( ( rule__XClosure__Group_0_0__0 ) ) ) + // InternalExport.g:15532:1: ( ( rule__XClosure__Group_0_0__0 ) ) + { + // InternalExport.g:15532:1: ( ( rule__XClosure__Group_0_0__0 ) ) + // InternalExport.g:15533:2: ( rule__XClosure__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_0_0()); + } + // InternalExport.g:15534:2: ( rule__XClosure__Group_0_0__0 ) + // InternalExport.g:15534:3: rule__XClosure__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_0_0__0" + // InternalExport.g:15543:1: rule__XClosure__Group_0_0__0 : rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ; + public final void rule__XClosure__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15547:1: ( rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ) + // InternalExport.g:15548:2: rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 + { + pushFollow(FOLLOW_30); + rule__XClosure__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__0" + + + // $ANTLR start "rule__XClosure__Group_0_0__0__Impl" + // InternalExport.g:15555:1: rule__XClosure__Group_0_0__0__Impl : ( () ) ; + public final void rule__XClosure__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15559:1: ( ( () ) ) + // InternalExport.g:15560:1: ( () ) + { + // InternalExport.g:15560:1: ( () ) + // InternalExport.g:15561:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); + } + // InternalExport.g:15562:2: () + // InternalExport.g:15562:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_0_0__1" + // InternalExport.g:15570:1: rule__XClosure__Group_0_0__1 : rule__XClosure__Group_0_0__1__Impl ; + public final void rule__XClosure__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15574:1: ( rule__XClosure__Group_0_0__1__Impl ) + // InternalExport.g:15575:2: rule__XClosure__Group_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__1" + + + // $ANTLR start "rule__XClosure__Group_0_0__1__Impl" + // InternalExport.g:15581:1: rule__XClosure__Group_0_0__1__Impl : ( '[' ) ; + public final void rule__XClosure__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15585:1: ( ( '[' ) ) + // InternalExport.g:15586:1: ( '[' ) + { + // InternalExport.g:15586:1: ( '[' ) + // InternalExport.g:15587:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1__0" + // InternalExport.g:15597:1: rule__XClosure__Group_1__0 : rule__XClosure__Group_1__0__Impl ; + public final void rule__XClosure__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15601:1: ( rule__XClosure__Group_1__0__Impl ) + // InternalExport.g:15602:2: rule__XClosure__Group_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1__0" + + + // $ANTLR start "rule__XClosure__Group_1__0__Impl" + // InternalExport.g:15608:1: rule__XClosure__Group_1__0__Impl : ( ( rule__XClosure__Group_1_0__0 ) ) ; + public final void rule__XClosure__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15612:1: ( ( ( rule__XClosure__Group_1_0__0 ) ) ) + // InternalExport.g:15613:1: ( ( rule__XClosure__Group_1_0__0 ) ) + { + // InternalExport.g:15613:1: ( ( rule__XClosure__Group_1_0__0 ) ) + // InternalExport.g:15614:2: ( rule__XClosure__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0()); + } + // InternalExport.g:15615:2: ( rule__XClosure__Group_1_0__0 ) + // InternalExport.g:15615:3: rule__XClosure__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0__0" + // InternalExport.g:15624:1: rule__XClosure__Group_1_0__0 : rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ; + public final void rule__XClosure__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15628:1: ( rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ) + // InternalExport.g:15629:2: rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 + { + pushFollow(FOLLOW_103); + rule__XClosure__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__0" + + + // $ANTLR start "rule__XClosure__Group_1_0__0__Impl" + // InternalExport.g:15636:1: rule__XClosure__Group_1_0__0__Impl : ( ( rule__XClosure__Group_1_0_0__0 )? ) ; + public final void rule__XClosure__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15640:1: ( ( ( rule__XClosure__Group_1_0_0__0 )? ) ) + // InternalExport.g:15641:1: ( ( rule__XClosure__Group_1_0_0__0 )? ) + { + // InternalExport.g:15641:1: ( ( rule__XClosure__Group_1_0_0__0 )? ) + // InternalExport.g:15642:2: ( rule__XClosure__Group_1_0_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); + } + // InternalExport.g:15643:2: ( rule__XClosure__Group_1_0_0__0 )? + int alt131=2; + int LA131_0 = input.LA(1); + + if ( (LA131_0==RULE_ID||LA131_0==51||LA131_0==77) ) { + alt131=1; + } + switch (alt131) { + case 1 : + // InternalExport.g:15643:3: rule__XClosure__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0__1" + // InternalExport.g:15651:1: rule__XClosure__Group_1_0__1 : rule__XClosure__Group_1_0__1__Impl ; + public final void rule__XClosure__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15655:1: ( rule__XClosure__Group_1_0__1__Impl ) + // InternalExport.g:15656:2: rule__XClosure__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__1" + + + // $ANTLR start "rule__XClosure__Group_1_0__1__Impl" + // InternalExport.g:15662:1: rule__XClosure__Group_1_0__1__Impl : ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ; + public final void rule__XClosure__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15666:1: ( ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ) + // InternalExport.g:15667:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) + { + // InternalExport.g:15667:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) + // InternalExport.g:15668:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); + } + // InternalExport.g:15669:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) + // InternalExport.g:15669:3: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XClosure__ExplicitSyntaxAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__0" + // InternalExport.g:15678:1: rule__XClosure__Group_1_0_0__0 : rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ; + public final void rule__XClosure__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15682:1: ( rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ) + // InternalExport.g:15683:2: rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 + { + pushFollow(FOLLOW_21); + rule__XClosure__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__0" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__0__Impl" + // InternalExport.g:15690:1: rule__XClosure__Group_1_0_0__0__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ; + public final void rule__XClosure__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15694:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ) + // InternalExport.g:15695:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) + { + // InternalExport.g:15695:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) + // InternalExport.g:15696:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); + } + // InternalExport.g:15697:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) + // InternalExport.g:15697:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__1" + // InternalExport.g:15705:1: rule__XClosure__Group_1_0_0__1 : rule__XClosure__Group_1_0_0__1__Impl ; + public final void rule__XClosure__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15709:1: ( rule__XClosure__Group_1_0_0__1__Impl ) + // InternalExport.g:15710:2: rule__XClosure__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__1" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__1__Impl" + // InternalExport.g:15716:1: rule__XClosure__Group_1_0_0__1__Impl : ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ; + public final void rule__XClosure__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15720:1: ( ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ) + // InternalExport.g:15721:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* ) + { + // InternalExport.g:15721:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* ) + // InternalExport.g:15722:2: ( rule__XClosure__Group_1_0_0_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); + } + // InternalExport.g:15723:2: ( rule__XClosure__Group_1_0_0_1__0 )* + loop132: + do { + int alt132=2; + int LA132_0 = input.LA(1); + + if ( (LA132_0==74) ) { + alt132=1; + } + + + switch (alt132) { + case 1 : + // InternalExport.g:15723:3: rule__XClosure__Group_1_0_0_1__0 + { + pushFollow(FOLLOW_22); + rule__XClosure__Group_1_0_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop132; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__0" + // InternalExport.g:15732:1: rule__XClosure__Group_1_0_0_1__0 : rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ; + public final void rule__XClosure__Group_1_0_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15736:1: ( rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ) + // InternalExport.g:15737:2: rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 + { + pushFollow(FOLLOW_78); + rule__XClosure__Group_1_0_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__0" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__0__Impl" + // InternalExport.g:15744:1: rule__XClosure__Group_1_0_0_1__0__Impl : ( ',' ) ; + public final void rule__XClosure__Group_1_0_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15748:1: ( ( ',' ) ) + // InternalExport.g:15749:1: ( ',' ) + { + // InternalExport.g:15749:1: ( ',' ) + // InternalExport.g:15750:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__1" + // InternalExport.g:15759:1: rule__XClosure__Group_1_0_0_1__1 : rule__XClosure__Group_1_0_0_1__1__Impl ; + public final void rule__XClosure__Group_1_0_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15763:1: ( rule__XClosure__Group_1_0_0_1__1__Impl ) + // InternalExport.g:15764:2: rule__XClosure__Group_1_0_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__1" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__1__Impl" + // InternalExport.g:15770:1: rule__XClosure__Group_1_0_0_1__1__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ; + public final void rule__XClosure__Group_1_0_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15774:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ) + // InternalExport.g:15775:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) + { + // InternalExport.g:15775:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) + // InternalExport.g:15776:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); + } + // InternalExport.g:15777:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) + // InternalExport.g:15777:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__1__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group__0" + // InternalExport.g:15786:1: rule__XExpressionInClosure__Group__0 : rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ; + public final void rule__XExpressionInClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15790:1: ( rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ) + // InternalExport.g:15791:2: rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 + { + pushFollow(FOLLOW_102); + rule__XExpressionInClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__0" + + + // $ANTLR start "rule__XExpressionInClosure__Group__0__Impl" + // InternalExport.g:15798:1: rule__XExpressionInClosure__Group__0__Impl : ( () ) ; + public final void rule__XExpressionInClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15802:1: ( ( () ) ) + // InternalExport.g:15803:1: ( () ) + { + // InternalExport.g:15803:1: ( () ) + // InternalExport.g:15804:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); + } + // InternalExport.g:15805:2: () + // InternalExport.g:15805:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__0__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group__1" + // InternalExport.g:15813:1: rule__XExpressionInClosure__Group__1 : rule__XExpressionInClosure__Group__1__Impl ; + public final void rule__XExpressionInClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15817:1: ( rule__XExpressionInClosure__Group__1__Impl ) + // InternalExport.g:15818:2: rule__XExpressionInClosure__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__1" + + + // $ANTLR start "rule__XExpressionInClosure__Group__1__Impl" + // InternalExport.g:15824:1: rule__XExpressionInClosure__Group__1__Impl : ( ( rule__XExpressionInClosure__Group_1__0 )* ) ; + public final void rule__XExpressionInClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15828:1: ( ( ( rule__XExpressionInClosure__Group_1__0 )* ) ) + // InternalExport.g:15829:1: ( ( rule__XExpressionInClosure__Group_1__0 )* ) + { + // InternalExport.g:15829:1: ( ( rule__XExpressionInClosure__Group_1__0 )* ) + // InternalExport.g:15830:2: ( rule__XExpressionInClosure__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); + } + // InternalExport.g:15831:2: ( rule__XExpressionInClosure__Group_1__0 )* + loop133: + do { + int alt133=2; + int LA133_0 = input.LA(1); + + if ( ((LA133_0>=RULE_ID && LA133_0<=RULE_STRING)||(LA133_0>=22 && LA133_0<=24)||LA133_0==27||(LA133_0>=36 && LA133_0<=37)||(LA133_0>=59 && LA133_0<=64)||LA133_0==66||LA133_0==68||LA133_0==72||LA133_0==77||LA133_0==87||LA133_0==90||LA133_0==95||(LA133_0>=97 && LA133_0<=104)||LA133_0==106||LA133_0==117) ) { + alt133=1; + } + + + switch (alt133) { + case 1 : + // InternalExport.g:15831:3: rule__XExpressionInClosure__Group_1__0 + { + pushFollow(FOLLOW_104); + rule__XExpressionInClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop133; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__1__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__0" + // InternalExport.g:15840:1: rule__XExpressionInClosure__Group_1__0 : rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ; + public final void rule__XExpressionInClosure__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15844:1: ( rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ) + // InternalExport.g:15845:2: rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 + { + pushFollow(FOLLOW_35); + rule__XExpressionInClosure__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__0" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__0__Impl" + // InternalExport.g:15852:1: rule__XExpressionInClosure__Group_1__0__Impl : ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ; + public final void rule__XExpressionInClosure__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15856:1: ( ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ) + // InternalExport.g:15857:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) + { + // InternalExport.g:15857:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) + // InternalExport.g:15858:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); + } + // InternalExport.g:15859:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) + // InternalExport.g:15859:3: rule__XExpressionInClosure__ExpressionsAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__ExpressionsAssignment_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__0__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__1" + // InternalExport.g:15867:1: rule__XExpressionInClosure__Group_1__1 : rule__XExpressionInClosure__Group_1__1__Impl ; + public final void rule__XExpressionInClosure__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15871:1: ( rule__XExpressionInClosure__Group_1__1__Impl ) + // InternalExport.g:15872:2: rule__XExpressionInClosure__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__1" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__1__Impl" + // InternalExport.g:15878:1: rule__XExpressionInClosure__Group_1__1__Impl : ( ( ';' )? ) ; + public final void rule__XExpressionInClosure__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15882:1: ( ( ( ';' )? ) ) + // InternalExport.g:15883:1: ( ( ';' )? ) + { + // InternalExport.g:15883:1: ( ( ';' )? ) + // InternalExport.g:15884:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + // InternalExport.g:15885:2: ( ';' )? + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==71) ) { + alt134=1; + } + switch (alt134) { + case 1 : + // InternalExport.g:15885:3: ';' + { + match(input,71,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group__0" + // InternalExport.g:15894:1: rule__XShortClosure__Group__0 : rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ; + public final void rule__XShortClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15898:1: ( rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ) + // InternalExport.g:15899:2: rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 + { + pushFollow(FOLLOW_98); + rule__XShortClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__0" + + + // $ANTLR start "rule__XShortClosure__Group__0__Impl" + // InternalExport.g:15906:1: rule__XShortClosure__Group__0__Impl : ( ( rule__XShortClosure__Group_0__0 ) ) ; + public final void rule__XShortClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15910:1: ( ( ( rule__XShortClosure__Group_0__0 ) ) ) + // InternalExport.g:15911:1: ( ( rule__XShortClosure__Group_0__0 ) ) + { + // InternalExport.g:15911:1: ( ( rule__XShortClosure__Group_0__0 ) ) + // InternalExport.g:15912:2: ( rule__XShortClosure__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0()); + } + // InternalExport.g:15913:2: ( rule__XShortClosure__Group_0__0 ) + // InternalExport.g:15913:3: rule__XShortClosure__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group__1" + // InternalExport.g:15921:1: rule__XShortClosure__Group__1 : rule__XShortClosure__Group__1__Impl ; + public final void rule__XShortClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15925:1: ( rule__XShortClosure__Group__1__Impl ) + // InternalExport.g:15926:2: rule__XShortClosure__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__1" + + + // $ANTLR start "rule__XShortClosure__Group__1__Impl" + // InternalExport.g:15932:1: rule__XShortClosure__Group__1__Impl : ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ; + public final void rule__XShortClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15936:1: ( ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ) + // InternalExport.g:15937:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) + { + // InternalExport.g:15937:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) + // InternalExport.g:15938:2: ( rule__XShortClosure__ExpressionAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); + } + // InternalExport.g:15939:2: ( rule__XShortClosure__ExpressionAssignment_1 ) + // InternalExport.g:15939:3: rule__XShortClosure__ExpressionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__ExpressionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0__0" + // InternalExport.g:15948:1: rule__XShortClosure__Group_0__0 : rule__XShortClosure__Group_0__0__Impl ; + public final void rule__XShortClosure__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15952:1: ( rule__XShortClosure__Group_0__0__Impl ) + // InternalExport.g:15953:2: rule__XShortClosure__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0__0" + + + // $ANTLR start "rule__XShortClosure__Group_0__0__Impl" + // InternalExport.g:15959:1: rule__XShortClosure__Group_0__0__Impl : ( ( rule__XShortClosure__Group_0_0__0 ) ) ; + public final void rule__XShortClosure__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15963:1: ( ( ( rule__XShortClosure__Group_0_0__0 ) ) ) + // InternalExport.g:15964:1: ( ( rule__XShortClosure__Group_0_0__0 ) ) + { + // InternalExport.g:15964:1: ( ( rule__XShortClosure__Group_0_0__0 ) ) + // InternalExport.g:15965:2: ( rule__XShortClosure__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); + } + // InternalExport.g:15966:2: ( rule__XShortClosure__Group_0_0__0 ) + // InternalExport.g:15966:3: rule__XShortClosure__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__0" + // InternalExport.g:15975:1: rule__XShortClosure__Group_0_0__0 : rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ; + public final void rule__XShortClosure__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15979:1: ( rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ) + // InternalExport.g:15980:2: rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 + { + pushFollow(FOLLOW_103); + rule__XShortClosure__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__0__Impl" + // InternalExport.g:15987:1: rule__XShortClosure__Group_0_0__0__Impl : ( () ) ; + public final void rule__XShortClosure__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:15991:1: ( ( () ) ) + // InternalExport.g:15992:1: ( () ) + { + // InternalExport.g:15992:1: ( () ) + // InternalExport.g:15993:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); + } + // InternalExport.g:15994:2: () + // InternalExport.g:15994:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__1" + // InternalExport.g:16002:1: rule__XShortClosure__Group_0_0__1 : rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ; + public final void rule__XShortClosure__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16006:1: ( rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ) + // InternalExport.g:16007:2: rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 + { + pushFollow(FOLLOW_103); + rule__XShortClosure__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__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__XShortClosure__Group_0_0__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__1__Impl" + // InternalExport.g:16014:1: rule__XShortClosure__Group_0_0__1__Impl : ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ; + public final void rule__XShortClosure__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16018:1: ( ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ) + // InternalExport.g:16019:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? ) + { + // InternalExport.g:16019:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? ) + // InternalExport.g:16020:2: ( rule__XShortClosure__Group_0_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); + } + // InternalExport.g:16021:2: ( rule__XShortClosure__Group_0_0_1__0 )? + int alt135=2; + int LA135_0 = input.LA(1); + + if ( (LA135_0==RULE_ID||LA135_0==51||LA135_0==77) ) { + alt135=1; + } + switch (alt135) { + case 1 : + // InternalExport.g:16021:3: rule__XShortClosure__Group_0_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__2" + // InternalExport.g:16029:1: rule__XShortClosure__Group_0_0__2 : rule__XShortClosure__Group_0_0__2__Impl ; + public final void rule__XShortClosure__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16033:1: ( rule__XShortClosure__Group_0_0__2__Impl ) + // InternalExport.g:16034:2: rule__XShortClosure__Group_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__2" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__2__Impl" + // InternalExport.g:16040:1: rule__XShortClosure__Group_0_0__2__Impl : ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ; + public final void rule__XShortClosure__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16044:1: ( ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ) + // InternalExport.g:16045:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) + { + // InternalExport.g:16045:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) + // InternalExport.g:16046:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); + } + // InternalExport.g:16047:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) + // InternalExport.g:16047:3: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__0" + // InternalExport.g:16056:1: rule__XShortClosure__Group_0_0_1__0 : rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ; + public final void rule__XShortClosure__Group_0_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16060:1: ( rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ) + // InternalExport.g:16061:2: rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 + { + pushFollow(FOLLOW_21); + rule__XShortClosure__Group_0_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__0__Impl" + // InternalExport.g:16068:1: rule__XShortClosure__Group_0_0_1__0__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ; + public final void rule__XShortClosure__Group_0_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16072:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ) + // InternalExport.g:16073:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) + { + // InternalExport.g:16073:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) + // InternalExport.g:16074:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); + } + // InternalExport.g:16075:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) + // InternalExport.g:16075:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__1" + // InternalExport.g:16083:1: rule__XShortClosure__Group_0_0_1__1 : rule__XShortClosure__Group_0_0_1__1__Impl ; + public final void rule__XShortClosure__Group_0_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16087:1: ( rule__XShortClosure__Group_0_0_1__1__Impl ) + // InternalExport.g:16088:2: rule__XShortClosure__Group_0_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__1__Impl" + // InternalExport.g:16094:1: rule__XShortClosure__Group_0_0_1__1__Impl : ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ; + public final void rule__XShortClosure__Group_0_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16098:1: ( ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ) + // InternalExport.g:16099:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) + { + // InternalExport.g:16099:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) + // InternalExport.g:16100:2: ( rule__XShortClosure__Group_0_0_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); + } + // InternalExport.g:16101:2: ( rule__XShortClosure__Group_0_0_1_1__0 )* + loop136: + do { + int alt136=2; + int LA136_0 = input.LA(1); + + if ( (LA136_0==74) ) { + alt136=1; + } + + + switch (alt136) { + case 1 : + // InternalExport.g:16101:3: rule__XShortClosure__Group_0_0_1_1__0 + { + pushFollow(FOLLOW_22); + rule__XShortClosure__Group_0_0_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop136; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0" + // InternalExport.g:16110:1: rule__XShortClosure__Group_0_0_1_1__0 : rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ; + public final void rule__XShortClosure__Group_0_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16114:1: ( rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ) + // InternalExport.g:16115:2: rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 + { + pushFollow(FOLLOW_78); + rule__XShortClosure__Group_0_0_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0__Impl" + // InternalExport.g:16122:1: rule__XShortClosure__Group_0_0_1_1__0__Impl : ( ',' ) ; + public final void rule__XShortClosure__Group_0_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16126:1: ( ( ',' ) ) + // InternalExport.g:16127:1: ( ',' ) + { + // InternalExport.g:16127:1: ( ',' ) + // InternalExport.g:16128:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1" + // InternalExport.g:16137:1: rule__XShortClosure__Group_0_0_1_1__1 : rule__XShortClosure__Group_0_0_1_1__1__Impl ; + public final void rule__XShortClosure__Group_0_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16141:1: ( rule__XShortClosure__Group_0_0_1_1__1__Impl ) + // InternalExport.g:16142:2: rule__XShortClosure__Group_0_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1__Impl" + // InternalExport.g:16148:1: rule__XShortClosure__Group_0_0_1_1__1__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ; + public final void rule__XShortClosure__Group_0_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16152:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ) + // InternalExport.g:16153:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) + { + // InternalExport.g:16153:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) + // InternalExport.g:16154:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); + } + // InternalExport.g:16155:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) + // InternalExport.g:16155:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__0" + // InternalExport.g:16164:1: rule__XParenthesizedExpression__Group__0 : rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ; + public final void rule__XParenthesizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16168:1: ( rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ) + // InternalExport.g:16169:2: rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 + { + pushFollow(FOLLOW_98); + rule__XParenthesizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__0" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__0__Impl" + // InternalExport.g:16176:1: rule__XParenthesizedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__XParenthesizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16180:1: ( ( '(' ) ) + // InternalExport.g:16181:1: ( '(' ) + { + // InternalExport.g:16181:1: ( '(' ) + // InternalExport.g:16182:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__1" + // InternalExport.g:16191:1: rule__XParenthesizedExpression__Group__1 : rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ; + public final void rule__XParenthesizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16195:1: ( rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ) + // InternalExport.g:16196:2: rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 + { + pushFollow(FOLLOW_25); + rule__XParenthesizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__1" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__1__Impl" + // InternalExport.g:16203:1: rule__XParenthesizedExpression__Group__1__Impl : ( ruleXExpression ) ; + public final void rule__XParenthesizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16207:1: ( ( ruleXExpression ) ) + // InternalExport.g:16208:1: ( ruleXExpression ) + { + // InternalExport.g:16208:1: ( ruleXExpression ) + // InternalExport.g:16209:2: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__2" + // InternalExport.g:16218:1: rule__XParenthesizedExpression__Group__2 : rule__XParenthesizedExpression__Group__2__Impl ; + public final void rule__XParenthesizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16222:1: ( rule__XParenthesizedExpression__Group__2__Impl ) + // InternalExport.g:16223:2: rule__XParenthesizedExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__2" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__2__Impl" + // InternalExport.g:16229:1: rule__XParenthesizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XParenthesizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16233:1: ( ( ')' ) ) + // InternalExport.g:16234:1: ( ')' ) + { + // InternalExport.g:16234:1: ( ')' ) + // InternalExport.g:16235:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__0" + // InternalExport.g:16245:1: rule__XIfExpression__Group__0 : rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ; + public final void rule__XIfExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16249:1: ( rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ) + // InternalExport.g:16250:2: rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 + { + pushFollow(FOLLOW_105); + rule__XIfExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__0" + + + // $ANTLR start "rule__XIfExpression__Group__0__Impl" + // InternalExport.g:16257:1: rule__XIfExpression__Group__0__Impl : ( () ) ; + public final void rule__XIfExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16261:1: ( ( () ) ) + // InternalExport.g:16262:1: ( () ) + { + // InternalExport.g:16262:1: ( () ) + // InternalExport.g:16263:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); + } + // InternalExport.g:16264:2: () + // InternalExport.g:16264:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__0__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__1" + // InternalExport.g:16272:1: rule__XIfExpression__Group__1 : rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ; + public final void rule__XIfExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16276:1: ( rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ) + // InternalExport.g:16277:2: rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 + { + pushFollow(FOLLOW_34); + rule__XIfExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__1" + + + // $ANTLR start "rule__XIfExpression__Group__1__Impl" + // InternalExport.g:16284:1: rule__XIfExpression__Group__1__Impl : ( 'if' ) ; + public final void rule__XIfExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16288:1: ( ( 'if' ) ) + // InternalExport.g:16289:1: ( 'if' ) + { + // InternalExport.g:16289:1: ( 'if' ) + // InternalExport.g:16290:2: 'if' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + match(input,87,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__1__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__2" + // InternalExport.g:16299:1: rule__XIfExpression__Group__2 : rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ; + public final void rule__XIfExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16303:1: ( rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ) + // InternalExport.g:16304:2: rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 + { + pushFollow(FOLLOW_98); + rule__XIfExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__2" + + + // $ANTLR start "rule__XIfExpression__Group__2__Impl" + // InternalExport.g:16311:1: rule__XIfExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XIfExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16315:1: ( ( '(' ) ) + // InternalExport.g:16316:1: ( '(' ) + { + // InternalExport.g:16316:1: ( '(' ) + // InternalExport.g:16317:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__2__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__3" + // InternalExport.g:16326:1: rule__XIfExpression__Group__3 : rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ; + public final void rule__XIfExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16330:1: ( rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ) + // InternalExport.g:16331:2: rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 + { + pushFollow(FOLLOW_25); + rule__XIfExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__3" + + + // $ANTLR start "rule__XIfExpression__Group__3__Impl" + // InternalExport.g:16338:1: rule__XIfExpression__Group__3__Impl : ( ( rule__XIfExpression__IfAssignment_3 ) ) ; + public final void rule__XIfExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16342:1: ( ( ( rule__XIfExpression__IfAssignment_3 ) ) ) + // InternalExport.g:16343:1: ( ( rule__XIfExpression__IfAssignment_3 ) ) + { + // InternalExport.g:16343:1: ( ( rule__XIfExpression__IfAssignment_3 ) ) + // InternalExport.g:16344:2: ( rule__XIfExpression__IfAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); + } + // InternalExport.g:16345:2: ( rule__XIfExpression__IfAssignment_3 ) + // InternalExport.g:16345:3: rule__XIfExpression__IfAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__IfAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__3__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__4" + // InternalExport.g:16353:1: rule__XIfExpression__Group__4 : rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ; + public final void rule__XIfExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16357:1: ( rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ) + // InternalExport.g:16358:2: rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 + { + pushFollow(FOLLOW_98); + rule__XIfExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__4" + + + // $ANTLR start "rule__XIfExpression__Group__4__Impl" + // InternalExport.g:16365:1: rule__XIfExpression__Group__4__Impl : ( ')' ) ; + public final void rule__XIfExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16369:1: ( ( ')' ) ) + // InternalExport.g:16370:1: ( ')' ) + { + // InternalExport.g:16370:1: ( ')' ) + // InternalExport.g:16371:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__4__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__5" + // InternalExport.g:16380:1: rule__XIfExpression__Group__5 : rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ; + public final void rule__XIfExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16384:1: ( rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ) + // InternalExport.g:16385:2: rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 + { + pushFollow(FOLLOW_45); + rule__XIfExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__5" + + + // $ANTLR start "rule__XIfExpression__Group__5__Impl" + // InternalExport.g:16392:1: rule__XIfExpression__Group__5__Impl : ( ( rule__XIfExpression__ThenAssignment_5 ) ) ; + public final void rule__XIfExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16396:1: ( ( ( rule__XIfExpression__ThenAssignment_5 ) ) ) + // InternalExport.g:16397:1: ( ( rule__XIfExpression__ThenAssignment_5 ) ) + { + // InternalExport.g:16397:1: ( ( rule__XIfExpression__ThenAssignment_5 ) ) + // InternalExport.g:16398:2: ( rule__XIfExpression__ThenAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); + } + // InternalExport.g:16399:2: ( rule__XIfExpression__ThenAssignment_5 ) + // InternalExport.g:16399:3: rule__XIfExpression__ThenAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__ThenAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__5__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__6" + // InternalExport.g:16407:1: rule__XIfExpression__Group__6 : rule__XIfExpression__Group__6__Impl ; + public final void rule__XIfExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16411:1: ( rule__XIfExpression__Group__6__Impl ) + // InternalExport.g:16412:2: rule__XIfExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__6" + + + // $ANTLR start "rule__XIfExpression__Group__6__Impl" + // InternalExport.g:16418:1: rule__XIfExpression__Group__6__Impl : ( ( rule__XIfExpression__Group_6__0 )? ) ; + public final void rule__XIfExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16422:1: ( ( ( rule__XIfExpression__Group_6__0 )? ) ) + // InternalExport.g:16423:1: ( ( rule__XIfExpression__Group_6__0 )? ) + { + // InternalExport.g:16423:1: ( ( rule__XIfExpression__Group_6__0 )? ) + // InternalExport.g:16424:2: ( rule__XIfExpression__Group_6__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getGroup_6()); + } + // InternalExport.g:16425:2: ( rule__XIfExpression__Group_6__0 )? + int alt137=2; + int LA137_0 = input.LA(1); + + if ( (LA137_0==89) ) { + int LA137_1 = input.LA(2); + + if ( (synpred211_InternalExport()) ) { + alt137=1; + } + } + switch (alt137) { + case 1 : + // InternalExport.g:16425:3: rule__XIfExpression__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getGroup_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__6__Impl" + + + // $ANTLR start "rule__XIfExpression__Group_6__0" + // InternalExport.g:16434:1: rule__XIfExpression__Group_6__0 : rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ; + public final void rule__XIfExpression__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16438:1: ( rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ) + // InternalExport.g:16439:2: rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 + { + pushFollow(FOLLOW_98); + rule__XIfExpression__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__0" + + + // $ANTLR start "rule__XIfExpression__Group_6__0__Impl" + // InternalExport.g:16446:1: rule__XIfExpression__Group_6__0__Impl : ( ( 'else' ) ) ; + public final void rule__XIfExpression__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16450:1: ( ( ( 'else' ) ) ) + // InternalExport.g:16451:1: ( ( 'else' ) ) + { + // InternalExport.g:16451:1: ( ( 'else' ) ) + // InternalExport.g:16452:2: ( 'else' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + // InternalExport.g:16453:2: ( 'else' ) + // InternalExport.g:16453:3: 'else' + { + match(input,89,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__0__Impl" + + + // $ANTLR start "rule__XIfExpression__Group_6__1" + // InternalExport.g:16461:1: rule__XIfExpression__Group_6__1 : rule__XIfExpression__Group_6__1__Impl ; + public final void rule__XIfExpression__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16465:1: ( rule__XIfExpression__Group_6__1__Impl ) + // InternalExport.g:16466:2: rule__XIfExpression__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__1" + + + // $ANTLR start "rule__XIfExpression__Group_6__1__Impl" + // InternalExport.g:16472:1: rule__XIfExpression__Group_6__1__Impl : ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ; + public final void rule__XIfExpression__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16476:1: ( ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ) + // InternalExport.g:16477:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) + { + // InternalExport.g:16477:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) + // InternalExport.g:16478:2: ( rule__XIfExpression__ElseAssignment_6_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); + } + // InternalExport.g:16479:2: ( rule__XIfExpression__ElseAssignment_6_1 ) + // InternalExport.g:16479:3: rule__XIfExpression__ElseAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__ElseAssignment_6_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__0" + // InternalExport.g:16488:1: rule__XSwitchExpression__Group__0 : rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ; + public final void rule__XSwitchExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16492:1: ( rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ) + // InternalExport.g:16493:2: rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 + { + pushFollow(FOLLOW_106); + rule__XSwitchExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__0" + + + // $ANTLR start "rule__XSwitchExpression__Group__0__Impl" + // InternalExport.g:16500:1: rule__XSwitchExpression__Group__0__Impl : ( () ) ; + public final void rule__XSwitchExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16504:1: ( ( () ) ) + // InternalExport.g:16505:1: ( () ) + { + // InternalExport.g:16505:1: ( () ) + // InternalExport.g:16506:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); + } + // InternalExport.g:16507:2: () + // InternalExport.g:16507:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__1" + // InternalExport.g:16515:1: rule__XSwitchExpression__Group__1 : rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ; + public final void rule__XSwitchExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16519:1: ( rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ) + // InternalExport.g:16520:2: rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 + { + pushFollow(FOLLOW_98); + rule__XSwitchExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__1" + + + // $ANTLR start "rule__XSwitchExpression__Group__1__Impl" + // InternalExport.g:16527:1: rule__XSwitchExpression__Group__1__Impl : ( 'switch' ) ; + public final void rule__XSwitchExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16531:1: ( ( 'switch' ) ) + // InternalExport.g:16532:1: ( 'switch' ) + { + // InternalExport.g:16532:1: ( 'switch' ) + // InternalExport.g:16533:2: 'switch' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + match(input,90,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__2" + // InternalExport.g:16542:1: rule__XSwitchExpression__Group__2 : rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ; + public final void rule__XSwitchExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16546:1: ( rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ) + // InternalExport.g:16547:2: rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 + { + pushFollow(FOLLOW_12); + rule__XSwitchExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__2" + + + // $ANTLR start "rule__XSwitchExpression__Group__2__Impl" + // InternalExport.g:16554:1: rule__XSwitchExpression__Group__2__Impl : ( ( rule__XSwitchExpression__Alternatives_2 ) ) ; + public final void rule__XSwitchExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16558:1: ( ( ( rule__XSwitchExpression__Alternatives_2 ) ) ) + // InternalExport.g:16559:1: ( ( rule__XSwitchExpression__Alternatives_2 ) ) + { + // InternalExport.g:16559:1: ( ( rule__XSwitchExpression__Alternatives_2 ) ) + // InternalExport.g:16560:2: ( rule__XSwitchExpression__Alternatives_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); + } + // InternalExport.g:16561:2: ( rule__XSwitchExpression__Alternatives_2 ) + // InternalExport.g:16561:3: rule__XSwitchExpression__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__3" + // InternalExport.g:16569:1: rule__XSwitchExpression__Group__3 : rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ; + public final void rule__XSwitchExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16573:1: ( rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ) + // InternalExport.g:16574:2: rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 + { + pushFollow(FOLLOW_107); + rule__XSwitchExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__3" + + + // $ANTLR start "rule__XSwitchExpression__Group__3__Impl" + // InternalExport.g:16581:1: rule__XSwitchExpression__Group__3__Impl : ( '{' ) ; + public final void rule__XSwitchExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16585:1: ( ( '{' ) ) + // InternalExport.g:16586:1: ( '{' ) + { + // InternalExport.g:16586:1: ( '{' ) + // InternalExport.g:16587:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__3__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__4" + // InternalExport.g:16596:1: rule__XSwitchExpression__Group__4 : rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ; + public final void rule__XSwitchExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16600:1: ( rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ) + // InternalExport.g:16601:2: rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 + { + pushFollow(FOLLOW_107); + rule__XSwitchExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__4" + + + // $ANTLR start "rule__XSwitchExpression__Group__4__Impl" + // InternalExport.g:16608:1: rule__XSwitchExpression__Group__4__Impl : ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ; + public final void rule__XSwitchExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16612:1: ( ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ) + // InternalExport.g:16613:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) + { + // InternalExport.g:16613:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) + // InternalExport.g:16614:2: ( rule__XSwitchExpression__CasesAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); + } + // InternalExport.g:16615:2: ( rule__XSwitchExpression__CasesAssignment_4 )* + loop138: + do { + int alt138=2; + int LA138_0 = input.LA(1); + + if ( (LA138_0==RULE_ID||LA138_0==51||LA138_0==74||LA138_0==77||LA138_0==85||LA138_0==92) ) { + alt138=1; + } + + + switch (alt138) { + case 1 : + // InternalExport.g:16615:3: rule__XSwitchExpression__CasesAssignment_4 + { + pushFollow(FOLLOW_108); + rule__XSwitchExpression__CasesAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop138; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__4__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__5" + // InternalExport.g:16623:1: rule__XSwitchExpression__Group__5 : rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ; + public final void rule__XSwitchExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16627:1: ( rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ) + // InternalExport.g:16628:2: rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 + { + pushFollow(FOLLOW_107); + rule__XSwitchExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__5" + + + // $ANTLR start "rule__XSwitchExpression__Group__5__Impl" + // InternalExport.g:16635:1: rule__XSwitchExpression__Group__5__Impl : ( ( rule__XSwitchExpression__Group_5__0 )? ) ; + public final void rule__XSwitchExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16639:1: ( ( ( rule__XSwitchExpression__Group_5__0 )? ) ) + // InternalExport.g:16640:1: ( ( rule__XSwitchExpression__Group_5__0 )? ) + { + // InternalExport.g:16640:1: ( ( rule__XSwitchExpression__Group_5__0 )? ) + // InternalExport.g:16641:2: ( rule__XSwitchExpression__Group_5__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); + } + // InternalExport.g:16642:2: ( rule__XSwitchExpression__Group_5__0 )? + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==91) ) { + alt139=1; + } + switch (alt139) { + case 1 : + // InternalExport.g:16642:3: rule__XSwitchExpression__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__5__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__6" + // InternalExport.g:16650:1: rule__XSwitchExpression__Group__6 : rule__XSwitchExpression__Group__6__Impl ; + public final void rule__XSwitchExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16654:1: ( rule__XSwitchExpression__Group__6__Impl ) + // InternalExport.g:16655:2: rule__XSwitchExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__6" + + + // $ANTLR start "rule__XSwitchExpression__Group__6__Impl" + // InternalExport.g:16661:1: rule__XSwitchExpression__Group__6__Impl : ( '}' ) ; + public final void rule__XSwitchExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16665:1: ( ( '}' ) ) + // InternalExport.g:16666:1: ( '}' ) + { + // InternalExport.g:16666:1: ( '}' ) + // InternalExport.g:16667:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + match(input,69,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__6__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__0" + // InternalExport.g:16677:1: rule__XSwitchExpression__Group_2_0__0 : rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ; + public final void rule__XSwitchExpression__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16681:1: ( rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ) + // InternalExport.g:16682:2: rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 + { + pushFollow(FOLLOW_98); + rule__XSwitchExpression__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__0__Impl" + // InternalExport.g:16689:1: rule__XSwitchExpression__Group_2_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16693:1: ( ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ) + // InternalExport.g:16694:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) + { + // InternalExport.g:16694:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) + // InternalExport.g:16695:2: ( rule__XSwitchExpression__Group_2_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); + } + // InternalExport.g:16696:2: ( rule__XSwitchExpression__Group_2_0_0__0 ) + // InternalExport.g:16696:3: rule__XSwitchExpression__Group_2_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__1" + // InternalExport.g:16704:1: rule__XSwitchExpression__Group_2_0__1 : rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ; + public final void rule__XSwitchExpression__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16708:1: ( rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ) + // InternalExport.g:16709:2: rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 + { + pushFollow(FOLLOW_25); + rule__XSwitchExpression__Group_2_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__1__Impl" + // InternalExport.g:16716:1: rule__XSwitchExpression__Group_2_0__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16720:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ) + // InternalExport.g:16721:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) + { + // InternalExport.g:16721:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) + // InternalExport.g:16722:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); + } + // InternalExport.g:16723:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) + // InternalExport.g:16723:3: rule__XSwitchExpression__SwitchAssignment_2_0_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__SwitchAssignment_2_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__2" + // InternalExport.g:16731:1: rule__XSwitchExpression__Group_2_0__2 : rule__XSwitchExpression__Group_2_0__2__Impl ; + public final void rule__XSwitchExpression__Group_2_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16735:1: ( rule__XSwitchExpression__Group_2_0__2__Impl ) + // InternalExport.g:16736:2: rule__XSwitchExpression__Group_2_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__2__Impl" + // InternalExport.g:16742:1: rule__XSwitchExpression__Group_2_0__2__Impl : ( ')' ) ; + public final void rule__XSwitchExpression__Group_2_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16746:1: ( ( ')' ) ) + // InternalExport.g:16747:1: ( ')' ) + { + // InternalExport.g:16747:1: ( ')' ) + // InternalExport.g:16748:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0" + // InternalExport.g:16758:1: rule__XSwitchExpression__Group_2_0_0__0 : rule__XSwitchExpression__Group_2_0_0__0__Impl ; + public final void rule__XSwitchExpression__Group_2_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16762:1: ( rule__XSwitchExpression__Group_2_0_0__0__Impl ) + // InternalExport.g:16763:2: rule__XSwitchExpression__Group_2_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0__Impl" + // InternalExport.g:16769:1: rule__XSwitchExpression__Group_2_0_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16773:1: ( ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ) + // InternalExport.g:16774:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) + { + // InternalExport.g:16774:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) + // InternalExport.g:16775:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); + } + // InternalExport.g:16776:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 ) + // InternalExport.g:16776:3: rule__XSwitchExpression__Group_2_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0" + // InternalExport.g:16785:1: rule__XSwitchExpression__Group_2_0_0_0__0 : rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ; + public final void rule__XSwitchExpression__Group_2_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16789:1: ( rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ) + // InternalExport.g:16790:2: rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 + { + pushFollow(FOLLOW_78); + rule__XSwitchExpression__Group_2_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0__Impl" + // InternalExport.g:16797:1: rule__XSwitchExpression__Group_2_0_0_0__0__Impl : ( '(' ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16801:1: ( ( '(' ) ) + // InternalExport.g:16802:1: ( '(' ) + { + // InternalExport.g:16802:1: ( '(' ) + // InternalExport.g:16803:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1" + // InternalExport.g:16812:1: rule__XSwitchExpression__Group_2_0_0_0__1 : rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ; + public final void rule__XSwitchExpression__Group_2_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16816:1: ( rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ) + // InternalExport.g:16817:2: rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 + { + pushFollow(FOLLOW_39); + rule__XSwitchExpression__Group_2_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1__Impl" + // InternalExport.g:16824:1: rule__XSwitchExpression__Group_2_0_0_0__1__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16828:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ) + // InternalExport.g:16829:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) + { + // InternalExport.g:16829:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) + // InternalExport.g:16830:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); + } + // InternalExport.g:16831:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) + // InternalExport.g:16831:3: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2" + // InternalExport.g:16839:1: rule__XSwitchExpression__Group_2_0_0_0__2 : rule__XSwitchExpression__Group_2_0_0_0__2__Impl ; + public final void rule__XSwitchExpression__Group_2_0_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16843:1: ( rule__XSwitchExpression__Group_2_0_0_0__2__Impl ) + // InternalExport.g:16844:2: rule__XSwitchExpression__Group_2_0_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2__Impl" + // InternalExport.g:16850:1: rule__XSwitchExpression__Group_2_0_0_0__2__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16854:1: ( ( ':' ) ) + // InternalExport.g:16855:1: ( ':' ) + { + // InternalExport.g:16855:1: ( ':' ) + // InternalExport.g:16856:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + match(input,85,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__0" + // InternalExport.g:16866:1: rule__XSwitchExpression__Group_2_1__0 : rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ; + public final void rule__XSwitchExpression__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16870:1: ( rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ) + // InternalExport.g:16871:2: rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 + { + pushFollow(FOLLOW_98); + rule__XSwitchExpression__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__0__Impl" + // InternalExport.g:16878:1: rule__XSwitchExpression__Group_2_1__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ; + public final void rule__XSwitchExpression__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16882:1: ( ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ) + // InternalExport.g:16883:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) + { + // InternalExport.g:16883:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) + // InternalExport.g:16884:2: ( rule__XSwitchExpression__Group_2_1_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); + } + // InternalExport.g:16885:2: ( rule__XSwitchExpression__Group_2_1_0__0 )? + int alt140=2; + alt140 = dfa140.predict(input); + switch (alt140) { + case 1 : + // InternalExport.g:16885:3: rule__XSwitchExpression__Group_2_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__1" + // InternalExport.g:16893:1: rule__XSwitchExpression__Group_2_1__1 : rule__XSwitchExpression__Group_2_1__1__Impl ; + public final void rule__XSwitchExpression__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16897:1: ( rule__XSwitchExpression__Group_2_1__1__Impl ) + // InternalExport.g:16898:2: rule__XSwitchExpression__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__1__Impl" + // InternalExport.g:16904:1: rule__XSwitchExpression__Group_2_1__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16908:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ) + // InternalExport.g:16909:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) + { + // InternalExport.g:16909:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) + // InternalExport.g:16910:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); + } + // InternalExport.g:16911:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) + // InternalExport.g:16911:3: rule__XSwitchExpression__SwitchAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__SwitchAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0" + // InternalExport.g:16920:1: rule__XSwitchExpression__Group_2_1_0__0 : rule__XSwitchExpression__Group_2_1_0__0__Impl ; + public final void rule__XSwitchExpression__Group_2_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16924:1: ( rule__XSwitchExpression__Group_2_1_0__0__Impl ) + // InternalExport.g:16925:2: rule__XSwitchExpression__Group_2_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0__Impl" + // InternalExport.g:16931:1: rule__XSwitchExpression__Group_2_1_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16935:1: ( ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ) + // InternalExport.g:16936:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) + { + // InternalExport.g:16936:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) + // InternalExport.g:16937:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); + } + // InternalExport.g:16938:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 ) + // InternalExport.g:16938:3: rule__XSwitchExpression__Group_2_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0" + // InternalExport.g:16947:1: rule__XSwitchExpression__Group_2_1_0_0__0 : rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ; + public final void rule__XSwitchExpression__Group_2_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16951:1: ( rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ) + // InternalExport.g:16952:2: rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 + { + pushFollow(FOLLOW_39); + rule__XSwitchExpression__Group_2_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0__Impl" + // InternalExport.g:16959:1: rule__XSwitchExpression__Group_2_1_0_0__0__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ; + public final void rule__XSwitchExpression__Group_2_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16963:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ) + // InternalExport.g:16964:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) + { + // InternalExport.g:16964:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) + // InternalExport.g:16965:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); + } + // InternalExport.g:16966:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) + // InternalExport.g:16966:3: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1" + // InternalExport.g:16974:1: rule__XSwitchExpression__Group_2_1_0_0__1 : rule__XSwitchExpression__Group_2_1_0_0__1__Impl ; + public final void rule__XSwitchExpression__Group_2_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16978:1: ( rule__XSwitchExpression__Group_2_1_0_0__1__Impl ) + // InternalExport.g:16979:2: rule__XSwitchExpression__Group_2_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1__Impl" + // InternalExport.g:16985:1: rule__XSwitchExpression__Group_2_1_0_0__1__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_2_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:16989:1: ( ( ':' ) ) + // InternalExport.g:16990:1: ( ':' ) + { + // InternalExport.g:16990:1: ( ':' ) + // InternalExport.g:16991:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + match(input,85,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__0" + // InternalExport.g:17001:1: rule__XSwitchExpression__Group_5__0 : rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ; + public final void rule__XSwitchExpression__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17005:1: ( rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ) + // InternalExport.g:17006:2: rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 + { + pushFollow(FOLLOW_39); + rule__XSwitchExpression__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__0__Impl" + // InternalExport.g:17013:1: rule__XSwitchExpression__Group_5__0__Impl : ( 'default' ) ; + public final void rule__XSwitchExpression__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17017:1: ( ( 'default' ) ) + // InternalExport.g:17018:1: ( 'default' ) + { + // InternalExport.g:17018:1: ( 'default' ) + // InternalExport.g:17019:2: 'default' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + match(input,91,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__1" + // InternalExport.g:17028:1: rule__XSwitchExpression__Group_5__1 : rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ; + public final void rule__XSwitchExpression__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17032:1: ( rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ) + // InternalExport.g:17033:2: rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 + { + pushFollow(FOLLOW_98); + rule__XSwitchExpression__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__1__Impl" + // InternalExport.g:17040:1: rule__XSwitchExpression__Group_5__1__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17044:1: ( ( ':' ) ) + // InternalExport.g:17045:1: ( ':' ) + { + // InternalExport.g:17045:1: ( ':' ) + // InternalExport.g:17046:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + match(input,85,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__2" + // InternalExport.g:17055:1: rule__XSwitchExpression__Group_5__2 : rule__XSwitchExpression__Group_5__2__Impl ; + public final void rule__XSwitchExpression__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17059:1: ( rule__XSwitchExpression__Group_5__2__Impl ) + // InternalExport.g:17060:2: rule__XSwitchExpression__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__2__Impl" + // InternalExport.g:17066:1: rule__XSwitchExpression__Group_5__2__Impl : ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ; + public final void rule__XSwitchExpression__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17070:1: ( ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ) + // InternalExport.g:17071:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) + { + // InternalExport.g:17071:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) + // InternalExport.g:17072:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); + } + // InternalExport.g:17073:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 ) + // InternalExport.g:17073:3: rule__XSwitchExpression__DefaultAssignment_5_2 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DefaultAssignment_5_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__2__Impl" + + + // $ANTLR start "rule__XCasePart__Group__0" + // InternalExport.g:17082:1: rule__XCasePart__Group__0 : rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ; + public final void rule__XCasePart__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17086:1: ( rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ) + // InternalExport.g:17087:2: rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 + { + pushFollow(FOLLOW_109); + rule__XCasePart__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__0" + + + // $ANTLR start "rule__XCasePart__Group__0__Impl" + // InternalExport.g:17094:1: rule__XCasePart__Group__0__Impl : ( () ) ; + public final void rule__XCasePart__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17098:1: ( ( () ) ) + // InternalExport.g:17099:1: ( () ) + { + // InternalExport.g:17099:1: ( () ) + // InternalExport.g:17100:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); + } + // InternalExport.g:17101:2: () + // InternalExport.g:17101:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group__1" + // InternalExport.g:17109:1: rule__XCasePart__Group__1 : rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ; + public final void rule__XCasePart__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17113:1: ( rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ) + // InternalExport.g:17114:2: rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 + { + pushFollow(FOLLOW_109); + rule__XCasePart__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__1" + + + // $ANTLR start "rule__XCasePart__Group__1__Impl" + // InternalExport.g:17121:1: rule__XCasePart__Group__1__Impl : ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ; + public final void rule__XCasePart__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17125:1: ( ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ) + // InternalExport.g:17126:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) + { + // InternalExport.g:17126:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) + // InternalExport.g:17127:2: ( rule__XCasePart__TypeGuardAssignment_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); + } + // InternalExport.g:17128:2: ( rule__XCasePart__TypeGuardAssignment_1 )? + int alt141=2; + int LA141_0 = input.LA(1); + + if ( (LA141_0==RULE_ID||LA141_0==51||LA141_0==77) ) { + alt141=1; + } + switch (alt141) { + case 1 : + // InternalExport.g:17128:3: rule__XCasePart__TypeGuardAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__TypeGuardAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__1__Impl" + + + // $ANTLR start "rule__XCasePart__Group__2" + // InternalExport.g:17136:1: rule__XCasePart__Group__2 : rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ; + public final void rule__XCasePart__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17140:1: ( rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ) + // InternalExport.g:17141:2: rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 + { + pushFollow(FOLLOW_109); + rule__XCasePart__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__2" + + + // $ANTLR start "rule__XCasePart__Group__2__Impl" + // InternalExport.g:17148:1: rule__XCasePart__Group__2__Impl : ( ( rule__XCasePart__Group_2__0 )? ) ; + public final void rule__XCasePart__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17152:1: ( ( ( rule__XCasePart__Group_2__0 )? ) ) + // InternalExport.g:17153:1: ( ( rule__XCasePart__Group_2__0 )? ) + { + // InternalExport.g:17153:1: ( ( rule__XCasePart__Group_2__0 )? ) + // InternalExport.g:17154:2: ( rule__XCasePart__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup_2()); + } + // InternalExport.g:17155:2: ( rule__XCasePart__Group_2__0 )? + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==92) ) { + alt142=1; + } + switch (alt142) { + case 1 : + // InternalExport.g:17155:3: rule__XCasePart__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__2__Impl" + + + // $ANTLR start "rule__XCasePart__Group__3" + // InternalExport.g:17163:1: rule__XCasePart__Group__3 : rule__XCasePart__Group__3__Impl ; + public final void rule__XCasePart__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17167:1: ( rule__XCasePart__Group__3__Impl ) + // InternalExport.g:17168:2: rule__XCasePart__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__3" + + + // $ANTLR start "rule__XCasePart__Group__3__Impl" + // InternalExport.g:17174:1: rule__XCasePart__Group__3__Impl : ( ( rule__XCasePart__Alternatives_3 ) ) ; + public final void rule__XCasePart__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17178:1: ( ( ( rule__XCasePart__Alternatives_3 ) ) ) + // InternalExport.g:17179:1: ( ( rule__XCasePart__Alternatives_3 ) ) + { + // InternalExport.g:17179:1: ( ( rule__XCasePart__Alternatives_3 ) ) + // InternalExport.g:17180:2: ( rule__XCasePart__Alternatives_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getAlternatives_3()); + } + // InternalExport.g:17181:2: ( rule__XCasePart__Alternatives_3 ) + // InternalExport.g:17181:3: rule__XCasePart__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getAlternatives_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__3__Impl" + + + // $ANTLR start "rule__XCasePart__Group_2__0" + // InternalExport.g:17190:1: rule__XCasePart__Group_2__0 : rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ; + public final void rule__XCasePart__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17194:1: ( rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ) + // InternalExport.g:17195:2: rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 + { + pushFollow(FOLLOW_98); + rule__XCasePart__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__0" + + + // $ANTLR start "rule__XCasePart__Group_2__0__Impl" + // InternalExport.g:17202:1: rule__XCasePart__Group_2__0__Impl : ( 'case' ) ; + public final void rule__XCasePart__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17206:1: ( ( 'case' ) ) + // InternalExport.g:17207:1: ( 'case' ) + { + // InternalExport.g:17207:1: ( 'case' ) + // InternalExport.g:17208:2: 'case' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group_2__1" + // InternalExport.g:17217:1: rule__XCasePart__Group_2__1 : rule__XCasePart__Group_2__1__Impl ; + public final void rule__XCasePart__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17221:1: ( rule__XCasePart__Group_2__1__Impl ) + // InternalExport.g:17222:2: rule__XCasePart__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__1" + + + // $ANTLR start "rule__XCasePart__Group_2__1__Impl" + // InternalExport.g:17228:1: rule__XCasePart__Group_2__1__Impl : ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ; + public final void rule__XCasePart__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17232:1: ( ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ) + // InternalExport.g:17233:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) ) + { + // InternalExport.g:17233:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) ) + // InternalExport.g:17234:2: ( rule__XCasePart__CaseAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); + } + // InternalExport.g:17235:2: ( rule__XCasePart__CaseAssignment_2_1 ) + // InternalExport.g:17235:3: rule__XCasePart__CaseAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__CaseAssignment_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__1__Impl" + + + // $ANTLR start "rule__XCasePart__Group_3_0__0" + // InternalExport.g:17244:1: rule__XCasePart__Group_3_0__0 : rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ; + public final void rule__XCasePart__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17248:1: ( rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ) + // InternalExport.g:17249:2: rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 + { + pushFollow(FOLLOW_98); + rule__XCasePart__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__0" + + + // $ANTLR start "rule__XCasePart__Group_3_0__0__Impl" + // InternalExport.g:17256:1: rule__XCasePart__Group_3_0__0__Impl : ( ':' ) ; + public final void rule__XCasePart__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17260:1: ( ( ':' ) ) + // InternalExport.g:17261:1: ( ':' ) + { + // InternalExport.g:17261:1: ( ':' ) + // InternalExport.g:17262:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + match(input,85,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group_3_0__1" + // InternalExport.g:17271:1: rule__XCasePart__Group_3_0__1 : rule__XCasePart__Group_3_0__1__Impl ; + public final void rule__XCasePart__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17275:1: ( rule__XCasePart__Group_3_0__1__Impl ) + // InternalExport.g:17276:2: rule__XCasePart__Group_3_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__1" + + + // $ANTLR start "rule__XCasePart__Group_3_0__1__Impl" + // InternalExport.g:17282:1: rule__XCasePart__Group_3_0__1__Impl : ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ; + public final void rule__XCasePart__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17286:1: ( ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ) + // InternalExport.g:17287:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) + { + // InternalExport.g:17287:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) + // InternalExport.g:17288:2: ( rule__XCasePart__ThenAssignment_3_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); + } + // InternalExport.g:17289:2: ( rule__XCasePart__ThenAssignment_3_0_1 ) + // InternalExport.g:17289:3: rule__XCasePart__ThenAssignment_3_0_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__ThenAssignment_3_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__0" + // InternalExport.g:17298:1: rule__XForLoopExpression__Group__0 : rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ; + public final void rule__XForLoopExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17302:1: ( rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ) + // InternalExport.g:17303:2: rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 + { + pushFollow(FOLLOW_98); + rule__XForLoopExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__0" + + + // $ANTLR start "rule__XForLoopExpression__Group__0__Impl" + // InternalExport.g:17310:1: rule__XForLoopExpression__Group__0__Impl : ( ( rule__XForLoopExpression__Group_0__0 ) ) ; + public final void rule__XForLoopExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17314:1: ( ( ( rule__XForLoopExpression__Group_0__0 ) ) ) + // InternalExport.g:17315:1: ( ( rule__XForLoopExpression__Group_0__0 ) ) + { + // InternalExport.g:17315:1: ( ( rule__XForLoopExpression__Group_0__0 ) ) + // InternalExport.g:17316:2: ( rule__XForLoopExpression__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); + } + // InternalExport.g:17317:2: ( rule__XForLoopExpression__Group_0__0 ) + // InternalExport.g:17317:3: rule__XForLoopExpression__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__1" + // InternalExport.g:17325:1: rule__XForLoopExpression__Group__1 : rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ; + public final void rule__XForLoopExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17329:1: ( rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ) + // InternalExport.g:17330:2: rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 + { + pushFollow(FOLLOW_25); + rule__XForLoopExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__1" + + + // $ANTLR start "rule__XForLoopExpression__Group__1__Impl" + // InternalExport.g:17337:1: rule__XForLoopExpression__Group__1__Impl : ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ; + public final void rule__XForLoopExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17341:1: ( ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ) + // InternalExport.g:17342:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) + { + // InternalExport.g:17342:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) + // InternalExport.g:17343:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); + } + // InternalExport.g:17344:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 ) + // InternalExport.g:17344:3: rule__XForLoopExpression__ForExpressionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__ForExpressionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__2" + // InternalExport.g:17352:1: rule__XForLoopExpression__Group__2 : rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ; + public final void rule__XForLoopExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17356:1: ( rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ) + // InternalExport.g:17357:2: rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 + { + pushFollow(FOLLOW_98); + rule__XForLoopExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__2" + + + // $ANTLR start "rule__XForLoopExpression__Group__2__Impl" + // InternalExport.g:17364:1: rule__XForLoopExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XForLoopExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17368:1: ( ( ')' ) ) + // InternalExport.g:17369:1: ( ')' ) + { + // InternalExport.g:17369:1: ( ')' ) + // InternalExport.g:17370:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__2__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__3" + // InternalExport.g:17379:1: rule__XForLoopExpression__Group__3 : rule__XForLoopExpression__Group__3__Impl ; + public final void rule__XForLoopExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17383:1: ( rule__XForLoopExpression__Group__3__Impl ) + // InternalExport.g:17384:2: rule__XForLoopExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__3" + + + // $ANTLR start "rule__XForLoopExpression__Group__3__Impl" + // InternalExport.g:17390:1: rule__XForLoopExpression__Group__3__Impl : ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ; + public final void rule__XForLoopExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17394:1: ( ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ) + // InternalExport.g:17395:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) + { + // InternalExport.g:17395:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) + // InternalExport.g:17396:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); + } + // InternalExport.g:17397:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 ) + // InternalExport.g:17397:3: rule__XForLoopExpression__EachExpressionAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__EachExpressionAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__3__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0__0" + // InternalExport.g:17406:1: rule__XForLoopExpression__Group_0__0 : rule__XForLoopExpression__Group_0__0__Impl ; + public final void rule__XForLoopExpression__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17410:1: ( rule__XForLoopExpression__Group_0__0__Impl ) + // InternalExport.g:17411:2: rule__XForLoopExpression__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0__0" + + + // $ANTLR start "rule__XForLoopExpression__Group_0__0__Impl" + // InternalExport.g:17417:1: rule__XForLoopExpression__Group_0__0__Impl : ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ; + public final void rule__XForLoopExpression__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17421:1: ( ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ) + // InternalExport.g:17422:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) ) + { + // InternalExport.g:17422:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) ) + // InternalExport.g:17423:2: ( rule__XForLoopExpression__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); + } + // InternalExport.g:17424:2: ( rule__XForLoopExpression__Group_0_0__0 ) + // InternalExport.g:17424:3: rule__XForLoopExpression__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__0" + // InternalExport.g:17433:1: rule__XForLoopExpression__Group_0_0__0 : rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ; + public final void rule__XForLoopExpression__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17437:1: ( rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ) + // InternalExport.g:17438:2: rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 + { + pushFollow(FOLLOW_10); + rule__XForLoopExpression__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__0" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__0__Impl" + // InternalExport.g:17445:1: rule__XForLoopExpression__Group_0_0__0__Impl : ( () ) ; + public final void rule__XForLoopExpression__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17449:1: ( ( () ) ) + // InternalExport.g:17450:1: ( () ) + { + // InternalExport.g:17450:1: ( () ) + // InternalExport.g:17451:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); + } + // InternalExport.g:17452:2: () + // InternalExport.g:17452:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__1" + // InternalExport.g:17460:1: rule__XForLoopExpression__Group_0_0__1 : rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ; + public final void rule__XForLoopExpression__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17464:1: ( rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ) + // InternalExport.g:17465:2: rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 + { + pushFollow(FOLLOW_34); + rule__XForLoopExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__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__XForLoopExpression__Group_0_0__1" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__1__Impl" + // InternalExport.g:17472:1: rule__XForLoopExpression__Group_0_0__1__Impl : ( 'for' ) ; + public final void rule__XForLoopExpression__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17476:1: ( ( 'for' ) ) + // InternalExport.g:17477:1: ( 'for' ) + { + // InternalExport.g:17477:1: ( 'for' ) + // InternalExport.g:17478:2: 'for' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__2" + // InternalExport.g:17487:1: rule__XForLoopExpression__Group_0_0__2 : rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ; + public final void rule__XForLoopExpression__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17491:1: ( rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ) + // InternalExport.g:17492:2: rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 + { + pushFollow(FOLLOW_78); + rule__XForLoopExpression__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__2" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__2__Impl" + // InternalExport.g:17499:1: rule__XForLoopExpression__Group_0_0__2__Impl : ( '(' ) ; + public final void rule__XForLoopExpression__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17503:1: ( ( '(' ) ) + // InternalExport.g:17504:1: ( '(' ) + { + // InternalExport.g:17504:1: ( '(' ) + // InternalExport.g:17505:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__3" + // InternalExport.g:17514:1: rule__XForLoopExpression__Group_0_0__3 : rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ; + public final void rule__XForLoopExpression__Group_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17518:1: ( rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ) + // InternalExport.g:17519:2: rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 + { + pushFollow(FOLLOW_39); + rule__XForLoopExpression__Group_0_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__3" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__3__Impl" + // InternalExport.g:17526:1: rule__XForLoopExpression__Group_0_0__3__Impl : ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ; + public final void rule__XForLoopExpression__Group_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17530:1: ( ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ) + // InternalExport.g:17531:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) + { + // InternalExport.g:17531:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) + // InternalExport.g:17532:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); + } + // InternalExport.g:17533:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) + // InternalExport.g:17533:3: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__DeclaredParamAssignment_0_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__3__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__4" + // InternalExport.g:17541:1: rule__XForLoopExpression__Group_0_0__4 : rule__XForLoopExpression__Group_0_0__4__Impl ; + public final void rule__XForLoopExpression__Group_0_0__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17545:1: ( rule__XForLoopExpression__Group_0_0__4__Impl ) + // InternalExport.g:17546:2: rule__XForLoopExpression__Group_0_0__4__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__4" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__4__Impl" + // InternalExport.g:17552:1: rule__XForLoopExpression__Group_0_0__4__Impl : ( ':' ) ; + public final void rule__XForLoopExpression__Group_0_0__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17556:1: ( ( ':' ) ) + // InternalExport.g:17557:1: ( ':' ) + { + // InternalExport.g:17557:1: ( ':' ) + // InternalExport.g:17558:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + match(input,85,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__4__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__0" + // InternalExport.g:17568:1: rule__XBasicForLoopExpression__Group__0 : rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ; + public final void rule__XBasicForLoopExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17572:1: ( rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ) + // InternalExport.g:17573:2: rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 + { + pushFollow(FOLLOW_10); + rule__XBasicForLoopExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__0__Impl" + // InternalExport.g:17580:1: rule__XBasicForLoopExpression__Group__0__Impl : ( () ) ; + public final void rule__XBasicForLoopExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17584:1: ( ( () ) ) + // InternalExport.g:17585:1: ( () ) + { + // InternalExport.g:17585:1: ( () ) + // InternalExport.g:17586:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); + } + // InternalExport.g:17587:2: () + // InternalExport.g:17587:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__1" + // InternalExport.g:17595:1: rule__XBasicForLoopExpression__Group__1 : rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ; + public final void rule__XBasicForLoopExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17599:1: ( rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ) + // InternalExport.g:17600:2: rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 + { + pushFollow(FOLLOW_34); + rule__XBasicForLoopExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__1__Impl" + // InternalExport.g:17607:1: rule__XBasicForLoopExpression__Group__1__Impl : ( 'for' ) ; + public final void rule__XBasicForLoopExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17611:1: ( ( 'for' ) ) + // InternalExport.g:17612:1: ( 'for' ) + { + // InternalExport.g:17612:1: ( 'for' ) + // InternalExport.g:17613:2: 'for' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__2" + // InternalExport.g:17622:1: rule__XBasicForLoopExpression__Group__2 : rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ; + public final void rule__XBasicForLoopExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17626:1: ( rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ) + // InternalExport.g:17627:2: rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 + { + pushFollow(FOLLOW_110); + rule__XBasicForLoopExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__2" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__2__Impl" + // InternalExport.g:17634:1: rule__XBasicForLoopExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XBasicForLoopExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17638:1: ( ( '(' ) ) + // InternalExport.g:17639:1: ( '(' ) + { + // InternalExport.g:17639:1: ( '(' ) + // InternalExport.g:17640:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__2__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__3" + // InternalExport.g:17649:1: rule__XBasicForLoopExpression__Group__3 : rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ; + public final void rule__XBasicForLoopExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17653:1: ( rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ) + // InternalExport.g:17654:2: rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 + { + pushFollow(FOLLOW_110); + rule__XBasicForLoopExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__3" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__3__Impl" + // InternalExport.g:17661:1: rule__XBasicForLoopExpression__Group__3__Impl : ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ; + public final void rule__XBasicForLoopExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17665:1: ( ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ) + // InternalExport.g:17666:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) + { + // InternalExport.g:17666:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) + // InternalExport.g:17667:2: ( rule__XBasicForLoopExpression__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); + } + // InternalExport.g:17668:2: ( rule__XBasicForLoopExpression__Group_3__0 )? + int alt143=2; + int LA143_0 = input.LA(1); + + if ( ((LA143_0>=RULE_ID && LA143_0<=RULE_STRING)||(LA143_0>=22 && LA143_0<=24)||LA143_0==27||(LA143_0>=36 && LA143_0<=37)||(LA143_0>=59 && LA143_0<=64)||LA143_0==66||LA143_0==68||LA143_0==72||LA143_0==77||LA143_0==87||LA143_0==90||LA143_0==95||(LA143_0>=97 && LA143_0<=104)||LA143_0==106||LA143_0==117) ) { + alt143=1; + } + switch (alt143) { + case 1 : + // InternalExport.g:17668:3: rule__XBasicForLoopExpression__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__3__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__4" + // InternalExport.g:17676:1: rule__XBasicForLoopExpression__Group__4 : rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ; + public final void rule__XBasicForLoopExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17680:1: ( rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ) + // InternalExport.g:17681:2: rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 + { + pushFollow(FOLLOW_111); + rule__XBasicForLoopExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__4" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__4__Impl" + // InternalExport.g:17688:1: rule__XBasicForLoopExpression__Group__4__Impl : ( ';' ) ; + public final void rule__XBasicForLoopExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17692:1: ( ( ';' ) ) + // InternalExport.g:17693:1: ( ';' ) + { + // InternalExport.g:17693:1: ( ';' ) + // InternalExport.g:17694:2: ';' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + match(input,71,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__4__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__5" + // InternalExport.g:17703:1: rule__XBasicForLoopExpression__Group__5 : rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ; + public final void rule__XBasicForLoopExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17707:1: ( rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ) + // InternalExport.g:17708:2: rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 + { + pushFollow(FOLLOW_111); + rule__XBasicForLoopExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__5" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__5__Impl" + // InternalExport.g:17715:1: rule__XBasicForLoopExpression__Group__5__Impl : ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ; + public final void rule__XBasicForLoopExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17719:1: ( ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ) + // InternalExport.g:17720:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) + { + // InternalExport.g:17720:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) + // InternalExport.g:17721:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); + } + // InternalExport.g:17722:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? + int alt144=2; + int LA144_0 = input.LA(1); + + if ( ((LA144_0>=RULE_ID && LA144_0<=RULE_STRING)||(LA144_0>=22 && LA144_0<=24)||LA144_0==27||(LA144_0>=36 && LA144_0<=37)||(LA144_0>=60 && LA144_0<=64)||LA144_0==66||LA144_0==68||LA144_0==72||LA144_0==77||LA144_0==87||LA144_0==90||LA144_0==95||(LA144_0>=97 && LA144_0<=104)||LA144_0==106) ) { + alt144=1; + } + switch (alt144) { + case 1 : + // InternalExport.g:17722:3: rule__XBasicForLoopExpression__ExpressionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__ExpressionAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__5__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__6" + // InternalExport.g:17730:1: rule__XBasicForLoopExpression__Group__6 : rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ; + public final void rule__XBasicForLoopExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17734:1: ( rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ) + // InternalExport.g:17735:2: rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 + { + pushFollow(FOLLOW_97); + rule__XBasicForLoopExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__7(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__6" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__6__Impl" + // InternalExport.g:17742:1: rule__XBasicForLoopExpression__Group__6__Impl : ( ';' ) ; + public final void rule__XBasicForLoopExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17746:1: ( ( ';' ) ) + // InternalExport.g:17747:1: ( ';' ) + { + // InternalExport.g:17747:1: ( ';' ) + // InternalExport.g:17748:2: ';' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + match(input,71,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__6__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__7" + // InternalExport.g:17757:1: rule__XBasicForLoopExpression__Group__7 : rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ; + public final void rule__XBasicForLoopExpression__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17761:1: ( rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ) + // InternalExport.g:17762:2: rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 + { + pushFollow(FOLLOW_97); + rule__XBasicForLoopExpression__Group__7__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__8(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__7" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__7__Impl" + // InternalExport.g:17769:1: rule__XBasicForLoopExpression__Group__7__Impl : ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ; + public final void rule__XBasicForLoopExpression__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17773:1: ( ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ) + // InternalExport.g:17774:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) + { + // InternalExport.g:17774:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) + // InternalExport.g:17775:2: ( rule__XBasicForLoopExpression__Group_7__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); + } + // InternalExport.g:17776:2: ( rule__XBasicForLoopExpression__Group_7__0 )? + int alt145=2; + int LA145_0 = input.LA(1); + + if ( ((LA145_0>=RULE_ID && LA145_0<=RULE_STRING)||(LA145_0>=22 && LA145_0<=24)||LA145_0==27||(LA145_0>=36 && LA145_0<=37)||(LA145_0>=60 && LA145_0<=64)||LA145_0==66||LA145_0==68||LA145_0==72||LA145_0==77||LA145_0==87||LA145_0==90||LA145_0==95||(LA145_0>=97 && LA145_0<=104)||LA145_0==106) ) { + alt145=1; + } + switch (alt145) { + case 1 : + // InternalExport.g:17776:3: rule__XBasicForLoopExpression__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__7__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__8" + // InternalExport.g:17784:1: rule__XBasicForLoopExpression__Group__8 : rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ; + public final void rule__XBasicForLoopExpression__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17788:1: ( rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ) + // InternalExport.g:17789:2: rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 + { + pushFollow(FOLLOW_98); + rule__XBasicForLoopExpression__Group__8__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__9(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__8" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__8__Impl" + // InternalExport.g:17796:1: rule__XBasicForLoopExpression__Group__8__Impl : ( ')' ) ; + public final void rule__XBasicForLoopExpression__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17800:1: ( ( ')' ) ) + // InternalExport.g:17801:1: ( ')' ) + { + // InternalExport.g:17801:1: ( ')' ) + // InternalExport.g:17802:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__8__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__9" + // InternalExport.g:17811:1: rule__XBasicForLoopExpression__Group__9 : rule__XBasicForLoopExpression__Group__9__Impl ; + public final void rule__XBasicForLoopExpression__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17815:1: ( rule__XBasicForLoopExpression__Group__9__Impl ) + // InternalExport.g:17816:2: rule__XBasicForLoopExpression__Group__9__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__9__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__9" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__9__Impl" + // InternalExport.g:17822:1: rule__XBasicForLoopExpression__Group__9__Impl : ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ; + public final void rule__XBasicForLoopExpression__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17826:1: ( ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ) + // InternalExport.g:17827:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) + { + // InternalExport.g:17827:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) + // InternalExport.g:17828:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); + } + // InternalExport.g:17829:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) + // InternalExport.g:17829:3: rule__XBasicForLoopExpression__EachExpressionAssignment_9 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__EachExpressionAssignment_9(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__9__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0" + // InternalExport.g:17838:1: rule__XBasicForLoopExpression__Group_3__0 : rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ; + public final void rule__XBasicForLoopExpression__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17842:1: ( rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ) + // InternalExport.g:17843:2: rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 + { + pushFollow(FOLLOW_21); + rule__XBasicForLoopExpression__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0__Impl" + // InternalExport.g:17850:1: rule__XBasicForLoopExpression__Group_3__0__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ; + public final void rule__XBasicForLoopExpression__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17854:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ) + // InternalExport.g:17855:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) + { + // InternalExport.g:17855:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) + // InternalExport.g:17856:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); + } + // InternalExport.g:17857:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) + // InternalExport.g:17857:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1" + // InternalExport.g:17865:1: rule__XBasicForLoopExpression__Group_3__1 : rule__XBasicForLoopExpression__Group_3__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17869:1: ( rule__XBasicForLoopExpression__Group_3__1__Impl ) + // InternalExport.g:17870:2: rule__XBasicForLoopExpression__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1__Impl" + // InternalExport.g:17876:1: rule__XBasicForLoopExpression__Group_3__1__Impl : ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ; + public final void rule__XBasicForLoopExpression__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17880:1: ( ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ) + // InternalExport.g:17881:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) + { + // InternalExport.g:17881:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) + // InternalExport.g:17882:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); + } + // InternalExport.g:17883:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )* + loop146: + do { + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==74) ) { + alt146=1; + } + + + switch (alt146) { + case 1 : + // InternalExport.g:17883:3: rule__XBasicForLoopExpression__Group_3_1__0 + { + pushFollow(FOLLOW_22); + rule__XBasicForLoopExpression__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop146; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0" + // InternalExport.g:17892:1: rule__XBasicForLoopExpression__Group_3_1__0 : rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ; + public final void rule__XBasicForLoopExpression__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17896:1: ( rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ) + // InternalExport.g:17897:2: rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 + { + pushFollow(FOLLOW_102); + rule__XBasicForLoopExpression__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0__Impl" + // InternalExport.g:17904:1: rule__XBasicForLoopExpression__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XBasicForLoopExpression__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17908:1: ( ( ',' ) ) + // InternalExport.g:17909:1: ( ',' ) + { + // InternalExport.g:17909:1: ( ',' ) + // InternalExport.g:17910:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1" + // InternalExport.g:17919:1: rule__XBasicForLoopExpression__Group_3_1__1 : rule__XBasicForLoopExpression__Group_3_1__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17923:1: ( rule__XBasicForLoopExpression__Group_3_1__1__Impl ) + // InternalExport.g:17924:2: rule__XBasicForLoopExpression__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1__Impl" + // InternalExport.g:17930:1: rule__XBasicForLoopExpression__Group_3_1__1__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ; + public final void rule__XBasicForLoopExpression__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17934:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ) + // InternalExport.g:17935:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) + { + // InternalExport.g:17935:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) + // InternalExport.g:17936:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); + } + // InternalExport.g:17937:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) + // InternalExport.g:17937:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0" + // InternalExport.g:17946:1: rule__XBasicForLoopExpression__Group_7__0 : rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ; + public final void rule__XBasicForLoopExpression__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17950:1: ( rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ) + // InternalExport.g:17951:2: rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 + { + pushFollow(FOLLOW_21); + rule__XBasicForLoopExpression__Group_7__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0__Impl" + // InternalExport.g:17958:1: rule__XBasicForLoopExpression__Group_7__0__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ; + public final void rule__XBasicForLoopExpression__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17962:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ) + // InternalExport.g:17963:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) + { + // InternalExport.g:17963:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) + // InternalExport.g:17964:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); + } + // InternalExport.g:17965:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) + // InternalExport.g:17965:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1" + // InternalExport.g:17973:1: rule__XBasicForLoopExpression__Group_7__1 : rule__XBasicForLoopExpression__Group_7__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17977:1: ( rule__XBasicForLoopExpression__Group_7__1__Impl ) + // InternalExport.g:17978:2: rule__XBasicForLoopExpression__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1__Impl" + // InternalExport.g:17984:1: rule__XBasicForLoopExpression__Group_7__1__Impl : ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ; + public final void rule__XBasicForLoopExpression__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:17988:1: ( ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ) + // InternalExport.g:17989:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) + { + // InternalExport.g:17989:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) + // InternalExport.g:17990:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); + } + // InternalExport.g:17991:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )* + loop147: + do { + int alt147=2; + int LA147_0 = input.LA(1); + + if ( (LA147_0==74) ) { + alt147=1; + } + + + switch (alt147) { + case 1 : + // InternalExport.g:17991:3: rule__XBasicForLoopExpression__Group_7_1__0 + { + pushFollow(FOLLOW_22); + rule__XBasicForLoopExpression__Group_7_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop147; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0" + // InternalExport.g:18000:1: rule__XBasicForLoopExpression__Group_7_1__0 : rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ; + public final void rule__XBasicForLoopExpression__Group_7_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18004:1: ( rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ) + // InternalExport.g:18005:2: rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 + { + pushFollow(FOLLOW_98); + rule__XBasicForLoopExpression__Group_7_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0__Impl" + // InternalExport.g:18012:1: rule__XBasicForLoopExpression__Group_7_1__0__Impl : ( ',' ) ; + public final void rule__XBasicForLoopExpression__Group_7_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18016:1: ( ( ',' ) ) + // InternalExport.g:18017:1: ( ',' ) + { + // InternalExport.g:18017:1: ( ',' ) + // InternalExport.g:18018:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1" + // InternalExport.g:18027:1: rule__XBasicForLoopExpression__Group_7_1__1 : rule__XBasicForLoopExpression__Group_7_1__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_7_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18031:1: ( rule__XBasicForLoopExpression__Group_7_1__1__Impl ) + // InternalExport.g:18032:2: rule__XBasicForLoopExpression__Group_7_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1__Impl" + // InternalExport.g:18038:1: rule__XBasicForLoopExpression__Group_7_1__1__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ; + public final void rule__XBasicForLoopExpression__Group_7_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18042:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ) + // InternalExport.g:18043:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) + { + // InternalExport.g:18043:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) + // InternalExport.g:18044:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); + } + // InternalExport.g:18045:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) + // InternalExport.g:18045:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__0" + // InternalExport.g:18054:1: rule__XWhileExpression__Group__0 : rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ; + public final void rule__XWhileExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18058:1: ( rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ) + // InternalExport.g:18059:2: rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 + { + pushFollow(FOLLOW_112); + rule__XWhileExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__0" + + + // $ANTLR start "rule__XWhileExpression__Group__0__Impl" + // InternalExport.g:18066:1: rule__XWhileExpression__Group__0__Impl : ( () ) ; + public final void rule__XWhileExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18070:1: ( ( () ) ) + // InternalExport.g:18071:1: ( () ) + { + // InternalExport.g:18071:1: ( () ) + // InternalExport.g:18072:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); + } + // InternalExport.g:18073:2: () + // InternalExport.g:18073:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__0__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__1" + // InternalExport.g:18081:1: rule__XWhileExpression__Group__1 : rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ; + public final void rule__XWhileExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18085:1: ( rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ) + // InternalExport.g:18086:2: rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 + { + pushFollow(FOLLOW_34); + rule__XWhileExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__1" + + + // $ANTLR start "rule__XWhileExpression__Group__1__Impl" + // InternalExport.g:18093:1: rule__XWhileExpression__Group__1__Impl : ( 'while' ) ; + public final void rule__XWhileExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18097:1: ( ( 'while' ) ) + // InternalExport.g:18098:1: ( 'while' ) + { + // InternalExport.g:18098:1: ( 'while' ) + // InternalExport.g:18099:2: 'while' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + match(input,98,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__1__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__2" + // InternalExport.g:18108:1: rule__XWhileExpression__Group__2 : rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ; + public final void rule__XWhileExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18112:1: ( rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ) + // InternalExport.g:18113:2: rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 + { + pushFollow(FOLLOW_98); + rule__XWhileExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__2" + + + // $ANTLR start "rule__XWhileExpression__Group__2__Impl" + // InternalExport.g:18120:1: rule__XWhileExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XWhileExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18124:1: ( ( '(' ) ) + // InternalExport.g:18125:1: ( '(' ) + { + // InternalExport.g:18125:1: ( '(' ) + // InternalExport.g:18126:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__2__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__3" + // InternalExport.g:18135:1: rule__XWhileExpression__Group__3 : rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ; + public final void rule__XWhileExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18139:1: ( rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ) + // InternalExport.g:18140:2: rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 + { + pushFollow(FOLLOW_25); + rule__XWhileExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__3" + + + // $ANTLR start "rule__XWhileExpression__Group__3__Impl" + // InternalExport.g:18147:1: rule__XWhileExpression__Group__3__Impl : ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ; + public final void rule__XWhileExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18151:1: ( ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ) + // InternalExport.g:18152:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) + { + // InternalExport.g:18152:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) + // InternalExport.g:18153:2: ( rule__XWhileExpression__PredicateAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); + } + // InternalExport.g:18154:2: ( rule__XWhileExpression__PredicateAssignment_3 ) + // InternalExport.g:18154:3: rule__XWhileExpression__PredicateAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__PredicateAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__3__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__4" + // InternalExport.g:18162:1: rule__XWhileExpression__Group__4 : rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ; + public final void rule__XWhileExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18166:1: ( rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ) + // InternalExport.g:18167:2: rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 + { + pushFollow(FOLLOW_98); + rule__XWhileExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__4" + + + // $ANTLR start "rule__XWhileExpression__Group__4__Impl" + // InternalExport.g:18174:1: rule__XWhileExpression__Group__4__Impl : ( ')' ) ; + public final void rule__XWhileExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18178:1: ( ( ')' ) ) + // InternalExport.g:18179:1: ( ')' ) + { + // InternalExport.g:18179:1: ( ')' ) + // InternalExport.g:18180:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__4__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__5" + // InternalExport.g:18189:1: rule__XWhileExpression__Group__5 : rule__XWhileExpression__Group__5__Impl ; + public final void rule__XWhileExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18193:1: ( rule__XWhileExpression__Group__5__Impl ) + // InternalExport.g:18194:2: rule__XWhileExpression__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__5" + + + // $ANTLR start "rule__XWhileExpression__Group__5__Impl" + // InternalExport.g:18200:1: rule__XWhileExpression__Group__5__Impl : ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ; + public final void rule__XWhileExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18204:1: ( ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ) + // InternalExport.g:18205:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) ) + { + // InternalExport.g:18205:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) ) + // InternalExport.g:18206:2: ( rule__XWhileExpression__BodyAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); + } + // InternalExport.g:18207:2: ( rule__XWhileExpression__BodyAssignment_5 ) + // InternalExport.g:18207:3: rule__XWhileExpression__BodyAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__BodyAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__5__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__0" + // InternalExport.g:18216:1: rule__XDoWhileExpression__Group__0 : rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ; + public final void rule__XDoWhileExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18220:1: ( rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ) + // InternalExport.g:18221:2: rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 + { + pushFollow(FOLLOW_113); + rule__XDoWhileExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__0" + + + // $ANTLR start "rule__XDoWhileExpression__Group__0__Impl" + // InternalExport.g:18228:1: rule__XDoWhileExpression__Group__0__Impl : ( () ) ; + public final void rule__XDoWhileExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18232:1: ( ( () ) ) + // InternalExport.g:18233:1: ( () ) + { + // InternalExport.g:18233:1: ( () ) + // InternalExport.g:18234:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); + } + // InternalExport.g:18235:2: () + // InternalExport.g:18235:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__0__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__1" + // InternalExport.g:18243:1: rule__XDoWhileExpression__Group__1 : rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ; + public final void rule__XDoWhileExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18247:1: ( rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ) + // InternalExport.g:18248:2: rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 + { + pushFollow(FOLLOW_98); + rule__XDoWhileExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__1" + + + // $ANTLR start "rule__XDoWhileExpression__Group__1__Impl" + // InternalExport.g:18255:1: rule__XDoWhileExpression__Group__1__Impl : ( 'do' ) ; + public final void rule__XDoWhileExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18259:1: ( ( 'do' ) ) + // InternalExport.g:18260:1: ( 'do' ) + { + // InternalExport.g:18260:1: ( 'do' ) + // InternalExport.g:18261:2: 'do' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + match(input,99,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__1__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__2" + // InternalExport.g:18270:1: rule__XDoWhileExpression__Group__2 : rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ; + public final void rule__XDoWhileExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18274:1: ( rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ) + // InternalExport.g:18275:2: rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 + { + pushFollow(FOLLOW_112); + rule__XDoWhileExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__2" + + + // $ANTLR start "rule__XDoWhileExpression__Group__2__Impl" + // InternalExport.g:18282:1: rule__XDoWhileExpression__Group__2__Impl : ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ; + public final void rule__XDoWhileExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18286:1: ( ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ) + // InternalExport.g:18287:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) + { + // InternalExport.g:18287:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) + // InternalExport.g:18288:2: ( rule__XDoWhileExpression__BodyAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); + } + // InternalExport.g:18289:2: ( rule__XDoWhileExpression__BodyAssignment_2 ) + // InternalExport.g:18289:3: rule__XDoWhileExpression__BodyAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__BodyAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__2__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__3" + // InternalExport.g:18297:1: rule__XDoWhileExpression__Group__3 : rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ; + public final void rule__XDoWhileExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18301:1: ( rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ) + // InternalExport.g:18302:2: rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 + { + pushFollow(FOLLOW_34); + rule__XDoWhileExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__3" + + + // $ANTLR start "rule__XDoWhileExpression__Group__3__Impl" + // InternalExport.g:18309:1: rule__XDoWhileExpression__Group__3__Impl : ( 'while' ) ; + public final void rule__XDoWhileExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18313:1: ( ( 'while' ) ) + // InternalExport.g:18314:1: ( 'while' ) + { + // InternalExport.g:18314:1: ( 'while' ) + // InternalExport.g:18315:2: 'while' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + match(input,98,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__3__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__4" + // InternalExport.g:18324:1: rule__XDoWhileExpression__Group__4 : rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ; + public final void rule__XDoWhileExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18328:1: ( rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ) + // InternalExport.g:18329:2: rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 + { + pushFollow(FOLLOW_98); + rule__XDoWhileExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__4" + + + // $ANTLR start "rule__XDoWhileExpression__Group__4__Impl" + // InternalExport.g:18336:1: rule__XDoWhileExpression__Group__4__Impl : ( '(' ) ; + public final void rule__XDoWhileExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18340:1: ( ( '(' ) ) + // InternalExport.g:18341:1: ( '(' ) + { + // InternalExport.g:18341:1: ( '(' ) + // InternalExport.g:18342:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__4__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__5" + // InternalExport.g:18351:1: rule__XDoWhileExpression__Group__5 : rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ; + public final void rule__XDoWhileExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18355:1: ( rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ) + // InternalExport.g:18356:2: rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 + { + pushFollow(FOLLOW_25); + rule__XDoWhileExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__5" + + + // $ANTLR start "rule__XDoWhileExpression__Group__5__Impl" + // InternalExport.g:18363:1: rule__XDoWhileExpression__Group__5__Impl : ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ; + public final void rule__XDoWhileExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18367:1: ( ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ) + // InternalExport.g:18368:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) + { + // InternalExport.g:18368:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) + // InternalExport.g:18369:2: ( rule__XDoWhileExpression__PredicateAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); + } + // InternalExport.g:18370:2: ( rule__XDoWhileExpression__PredicateAssignment_5 ) + // InternalExport.g:18370:3: rule__XDoWhileExpression__PredicateAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__PredicateAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__5__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__6" + // InternalExport.g:18378:1: rule__XDoWhileExpression__Group__6 : rule__XDoWhileExpression__Group__6__Impl ; + public final void rule__XDoWhileExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18382:1: ( rule__XDoWhileExpression__Group__6__Impl ) + // InternalExport.g:18383:2: rule__XDoWhileExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__6" + + + // $ANTLR start "rule__XDoWhileExpression__Group__6__Impl" + // InternalExport.g:18389:1: rule__XDoWhileExpression__Group__6__Impl : ( ')' ) ; + public final void rule__XDoWhileExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18393:1: ( ( ')' ) ) + // InternalExport.g:18394:1: ( ')' ) + { + // InternalExport.g:18394:1: ( ')' ) + // InternalExport.g:18395:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__6__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__0" + // InternalExport.g:18405:1: rule__XBlockExpression__Group__0 : rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ; + public final void rule__XBlockExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18409:1: ( rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ) + // InternalExport.g:18410:2: rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 + { + pushFollow(FOLLOW_12); + rule__XBlockExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__0" + + + // $ANTLR start "rule__XBlockExpression__Group__0__Impl" + // InternalExport.g:18417:1: rule__XBlockExpression__Group__0__Impl : ( () ) ; + public final void rule__XBlockExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18421:1: ( ( () ) ) + // InternalExport.g:18422:1: ( () ) + { + // InternalExport.g:18422:1: ( () ) + // InternalExport.g:18423:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); + } + // InternalExport.g:18424:2: () + // InternalExport.g:18424:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__0__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__1" + // InternalExport.g:18432:1: rule__XBlockExpression__Group__1 : rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ; + public final void rule__XBlockExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18436:1: ( rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ) + // InternalExport.g:18437:2: rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 + { + pushFollow(FOLLOW_114); + rule__XBlockExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__1" + + + // $ANTLR start "rule__XBlockExpression__Group__1__Impl" + // InternalExport.g:18444:1: rule__XBlockExpression__Group__1__Impl : ( '{' ) ; + public final void rule__XBlockExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18448:1: ( ( '{' ) ) + // InternalExport.g:18449:1: ( '{' ) + { + // InternalExport.g:18449:1: ( '{' ) + // InternalExport.g:18450:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__1__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__2" + // InternalExport.g:18459:1: rule__XBlockExpression__Group__2 : rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ; + public final void rule__XBlockExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18463:1: ( rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ) + // InternalExport.g:18464:2: rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 + { + pushFollow(FOLLOW_114); + rule__XBlockExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__2" + + + // $ANTLR start "rule__XBlockExpression__Group__2__Impl" + // InternalExport.g:18471:1: rule__XBlockExpression__Group__2__Impl : ( ( rule__XBlockExpression__Group_2__0 )* ) ; + public final void rule__XBlockExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18475:1: ( ( ( rule__XBlockExpression__Group_2__0 )* ) ) + // InternalExport.g:18476:1: ( ( rule__XBlockExpression__Group_2__0 )* ) + { + // InternalExport.g:18476:1: ( ( rule__XBlockExpression__Group_2__0 )* ) + // InternalExport.g:18477:2: ( rule__XBlockExpression__Group_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); + } + // InternalExport.g:18478:2: ( rule__XBlockExpression__Group_2__0 )* + loop148: + do { + int alt148=2; + int LA148_0 = input.LA(1); + + if ( ((LA148_0>=RULE_ID && LA148_0<=RULE_STRING)||(LA148_0>=22 && LA148_0<=24)||LA148_0==27||(LA148_0>=36 && LA148_0<=37)||(LA148_0>=59 && LA148_0<=64)||LA148_0==66||LA148_0==68||LA148_0==72||LA148_0==77||LA148_0==87||LA148_0==90||LA148_0==95||(LA148_0>=97 && LA148_0<=104)||LA148_0==106||LA148_0==117) ) { + alt148=1; + } + + + switch (alt148) { + case 1 : + // InternalExport.g:18478:3: rule__XBlockExpression__Group_2__0 + { + pushFollow(FOLLOW_104); + rule__XBlockExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop148; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__2__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__3" + // InternalExport.g:18486:1: rule__XBlockExpression__Group__3 : rule__XBlockExpression__Group__3__Impl ; + public final void rule__XBlockExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18490:1: ( rule__XBlockExpression__Group__3__Impl ) + // InternalExport.g:18491:2: rule__XBlockExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__3" + + + // $ANTLR start "rule__XBlockExpression__Group__3__Impl" + // InternalExport.g:18497:1: rule__XBlockExpression__Group__3__Impl : ( '}' ) ; + public final void rule__XBlockExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18501:1: ( ( '}' ) ) + // InternalExport.g:18502:1: ( '}' ) + { + // InternalExport.g:18502:1: ( '}' ) + // InternalExport.g:18503:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + match(input,69,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__3__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group_2__0" + // InternalExport.g:18513:1: rule__XBlockExpression__Group_2__0 : rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ; + public final void rule__XBlockExpression__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18517:1: ( rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ) + // InternalExport.g:18518:2: rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 + { + pushFollow(FOLLOW_35); + rule__XBlockExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__0" + + + // $ANTLR start "rule__XBlockExpression__Group_2__0__Impl" + // InternalExport.g:18525:1: rule__XBlockExpression__Group_2__0__Impl : ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ; + public final void rule__XBlockExpression__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18529:1: ( ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ) + // InternalExport.g:18530:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) + { + // InternalExport.g:18530:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) + // InternalExport.g:18531:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); + } + // InternalExport.g:18532:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) + // InternalExport.g:18532:3: rule__XBlockExpression__ExpressionsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__ExpressionsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__0__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group_2__1" + // InternalExport.g:18540:1: rule__XBlockExpression__Group_2__1 : rule__XBlockExpression__Group_2__1__Impl ; + public final void rule__XBlockExpression__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18544:1: ( rule__XBlockExpression__Group_2__1__Impl ) + // InternalExport.g:18545:2: rule__XBlockExpression__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__1" + + + // $ANTLR start "rule__XBlockExpression__Group_2__1__Impl" + // InternalExport.g:18551:1: rule__XBlockExpression__Group_2__1__Impl : ( ( ';' )? ) ; + public final void rule__XBlockExpression__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18555:1: ( ( ( ';' )? ) ) + // InternalExport.g:18556:1: ( ( ';' )? ) + { + // InternalExport.g:18556:1: ( ( ';' )? ) + // InternalExport.g:18557:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + // InternalExport.g:18558:2: ( ';' )? + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==71) ) { + alt149=1; + } + switch (alt149) { + case 1 : + // InternalExport.g:18558:3: ';' + { + match(input,71,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__0" + // InternalExport.g:18567:1: rule__XVariableDeclaration__Group__0 : rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ; + public final void rule__XVariableDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18571:1: ( rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ) + // InternalExport.g:18572:2: rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 + { + pushFollow(FOLLOW_115); + rule__XVariableDeclaration__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group__0__Impl" + // InternalExport.g:18579:1: rule__XVariableDeclaration__Group__0__Impl : ( () ) ; + public final void rule__XVariableDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18583:1: ( ( () ) ) + // InternalExport.g:18584:1: ( () ) + { + // InternalExport.g:18584:1: ( () ) + // InternalExport.g:18585:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); + } + // InternalExport.g:18586:2: () + // InternalExport.g:18586:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__1" + // InternalExport.g:18594:1: rule__XVariableDeclaration__Group__1 : rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ; + public final void rule__XVariableDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18598:1: ( rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ) + // InternalExport.g:18599:2: rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 + { + pushFollow(FOLLOW_78); + rule__XVariableDeclaration__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group__1__Impl" + // InternalExport.g:18606:1: rule__XVariableDeclaration__Group__1__Impl : ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ; + public final void rule__XVariableDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18610:1: ( ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ) + // InternalExport.g:18611:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) ) + { + // InternalExport.g:18611:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) ) + // InternalExport.g:18612:2: ( rule__XVariableDeclaration__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); + } + // InternalExport.g:18613:2: ( rule__XVariableDeclaration__Alternatives_1 ) + // InternalExport.g:18613:3: rule__XVariableDeclaration__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__2" + // InternalExport.g:18621:1: rule__XVariableDeclaration__Group__2 : rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ; + public final void rule__XVariableDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18625:1: ( rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ) + // InternalExport.g:18626:2: rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 + { + pushFollow(FOLLOW_32); + rule__XVariableDeclaration__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__2" + + + // $ANTLR start "rule__XVariableDeclaration__Group__2__Impl" + // InternalExport.g:18633:1: rule__XVariableDeclaration__Group__2__Impl : ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ; + public final void rule__XVariableDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18637:1: ( ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ) + // InternalExport.g:18638:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) ) + { + // InternalExport.g:18638:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) ) + // InternalExport.g:18639:2: ( rule__XVariableDeclaration__Alternatives_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); + } + // InternalExport.g:18640:2: ( rule__XVariableDeclaration__Alternatives_2 ) + // InternalExport.g:18640:3: rule__XVariableDeclaration__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__3" + // InternalExport.g:18648:1: rule__XVariableDeclaration__Group__3 : rule__XVariableDeclaration__Group__3__Impl ; + public final void rule__XVariableDeclaration__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18652:1: ( rule__XVariableDeclaration__Group__3__Impl ) + // InternalExport.g:18653:2: rule__XVariableDeclaration__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__3" + + + // $ANTLR start "rule__XVariableDeclaration__Group__3__Impl" + // InternalExport.g:18659:1: rule__XVariableDeclaration__Group__3__Impl : ( ( rule__XVariableDeclaration__Group_3__0 )? ) ; + public final void rule__XVariableDeclaration__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18663:1: ( ( ( rule__XVariableDeclaration__Group_3__0 )? ) ) + // InternalExport.g:18664:1: ( ( rule__XVariableDeclaration__Group_3__0 )? ) + { + // InternalExport.g:18664:1: ( ( rule__XVariableDeclaration__Group_3__0 )? ) + // InternalExport.g:18665:2: ( rule__XVariableDeclaration__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); + } + // InternalExport.g:18666:2: ( rule__XVariableDeclaration__Group_3__0 )? + int alt150=2; + int LA150_0 = input.LA(1); + + if ( (LA150_0==14) ) { + alt150=1; + } + switch (alt150) { + case 1 : + // InternalExport.g:18666:3: rule__XVariableDeclaration__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__3__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0" + // InternalExport.g:18675:1: rule__XVariableDeclaration__Group_2_0__0 : rule__XVariableDeclaration__Group_2_0__0__Impl ; + public final void rule__XVariableDeclaration__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18679:1: ( rule__XVariableDeclaration__Group_2_0__0__Impl ) + // InternalExport.g:18680:2: rule__XVariableDeclaration__Group_2_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0__Impl" + // InternalExport.g:18686:1: rule__XVariableDeclaration__Group_2_0__0__Impl : ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18690:1: ( ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ) + // InternalExport.g:18691:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) + { + // InternalExport.g:18691:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) + // InternalExport.g:18692:2: ( rule__XVariableDeclaration__Group_2_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); + } + // InternalExport.g:18693:2: ( rule__XVariableDeclaration__Group_2_0_0__0 ) + // InternalExport.g:18693:3: rule__XVariableDeclaration__Group_2_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0" + // InternalExport.g:18702:1: rule__XVariableDeclaration__Group_2_0_0__0 : rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ; + public final void rule__XVariableDeclaration__Group_2_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18706:1: ( rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ) + // InternalExport.g:18707:2: rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 + { + pushFollow(FOLLOW_11); + rule__XVariableDeclaration__Group_2_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0__Impl" + // InternalExport.g:18714:1: rule__XVariableDeclaration__Group_2_0_0__0__Impl : ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18718:1: ( ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ) + // InternalExport.g:18719:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) + { + // InternalExport.g:18719:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) + // InternalExport.g:18720:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); + } + // InternalExport.g:18721:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) + // InternalExport.g:18721:3: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__TypeAssignment_2_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1" + // InternalExport.g:18729:1: rule__XVariableDeclaration__Group_2_0_0__1 : rule__XVariableDeclaration__Group_2_0_0__1__Impl ; + public final void rule__XVariableDeclaration__Group_2_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18733:1: ( rule__XVariableDeclaration__Group_2_0_0__1__Impl ) + // InternalExport.g:18734:2: rule__XVariableDeclaration__Group_2_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1__Impl" + // InternalExport.g:18740:1: rule__XVariableDeclaration__Group_2_0_0__1__Impl : ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18744:1: ( ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ) + // InternalExport.g:18745:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) + { + // InternalExport.g:18745:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) + // InternalExport.g:18746:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); + } + // InternalExport.g:18747:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) + // InternalExport.g:18747:3: rule__XVariableDeclaration__NameAssignment_2_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__NameAssignment_2_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__0" + // InternalExport.g:18756:1: rule__XVariableDeclaration__Group_3__0 : rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ; + public final void rule__XVariableDeclaration__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18760:1: ( rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ) + // InternalExport.g:18761:2: rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 + { + pushFollow(FOLLOW_98); + rule__XVariableDeclaration__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__0__Impl" + // InternalExport.g:18768:1: rule__XVariableDeclaration__Group_3__0__Impl : ( '=' ) ; + public final void rule__XVariableDeclaration__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18772:1: ( ( '=' ) ) + // InternalExport.g:18773:1: ( '=' ) + { + // InternalExport.g:18773:1: ( '=' ) + // InternalExport.g:18774:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__1" + // InternalExport.g:18783:1: rule__XVariableDeclaration__Group_3__1 : rule__XVariableDeclaration__Group_3__1__Impl ; + public final void rule__XVariableDeclaration__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18787:1: ( rule__XVariableDeclaration__Group_3__1__Impl ) + // InternalExport.g:18788:2: rule__XVariableDeclaration__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__1__Impl" + // InternalExport.g:18794:1: rule__XVariableDeclaration__Group_3__1__Impl : ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ; + public final void rule__XVariableDeclaration__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18798:1: ( ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ) + // InternalExport.g:18799:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) + { + // InternalExport.g:18799:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) + // InternalExport.g:18800:2: ( rule__XVariableDeclaration__RightAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); + } + // InternalExport.g:18801:2: ( rule__XVariableDeclaration__RightAssignment_3_1 ) + // InternalExport.g:18801:3: rule__XVariableDeclaration__RightAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__RightAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__1__Impl" + + + // $ANTLR start "rule__JvmFormalParameter__Group__0" + // InternalExport.g:18810:1: rule__JvmFormalParameter__Group__0 : rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ; + public final void rule__JvmFormalParameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18814:1: ( rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ) + // InternalExport.g:18815:2: rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 + { + pushFollow(FOLLOW_78); + rule__JvmFormalParameter__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__0" + + + // $ANTLR start "rule__JvmFormalParameter__Group__0__Impl" + // InternalExport.g:18822:1: rule__JvmFormalParameter__Group__0__Impl : ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ; + public final void rule__JvmFormalParameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18826:1: ( ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ) + // InternalExport.g:18827:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) + { + // InternalExport.g:18827:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) + // InternalExport.g:18828:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + // InternalExport.g:18829:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? + int alt151=2; + int LA151_0 = input.LA(1); + + if ( (LA151_0==RULE_ID) ) { + int LA151_1 = input.LA(2); + + if ( (LA151_1==RULE_ID||LA151_1==22||LA151_1==58||LA151_1==72) ) { + alt151=1; + } + } + else if ( (LA151_0==51||LA151_0==77) ) { + alt151=1; + } + switch (alt151) { + case 1 : + // InternalExport.g:18829:3: rule__JvmFormalParameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__ParameterTypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__0__Impl" + + + // $ANTLR start "rule__JvmFormalParameter__Group__1" + // InternalExport.g:18837:1: rule__JvmFormalParameter__Group__1 : rule__JvmFormalParameter__Group__1__Impl ; + public final void rule__JvmFormalParameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18841:1: ( rule__JvmFormalParameter__Group__1__Impl ) + // InternalExport.g:18842:2: rule__JvmFormalParameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__1" + + + // $ANTLR start "rule__JvmFormalParameter__Group__1__Impl" + // InternalExport.g:18848:1: rule__JvmFormalParameter__Group__1__Impl : ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ; + public final void rule__JvmFormalParameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18852:1: ( ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ) + // InternalExport.g:18853:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) + { + // InternalExport.g:18853:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) + // InternalExport.g:18854:2: ( rule__JvmFormalParameter__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); + } + // InternalExport.g:18855:2: ( rule__JvmFormalParameter__NameAssignment_1 ) + // InternalExport.g:18855:3: rule__JvmFormalParameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__1__Impl" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__0" + // InternalExport.g:18864:1: rule__FullJvmFormalParameter__Group__0 : rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ; + public final void rule__FullJvmFormalParameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18868:1: ( rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ) + // InternalExport.g:18869:2: rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 + { + pushFollow(FOLLOW_11); + rule__FullJvmFormalParameter__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__0" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__0__Impl" + // InternalExport.g:18876:1: rule__FullJvmFormalParameter__Group__0__Impl : ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ; + public final void rule__FullJvmFormalParameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18880:1: ( ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ) + // InternalExport.g:18881:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) + { + // InternalExport.g:18881:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) + // InternalExport.g:18882:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + // InternalExport.g:18883:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) + // InternalExport.g:18883:3: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__ParameterTypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__0__Impl" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__1" + // InternalExport.g:18891:1: rule__FullJvmFormalParameter__Group__1 : rule__FullJvmFormalParameter__Group__1__Impl ; + public final void rule__FullJvmFormalParameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18895:1: ( rule__FullJvmFormalParameter__Group__1__Impl ) + // InternalExport.g:18896:2: rule__FullJvmFormalParameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__1" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__1__Impl" + // InternalExport.g:18902:1: rule__FullJvmFormalParameter__Group__1__Impl : ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ; + public final void rule__FullJvmFormalParameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18906:1: ( ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ) + // InternalExport.g:18907:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) + { + // InternalExport.g:18907:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) + // InternalExport.g:18908:2: ( rule__FullJvmFormalParameter__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); + } + // InternalExport.g:18909:2: ( rule__FullJvmFormalParameter__NameAssignment_1 ) + // InternalExport.g:18909:3: rule__FullJvmFormalParameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__0" + // InternalExport.g:18918:1: rule__XFeatureCall__Group__0 : rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ; + public final void rule__XFeatureCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18922:1: ( rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ) + // InternalExport.g:18923:2: rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 + { + pushFollow(FOLLOW_93); + rule__XFeatureCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__0" + + + // $ANTLR start "rule__XFeatureCall__Group__0__Impl" + // InternalExport.g:18930:1: rule__XFeatureCall__Group__0__Impl : ( () ) ; + public final void rule__XFeatureCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18934:1: ( ( () ) ) + // InternalExport.g:18935:1: ( () ) + { + // InternalExport.g:18935:1: ( () ) + // InternalExport.g:18936:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); + } + // InternalExport.g:18937:2: () + // InternalExport.g:18937:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__1" + // InternalExport.g:18945:1: rule__XFeatureCall__Group__1 : rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ; + public final void rule__XFeatureCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18949:1: ( rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ) + // InternalExport.g:18950:2: rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 + { + pushFollow(FOLLOW_93); + rule__XFeatureCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__1" + + + // $ANTLR start "rule__XFeatureCall__Group__1__Impl" + // InternalExport.g:18957:1: rule__XFeatureCall__Group__1__Impl : ( ( rule__XFeatureCall__Group_1__0 )? ) ; + public final void rule__XFeatureCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18961:1: ( ( ( rule__XFeatureCall__Group_1__0 )? ) ) + // InternalExport.g:18962:1: ( ( rule__XFeatureCall__Group_1__0 )? ) + { + // InternalExport.g:18962:1: ( ( rule__XFeatureCall__Group_1__0 )? ) + // InternalExport.g:18963:2: ( rule__XFeatureCall__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_1()); + } + // InternalExport.g:18964:2: ( rule__XFeatureCall__Group_1__0 )? + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==22) ) { + alt152=1; + } + switch (alt152) { + case 1 : + // InternalExport.g:18964:3: rule__XFeatureCall__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__2" + // InternalExport.g:18972:1: rule__XFeatureCall__Group__2 : rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ; + public final void rule__XFeatureCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18976:1: ( rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ) + // InternalExport.g:18977:2: rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 + { + pushFollow(FOLLOW_94); + rule__XFeatureCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__2" + + + // $ANTLR start "rule__XFeatureCall__Group__2__Impl" + // InternalExport.g:18984:1: rule__XFeatureCall__Group__2__Impl : ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ; + public final void rule__XFeatureCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:18988:1: ( ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ) + // InternalExport.g:18989:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) + { + // InternalExport.g:18989:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) + // InternalExport.g:18990:2: ( rule__XFeatureCall__FeatureAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); + } + // InternalExport.g:18991:2: ( rule__XFeatureCall__FeatureAssignment_2 ) + // InternalExport.g:18991:3: rule__XFeatureCall__FeatureAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__3" + // InternalExport.g:18999:1: rule__XFeatureCall__Group__3 : rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ; + public final void rule__XFeatureCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19003:1: ( rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ) + // InternalExport.g:19004:2: rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 + { + pushFollow(FOLLOW_94); + rule__XFeatureCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__3" + + + // $ANTLR start "rule__XFeatureCall__Group__3__Impl" + // InternalExport.g:19011:1: rule__XFeatureCall__Group__3__Impl : ( ( rule__XFeatureCall__Group_3__0 )? ) ; + public final void rule__XFeatureCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19015:1: ( ( ( rule__XFeatureCall__Group_3__0 )? ) ) + // InternalExport.g:19016:1: ( ( rule__XFeatureCall__Group_3__0 )? ) + { + // InternalExport.g:19016:1: ( ( rule__XFeatureCall__Group_3__0 )? ) + // InternalExport.g:19017:2: ( rule__XFeatureCall__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3()); + } + // InternalExport.g:19018:2: ( rule__XFeatureCall__Group_3__0 )? + int alt153=2; + alt153 = dfa153.predict(input); + switch (alt153) { + case 1 : + // InternalExport.g:19018:3: rule__XFeatureCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__3__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__4" + // InternalExport.g:19026:1: rule__XFeatureCall__Group__4 : rule__XFeatureCall__Group__4__Impl ; + public final void rule__XFeatureCall__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19030:1: ( rule__XFeatureCall__Group__4__Impl ) + // InternalExport.g:19031:2: rule__XFeatureCall__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__4" + + + // $ANTLR start "rule__XFeatureCall__Group__4__Impl" + // InternalExport.g:19037:1: rule__XFeatureCall__Group__4__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ; + public final void rule__XFeatureCall__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19041:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ) + // InternalExport.g:19042:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) + { + // InternalExport.g:19042:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) + // InternalExport.g:19043:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); + } + // InternalExport.g:19044:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? + int alt154=2; + alt154 = dfa154.predict(input); + switch (alt154) { + case 1 : + // InternalExport.g:19044:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__4__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__0" + // InternalExport.g:19053:1: rule__XFeatureCall__Group_1__0 : rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ; + public final void rule__XFeatureCall__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19057:1: ( rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ) + // InternalExport.g:19058:2: rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 + { + pushFollow(FOLLOW_95); + rule__XFeatureCall__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_1__0__Impl" + // InternalExport.g:19065:1: rule__XFeatureCall__Group_1__0__Impl : ( '<' ) ; + public final void rule__XFeatureCall__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19069:1: ( ( '<' ) ) + // InternalExport.g:19070:1: ( '<' ) + { + // InternalExport.g:19070:1: ( '<' ) + // InternalExport.g:19071:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__1" + // InternalExport.g:19080:1: rule__XFeatureCall__Group_1__1 : rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ; + public final void rule__XFeatureCall__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19084:1: ( rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ) + // InternalExport.g:19085:2: rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 + { + pushFollow(FOLLOW_96); + rule__XFeatureCall__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_1__1__Impl" + // InternalExport.g:19092:1: rule__XFeatureCall__Group_1__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ; + public final void rule__XFeatureCall__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19096:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ) + // InternalExport.g:19097:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) + { + // InternalExport.g:19097:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) + // InternalExport.g:19098:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); + } + // InternalExport.g:19099:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) + // InternalExport.g:19099:3: rule__XFeatureCall__TypeArgumentsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__TypeArgumentsAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__2" + // InternalExport.g:19107:1: rule__XFeatureCall__Group_1__2 : rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ; + public final void rule__XFeatureCall__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19111:1: ( rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ) + // InternalExport.g:19112:2: rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 + { + pushFollow(FOLLOW_96); + rule__XFeatureCall__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__2" + + + // $ANTLR start "rule__XFeatureCall__Group_1__2__Impl" + // InternalExport.g:19119:1: rule__XFeatureCall__Group_1__2__Impl : ( ( rule__XFeatureCall__Group_1_2__0 )* ) ; + public final void rule__XFeatureCall__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19123:1: ( ( ( rule__XFeatureCall__Group_1_2__0 )* ) ) + // InternalExport.g:19124:1: ( ( rule__XFeatureCall__Group_1_2__0 )* ) + { + // InternalExport.g:19124:1: ( ( rule__XFeatureCall__Group_1_2__0 )* ) + // InternalExport.g:19125:2: ( rule__XFeatureCall__Group_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); + } + // InternalExport.g:19126:2: ( rule__XFeatureCall__Group_1_2__0 )* + loop155: + do { + int alt155=2; + int LA155_0 = input.LA(1); + + if ( (LA155_0==74) ) { + alt155=1; + } + + + switch (alt155) { + case 1 : + // InternalExport.g:19126:3: rule__XFeatureCall__Group_1_2__0 + { + pushFollow(FOLLOW_22); + rule__XFeatureCall__Group_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop155; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__3" + // InternalExport.g:19134:1: rule__XFeatureCall__Group_1__3 : rule__XFeatureCall__Group_1__3__Impl ; + public final void rule__XFeatureCall__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19138:1: ( rule__XFeatureCall__Group_1__3__Impl ) + // InternalExport.g:19139:2: rule__XFeatureCall__Group_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__3" + + + // $ANTLR start "rule__XFeatureCall__Group_1__3__Impl" + // InternalExport.g:19145:1: rule__XFeatureCall__Group_1__3__Impl : ( '>' ) ; + public final void rule__XFeatureCall__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19149:1: ( ( '>' ) ) + // InternalExport.g:19150:1: ( '>' ) + { + // InternalExport.g:19150:1: ( '>' ) + // InternalExport.g:19151:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__3__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__0" + // InternalExport.g:19161:1: rule__XFeatureCall__Group_1_2__0 : rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ; + public final void rule__XFeatureCall__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19165:1: ( rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ) + // InternalExport.g:19166:2: rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 + { + pushFollow(FOLLOW_95); + rule__XFeatureCall__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__0" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__0__Impl" + // InternalExport.g:19173:1: rule__XFeatureCall__Group_1_2__0__Impl : ( ',' ) ; + public final void rule__XFeatureCall__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19177:1: ( ( ',' ) ) + // InternalExport.g:19178:1: ( ',' ) + { + // InternalExport.g:19178:1: ( ',' ) + // InternalExport.g:19179:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__1" + // InternalExport.g:19188:1: rule__XFeatureCall__Group_1_2__1 : rule__XFeatureCall__Group_1_2__1__Impl ; + public final void rule__XFeatureCall__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19192:1: ( rule__XFeatureCall__Group_1_2__1__Impl ) + // InternalExport.g:19193:2: rule__XFeatureCall__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__1" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__1__Impl" + // InternalExport.g:19199:1: rule__XFeatureCall__Group_1_2__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ; + public final void rule__XFeatureCall__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19203:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ) + // InternalExport.g:19204:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) + { + // InternalExport.g:19204:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) + // InternalExport.g:19205:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); + } + // InternalExport.g:19206:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) + // InternalExport.g:19206:3: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__TypeArgumentsAssignment_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__0" + // InternalExport.g:19215:1: rule__XFeatureCall__Group_3__0 : rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ; + public final void rule__XFeatureCall__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19219:1: ( rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ) + // InternalExport.g:19220:2: rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 + { + pushFollow(FOLLOW_97); + rule__XFeatureCall__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3__0__Impl" + // InternalExport.g:19227:1: rule__XFeatureCall__Group_3__0__Impl : ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ; + public final void rule__XFeatureCall__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19231:1: ( ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ) + // InternalExport.g:19232:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) + { + // InternalExport.g:19232:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) + // InternalExport.g:19233:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); + } + // InternalExport.g:19234:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) + // InternalExport.g:19234:3: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__ExplicitOperationCallAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__1" + // InternalExport.g:19242:1: rule__XFeatureCall__Group_3__1 : rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ; + public final void rule__XFeatureCall__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19246:1: ( rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ) + // InternalExport.g:19247:2: rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 + { + pushFollow(FOLLOW_97); + rule__XFeatureCall__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3__1__Impl" + // InternalExport.g:19254:1: rule__XFeatureCall__Group_3__1__Impl : ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ; + public final void rule__XFeatureCall__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19258:1: ( ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ) + // InternalExport.g:19259:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? ) + { + // InternalExport.g:19259:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? ) + // InternalExport.g:19260:2: ( rule__XFeatureCall__Alternatives_3_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); + } + // InternalExport.g:19261:2: ( rule__XFeatureCall__Alternatives_3_1 )? + int alt156=2; + int LA156_0 = input.LA(1); + + if ( ((LA156_0>=RULE_ID && LA156_0<=RULE_STRING)||(LA156_0>=22 && LA156_0<=24)||LA156_0==27||(LA156_0>=36 && LA156_0<=37)||LA156_0==51||(LA156_0>=60 && LA156_0<=64)||LA156_0==66||LA156_0==68||LA156_0==72||LA156_0==77||LA156_0==87||LA156_0==90||LA156_0==93||LA156_0==95||(LA156_0>=97 && LA156_0<=104)||LA156_0==106) ) { + alt156=1; + } + switch (alt156) { + case 1 : + // InternalExport.g:19261:3: rule__XFeatureCall__Alternatives_3_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Alternatives_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__2" + // InternalExport.g:19269:1: rule__XFeatureCall__Group_3__2 : rule__XFeatureCall__Group_3__2__Impl ; + public final void rule__XFeatureCall__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19273:1: ( rule__XFeatureCall__Group_3__2__Impl ) + // InternalExport.g:19274:2: rule__XFeatureCall__Group_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__2" + + + // $ANTLR start "rule__XFeatureCall__Group_3__2__Impl" + // InternalExport.g:19280:1: rule__XFeatureCall__Group_3__2__Impl : ( ')' ) ; + public final void rule__XFeatureCall__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19284:1: ( ( ')' ) ) + // InternalExport.g:19285:1: ( ')' ) + { + // InternalExport.g:19285:1: ( ')' ) + // InternalExport.g:19286:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0" + // InternalExport.g:19296:1: rule__XFeatureCall__Group_3_1_1__0 : rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ; + public final void rule__XFeatureCall__Group_3_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19300:1: ( rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ) + // InternalExport.g:19301:2: rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 + { + pushFollow(FOLLOW_21); + rule__XFeatureCall__Group_3_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0__Impl" + // InternalExport.g:19308:1: rule__XFeatureCall__Group_3_1_1__0__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ; + public final void rule__XFeatureCall__Group_3_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19312:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ) + // InternalExport.g:19313:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) + { + // InternalExport.g:19313:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) + // InternalExport.g:19314:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); + } + // InternalExport.g:19315:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) + // InternalExport.g:19315:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1" + // InternalExport.g:19323:1: rule__XFeatureCall__Group_3_1_1__1 : rule__XFeatureCall__Group_3_1_1__1__Impl ; + public final void rule__XFeatureCall__Group_3_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19327:1: ( rule__XFeatureCall__Group_3_1_1__1__Impl ) + // InternalExport.g:19328:2: rule__XFeatureCall__Group_3_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1__Impl" + // InternalExport.g:19334:1: rule__XFeatureCall__Group_3_1_1__1__Impl : ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ; + public final void rule__XFeatureCall__Group_3_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19338:1: ( ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ) + // InternalExport.g:19339:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) + { + // InternalExport.g:19339:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) + // InternalExport.g:19340:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); + } + // InternalExport.g:19341:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )* + loop157: + do { + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==74) ) { + alt157=1; + } + + + switch (alt157) { + case 1 : + // InternalExport.g:19341:3: rule__XFeatureCall__Group_3_1_1_1__0 + { + pushFollow(FOLLOW_22); + rule__XFeatureCall__Group_3_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop157; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0" + // InternalExport.g:19350:1: rule__XFeatureCall__Group_3_1_1_1__0 : rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ; + public final void rule__XFeatureCall__Group_3_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19354:1: ( rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ) + // InternalExport.g:19355:2: rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 + { + pushFollow(FOLLOW_98); + rule__XFeatureCall__Group_3_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0__Impl" + // InternalExport.g:19362:1: rule__XFeatureCall__Group_3_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XFeatureCall__Group_3_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19366:1: ( ( ',' ) ) + // InternalExport.g:19367:1: ( ',' ) + { + // InternalExport.g:19367:1: ( ',' ) + // InternalExport.g:19368:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1" + // InternalExport.g:19377:1: rule__XFeatureCall__Group_3_1_1_1__1 : rule__XFeatureCall__Group_3_1_1_1__1__Impl ; + public final void rule__XFeatureCall__Group_3_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19381:1: ( rule__XFeatureCall__Group_3_1_1_1__1__Impl ) + // InternalExport.g:19382:2: rule__XFeatureCall__Group_3_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1__Impl" + // InternalExport.g:19388:1: rule__XFeatureCall__Group_3_1_1_1__1__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ; + public final void rule__XFeatureCall__Group_3_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19392:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ) + // InternalExport.g:19393:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) + { + // InternalExport.g:19393:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) + // InternalExport.g:19394:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); + } + // InternalExport.g:19395:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) + // InternalExport.g:19395:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__0" + // InternalExport.g:19404:1: rule__XConstructorCall__Group__0 : rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ; + public final void rule__XConstructorCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19408:1: ( rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ) + // InternalExport.g:19409:2: rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 + { + pushFollow(FOLLOW_116); + rule__XConstructorCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__0" + + + // $ANTLR start "rule__XConstructorCall__Group__0__Impl" + // InternalExport.g:19416:1: rule__XConstructorCall__Group__0__Impl : ( () ) ; + public final void rule__XConstructorCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19420:1: ( ( () ) ) + // InternalExport.g:19421:1: ( () ) + { + // InternalExport.g:19421:1: ( () ) + // InternalExport.g:19422:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); + } + // InternalExport.g:19423:2: () + // InternalExport.g:19423:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__1" + // InternalExport.g:19431:1: rule__XConstructorCall__Group__1 : rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ; + public final void rule__XConstructorCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19435:1: ( rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ) + // InternalExport.g:19436:2: rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 + { + pushFollow(FOLLOW_11); + rule__XConstructorCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__1" + + + // $ANTLR start "rule__XConstructorCall__Group__1__Impl" + // InternalExport.g:19443:1: rule__XConstructorCall__Group__1__Impl : ( 'new' ) ; + public final void rule__XConstructorCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19447:1: ( ( 'new' ) ) + // InternalExport.g:19448:1: ( 'new' ) + { + // InternalExport.g:19448:1: ( 'new' ) + // InternalExport.g:19449:2: 'new' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__2" + // InternalExport.g:19458:1: rule__XConstructorCall__Group__2 : rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ; + public final void rule__XConstructorCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19462:1: ( rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ) + // InternalExport.g:19463:2: rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 + { + pushFollow(FOLLOW_117); + rule__XConstructorCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__2" + + + // $ANTLR start "rule__XConstructorCall__Group__2__Impl" + // InternalExport.g:19470:1: rule__XConstructorCall__Group__2__Impl : ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ; + public final void rule__XConstructorCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19474:1: ( ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ) + // InternalExport.g:19475:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) + { + // InternalExport.g:19475:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) + // InternalExport.g:19476:2: ( rule__XConstructorCall__ConstructorAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); + } + // InternalExport.g:19477:2: ( rule__XConstructorCall__ConstructorAssignment_2 ) + // InternalExport.g:19477:3: rule__XConstructorCall__ConstructorAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ConstructorAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__3" + // InternalExport.g:19485:1: rule__XConstructorCall__Group__3 : rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ; + public final void rule__XConstructorCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19489:1: ( rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ) + // InternalExport.g:19490:2: rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 + { + pushFollow(FOLLOW_117); + rule__XConstructorCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__3" + + + // $ANTLR start "rule__XConstructorCall__Group__3__Impl" + // InternalExport.g:19497:1: rule__XConstructorCall__Group__3__Impl : ( ( rule__XConstructorCall__Group_3__0 )? ) ; + public final void rule__XConstructorCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19501:1: ( ( ( rule__XConstructorCall__Group_3__0 )? ) ) + // InternalExport.g:19502:1: ( ( rule__XConstructorCall__Group_3__0 )? ) + { + // InternalExport.g:19502:1: ( ( rule__XConstructorCall__Group_3__0 )? ) + // InternalExport.g:19503:2: ( rule__XConstructorCall__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_3()); + } + // InternalExport.g:19504:2: ( rule__XConstructorCall__Group_3__0 )? + int alt158=2; + alt158 = dfa158.predict(input); + switch (alt158) { + case 1 : + // InternalExport.g:19504:3: rule__XConstructorCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__3__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__4" + // InternalExport.g:19512:1: rule__XConstructorCall__Group__4 : rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ; + public final void rule__XConstructorCall__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19516:1: ( rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ) + // InternalExport.g:19517:2: rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 + { + pushFollow(FOLLOW_117); + rule__XConstructorCall__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__4" + + + // $ANTLR start "rule__XConstructorCall__Group__4__Impl" + // InternalExport.g:19524:1: rule__XConstructorCall__Group__4__Impl : ( ( rule__XConstructorCall__Group_4__0 )? ) ; + public final void rule__XConstructorCall__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19528:1: ( ( ( rule__XConstructorCall__Group_4__0 )? ) ) + // InternalExport.g:19529:1: ( ( rule__XConstructorCall__Group_4__0 )? ) + { + // InternalExport.g:19529:1: ( ( rule__XConstructorCall__Group_4__0 )? ) + // InternalExport.g:19530:2: ( rule__XConstructorCall__Group_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4()); + } + // InternalExport.g:19531:2: ( rule__XConstructorCall__Group_4__0 )? + int alt159=2; + alt159 = dfa159.predict(input); + switch (alt159) { + case 1 : + // InternalExport.g:19531:3: rule__XConstructorCall__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__4__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__5" + // InternalExport.g:19539:1: rule__XConstructorCall__Group__5 : rule__XConstructorCall__Group__5__Impl ; + public final void rule__XConstructorCall__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19543:1: ( rule__XConstructorCall__Group__5__Impl ) + // InternalExport.g:19544:2: rule__XConstructorCall__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__5" + + + // $ANTLR start "rule__XConstructorCall__Group__5__Impl" + // InternalExport.g:19550:1: rule__XConstructorCall__Group__5__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ; + public final void rule__XConstructorCall__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19554:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ) + // InternalExport.g:19555:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) + { + // InternalExport.g:19555:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) + // InternalExport.g:19556:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); + } + // InternalExport.g:19557:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )? + int alt160=2; + alt160 = dfa160.predict(input); + switch (alt160) { + case 1 : + // InternalExport.g:19557:3: rule__XConstructorCall__ArgumentsAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__5__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__0" + // InternalExport.g:19566:1: rule__XConstructorCall__Group_3__0 : rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ; + public final void rule__XConstructorCall__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19570:1: ( rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ) + // InternalExport.g:19571:2: rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 + { + pushFollow(FOLLOW_95); + rule__XConstructorCall__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__0" + + + // $ANTLR start "rule__XConstructorCall__Group_3__0__Impl" + // InternalExport.g:19578:1: rule__XConstructorCall__Group_3__0__Impl : ( ( '<' ) ) ; + public final void rule__XConstructorCall__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19582:1: ( ( ( '<' ) ) ) + // InternalExport.g:19583:1: ( ( '<' ) ) + { + // InternalExport.g:19583:1: ( ( '<' ) ) + // InternalExport.g:19584:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + // InternalExport.g:19585:2: ( '<' ) + // InternalExport.g:19585:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__1" + // InternalExport.g:19593:1: rule__XConstructorCall__Group_3__1 : rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ; + public final void rule__XConstructorCall__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19597:1: ( rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ) + // InternalExport.g:19598:2: rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 + { + pushFollow(FOLLOW_96); + rule__XConstructorCall__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__1" + + + // $ANTLR start "rule__XConstructorCall__Group_3__1__Impl" + // InternalExport.g:19605:1: rule__XConstructorCall__Group_3__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ; + public final void rule__XConstructorCall__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19609:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ) + // InternalExport.g:19610:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) + { + // InternalExport.g:19610:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) + // InternalExport.g:19611:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); + } + // InternalExport.g:19612:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) + // InternalExport.g:19612:3: rule__XConstructorCall__TypeArgumentsAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__TypeArgumentsAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__2" + // InternalExport.g:19620:1: rule__XConstructorCall__Group_3__2 : rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ; + public final void rule__XConstructorCall__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19624:1: ( rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ) + // InternalExport.g:19625:2: rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 + { + pushFollow(FOLLOW_96); + rule__XConstructorCall__Group_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__2" + + + // $ANTLR start "rule__XConstructorCall__Group_3__2__Impl" + // InternalExport.g:19632:1: rule__XConstructorCall__Group_3__2__Impl : ( ( rule__XConstructorCall__Group_3_2__0 )* ) ; + public final void rule__XConstructorCall__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19636:1: ( ( ( rule__XConstructorCall__Group_3_2__0 )* ) ) + // InternalExport.g:19637:1: ( ( rule__XConstructorCall__Group_3_2__0 )* ) + { + // InternalExport.g:19637:1: ( ( rule__XConstructorCall__Group_3_2__0 )* ) + // InternalExport.g:19638:2: ( rule__XConstructorCall__Group_3_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); + } + // InternalExport.g:19639:2: ( rule__XConstructorCall__Group_3_2__0 )* + loop161: + do { + int alt161=2; + int LA161_0 = input.LA(1); + + if ( (LA161_0==74) ) { + alt161=1; + } + + + switch (alt161) { + case 1 : + // InternalExport.g:19639:3: rule__XConstructorCall__Group_3_2__0 + { + pushFollow(FOLLOW_22); + rule__XConstructorCall__Group_3_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop161; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__3" + // InternalExport.g:19647:1: rule__XConstructorCall__Group_3__3 : rule__XConstructorCall__Group_3__3__Impl ; + public final void rule__XConstructorCall__Group_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19651:1: ( rule__XConstructorCall__Group_3__3__Impl ) + // InternalExport.g:19652:2: rule__XConstructorCall__Group_3__3__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__3" + + + // $ANTLR start "rule__XConstructorCall__Group_3__3__Impl" + // InternalExport.g:19658:1: rule__XConstructorCall__Group_3__3__Impl : ( '>' ) ; + public final void rule__XConstructorCall__Group_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19662:1: ( ( '>' ) ) + // InternalExport.g:19663:1: ( '>' ) + { + // InternalExport.g:19663:1: ( '>' ) + // InternalExport.g:19664:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__3__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__0" + // InternalExport.g:19674:1: rule__XConstructorCall__Group_3_2__0 : rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ; + public final void rule__XConstructorCall__Group_3_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19678:1: ( rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ) + // InternalExport.g:19679:2: rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 + { + pushFollow(FOLLOW_95); + rule__XConstructorCall__Group_3_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__0" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__0__Impl" + // InternalExport.g:19686:1: rule__XConstructorCall__Group_3_2__0__Impl : ( ',' ) ; + public final void rule__XConstructorCall__Group_3_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19690:1: ( ( ',' ) ) + // InternalExport.g:19691:1: ( ',' ) + { + // InternalExport.g:19691:1: ( ',' ) + // InternalExport.g:19692:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__1" + // InternalExport.g:19701:1: rule__XConstructorCall__Group_3_2__1 : rule__XConstructorCall__Group_3_2__1__Impl ; + public final void rule__XConstructorCall__Group_3_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19705:1: ( rule__XConstructorCall__Group_3_2__1__Impl ) + // InternalExport.g:19706:2: rule__XConstructorCall__Group_3_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__1" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__1__Impl" + // InternalExport.g:19712:1: rule__XConstructorCall__Group_3_2__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ; + public final void rule__XConstructorCall__Group_3_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19716:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ) + // InternalExport.g:19717:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) + { + // InternalExport.g:19717:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) + // InternalExport.g:19718:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); + } + // InternalExport.g:19719:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) + // InternalExport.g:19719:3: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__TypeArgumentsAssignment_3_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__0" + // InternalExport.g:19728:1: rule__XConstructorCall__Group_4__0 : rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ; + public final void rule__XConstructorCall__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19732:1: ( rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ) + // InternalExport.g:19733:2: rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 + { + pushFollow(FOLLOW_97); + rule__XConstructorCall__Group_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4__0__Impl" + // InternalExport.g:19740:1: rule__XConstructorCall__Group_4__0__Impl : ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ; + public final void rule__XConstructorCall__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19744:1: ( ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ) + // InternalExport.g:19745:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) + { + // InternalExport.g:19745:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) + // InternalExport.g:19746:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); + } + // InternalExport.g:19747:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) + // InternalExport.g:19747:3: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__1" + // InternalExport.g:19755:1: rule__XConstructorCall__Group_4__1 : rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ; + public final void rule__XConstructorCall__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19759:1: ( rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ) + // InternalExport.g:19760:2: rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 + { + pushFollow(FOLLOW_97); + rule__XConstructorCall__Group_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4__1__Impl" + // InternalExport.g:19767:1: rule__XConstructorCall__Group_4__1__Impl : ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ; + public final void rule__XConstructorCall__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19771:1: ( ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ) + // InternalExport.g:19772:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? ) + { + // InternalExport.g:19772:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? ) + // InternalExport.g:19773:2: ( rule__XConstructorCall__Alternatives_4_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); + } + // InternalExport.g:19774:2: ( rule__XConstructorCall__Alternatives_4_1 )? + int alt162=2; + int LA162_0 = input.LA(1); + + if ( ((LA162_0>=RULE_ID && LA162_0<=RULE_STRING)||(LA162_0>=22 && LA162_0<=24)||LA162_0==27||(LA162_0>=36 && LA162_0<=37)||LA162_0==51||(LA162_0>=60 && LA162_0<=64)||LA162_0==66||LA162_0==68||LA162_0==72||LA162_0==77||LA162_0==87||LA162_0==90||LA162_0==93||LA162_0==95||(LA162_0>=97 && LA162_0<=104)||LA162_0==106) ) { + alt162=1; + } + switch (alt162) { + case 1 : + // InternalExport.g:19774:3: rule__XConstructorCall__Alternatives_4_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Alternatives_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__2" + // InternalExport.g:19782:1: rule__XConstructorCall__Group_4__2 : rule__XConstructorCall__Group_4__2__Impl ; + public final void rule__XConstructorCall__Group_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19786:1: ( rule__XConstructorCall__Group_4__2__Impl ) + // InternalExport.g:19787:2: rule__XConstructorCall__Group_4__2__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__2" + + + // $ANTLR start "rule__XConstructorCall__Group_4__2__Impl" + // InternalExport.g:19793:1: rule__XConstructorCall__Group_4__2__Impl : ( ')' ) ; + public final void rule__XConstructorCall__Group_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19797:1: ( ( ')' ) ) + // InternalExport.g:19798:1: ( ')' ) + { + // InternalExport.g:19798:1: ( ')' ) + // InternalExport.g:19799:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0" + // InternalExport.g:19809:1: rule__XConstructorCall__Group_4_1_1__0 : rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ; + public final void rule__XConstructorCall__Group_4_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19813:1: ( rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ) + // InternalExport.g:19814:2: rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 + { + pushFollow(FOLLOW_21); + rule__XConstructorCall__Group_4_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0__Impl" + // InternalExport.g:19821:1: rule__XConstructorCall__Group_4_1_1__0__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ; + public final void rule__XConstructorCall__Group_4_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19825:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ) + // InternalExport.g:19826:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) + { + // InternalExport.g:19826:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) + // InternalExport.g:19827:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); + } + // InternalExport.g:19828:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) + // InternalExport.g:19828:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1" + // InternalExport.g:19836:1: rule__XConstructorCall__Group_4_1_1__1 : rule__XConstructorCall__Group_4_1_1__1__Impl ; + public final void rule__XConstructorCall__Group_4_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19840:1: ( rule__XConstructorCall__Group_4_1_1__1__Impl ) + // InternalExport.g:19841:2: rule__XConstructorCall__Group_4_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1__Impl" + // InternalExport.g:19847:1: rule__XConstructorCall__Group_4_1_1__1__Impl : ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ; + public final void rule__XConstructorCall__Group_4_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19851:1: ( ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ) + // InternalExport.g:19852:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) + { + // InternalExport.g:19852:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) + // InternalExport.g:19853:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); + } + // InternalExport.g:19854:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )* + loop163: + do { + int alt163=2; + int LA163_0 = input.LA(1); + + if ( (LA163_0==74) ) { + alt163=1; + } + + + switch (alt163) { + case 1 : + // InternalExport.g:19854:3: rule__XConstructorCall__Group_4_1_1_1__0 + { + pushFollow(FOLLOW_22); + rule__XConstructorCall__Group_4_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop163; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0" + // InternalExport.g:19863:1: rule__XConstructorCall__Group_4_1_1_1__0 : rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ; + public final void rule__XConstructorCall__Group_4_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19867:1: ( rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ) + // InternalExport.g:19868:2: rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 + { + pushFollow(FOLLOW_98); + rule__XConstructorCall__Group_4_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0__Impl" + // InternalExport.g:19875:1: rule__XConstructorCall__Group_4_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XConstructorCall__Group_4_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19879:1: ( ( ',' ) ) + // InternalExport.g:19880:1: ( ',' ) + { + // InternalExport.g:19880:1: ( ',' ) + // InternalExport.g:19881:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1" + // InternalExport.g:19890:1: rule__XConstructorCall__Group_4_1_1_1__1 : rule__XConstructorCall__Group_4_1_1_1__1__Impl ; + public final void rule__XConstructorCall__Group_4_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19894:1: ( rule__XConstructorCall__Group_4_1_1_1__1__Impl ) + // InternalExport.g:19895:2: rule__XConstructorCall__Group_4_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1__Impl" + // InternalExport.g:19901:1: rule__XConstructorCall__Group_4_1_1_1__1__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ; + public final void rule__XConstructorCall__Group_4_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19905:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ) + // InternalExport.g:19906:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) + { + // InternalExport.g:19906:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) + // InternalExport.g:19907:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); + } + // InternalExport.g:19908:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) + // InternalExport.g:19908:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1__Impl" + + + // $ANTLR start "rule__XBooleanLiteral__Group__0" + // InternalExport.g:19917:1: rule__XBooleanLiteral__Group__0 : rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ; + public final void rule__XBooleanLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19921:1: ( rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ) + // InternalExport.g:19922:2: rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 + { + pushFollow(FOLLOW_118); + rule__XBooleanLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__0" + + + // $ANTLR start "rule__XBooleanLiteral__Group__0__Impl" + // InternalExport.g:19929:1: rule__XBooleanLiteral__Group__0__Impl : ( () ) ; + public final void rule__XBooleanLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19933:1: ( ( () ) ) + // InternalExport.g:19934:1: ( () ) + { + // InternalExport.g:19934:1: ( () ) + // InternalExport.g:19935:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); + } + // InternalExport.g:19936:2: () + // InternalExport.g:19936:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XBooleanLiteral__Group__1" + // InternalExport.g:19944:1: rule__XBooleanLiteral__Group__1 : rule__XBooleanLiteral__Group__1__Impl ; + public final void rule__XBooleanLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19948:1: ( rule__XBooleanLiteral__Group__1__Impl ) + // InternalExport.g:19949:2: rule__XBooleanLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__1" + + + // $ANTLR start "rule__XBooleanLiteral__Group__1__Impl" + // InternalExport.g:19955:1: rule__XBooleanLiteral__Group__1__Impl : ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ; + public final void rule__XBooleanLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19959:1: ( ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ) + // InternalExport.g:19960:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) ) + { + // InternalExport.g:19960:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) ) + // InternalExport.g:19961:2: ( rule__XBooleanLiteral__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); + } + // InternalExport.g:19962:2: ( rule__XBooleanLiteral__Alternatives_1 ) + // InternalExport.g:19962:3: rule__XBooleanLiteral__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XNullLiteral__Group__0" + // InternalExport.g:19971:1: rule__XNullLiteral__Group__0 : rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ; + public final void rule__XNullLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19975:1: ( rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ) + // InternalExport.g:19976:2: rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 + { + pushFollow(FOLLOW_119); + rule__XNullLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__0" + + + // $ANTLR start "rule__XNullLiteral__Group__0__Impl" + // InternalExport.g:19983:1: rule__XNullLiteral__Group__0__Impl : ( () ) ; + public final void rule__XNullLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:19987:1: ( ( () ) ) + // InternalExport.g:19988:1: ( () ) + { + // InternalExport.g:19988:1: ( () ) + // InternalExport.g:19989:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); + } + // InternalExport.g:19990:2: () + // InternalExport.g:19990:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XNullLiteral__Group__1" + // InternalExport.g:19998:1: rule__XNullLiteral__Group__1 : rule__XNullLiteral__Group__1__Impl ; + public final void rule__XNullLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20002:1: ( rule__XNullLiteral__Group__1__Impl ) + // InternalExport.g:20003:2: rule__XNullLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__1" + + + // $ANTLR start "rule__XNullLiteral__Group__1__Impl" + // InternalExport.g:20009:1: rule__XNullLiteral__Group__1__Impl : ( 'null' ) ; + public final void rule__XNullLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20013:1: ( ( 'null' ) ) + // InternalExport.g:20014:1: ( 'null' ) + { + // InternalExport.g:20014:1: ( 'null' ) + // InternalExport.g:20015:2: 'null' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + match(input,100,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XNumberLiteral__Group__0" + // InternalExport.g:20025:1: rule__XNumberLiteral__Group__0 : rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ; + public final void rule__XNumberLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20029:1: ( rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ) + // InternalExport.g:20030:2: rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 + { + pushFollow(FOLLOW_120); + rule__XNumberLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__0" + + + // $ANTLR start "rule__XNumberLiteral__Group__0__Impl" + // InternalExport.g:20037:1: rule__XNumberLiteral__Group__0__Impl : ( () ) ; + public final void rule__XNumberLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20041:1: ( ( () ) ) + // InternalExport.g:20042:1: ( () ) + { + // InternalExport.g:20042:1: ( () ) + // InternalExport.g:20043:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); + } + // InternalExport.g:20044:2: () + // InternalExport.g:20044:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XNumberLiteral__Group__1" + // InternalExport.g:20052:1: rule__XNumberLiteral__Group__1 : rule__XNumberLiteral__Group__1__Impl ; + public final void rule__XNumberLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20056:1: ( rule__XNumberLiteral__Group__1__Impl ) + // InternalExport.g:20057:2: rule__XNumberLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__1" + + + // $ANTLR start "rule__XNumberLiteral__Group__1__Impl" + // InternalExport.g:20063:1: rule__XNumberLiteral__Group__1__Impl : ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ; + public final void rule__XNumberLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20067:1: ( ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ) + // InternalExport.g:20068:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) + { + // InternalExport.g:20068:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) + // InternalExport.g:20069:2: ( rule__XNumberLiteral__ValueAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); + } + // InternalExport.g:20070:2: ( rule__XNumberLiteral__ValueAssignment_1 ) + // InternalExport.g:20070:3: rule__XNumberLiteral__ValueAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__ValueAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XStringLiteral__Group__0" + // InternalExport.g:20079:1: rule__XStringLiteral__Group__0 : rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ; + public final void rule__XStringLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20083:1: ( rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ) + // InternalExport.g:20084:2: rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 + { + pushFollow(FOLLOW_14); + rule__XStringLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__0" + + + // $ANTLR start "rule__XStringLiteral__Group__0__Impl" + // InternalExport.g:20091:1: rule__XStringLiteral__Group__0__Impl : ( () ) ; + public final void rule__XStringLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20095:1: ( ( () ) ) + // InternalExport.g:20096:1: ( () ) + { + // InternalExport.g:20096:1: ( () ) + // InternalExport.g:20097:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); + } + // InternalExport.g:20098:2: () + // InternalExport.g:20098:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XStringLiteral__Group__1" + // InternalExport.g:20106:1: rule__XStringLiteral__Group__1 : rule__XStringLiteral__Group__1__Impl ; + public final void rule__XStringLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20110:1: ( rule__XStringLiteral__Group__1__Impl ) + // InternalExport.g:20111:2: rule__XStringLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__1" + + + // $ANTLR start "rule__XStringLiteral__Group__1__Impl" + // InternalExport.g:20117:1: rule__XStringLiteral__Group__1__Impl : ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ; + public final void rule__XStringLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20121:1: ( ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ) + // InternalExport.g:20122:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) ) + { + // InternalExport.g:20122:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) ) + // InternalExport.g:20123:2: ( rule__XStringLiteral__ValueAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); + } + // InternalExport.g:20124:2: ( rule__XStringLiteral__ValueAssignment_1 ) + // InternalExport.g:20124:3: rule__XStringLiteral__ValueAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__ValueAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__0" + // InternalExport.g:20133:1: rule__XTypeLiteral__Group__0 : rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ; + public final void rule__XTypeLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20137:1: ( rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ) + // InternalExport.g:20138:2: rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 + { + pushFollow(FOLLOW_121); + rule__XTypeLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__0" + + + // $ANTLR start "rule__XTypeLiteral__Group__0__Impl" + // InternalExport.g:20145:1: rule__XTypeLiteral__Group__0__Impl : ( () ) ; + public final void rule__XTypeLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20149:1: ( ( () ) ) + // InternalExport.g:20150:1: ( () ) + { + // InternalExport.g:20150:1: ( () ) + // InternalExport.g:20151:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); + } + // InternalExport.g:20152:2: () + // InternalExport.g:20152:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__1" + // InternalExport.g:20160:1: rule__XTypeLiteral__Group__1 : rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ; + public final void rule__XTypeLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20164:1: ( rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ) + // InternalExport.g:20165:2: rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 + { + pushFollow(FOLLOW_34); + rule__XTypeLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__1" + + + // $ANTLR start "rule__XTypeLiteral__Group__1__Impl" + // InternalExport.g:20172:1: rule__XTypeLiteral__Group__1__Impl : ( 'typeof' ) ; + public final void rule__XTypeLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20176:1: ( ( 'typeof' ) ) + // InternalExport.g:20177:1: ( 'typeof' ) + { + // InternalExport.g:20177:1: ( 'typeof' ) + // InternalExport.g:20178:2: 'typeof' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + match(input,101,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__2" + // InternalExport.g:20187:1: rule__XTypeLiteral__Group__2 : rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ; + public final void rule__XTypeLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20191:1: ( rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ) + // InternalExport.g:20192:2: rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 + { + pushFollow(FOLLOW_11); + rule__XTypeLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__2" + + + // $ANTLR start "rule__XTypeLiteral__Group__2__Impl" + // InternalExport.g:20199:1: rule__XTypeLiteral__Group__2__Impl : ( '(' ) ; + public final void rule__XTypeLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20203:1: ( ( '(' ) ) + // InternalExport.g:20204:1: ( '(' ) + { + // InternalExport.g:20204:1: ( '(' ) + // InternalExport.g:20205:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__3" + // InternalExport.g:20214:1: rule__XTypeLiteral__Group__3 : rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ; + public final void rule__XTypeLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20218:1: ( rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ) + // InternalExport.g:20219:2: rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 + { + pushFollow(FOLLOW_122); + rule__XTypeLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__3" + + + // $ANTLR start "rule__XTypeLiteral__Group__3__Impl" + // InternalExport.g:20226:1: rule__XTypeLiteral__Group__3__Impl : ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ; + public final void rule__XTypeLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20230:1: ( ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ) + // InternalExport.g:20231:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) + { + // InternalExport.g:20231:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) + // InternalExport.g:20232:2: ( rule__XTypeLiteral__TypeAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); + } + // InternalExport.g:20233:2: ( rule__XTypeLiteral__TypeAssignment_3 ) + // InternalExport.g:20233:3: rule__XTypeLiteral__TypeAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__TypeAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__4" + // InternalExport.g:20241:1: rule__XTypeLiteral__Group__4 : rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ; + public final void rule__XTypeLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20245:1: ( rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ) + // InternalExport.g:20246:2: rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 + { + pushFollow(FOLLOW_122); + rule__XTypeLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__4" + + + // $ANTLR start "rule__XTypeLiteral__Group__4__Impl" + // InternalExport.g:20253:1: rule__XTypeLiteral__Group__4__Impl : ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ; + public final void rule__XTypeLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20257:1: ( ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ) + // InternalExport.g:20258:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) + { + // InternalExport.g:20258:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) + // InternalExport.g:20259:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); + } + // InternalExport.g:20260:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* + loop164: + do { + int alt164=2; + int LA164_0 = input.LA(1); + + if ( (LA164_0==72) ) { + alt164=1; + } + + + switch (alt164) { + case 1 : + // InternalExport.g:20260:3: rule__XTypeLiteral__ArrayDimensionsAssignment_4 + { + pushFollow(FOLLOW_123); + rule__XTypeLiteral__ArrayDimensionsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop164; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__5" + // InternalExport.g:20268:1: rule__XTypeLiteral__Group__5 : rule__XTypeLiteral__Group__5__Impl ; + public final void rule__XTypeLiteral__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20272:1: ( rule__XTypeLiteral__Group__5__Impl ) + // InternalExport.g:20273:2: rule__XTypeLiteral__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__5" + + + // $ANTLR start "rule__XTypeLiteral__Group__5__Impl" + // InternalExport.g:20279:1: rule__XTypeLiteral__Group__5__Impl : ( ')' ) ; + public final void rule__XTypeLiteral__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20283:1: ( ( ')' ) ) + // InternalExport.g:20284:1: ( ')' ) + { + // InternalExport.g:20284:1: ( ')' ) + // InternalExport.g:20285:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__5__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__0" + // InternalExport.g:20295:1: rule__XThrowExpression__Group__0 : rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ; + public final void rule__XThrowExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20299:1: ( rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ) + // InternalExport.g:20300:2: rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 + { + pushFollow(FOLLOW_124); + rule__XThrowExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__0" + + + // $ANTLR start "rule__XThrowExpression__Group__0__Impl" + // InternalExport.g:20307:1: rule__XThrowExpression__Group__0__Impl : ( () ) ; + public final void rule__XThrowExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20311:1: ( ( () ) ) + // InternalExport.g:20312:1: ( () ) + { + // InternalExport.g:20312:1: ( () ) + // InternalExport.g:20313:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); + } + // InternalExport.g:20314:2: () + // InternalExport.g:20314:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__0__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__1" + // InternalExport.g:20322:1: rule__XThrowExpression__Group__1 : rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ; + public final void rule__XThrowExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20326:1: ( rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ) + // InternalExport.g:20327:2: rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 + { + pushFollow(FOLLOW_98); + rule__XThrowExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__1" + + + // $ANTLR start "rule__XThrowExpression__Group__1__Impl" + // InternalExport.g:20334:1: rule__XThrowExpression__Group__1__Impl : ( 'throw' ) ; + public final void rule__XThrowExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20338:1: ( ( 'throw' ) ) + // InternalExport.g:20339:1: ( 'throw' ) + { + // InternalExport.g:20339:1: ( 'throw' ) + // InternalExport.g:20340:2: 'throw' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + match(input,102,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__1__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__2" + // InternalExport.g:20349:1: rule__XThrowExpression__Group__2 : rule__XThrowExpression__Group__2__Impl ; + public final void rule__XThrowExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20353:1: ( rule__XThrowExpression__Group__2__Impl ) + // InternalExport.g:20354:2: rule__XThrowExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__2" + + + // $ANTLR start "rule__XThrowExpression__Group__2__Impl" + // InternalExport.g:20360:1: rule__XThrowExpression__Group__2__Impl : ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ; + public final void rule__XThrowExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20364:1: ( ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ) + // InternalExport.g:20365:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) + { + // InternalExport.g:20365:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) + // InternalExport.g:20366:2: ( rule__XThrowExpression__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); + } + // InternalExport.g:20367:2: ( rule__XThrowExpression__ExpressionAssignment_2 ) + // InternalExport.g:20367:3: rule__XThrowExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__2__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__0" + // InternalExport.g:20376:1: rule__XReturnExpression__Group__0 : rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ; + public final void rule__XReturnExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20380:1: ( rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ) + // InternalExport.g:20381:2: rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 + { + pushFollow(FOLLOW_125); + rule__XReturnExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__0" + + + // $ANTLR start "rule__XReturnExpression__Group__0__Impl" + // InternalExport.g:20388:1: rule__XReturnExpression__Group__0__Impl : ( () ) ; + public final void rule__XReturnExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20392:1: ( ( () ) ) + // InternalExport.g:20393:1: ( () ) + { + // InternalExport.g:20393:1: ( () ) + // InternalExport.g:20394:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); + } + // InternalExport.g:20395:2: () + // InternalExport.g:20395:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__0__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__1" + // InternalExport.g:20403:1: rule__XReturnExpression__Group__1 : rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ; + public final void rule__XReturnExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20407:1: ( rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ) + // InternalExport.g:20408:2: rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 + { + pushFollow(FOLLOW_98); + rule__XReturnExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__1" + + + // $ANTLR start "rule__XReturnExpression__Group__1__Impl" + // InternalExport.g:20415:1: rule__XReturnExpression__Group__1__Impl : ( 'return' ) ; + public final void rule__XReturnExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20419:1: ( ( 'return' ) ) + // InternalExport.g:20420:1: ( 'return' ) + { + // InternalExport.g:20420:1: ( 'return' ) + // InternalExport.g:20421:2: 'return' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + match(input,103,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__1__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__2" + // InternalExport.g:20430:1: rule__XReturnExpression__Group__2 : rule__XReturnExpression__Group__2__Impl ; + public final void rule__XReturnExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20434:1: ( rule__XReturnExpression__Group__2__Impl ) + // InternalExport.g:20435:2: rule__XReturnExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__2" + + + // $ANTLR start "rule__XReturnExpression__Group__2__Impl" + // InternalExport.g:20441:1: rule__XReturnExpression__Group__2__Impl : ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ; + public final void rule__XReturnExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20445:1: ( ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ) + // InternalExport.g:20446:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) + { + // InternalExport.g:20446:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) + // InternalExport.g:20447:2: ( rule__XReturnExpression__ExpressionAssignment_2 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); + } + // InternalExport.g:20448:2: ( rule__XReturnExpression__ExpressionAssignment_2 )? + int alt165=2; + alt165 = dfa165.predict(input); + switch (alt165) { + case 1 : + // InternalExport.g:20448:3: rule__XReturnExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__2__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0" + // InternalExport.g:20457:1: rule__XTryCatchFinallyExpression__Group__0 : rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ; + public final void rule__XTryCatchFinallyExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20461:1: ( rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ) + // InternalExport.g:20462:2: rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 + { + pushFollow(FOLLOW_126); + rule__XTryCatchFinallyExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0__Impl" + // InternalExport.g:20469:1: rule__XTryCatchFinallyExpression__Group__0__Impl : ( () ) ; + public final void rule__XTryCatchFinallyExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20473:1: ( ( () ) ) + // InternalExport.g:20474:1: ( () ) + { + // InternalExport.g:20474:1: ( () ) + // InternalExport.g:20475:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); + } + // InternalExport.g:20476:2: () + // InternalExport.g:20476:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1" + // InternalExport.g:20484:1: rule__XTryCatchFinallyExpression__Group__1 : rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ; + public final void rule__XTryCatchFinallyExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20488:1: ( rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ) + // InternalExport.g:20489:2: rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 + { + pushFollow(FOLLOW_98); + rule__XTryCatchFinallyExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1__Impl" + // InternalExport.g:20496:1: rule__XTryCatchFinallyExpression__Group__1__Impl : ( 'try' ) ; + public final void rule__XTryCatchFinallyExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20500:1: ( ( 'try' ) ) + // InternalExport.g:20501:1: ( 'try' ) + { + // InternalExport.g:20501:1: ( 'try' ) + // InternalExport.g:20502:2: 'try' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + match(input,104,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2" + // InternalExport.g:20511:1: rule__XTryCatchFinallyExpression__Group__2 : rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ; + public final void rule__XTryCatchFinallyExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20515:1: ( rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ) + // InternalExport.g:20516:2: rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 + { + pushFollow(FOLLOW_127); + rule__XTryCatchFinallyExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2__Impl" + // InternalExport.g:20523:1: rule__XTryCatchFinallyExpression__Group__2__Impl : ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20527:1: ( ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ) + // InternalExport.g:20528:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) + { + // InternalExport.g:20528:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) + // InternalExport.g:20529:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); + } + // InternalExport.g:20530:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) + // InternalExport.g:20530:3: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3" + // InternalExport.g:20538:1: rule__XTryCatchFinallyExpression__Group__3 : rule__XTryCatchFinallyExpression__Group__3__Impl ; + public final void rule__XTryCatchFinallyExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20542:1: ( rule__XTryCatchFinallyExpression__Group__3__Impl ) + // InternalExport.g:20543:2: rule__XTryCatchFinallyExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3__Impl" + // InternalExport.g:20549:1: rule__XTryCatchFinallyExpression__Group__3__Impl : ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20553:1: ( ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ) + // InternalExport.g:20554:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) + { + // InternalExport.g:20554:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) + // InternalExport.g:20555:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); + } + // InternalExport.g:20556:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 ) + // InternalExport.g:20556:3: rule__XTryCatchFinallyExpression__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0" + // InternalExport.g:20565:1: rule__XTryCatchFinallyExpression__Group_3_0__0 : rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20569:1: ( rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ) + // InternalExport.g:20570:2: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 + { + pushFollow(FOLLOW_128); + rule__XTryCatchFinallyExpression__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl" + // InternalExport.g:20577:1: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl : ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20581:1: ( ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ) + // InternalExport.g:20582:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) + { + // InternalExport.g:20582:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) + // InternalExport.g:20583:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) + { + // InternalExport.g:20583:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) + // InternalExport.g:20584:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + // InternalExport.g:20585:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + // InternalExport.g:20585:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_129); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + + } + + // InternalExport.g:20588:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) + // InternalExport.g:20589:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + // InternalExport.g:20590:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* + loop166: + do { + int alt166=2; + int LA166_0 = input.LA(1); + + if ( (LA166_0==107) ) { + int LA166_2 = input.LA(2); + + if ( (synpred240_InternalExport()) ) { + alt166=1; + } + + + } + + + switch (alt166) { + case 1 : + // InternalExport.g:20590:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_129); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop166; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + + } + + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1" + // InternalExport.g:20599:1: rule__XTryCatchFinallyExpression__Group_3_0__1 : rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20603:1: ( rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ) + // InternalExport.g:20604:2: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl" + // InternalExport.g:20610:1: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl : ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20614:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ) + // InternalExport.g:20615:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) + { + // InternalExport.g:20615:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) + // InternalExport.g:20616:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); + } + // InternalExport.g:20617:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? + int alt167=2; + int LA167_0 = input.LA(1); + + if ( (LA167_0==105) ) { + int LA167_1 = input.LA(2); + + if ( (synpred241_InternalExport()) ) { + alt167=1; + } + } + switch (alt167) { + case 1 : + // InternalExport.g:20617:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0" + // InternalExport.g:20626:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0 : rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20630:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ) + // InternalExport.g:20631:2: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 + { + pushFollow(FOLLOW_98); + rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl" + // InternalExport.g:20638:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl : ( ( 'finally' ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20642:1: ( ( ( 'finally' ) ) ) + // InternalExport.g:20643:1: ( ( 'finally' ) ) + { + // InternalExport.g:20643:1: ( ( 'finally' ) ) + // InternalExport.g:20644:2: ( 'finally' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + // InternalExport.g:20645:2: ( 'finally' ) + // InternalExport.g:20645:3: 'finally' + { + match(input,105,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1" + // InternalExport.g:20653:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1 : rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20657:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ) + // InternalExport.g:20658:2: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl" + // InternalExport.g:20664:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20668:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ) + // InternalExport.g:20669:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) + { + // InternalExport.g:20669:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) + // InternalExport.g:20670:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); + } + // InternalExport.g:20671:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) + // InternalExport.g:20671:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0" + // InternalExport.g:20680:1: rule__XTryCatchFinallyExpression__Group_3_1__0 : rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20684:1: ( rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ) + // InternalExport.g:20685:2: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 + { + pushFollow(FOLLOW_98); + rule__XTryCatchFinallyExpression__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl" + // InternalExport.g:20692:1: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl : ( 'finally' ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20696:1: ( ( 'finally' ) ) + // InternalExport.g:20697:1: ( 'finally' ) + { + // InternalExport.g:20697:1: ( 'finally' ) + // InternalExport.g:20698:2: 'finally' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + match(input,105,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1" + // InternalExport.g:20707:1: rule__XTryCatchFinallyExpression__Group_3_1__1 : rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20711:1: ( rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ) + // InternalExport.g:20712:2: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl" + // InternalExport.g:20718:1: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20722:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ) + // InternalExport.g:20723:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) + { + // InternalExport.g:20723:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) + // InternalExport.g:20724:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); + } + // InternalExport.g:20725:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) + // InternalExport.g:20725:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__0" + // InternalExport.g:20734:1: rule__XSynchronizedExpression__Group__0 : rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ; + public final void rule__XSynchronizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20738:1: ( rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ) + // InternalExport.g:20739:2: rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 + { + pushFollow(FOLLOW_98); + rule__XSynchronizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__0__Impl" + // InternalExport.g:20746:1: rule__XSynchronizedExpression__Group__0__Impl : ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ; + public final void rule__XSynchronizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20750:1: ( ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ) + // InternalExport.g:20751:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) ) + { + // InternalExport.g:20751:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) ) + // InternalExport.g:20752:2: ( rule__XSynchronizedExpression__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); + } + // InternalExport.g:20753:2: ( rule__XSynchronizedExpression__Group_0__0 ) + // InternalExport.g:20753:3: rule__XSynchronizedExpression__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__1" + // InternalExport.g:20761:1: rule__XSynchronizedExpression__Group__1 : rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ; + public final void rule__XSynchronizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20765:1: ( rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ) + // InternalExport.g:20766:2: rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 + { + pushFollow(FOLLOW_25); + rule__XSynchronizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__1" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__1__Impl" + // InternalExport.g:20773:1: rule__XSynchronizedExpression__Group__1__Impl : ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ; + public final void rule__XSynchronizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20777:1: ( ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ) + // InternalExport.g:20778:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) + { + // InternalExport.g:20778:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) + // InternalExport.g:20779:2: ( rule__XSynchronizedExpression__ParamAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); + } + // InternalExport.g:20780:2: ( rule__XSynchronizedExpression__ParamAssignment_1 ) + // InternalExport.g:20780:3: rule__XSynchronizedExpression__ParamAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__ParamAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__2" + // InternalExport.g:20788:1: rule__XSynchronizedExpression__Group__2 : rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ; + public final void rule__XSynchronizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20792:1: ( rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ) + // InternalExport.g:20793:2: rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 + { + pushFollow(FOLLOW_98); + rule__XSynchronizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__2" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__2__Impl" + // InternalExport.g:20800:1: rule__XSynchronizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XSynchronizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20804:1: ( ( ')' ) ) + // InternalExport.g:20805:1: ( ')' ) + { + // InternalExport.g:20805:1: ( ')' ) + // InternalExport.g:20806:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__3" + // InternalExport.g:20815:1: rule__XSynchronizedExpression__Group__3 : rule__XSynchronizedExpression__Group__3__Impl ; + public final void rule__XSynchronizedExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20819:1: ( rule__XSynchronizedExpression__Group__3__Impl ) + // InternalExport.g:20820:2: rule__XSynchronizedExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__3" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__3__Impl" + // InternalExport.g:20826:1: rule__XSynchronizedExpression__Group__3__Impl : ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ; + public final void rule__XSynchronizedExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20830:1: ( ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ) + // InternalExport.g:20831:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) + { + // InternalExport.g:20831:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) + // InternalExport.g:20832:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); + } + // InternalExport.g:20833:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) + // InternalExport.g:20833:3: rule__XSynchronizedExpression__ExpressionAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__ExpressionAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__3__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0__0" + // InternalExport.g:20842:1: rule__XSynchronizedExpression__Group_0__0 : rule__XSynchronizedExpression__Group_0__0__Impl ; + public final void rule__XSynchronizedExpression__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20846:1: ( rule__XSynchronizedExpression__Group_0__0__Impl ) + // InternalExport.g:20847:2: rule__XSynchronizedExpression__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0__0__Impl" + // InternalExport.g:20853:1: rule__XSynchronizedExpression__Group_0__0__Impl : ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ; + public final void rule__XSynchronizedExpression__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20857:1: ( ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ) + // InternalExport.g:20858:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) + { + // InternalExport.g:20858:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) + // InternalExport.g:20859:2: ( rule__XSynchronizedExpression__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); + } + // InternalExport.g:20860:2: ( rule__XSynchronizedExpression__Group_0_0__0 ) + // InternalExport.g:20860:3: rule__XSynchronizedExpression__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0" + // InternalExport.g:20869:1: rule__XSynchronizedExpression__Group_0_0__0 : rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ; + public final void rule__XSynchronizedExpression__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20873:1: ( rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ) + // InternalExport.g:20874:2: rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 + { + pushFollow(FOLLOW_130); + rule__XSynchronizedExpression__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0__Impl" + // InternalExport.g:20881:1: rule__XSynchronizedExpression__Group_0_0__0__Impl : ( () ) ; + public final void rule__XSynchronizedExpression__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20885:1: ( ( () ) ) + // InternalExport.g:20886:1: ( () ) + { + // InternalExport.g:20886:1: ( () ) + // InternalExport.g:20887:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); + } + // InternalExport.g:20888:2: () + // InternalExport.g:20888:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1" + // InternalExport.g:20896:1: rule__XSynchronizedExpression__Group_0_0__1 : rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ; + public final void rule__XSynchronizedExpression__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20900:1: ( rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ) + // InternalExport.g:20901:2: rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 + { + pushFollow(FOLLOW_34); + rule__XSynchronizedExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__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__XSynchronizedExpression__Group_0_0__1" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1__Impl" + // InternalExport.g:20908:1: rule__XSynchronizedExpression__Group_0_0__1__Impl : ( 'synchronized' ) ; + public final void rule__XSynchronizedExpression__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20912:1: ( ( 'synchronized' ) ) + // InternalExport.g:20913:1: ( 'synchronized' ) + { + // InternalExport.g:20913:1: ( 'synchronized' ) + // InternalExport.g:20914:2: 'synchronized' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + match(input,106,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2" + // InternalExport.g:20923:1: rule__XSynchronizedExpression__Group_0_0__2 : rule__XSynchronizedExpression__Group_0_0__2__Impl ; + public final void rule__XSynchronizedExpression__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20927:1: ( rule__XSynchronizedExpression__Group_0_0__2__Impl ) + // InternalExport.g:20928:2: rule__XSynchronizedExpression__Group_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2__Impl" + // InternalExport.g:20934:1: rule__XSynchronizedExpression__Group_0_0__2__Impl : ( '(' ) ; + public final void rule__XSynchronizedExpression__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20938:1: ( ( '(' ) ) + // InternalExport.g:20939:1: ( '(' ) + { + // InternalExport.g:20939:1: ( '(' ) + // InternalExport.g:20940:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__0" + // InternalExport.g:20950:1: rule__XCatchClause__Group__0 : rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ; + public final void rule__XCatchClause__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20954:1: ( rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ) + // InternalExport.g:20955:2: rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 + { + pushFollow(FOLLOW_34); + rule__XCatchClause__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__0" + + + // $ANTLR start "rule__XCatchClause__Group__0__Impl" + // InternalExport.g:20962:1: rule__XCatchClause__Group__0__Impl : ( ( 'catch' ) ) ; + public final void rule__XCatchClause__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20966:1: ( ( ( 'catch' ) ) ) + // InternalExport.g:20967:1: ( ( 'catch' ) ) + { + // InternalExport.g:20967:1: ( ( 'catch' ) ) + // InternalExport.g:20968:2: ( 'catch' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + // InternalExport.g:20969:2: ( 'catch' ) + // InternalExport.g:20969:3: 'catch' + { + match(input,107,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__0__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__1" + // InternalExport.g:20977:1: rule__XCatchClause__Group__1 : rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ; + public final void rule__XCatchClause__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20981:1: ( rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ) + // InternalExport.g:20982:2: rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 + { + pushFollow(FOLLOW_78); + rule__XCatchClause__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__1" + + + // $ANTLR start "rule__XCatchClause__Group__1__Impl" + // InternalExport.g:20989:1: rule__XCatchClause__Group__1__Impl : ( '(' ) ; + public final void rule__XCatchClause__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:20993:1: ( ( '(' ) ) + // InternalExport.g:20994:1: ( '(' ) + { + // InternalExport.g:20994:1: ( '(' ) + // InternalExport.g:20995:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__1__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__2" + // InternalExport.g:21004:1: rule__XCatchClause__Group__2 : rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ; + public final void rule__XCatchClause__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21008:1: ( rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ) + // InternalExport.g:21009:2: rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 + { + pushFollow(FOLLOW_25); + rule__XCatchClause__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__2" + + + // $ANTLR start "rule__XCatchClause__Group__2__Impl" + // InternalExport.g:21016:1: rule__XCatchClause__Group__2__Impl : ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ; + public final void rule__XCatchClause__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21020:1: ( ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ) + // InternalExport.g:21021:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) + { + // InternalExport.g:21021:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) + // InternalExport.g:21022:2: ( rule__XCatchClause__DeclaredParamAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); + } + // InternalExport.g:21023:2: ( rule__XCatchClause__DeclaredParamAssignment_2 ) + // InternalExport.g:21023:3: rule__XCatchClause__DeclaredParamAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__DeclaredParamAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__2__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__3" + // InternalExport.g:21031:1: rule__XCatchClause__Group__3 : rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ; + public final void rule__XCatchClause__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21035:1: ( rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ) + // InternalExport.g:21036:2: rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 + { + pushFollow(FOLLOW_98); + rule__XCatchClause__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__3" + + + // $ANTLR start "rule__XCatchClause__Group__3__Impl" + // InternalExport.g:21043:1: rule__XCatchClause__Group__3__Impl : ( ')' ) ; + public final void rule__XCatchClause__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21047:1: ( ( ')' ) ) + // InternalExport.g:21048:1: ( ')' ) + { + // InternalExport.g:21048:1: ( ')' ) + // InternalExport.g:21049:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__3__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__4" + // InternalExport.g:21058:1: rule__XCatchClause__Group__4 : rule__XCatchClause__Group__4__Impl ; + public final void rule__XCatchClause__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21062:1: ( rule__XCatchClause__Group__4__Impl ) + // InternalExport.g:21063:2: rule__XCatchClause__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__4" + + + // $ANTLR start "rule__XCatchClause__Group__4__Impl" + // InternalExport.g:21069:1: rule__XCatchClause__Group__4__Impl : ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ; + public final void rule__XCatchClause__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21073:1: ( ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ) + // InternalExport.g:21074:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) + { + // InternalExport.g:21074:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) + // InternalExport.g:21075:2: ( rule__XCatchClause__ExpressionAssignment_4 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); + } + // InternalExport.g:21076:2: ( rule__XCatchClause__ExpressionAssignment_4 ) + // InternalExport.g:21076:3: rule__XCatchClause__ExpressionAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__ExpressionAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__4__Impl" + + + // $ANTLR start "rule__QualifiedName__Group__0" + // InternalExport.g:21085: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 { + // InternalExport.g:21089:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) + // InternalExport.g:21090:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 + { + pushFollow(FOLLOW_62); + rule__QualifiedName__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__0" + + + // $ANTLR start "rule__QualifiedName__Group__0__Impl" + // InternalExport.g:21097:1: rule__QualifiedName__Group__0__Impl : ( ruleValidID ) ; + public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21101:1: ( ( ruleValidID ) ) + // InternalExport.g:21102:1: ( ruleValidID ) + { + // InternalExport.g:21102:1: ( ruleValidID ) + // InternalExport.g:21103:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group__1" + // InternalExport.g:21112:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; + public final void rule__QualifiedName__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21116:1: ( rule__QualifiedName__Group__1__Impl ) + // InternalExport.g:21117:2: rule__QualifiedName__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__1" + + + // $ANTLR start "rule__QualifiedName__Group__1__Impl" + // InternalExport.g:21123: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 { + // InternalExport.g:21127:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) + // InternalExport.g:21128:1: ( ( rule__QualifiedName__Group_1__0 )* ) + { + // InternalExport.g:21128:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalExport.g:21129:2: ( rule__QualifiedName__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getGroup_1()); + } + // InternalExport.g:21130:2: ( rule__QualifiedName__Group_1__0 )* + loop168: + do { + int alt168=2; + int LA168_0 = input.LA(1); + + if ( (LA168_0==58) ) { + int LA168_2 = input.LA(2); + + if ( (LA168_2==RULE_ID) ) { + int LA168_3 = input.LA(3); + + if ( (synpred242_InternalExport()) ) { + alt168=1; + } + + + } + + + } + + + switch (alt168) { + case 1 : + // InternalExport.g:21130:3: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_63); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop168; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__0" + // InternalExport.g:21139: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 { + // InternalExport.g:21143:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) + // InternalExport.g:21144:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 + { + pushFollow(FOLLOW_11); + rule__QualifiedName__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0" + + + // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" + // InternalExport.g:21151:1: rule__QualifiedName__Group_1__0__Impl : ( ( '.' ) ) ; + public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21155:1: ( ( ( '.' ) ) ) + // InternalExport.g:21156:1: ( ( '.' ) ) + { + // InternalExport.g:21156:1: ( ( '.' ) ) + // InternalExport.g:21157:2: ( '.' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + // InternalExport.g:21158:2: ( '.' ) + // InternalExport.g:21158:3: '.' + { + match(input,58,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__1" + // InternalExport.g:21166: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 { + // InternalExport.g:21170:1: ( rule__QualifiedName__Group_1__1__Impl ) + // InternalExport.g:21171:2: rule__QualifiedName__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1" + + + // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" + // InternalExport.g:21177:1: rule__QualifiedName__Group_1__1__Impl : ( ruleValidID ) ; + public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21181:1: ( ( ruleValidID ) ) + // InternalExport.g:21182:1: ( ruleValidID ) + { + // InternalExport.g:21182:1: ( ruleValidID ) + // InternalExport.g:21183:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1__Impl" + + + // $ANTLR start "rule__Number__Group_1__0" + // InternalExport.g:21193:1: rule__Number__Group_1__0 : rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ; + public final void rule__Number__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21197:1: ( rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ) + // InternalExport.g:21198:2: rule__Number__Group_1__0__Impl rule__Number__Group_1__1 + { + pushFollow(FOLLOW_62); + rule__Number__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Number__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__0" + + + // $ANTLR start "rule__Number__Group_1__0__Impl" + // InternalExport.g:21205:1: rule__Number__Group_1__0__Impl : ( ( rule__Number__Alternatives_1_0 ) ) ; + public final void rule__Number__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21209:1: ( ( ( rule__Number__Alternatives_1_0 ) ) ) + // InternalExport.g:21210:1: ( ( rule__Number__Alternatives_1_0 ) ) + { + // InternalExport.g:21210:1: ( ( rule__Number__Alternatives_1_0 ) ) + // InternalExport.g:21211:2: ( rule__Number__Alternatives_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives_1_0()); + } + // InternalExport.g:21212:2: ( rule__Number__Alternatives_1_0 ) + // InternalExport.g:21212:3: rule__Number__Alternatives_1_0 + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getAlternatives_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__0__Impl" + + + // $ANTLR start "rule__Number__Group_1__1" + // InternalExport.g:21220:1: rule__Number__Group_1__1 : rule__Number__Group_1__1__Impl ; + public final void rule__Number__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21224:1: ( rule__Number__Group_1__1__Impl ) + // InternalExport.g:21225:2: rule__Number__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Number__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__1" + + + // $ANTLR start "rule__Number__Group_1__1__Impl" + // InternalExport.g:21231:1: rule__Number__Group_1__1__Impl : ( ( rule__Number__Group_1_1__0 )? ) ; + public final void rule__Number__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21235:1: ( ( ( rule__Number__Group_1_1__0 )? ) ) + // InternalExport.g:21236:1: ( ( rule__Number__Group_1_1__0 )? ) + { + // InternalExport.g:21236:1: ( ( rule__Number__Group_1_1__0 )? ) + // InternalExport.g:21237:2: ( rule__Number__Group_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getGroup_1_1()); + } + // InternalExport.g:21238:2: ( rule__Number__Group_1_1__0 )? + int alt169=2; + int LA169_0 = input.LA(1); + + if ( (LA169_0==58) ) { + int LA169_1 = input.LA(2); + + if ( ((LA169_1>=RULE_INT && LA169_1<=RULE_DECIMAL)) ) { + alt169=1; + } + } + switch (alt169) { + case 1 : + // InternalExport.g:21238:3: rule__Number__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getGroup_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__1__Impl" + + + // $ANTLR start "rule__Number__Group_1_1__0" + // InternalExport.g:21247:1: rule__Number__Group_1_1__0 : rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ; + public final void rule__Number__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21251:1: ( rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ) + // InternalExport.g:21252:2: rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 + { + pushFollow(FOLLOW_131); + rule__Number__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__0" + + + // $ANTLR start "rule__Number__Group_1_1__0__Impl" + // InternalExport.g:21259:1: rule__Number__Group_1_1__0__Impl : ( '.' ) ; + public final void rule__Number__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21263:1: ( ( '.' ) ) + // InternalExport.g:21264:1: ( '.' ) + { + // InternalExport.g:21264:1: ( '.' ) + // InternalExport.g:21265:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__0__Impl" + + + // $ANTLR start "rule__Number__Group_1_1__1" + // InternalExport.g:21274:1: rule__Number__Group_1_1__1 : rule__Number__Group_1_1__1__Impl ; + public final void rule__Number__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21278:1: ( rule__Number__Group_1_1__1__Impl ) + // InternalExport.g:21279:2: rule__Number__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__1" + + + // $ANTLR start "rule__Number__Group_1_1__1__Impl" + // InternalExport.g:21285:1: rule__Number__Group_1_1__1__Impl : ( ( rule__Number__Alternatives_1_1_1 ) ) ; + public final void rule__Number__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21289:1: ( ( ( rule__Number__Alternatives_1_1_1 ) ) ) + // InternalExport.g:21290:1: ( ( rule__Number__Alternatives_1_1_1 ) ) + { + // InternalExport.g:21290:1: ( ( rule__Number__Alternatives_1_1_1 ) ) + // InternalExport.g:21291:2: ( rule__Number__Alternatives_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); + } + // InternalExport.g:21292:2: ( rule__Number__Alternatives_1_1_1 ) + // InternalExport.g:21292:3: rule__Number__Alternatives_1_1_1 + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__1__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__0" + // InternalExport.g:21301:1: rule__JvmTypeReference__Group_0__0 : rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ; + public final void rule__JvmTypeReference__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21305:1: ( rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ) + // InternalExport.g:21306:2: rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 + { + pushFollow(FOLLOW_30); + rule__JvmTypeReference__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__0__Impl" + // InternalExport.g:21313:1: rule__JvmTypeReference__Group_0__0__Impl : ( ruleJvmParameterizedTypeReference ) ; + public final void rule__JvmTypeReference__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21317:1: ( ( ruleJvmParameterizedTypeReference ) ) + // InternalExport.g:21318:1: ( ruleJvmParameterizedTypeReference ) + { + // InternalExport.g:21318:1: ( ruleJvmParameterizedTypeReference ) + // InternalExport.g:21319:2: ruleJvmParameterizedTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__1" + // InternalExport.g:21328:1: rule__JvmTypeReference__Group_0__1 : rule__JvmTypeReference__Group_0__1__Impl ; + public final void rule__JvmTypeReference__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21332:1: ( rule__JvmTypeReference__Group_0__1__Impl ) + // InternalExport.g:21333:2: rule__JvmTypeReference__Group_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__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__JvmTypeReference__Group_0__1" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__1__Impl" + // InternalExport.g:21339:1: rule__JvmTypeReference__Group_0__1__Impl : ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ; + public final void rule__JvmTypeReference__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21343:1: ( ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ) + // InternalExport.g:21344:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) + { + // InternalExport.g:21344:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) + // InternalExport.g:21345:2: ( rule__JvmTypeReference__Group_0_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); + } + // InternalExport.g:21346:2: ( rule__JvmTypeReference__Group_0_1__0 )* + loop170: + do { + int alt170=2; + int LA170_0 = input.LA(1); + + if ( (LA170_0==72) ) { + int LA170_2 = input.LA(2); + + if ( (LA170_2==73) ) { + int LA170_3 = input.LA(3); + + if ( (synpred244_InternalExport()) ) { + alt170=1; + } + + + } + + + } + + + switch (alt170) { + case 1 : + // InternalExport.g:21346:3: rule__JvmTypeReference__Group_0_1__0 + { + pushFollow(FOLLOW_123); + rule__JvmTypeReference__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop170; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__1__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1__0" + // InternalExport.g:21355:1: rule__JvmTypeReference__Group_0_1__0 : rule__JvmTypeReference__Group_0_1__0__Impl ; + public final void rule__JvmTypeReference__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21359:1: ( rule__JvmTypeReference__Group_0_1__0__Impl ) + // InternalExport.g:21360:2: rule__JvmTypeReference__Group_0_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1__0__Impl" + // InternalExport.g:21366:1: rule__JvmTypeReference__Group_0_1__0__Impl : ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ; + public final void rule__JvmTypeReference__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21370:1: ( ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ) + // InternalExport.g:21371:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) + { + // InternalExport.g:21371:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) + // InternalExport.g:21372:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); + } + // InternalExport.g:21373:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) + // InternalExport.g:21373:3: rule__JvmTypeReference__Group_0_1_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0" + // InternalExport.g:21382:1: rule__JvmTypeReference__Group_0_1_0__0 : rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ; + public final void rule__JvmTypeReference__Group_0_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21386:1: ( rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ) + // InternalExport.g:21387:2: rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 + { + pushFollow(FOLLOW_30); + rule__JvmTypeReference__Group_0_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0__Impl" + // InternalExport.g:21394:1: rule__JvmTypeReference__Group_0_1_0__0__Impl : ( () ) ; + public final void rule__JvmTypeReference__Group_0_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21398:1: ( ( () ) ) + // InternalExport.g:21399:1: ( () ) + { + // InternalExport.g:21399:1: ( () ) + // InternalExport.g:21400:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); + } + // InternalExport.g:21401:2: () + // InternalExport.g:21401:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1" + // InternalExport.g:21409:1: rule__JvmTypeReference__Group_0_1_0__1 : rule__JvmTypeReference__Group_0_1_0__1__Impl ; + public final void rule__JvmTypeReference__Group_0_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21413:1: ( rule__JvmTypeReference__Group_0_1_0__1__Impl ) + // InternalExport.g:21414:2: rule__JvmTypeReference__Group_0_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1__Impl" + // InternalExport.g:21420:1: rule__JvmTypeReference__Group_0_1_0__1__Impl : ( ruleArrayBrackets ) ; + public final void rule__JvmTypeReference__Group_0_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21424:1: ( ( ruleArrayBrackets ) ) + // InternalExport.g:21425:1: ( ruleArrayBrackets ) + { + // InternalExport.g:21425:1: ( ruleArrayBrackets ) + // InternalExport.g:21426:2: ruleArrayBrackets + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1__Impl" + + + // $ANTLR start "rule__ArrayBrackets__Group__0" + // InternalExport.g:21436:1: rule__ArrayBrackets__Group__0 : rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ; + public final void rule__ArrayBrackets__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21440:1: ( rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ) + // InternalExport.g:21441:2: rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 + { + pushFollow(FOLLOW_19); + rule__ArrayBrackets__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__0" + + + // $ANTLR start "rule__ArrayBrackets__Group__0__Impl" + // InternalExport.g:21448:1: rule__ArrayBrackets__Group__0__Impl : ( '[' ) ; + public final void rule__ArrayBrackets__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21452:1: ( ( '[' ) ) + // InternalExport.g:21453:1: ( '[' ) + { + // InternalExport.g:21453:1: ( '[' ) + // InternalExport.g:21454:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__0__Impl" + + + // $ANTLR start "rule__ArrayBrackets__Group__1" + // InternalExport.g:21463:1: rule__ArrayBrackets__Group__1 : rule__ArrayBrackets__Group__1__Impl ; + public final void rule__ArrayBrackets__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21467:1: ( rule__ArrayBrackets__Group__1__Impl ) + // InternalExport.g:21468:2: rule__ArrayBrackets__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__1" + + + // $ANTLR start "rule__ArrayBrackets__Group__1__Impl" + // InternalExport.g:21474:1: rule__ArrayBrackets__Group__1__Impl : ( ']' ) ; + public final void rule__ArrayBrackets__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21478:1: ( ( ']' ) ) + // InternalExport.g:21479:1: ( ']' ) + { + // InternalExport.g:21479:1: ( ']' ) + // InternalExport.g:21480:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__0" + // InternalExport.g:21490:1: rule__XFunctionTypeRef__Group__0 : rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ; + public final void rule__XFunctionTypeRef__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21494:1: ( rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ) + // InternalExport.g:21495:2: rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 + { + pushFollow(FOLLOW_78); + rule__XFunctionTypeRef__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__0__Impl" + // InternalExport.g:21502:1: rule__XFunctionTypeRef__Group__0__Impl : ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ; + public final void rule__XFunctionTypeRef__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21506:1: ( ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ) + // InternalExport.g:21507:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) + { + // InternalExport.g:21507:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) + // InternalExport.g:21508:2: ( rule__XFunctionTypeRef__Group_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); + } + // InternalExport.g:21509:2: ( rule__XFunctionTypeRef__Group_0__0 )? + int alt171=2; + int LA171_0 = input.LA(1); + + if ( (LA171_0==77) ) { + alt171=1; + } + switch (alt171) { + case 1 : + // InternalExport.g:21509:3: rule__XFunctionTypeRef__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__1" + // InternalExport.g:21517:1: rule__XFunctionTypeRef__Group__1 : rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ; + public final void rule__XFunctionTypeRef__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21521:1: ( rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ) + // InternalExport.g:21522:2: rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 + { + pushFollow(FOLLOW_78); + rule__XFunctionTypeRef__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__1__Impl" + // InternalExport.g:21529:1: rule__XFunctionTypeRef__Group__1__Impl : ( '=>' ) ; + public final void rule__XFunctionTypeRef__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21533:1: ( ( '=>' ) ) + // InternalExport.g:21534:1: ( '=>' ) + { + // InternalExport.g:21534:1: ( '=>' ) + // InternalExport.g:21535:2: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__2" + // InternalExport.g:21544:1: rule__XFunctionTypeRef__Group__2 : rule__XFunctionTypeRef__Group__2__Impl ; + public final void rule__XFunctionTypeRef__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21548:1: ( rule__XFunctionTypeRef__Group__2__Impl ) + // InternalExport.g:21549:2: rule__XFunctionTypeRef__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__2" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__2__Impl" + // InternalExport.g:21555:1: rule__XFunctionTypeRef__Group__2__Impl : ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ; + public final void rule__XFunctionTypeRef__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21559:1: ( ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ) + // InternalExport.g:21560:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) + { + // InternalExport.g:21560:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) + // InternalExport.g:21561:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); + } + // InternalExport.g:21562:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) + // InternalExport.g:21562:3: rule__XFunctionTypeRef__ReturnTypeAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ReturnTypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__2__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__0" + // InternalExport.g:21571:1: rule__XFunctionTypeRef__Group_0__0 : rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ; + public final void rule__XFunctionTypeRef__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21575:1: ( rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ) + // InternalExport.g:21576:2: rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 + { + pushFollow(FOLLOW_132); + rule__XFunctionTypeRef__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__0__Impl" + // InternalExport.g:21583:1: rule__XFunctionTypeRef__Group_0__0__Impl : ( '(' ) ; + public final void rule__XFunctionTypeRef__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21587:1: ( ( '(' ) ) + // InternalExport.g:21588:1: ( '(' ) + { + // InternalExport.g:21588:1: ( '(' ) + // InternalExport.g:21589:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__1" + // InternalExport.g:21598:1: rule__XFunctionTypeRef__Group_0__1 : rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ; + public final void rule__XFunctionTypeRef__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21602:1: ( rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ) + // InternalExport.g:21603:2: rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 + { + pushFollow(FOLLOW_132); + rule__XFunctionTypeRef__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__1__Impl" + // InternalExport.g:21610:1: rule__XFunctionTypeRef__Group_0__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ; + public final void rule__XFunctionTypeRef__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21614:1: ( ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ) + // InternalExport.g:21615:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) + { + // InternalExport.g:21615:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) + // InternalExport.g:21616:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); + } + // InternalExport.g:21617:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? + int alt172=2; + int LA172_0 = input.LA(1); + + if ( (LA172_0==RULE_ID||LA172_0==51||LA172_0==77) ) { + alt172=1; + } + switch (alt172) { + case 1 : + // InternalExport.g:21617:3: rule__XFunctionTypeRef__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__2" + // InternalExport.g:21625:1: rule__XFunctionTypeRef__Group_0__2 : rule__XFunctionTypeRef__Group_0__2__Impl ; + public final void rule__XFunctionTypeRef__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21629:1: ( rule__XFunctionTypeRef__Group_0__2__Impl ) + // InternalExport.g:21630:2: rule__XFunctionTypeRef__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__2" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__2__Impl" + // InternalExport.g:21636:1: rule__XFunctionTypeRef__Group_0__2__Impl : ( ')' ) ; + public final void rule__XFunctionTypeRef__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21640:1: ( ( ')' ) ) + // InternalExport.g:21641:1: ( ')' ) + { + // InternalExport.g:21641:1: ( ')' ) + // InternalExport.g:21642:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__2__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0" + // InternalExport.g:21652:1: rule__XFunctionTypeRef__Group_0_1__0 : rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ; + public final void rule__XFunctionTypeRef__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21656:1: ( rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ) + // InternalExport.g:21657:2: rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 + { + pushFollow(FOLLOW_21); + rule__XFunctionTypeRef__Group_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0__Impl" + // InternalExport.g:21664:1: rule__XFunctionTypeRef__Group_0_1__0__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ; + public final void rule__XFunctionTypeRef__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21668:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ) + // InternalExport.g:21669:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) + { + // InternalExport.g:21669:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) + // InternalExport.g:21670:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); + } + // InternalExport.g:21671:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) + // InternalExport.g:21671:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1" + // InternalExport.g:21679:1: rule__XFunctionTypeRef__Group_0_1__1 : rule__XFunctionTypeRef__Group_0_1__1__Impl ; + public final void rule__XFunctionTypeRef__Group_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21683:1: ( rule__XFunctionTypeRef__Group_0_1__1__Impl ) + // InternalExport.g:21684:2: rule__XFunctionTypeRef__Group_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1__Impl" + // InternalExport.g:21690:1: rule__XFunctionTypeRef__Group_0_1__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ; + public final void rule__XFunctionTypeRef__Group_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21694:1: ( ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ) + // InternalExport.g:21695:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) + { + // InternalExport.g:21695:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) + // InternalExport.g:21696:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); + } + // InternalExport.g:21697:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* + loop173: + do { + int alt173=2; + int LA173_0 = input.LA(1); + + if ( (LA173_0==74) ) { + alt173=1; + } + + + switch (alt173) { + case 1 : + // InternalExport.g:21697:3: rule__XFunctionTypeRef__Group_0_1_1__0 + { + pushFollow(FOLLOW_22); + rule__XFunctionTypeRef__Group_0_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop173; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0" + // InternalExport.g:21706:1: rule__XFunctionTypeRef__Group_0_1_1__0 : rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ; + public final void rule__XFunctionTypeRef__Group_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21710:1: ( rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ) + // InternalExport.g:21711:2: rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 + { + pushFollow(FOLLOW_78); + rule__XFunctionTypeRef__Group_0_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" + // InternalExport.g:21718:1: rule__XFunctionTypeRef__Group_0_1_1__0__Impl : ( ',' ) ; + public final void rule__XFunctionTypeRef__Group_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21722:1: ( ( ',' ) ) + // InternalExport.g:21723:1: ( ',' ) + { + // InternalExport.g:21723:1: ( ',' ) + // InternalExport.g:21724:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1" + // InternalExport.g:21733:1: rule__XFunctionTypeRef__Group_0_1_1__1 : rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; + public final void rule__XFunctionTypeRef__Group_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21737:1: ( rule__XFunctionTypeRef__Group_0_1_1__1__Impl ) + // InternalExport.g:21738:2: rule__XFunctionTypeRef__Group_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" + // InternalExport.g:21744:1: rule__XFunctionTypeRef__Group_0_1_1__1__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ; + public final void rule__XFunctionTypeRef__Group_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21748:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ) + // InternalExport.g:21749:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) + { + // InternalExport.g:21749:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) + // InternalExport.g:21750:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); + } + // InternalExport.g:21751:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) + // InternalExport.g:21751:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0" + // InternalExport.g:21760:1: rule__JvmParameterizedTypeReference__Group__0 : rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ; + public final void rule__JvmParameterizedTypeReference__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21764:1: ( rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ) + // InternalExport.g:21765:2: rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 + { + pushFollow(FOLLOW_72); + rule__JvmParameterizedTypeReference__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0__Impl" + // InternalExport.g:21772:1: rule__JvmParameterizedTypeReference__Group__0__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21776:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ) + // InternalExport.g:21777:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) + { + // InternalExport.g:21777:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) + // InternalExport.g:21778:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); + } + // InternalExport.g:21779:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) + // InternalExport.g:21779:3: rule__JvmParameterizedTypeReference__TypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__TypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1" + // InternalExport.g:21787:1: rule__JvmParameterizedTypeReference__Group__1 : rule__JvmParameterizedTypeReference__Group__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21791:1: ( rule__JvmParameterizedTypeReference__Group__1__Impl ) + // InternalExport.g:21792:2: rule__JvmParameterizedTypeReference__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1__Impl" + // InternalExport.g:21798:1: rule__JvmParameterizedTypeReference__Group__1__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ; + public final void rule__JvmParameterizedTypeReference__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21802:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ) + // InternalExport.g:21803:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) + { + // InternalExport.g:21803:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) + // InternalExport.g:21804:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); + } + // InternalExport.g:21805:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? + int alt174=2; + alt174 = dfa174.predict(input); + switch (alt174) { + case 1 : + // InternalExport.g:21805:3: rule__JvmParameterizedTypeReference__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0" + // InternalExport.g:21814:1: rule__JvmParameterizedTypeReference__Group_1__0 : rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21818:1: ( rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ) + // InternalExport.g:21819:2: rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 + { + pushFollow(FOLLOW_95); + rule__JvmParameterizedTypeReference__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0__Impl" + // InternalExport.g:21826:1: rule__JvmParameterizedTypeReference__Group_1__0__Impl : ( ( '<' ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21830:1: ( ( ( '<' ) ) ) + // InternalExport.g:21831:1: ( ( '<' ) ) + { + // InternalExport.g:21831:1: ( ( '<' ) ) + // InternalExport.g:21832:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + // InternalExport.g:21833:2: ( '<' ) + // InternalExport.g:21833:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1" + // InternalExport.g:21841:1: rule__JvmParameterizedTypeReference__Group_1__1 : rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21845:1: ( rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ) + // InternalExport.g:21846:2: rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 + { + pushFollow(FOLLOW_96); + rule__JvmParameterizedTypeReference__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1__Impl" + // InternalExport.g:21853:1: rule__JvmParameterizedTypeReference__Group_1__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21857:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ) + // InternalExport.g:21858:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) + { + // InternalExport.g:21858:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) + // InternalExport.g:21859:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); + } + // InternalExport.g:21860:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) + // InternalExport.g:21860:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2" + // InternalExport.g:21868:1: rule__JvmParameterizedTypeReference__Group_1__2 : rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ; + public final void rule__JvmParameterizedTypeReference__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21872:1: ( rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ) + // InternalExport.g:21873:2: rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 + { + pushFollow(FOLLOW_96); + rule__JvmParameterizedTypeReference__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2__Impl" + // InternalExport.g:21880:1: rule__JvmParameterizedTypeReference__Group_1__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21884:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ) + // InternalExport.g:21885:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) + { + // InternalExport.g:21885:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) + // InternalExport.g:21886:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); + } + // InternalExport.g:21887:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* + loop175: + do { + int alt175=2; + int LA175_0 = input.LA(1); + + if ( (LA175_0==74) ) { + alt175=1; + } + + + switch (alt175) { + case 1 : + // InternalExport.g:21887:3: rule__JvmParameterizedTypeReference__Group_1_2__0 + { + pushFollow(FOLLOW_22); + rule__JvmParameterizedTypeReference__Group_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop175; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3" + // InternalExport.g:21895:1: rule__JvmParameterizedTypeReference__Group_1__3 : rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ; + public final void rule__JvmParameterizedTypeReference__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21899:1: ( rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ) + // InternalExport.g:21900:2: rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 + { + pushFollow(FOLLOW_62); + rule__JvmParameterizedTypeReference__Group_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3__Impl" + // InternalExport.g:21907:1: rule__JvmParameterizedTypeReference__Group_1__3__Impl : ( '>' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21911:1: ( ( '>' ) ) + // InternalExport.g:21912:1: ( '>' ) + { + // InternalExport.g:21912:1: ( '>' ) + // InternalExport.g:21913:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4" + // InternalExport.g:21922:1: rule__JvmParameterizedTypeReference__Group_1__4 : rule__JvmParameterizedTypeReference__Group_1__4__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21926:1: ( rule__JvmParameterizedTypeReference__Group_1__4__Impl ) + // InternalExport.g:21927:2: rule__JvmParameterizedTypeReference__Group_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4__Impl" + // InternalExport.g:21933:1: rule__JvmParameterizedTypeReference__Group_1__4__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21937:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ) + // InternalExport.g:21938:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) + { + // InternalExport.g:21938:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) + // InternalExport.g:21939:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); + } + // InternalExport.g:21940:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* + loop176: + do { + int alt176=2; + int LA176_0 = input.LA(1); + + if ( (LA176_0==58) ) { + int LA176_2 = input.LA(2); + + if ( (LA176_2==RULE_ID) ) { + int LA176_3 = input.LA(3); + + if ( (synpred250_InternalExport()) ) { + alt176=1; + } + + + } + + + } + + + switch (alt176) { + case 1 : + // InternalExport.g:21940:3: rule__JvmParameterizedTypeReference__Group_1_4__0 + { + pushFollow(FOLLOW_63); + rule__JvmParameterizedTypeReference__Group_1_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop176; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0" + // InternalExport.g:21949:1: rule__JvmParameterizedTypeReference__Group_1_2__0 : rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21953:1: ( rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ) + // InternalExport.g:21954:2: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 + { + pushFollow(FOLLOW_95); + rule__JvmParameterizedTypeReference__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" + // InternalExport.g:21961:1: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl : ( ',' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21965:1: ( ( ',' ) ) + // InternalExport.g:21966:1: ( ',' ) + { + // InternalExport.g:21966:1: ( ',' ) + // InternalExport.g:21967:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1" + // InternalExport.g:21976:1: rule__JvmParameterizedTypeReference__Group_1_2__1 : rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21980:1: ( rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ) + // InternalExport.g:21981:2: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" + // InternalExport.g:21987:1: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:21991:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ) + // InternalExport.g:21992:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) + { + // InternalExport.g:21992:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) + // InternalExport.g:21993:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); + } + // InternalExport.g:21994:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) + // InternalExport.g:21994:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0" + // InternalExport.g:22003:1: rule__JvmParameterizedTypeReference__Group_1_4__0 : rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22007:1: ( rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ) + // InternalExport.g:22008:2: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 + { + pushFollow(FOLLOW_11); + rule__JvmParameterizedTypeReference__Group_1_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" + // InternalExport.g:22015:1: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22019:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ) + // InternalExport.g:22020:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) + { + // InternalExport.g:22020:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) + // InternalExport.g:22021:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); + } + // InternalExport.g:22022:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) + // InternalExport.g:22022:3: rule__JvmParameterizedTypeReference__Group_1_4_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1" + // InternalExport.g:22030:1: rule__JvmParameterizedTypeReference__Group_1_4__1 : rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22034:1: ( rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ) + // InternalExport.g:22035:2: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 + { + pushFollow(FOLLOW_72); + rule__JvmParameterizedTypeReference__Group_1_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" + // InternalExport.g:22042:1: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22046:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ) + // InternalExport.g:22047:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) + { + // InternalExport.g:22047:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) + // InternalExport.g:22048:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); + } + // InternalExport.g:22049:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) + // InternalExport.g:22049:3: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2" + // InternalExport.g:22057:1: rule__JvmParameterizedTypeReference__Group_1_4__2 : rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22061:1: ( rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ) + // InternalExport.g:22062:2: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" + // InternalExport.g:22068:1: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22072:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ) + // InternalExport.g:22073:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) + { + // InternalExport.g:22073:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) + // InternalExport.g:22074:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); + } + // InternalExport.g:22075:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? + int alt177=2; + alt177 = dfa177.predict(input); + switch (alt177) { + case 1 : + // InternalExport.g:22075:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0" + // InternalExport.g:22084:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22088:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ) + // InternalExport.g:22089:2: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" + // InternalExport.g:22095:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22099:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ) + // InternalExport.g:22100:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) + { + // InternalExport.g:22100:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) + // InternalExport.g:22101:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); + } + // InternalExport.g:22102:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) + // InternalExport.g:22102:3: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" + // InternalExport.g:22111:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22115:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ) + // InternalExport.g:22116:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 + { + pushFollow(FOLLOW_62); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" + // InternalExport.g:22123:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl : ( () ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22127:1: ( ( () ) ) + // InternalExport.g:22128:1: ( () ) + { + // InternalExport.g:22128:1: ( () ) + // InternalExport.g:22129:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); + } + // InternalExport.g:22130:2: () + // InternalExport.g:22130:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" + // InternalExport.g:22138:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22142:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ) + // InternalExport.g:22143:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" + // InternalExport.g:22149:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl : ( '.' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22153:1: ( ( '.' ) ) + // InternalExport.g:22154:1: ( '.' ) + { + // InternalExport.g:22154:1: ( '.' ) + // InternalExport.g:22155:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0" + // InternalExport.g:22165:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22169:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ) + // InternalExport.g:22170:2: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 + { + pushFollow(FOLLOW_95); + rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" + // InternalExport.g:22177:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl : ( ( '<' ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22181:1: ( ( ( '<' ) ) ) + // InternalExport.g:22182:1: ( ( '<' ) ) + { + // InternalExport.g:22182:1: ( ( '<' ) ) + // InternalExport.g:22183:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + // InternalExport.g:22184:2: ( '<' ) + // InternalExport.g:22184:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1" + // InternalExport.g:22192:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22196:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ) + // InternalExport.g:22197:2: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 + { + pushFollow(FOLLOW_96); + rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" + // InternalExport.g:22204:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22208:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ) + // InternalExport.g:22209:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) + { + // InternalExport.g:22209:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) + // InternalExport.g:22210:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); + } + // InternalExport.g:22211:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) + // InternalExport.g:22211:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2" + // InternalExport.g:22219:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2 : rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22223:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ) + // InternalExport.g:22224:2: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 + { + pushFollow(FOLLOW_96); + rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" + // InternalExport.g:22231:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22235:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ) + // InternalExport.g:22236:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) + { + // InternalExport.g:22236:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) + // InternalExport.g:22237:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); + } + // InternalExport.g:22238:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* + loop178: + do { + int alt178=2; + int LA178_0 = input.LA(1); + + if ( (LA178_0==74) ) { + alt178=1; + } + + + switch (alt178) { + case 1 : + // InternalExport.g:22238:3: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 + { + pushFollow(FOLLOW_22); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop178; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3" + // InternalExport.g:22246:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3 : rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22250:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ) + // InternalExport.g:22251:2: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" + // InternalExport.g:22257:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl : ( '>' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22261:1: ( ( '>' ) ) + // InternalExport.g:22262:1: ( '>' ) + { + // InternalExport.g:22262:1: ( '>' ) + // InternalExport.g:22263:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" + // InternalExport.g:22273:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22277:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ) + // InternalExport.g:22278:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 + { + pushFollow(FOLLOW_95); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" + // InternalExport.g:22285:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl : ( ',' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22289:1: ( ( ',' ) ) + // InternalExport.g:22290:1: ( ',' ) + { + // InternalExport.g:22290:1: ( ',' ) + // InternalExport.g:22291:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" + // InternalExport.g:22300:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22304:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ) + // InternalExport.g:22305:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" + // InternalExport.g:22311:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22315:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ) + // InternalExport.g:22316:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) + { + // InternalExport.g:22316:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) + // InternalExport.g:22317:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); + } + // InternalExport.g:22318:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) + // InternalExport.g:22318:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__0" + // InternalExport.g:22327:1: rule__JvmWildcardTypeReference__Group__0 : rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ; + public final void rule__JvmWildcardTypeReference__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22331:1: ( rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ) + // InternalExport.g:22332:2: rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 + { + pushFollow(FOLLOW_95); + rule__JvmWildcardTypeReference__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__0__Impl" + // InternalExport.g:22339:1: rule__JvmWildcardTypeReference__Group__0__Impl : ( () ) ; + public final void rule__JvmWildcardTypeReference__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22343:1: ( ( () ) ) + // InternalExport.g:22344:1: ( () ) + { + // InternalExport.g:22344:1: ( () ) + // InternalExport.g:22345:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); + } + // InternalExport.g:22346:2: () + // InternalExport.g:22346:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__1" + // InternalExport.g:22354:1: rule__JvmWildcardTypeReference__Group__1 : rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ; + public final void rule__JvmWildcardTypeReference__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22358:1: ( rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ) + // InternalExport.g:22359:2: rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 + { + pushFollow(FOLLOW_133); + rule__JvmWildcardTypeReference__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__1__Impl" + // InternalExport.g:22366:1: rule__JvmWildcardTypeReference__Group__1__Impl : ( '?' ) ; + public final void rule__JvmWildcardTypeReference__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22370:1: ( ( '?' ) ) + // InternalExport.g:22371:1: ( '?' ) + { + // InternalExport.g:22371:1: ( '?' ) + // InternalExport.g:22372:2: '?' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__2" + // InternalExport.g:22381:1: rule__JvmWildcardTypeReference__Group__2 : rule__JvmWildcardTypeReference__Group__2__Impl ; + public final void rule__JvmWildcardTypeReference__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22385:1: ( rule__JvmWildcardTypeReference__Group__2__Impl ) + // InternalExport.g:22386:2: rule__JvmWildcardTypeReference__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__2" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__2__Impl" + // InternalExport.g:22392:1: rule__JvmWildcardTypeReference__Group__2__Impl : ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ; + public final void rule__JvmWildcardTypeReference__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22396:1: ( ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ) + // InternalExport.g:22397:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) + { + // InternalExport.g:22397:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) + // InternalExport.g:22398:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); + } + // InternalExport.g:22399:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? + int alt179=2; + int LA179_0 = input.LA(1); + + if ( (LA179_0==60||LA179_0==64) ) { + alt179=1; + } + switch (alt179) { + case 1 : + // InternalExport.g:22399:3: rule__JvmWildcardTypeReference__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__2__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0" + // InternalExport.g:22408:1: rule__JvmWildcardTypeReference__Group_2_0__0 : rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ; + public final void rule__JvmWildcardTypeReference__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22412:1: ( rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ) + // InternalExport.g:22413:2: rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 + { + pushFollow(FOLLOW_134); + rule__JvmWildcardTypeReference__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" + // InternalExport.g:22420:1: rule__JvmWildcardTypeReference__Group_2_0__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ; + public final void rule__JvmWildcardTypeReference__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22424:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ) + // InternalExport.g:22425:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) + { + // InternalExport.g:22425:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) + // InternalExport.g:22426:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); + } + // InternalExport.g:22427:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) + // InternalExport.g:22427:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1" + // InternalExport.g:22435:1: rule__JvmWildcardTypeReference__Group_2_0__1 : rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; + public final void rule__JvmWildcardTypeReference__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22439:1: ( rule__JvmWildcardTypeReference__Group_2_0__1__Impl ) + // InternalExport.g:22440:2: rule__JvmWildcardTypeReference__Group_2_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" + // InternalExport.g:22446:1: rule__JvmWildcardTypeReference__Group_2_0__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ; + public final void rule__JvmWildcardTypeReference__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22450:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ) + // InternalExport.g:22451:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) + { + // InternalExport.g:22451:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) + // InternalExport.g:22452:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); + } + // InternalExport.g:22453:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* + loop180: + do { + int alt180=2; + int LA180_0 = input.LA(1); + + if ( (LA180_0==108) ) { + alt180=1; + } + + + switch (alt180) { + case 1 : + // InternalExport.g:22453:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 + { + pushFollow(FOLLOW_135); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop180; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0" + // InternalExport.g:22462:1: rule__JvmWildcardTypeReference__Group_2_1__0 : rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ; + public final void rule__JvmWildcardTypeReference__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22466:1: ( rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ) + // InternalExport.g:22467:2: rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 + { + pushFollow(FOLLOW_134); + rule__JvmWildcardTypeReference__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" + // InternalExport.g:22474:1: rule__JvmWildcardTypeReference__Group_2_1__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ; + public final void rule__JvmWildcardTypeReference__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22478:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ) + // InternalExport.g:22479:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) + { + // InternalExport.g:22479:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) + // InternalExport.g:22480:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); + } + // InternalExport.g:22481:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) + // InternalExport.g:22481:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1" + // InternalExport.g:22489:1: rule__JvmWildcardTypeReference__Group_2_1__1 : rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; + public final void rule__JvmWildcardTypeReference__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22493:1: ( rule__JvmWildcardTypeReference__Group_2_1__1__Impl ) + // InternalExport.g:22494:2: rule__JvmWildcardTypeReference__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" + // InternalExport.g:22500:1: rule__JvmWildcardTypeReference__Group_2_1__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ; + public final void rule__JvmWildcardTypeReference__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22504:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ) + // InternalExport.g:22505:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) + { + // InternalExport.g:22505:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) + // InternalExport.g:22506:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); + } + // InternalExport.g:22507:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* + loop181: + do { + int alt181=2; + int LA181_0 = input.LA(1); + + if ( (LA181_0==108) ) { + alt181=1; + } + + + switch (alt181) { + case 1 : + // InternalExport.g:22507:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 + { + pushFollow(FOLLOW_135); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop181; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" + + + // $ANTLR start "rule__JvmUpperBound__Group__0" + // InternalExport.g:22516:1: rule__JvmUpperBound__Group__0 : rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ; + public final void rule__JvmUpperBound__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22520:1: ( rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ) + // InternalExport.g:22521:2: rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 + { + pushFollow(FOLLOW_78); + rule__JvmUpperBound__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__0" + + + // $ANTLR start "rule__JvmUpperBound__Group__0__Impl" + // InternalExport.g:22528:1: rule__JvmUpperBound__Group__0__Impl : ( 'extends' ) ; + public final void rule__JvmUpperBound__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22532:1: ( ( 'extends' ) ) + // InternalExport.g:22533:1: ( 'extends' ) + { + // InternalExport.g:22533:1: ( 'extends' ) + // InternalExport.g:22534:2: 'extends' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + match(input,60,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__0__Impl" + + + // $ANTLR start "rule__JvmUpperBound__Group__1" + // InternalExport.g:22543:1: rule__JvmUpperBound__Group__1 : rule__JvmUpperBound__Group__1__Impl ; + public final void rule__JvmUpperBound__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22547:1: ( rule__JvmUpperBound__Group__1__Impl ) + // InternalExport.g:22548:2: rule__JvmUpperBound__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__1" + + + // $ANTLR start "rule__JvmUpperBound__Group__1__Impl" + // InternalExport.g:22554:1: rule__JvmUpperBound__Group__1__Impl : ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmUpperBound__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22558:1: ( ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ) + // InternalExport.g:22559:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) + { + // InternalExport.g:22559:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) + // InternalExport.g:22560:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); + } + // InternalExport.g:22561:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) + // InternalExport.g:22561:3: rule__JvmUpperBound__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__1__Impl" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__0" + // InternalExport.g:22570:1: rule__JvmUpperBoundAnded__Group__0 : rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ; + public final void rule__JvmUpperBoundAnded__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22574:1: ( rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ) + // InternalExport.g:22575:2: rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 + { + pushFollow(FOLLOW_78); + rule__JvmUpperBoundAnded__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__0" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__0__Impl" + // InternalExport.g:22582:1: rule__JvmUpperBoundAnded__Group__0__Impl : ( '&' ) ; + public final void rule__JvmUpperBoundAnded__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22586:1: ( ( '&' ) ) + // InternalExport.g:22587:1: ( '&' ) + { + // InternalExport.g:22587:1: ( '&' ) + // InternalExport.g:22588:2: '&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + match(input,108,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__0__Impl" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__1" + // InternalExport.g:22597:1: rule__JvmUpperBoundAnded__Group__1 : rule__JvmUpperBoundAnded__Group__1__Impl ; + public final void rule__JvmUpperBoundAnded__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22601:1: ( rule__JvmUpperBoundAnded__Group__1__Impl ) + // InternalExport.g:22602:2: rule__JvmUpperBoundAnded__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__1" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__1__Impl" + // InternalExport.g:22608:1: rule__JvmUpperBoundAnded__Group__1__Impl : ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmUpperBoundAnded__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22612:1: ( ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ) + // InternalExport.g:22613:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) + { + // InternalExport.g:22613:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) + // InternalExport.g:22614:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); + } + // InternalExport.g:22615:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) + // InternalExport.g:22615:3: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__1__Impl" + + + // $ANTLR start "rule__JvmLowerBound__Group__0" + // InternalExport.g:22624:1: rule__JvmLowerBound__Group__0 : rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ; + public final void rule__JvmLowerBound__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22628:1: ( rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ) + // InternalExport.g:22629:2: rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 + { + pushFollow(FOLLOW_78); + rule__JvmLowerBound__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__0" + + + // $ANTLR start "rule__JvmLowerBound__Group__0__Impl" + // InternalExport.g:22636:1: rule__JvmLowerBound__Group__0__Impl : ( 'super' ) ; + public final void rule__JvmLowerBound__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22640:1: ( ( 'super' ) ) + // InternalExport.g:22641:1: ( 'super' ) + { + // InternalExport.g:22641:1: ( 'super' ) + // InternalExport.g:22642:2: 'super' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + match(input,64,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__0__Impl" + + + // $ANTLR start "rule__JvmLowerBound__Group__1" + // InternalExport.g:22651:1: rule__JvmLowerBound__Group__1 : rule__JvmLowerBound__Group__1__Impl ; + public final void rule__JvmLowerBound__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22655:1: ( rule__JvmLowerBound__Group__1__Impl ) + // InternalExport.g:22656:2: rule__JvmLowerBound__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__1" + + + // $ANTLR start "rule__JvmLowerBound__Group__1__Impl" + // InternalExport.g:22662:1: rule__JvmLowerBound__Group__1__Impl : ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmLowerBound__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22666:1: ( ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ) + // InternalExport.g:22667:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) + { + // InternalExport.g:22667:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) + // InternalExport.g:22668:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); + } + // InternalExport.g:22669:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) + // InternalExport.g:22669:3: rule__JvmLowerBound__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__1__Impl" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__0" + // InternalExport.g:22678:1: rule__JvmLowerBoundAnded__Group__0 : rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ; + public final void rule__JvmLowerBoundAnded__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22682:1: ( rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ) + // InternalExport.g:22683:2: rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 + { + pushFollow(FOLLOW_78); + rule__JvmLowerBoundAnded__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__0" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__0__Impl" + // InternalExport.g:22690:1: rule__JvmLowerBoundAnded__Group__0__Impl : ( '&' ) ; + public final void rule__JvmLowerBoundAnded__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22694:1: ( ( '&' ) ) + // InternalExport.g:22695:1: ( '&' ) + { + // InternalExport.g:22695:1: ( '&' ) + // InternalExport.g:22696:2: '&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + match(input,108,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__0__Impl" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__1" + // InternalExport.g:22705:1: rule__JvmLowerBoundAnded__Group__1 : rule__JvmLowerBoundAnded__Group__1__Impl ; + public final void rule__JvmLowerBoundAnded__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22709:1: ( rule__JvmLowerBoundAnded__Group__1__Impl ) + // InternalExport.g:22710:2: rule__JvmLowerBoundAnded__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__1" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__1__Impl" + // InternalExport.g:22716:1: rule__JvmLowerBoundAnded__Group__1__Impl : ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmLowerBoundAnded__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22720:1: ( ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ) + // InternalExport.g:22721:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) + { + // InternalExport.g:22721:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) + // InternalExport.g:22722:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); + } + // InternalExport.g:22723:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) + // InternalExport.g:22723:3: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0" + // InternalExport.g:22732:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ; + public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22736:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ) + // InternalExport.g:22737:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 + { + pushFollow(FOLLOW_62); + rule__QualifiedNameWithWildcard__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl" + // InternalExport.g:22744:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ; + public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22748:1: ( ( ruleQualifiedName ) ) + // InternalExport.g:22749:1: ( ruleQualifiedName ) + { + // InternalExport.g:22749:1: ( ruleQualifiedName ) + // InternalExport.g:22750:2: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1" + // InternalExport.g:22759:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ; + public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22763:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ) + // InternalExport.g:22764:2: rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 + { + pushFollow(FOLLOW_136); + rule__QualifiedNameWithWildcard__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl" + // InternalExport.g:22771:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( '.' ) ; + public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22775:1: ( ( '.' ) ) + // InternalExport.g:22776:1: ( '.' ) + { + // InternalExport.g:22776:1: ( '.' ) + // InternalExport.g:22777:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2" + // InternalExport.g:22786:1: rule__QualifiedNameWithWildcard__Group__2 : rule__QualifiedNameWithWildcard__Group__2__Impl ; + public final void rule__QualifiedNameWithWildcard__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22790:1: ( rule__QualifiedNameWithWildcard__Group__2__Impl ) + // InternalExport.g:22791:2: rule__QualifiedNameWithWildcard__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2__Impl" + // InternalExport.g:22797:1: rule__QualifiedNameWithWildcard__Group__2__Impl : ( '*' ) ; + public final void rule__QualifiedNameWithWildcard__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22801:1: ( ( '*' ) ) + // InternalExport.g:22802:1: ( '*' ) + { + // InternalExport.g:22802:1: ( '*' ) + // InternalExport.g:22803:2: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__0" + // InternalExport.g:22813:1: rule__XImportDeclaration__Group__0 : rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ; + public final void rule__XImportDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22817:1: ( rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ) + // InternalExport.g:22818:2: rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 + { + pushFollow(FOLLOW_137); + rule__XImportDeclaration__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__0" + + + // $ANTLR start "rule__XImportDeclaration__Group__0__Impl" + // InternalExport.g:22825:1: rule__XImportDeclaration__Group__0__Impl : ( 'import' ) ; + public final void rule__XImportDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22829:1: ( ( 'import' ) ) + // InternalExport.g:22830:1: ( 'import' ) + { + // InternalExport.g:22830:1: ( 'import' ) + // InternalExport.g:22831:2: 'import' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + match(input,62,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__1" + // InternalExport.g:22840:1: rule__XImportDeclaration__Group__1 : rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ; + public final void rule__XImportDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22844:1: ( rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ) + // InternalExport.g:22845:2: rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 + { + pushFollow(FOLLOW_35); + rule__XImportDeclaration__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__1" + + + // $ANTLR start "rule__XImportDeclaration__Group__1__Impl" + // InternalExport.g:22852:1: rule__XImportDeclaration__Group__1__Impl : ( ( rule__XImportDeclaration__Alternatives_1 ) ) ; + public final void rule__XImportDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22856:1: ( ( ( rule__XImportDeclaration__Alternatives_1 ) ) ) + // InternalExport.g:22857:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) + { + // InternalExport.g:22857:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) + // InternalExport.g:22858:2: ( rule__XImportDeclaration__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); + } + // InternalExport.g:22859:2: ( rule__XImportDeclaration__Alternatives_1 ) + // InternalExport.g:22859:3: rule__XImportDeclaration__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__2" + // InternalExport.g:22867:1: rule__XImportDeclaration__Group__2 : rule__XImportDeclaration__Group__2__Impl ; + public final void rule__XImportDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22871:1: ( rule__XImportDeclaration__Group__2__Impl ) + // InternalExport.g:22872:2: rule__XImportDeclaration__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__2" + + + // $ANTLR start "rule__XImportDeclaration__Group__2__Impl" + // InternalExport.g:22878:1: rule__XImportDeclaration__Group__2__Impl : ( ( ';' )? ) ; + public final void rule__XImportDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22882:1: ( ( ( ';' )? ) ) + // InternalExport.g:22883:1: ( ( ';' )? ) + { + // InternalExport.g:22883:1: ( ( ';' )? ) + // InternalExport.g:22884:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + // InternalExport.g:22885:2: ( ';' )? + int alt182=2; + int LA182_0 = input.LA(1); + + if ( (LA182_0==71) ) { + alt182=1; + } + switch (alt182) { + case 1 : + // InternalExport.g:22885:3: ';' + { + match(input,71,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__0" + // InternalExport.g:22894:1: rule__XImportDeclaration__Group_1_0__0 : rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ; + public final void rule__XImportDeclaration__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22898:1: ( rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ) + // InternalExport.g:22899:2: rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 + { + pushFollow(FOLLOW_9); + rule__XImportDeclaration__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__0" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__0__Impl" + // InternalExport.g:22906:1: rule__XImportDeclaration__Group_1_0__0__Impl : ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22910:1: ( ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ) + // InternalExport.g:22911:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) + { + // InternalExport.g:22911:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) + // InternalExport.g:22912:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); + } + // InternalExport.g:22913:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) + // InternalExport.g:22913:3: rule__XImportDeclaration__StaticAssignment_1_0_0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__StaticAssignment_1_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__1" + // InternalExport.g:22921:1: rule__XImportDeclaration__Group_1_0__1 : rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ; + public final void rule__XImportDeclaration__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22925:1: ( rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ) + // InternalExport.g:22926:2: rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 + { + pushFollow(FOLLOW_9); + rule__XImportDeclaration__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__1" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__1__Impl" + // InternalExport.g:22933:1: rule__XImportDeclaration__Group_1_0__1__Impl : ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ; + public final void rule__XImportDeclaration__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22937:1: ( ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ) + // InternalExport.g:22938:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) + { + // InternalExport.g:22938:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) + // InternalExport.g:22939:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); + } + // InternalExport.g:22940:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? + int alt183=2; + int LA183_0 = input.LA(1); + + if ( (LA183_0==63) ) { + alt183=1; + } + switch (alt183) { + case 1 : + // InternalExport.g:22940:3: rule__XImportDeclaration__ExtensionAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ExtensionAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__2" + // InternalExport.g:22948:1: rule__XImportDeclaration__Group_1_0__2 : rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ; + public final void rule__XImportDeclaration__Group_1_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22952:1: ( rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ) + // InternalExport.g:22953:2: rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 + { + pushFollow(FOLLOW_138); + rule__XImportDeclaration__Group_1_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__2" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__2__Impl" + // InternalExport.g:22960:1: rule__XImportDeclaration__Group_1_0__2__Impl : ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22964:1: ( ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ) + // InternalExport.g:22965:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) + { + // InternalExport.g:22965:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) + // InternalExport.g:22966:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); + } + // InternalExport.g:22967:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) + // InternalExport.g:22967:3: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedTypeAssignment_1_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__3" + // InternalExport.g:22975:1: rule__XImportDeclaration__Group_1_0__3 : rule__XImportDeclaration__Group_1_0__3__Impl ; + public final void rule__XImportDeclaration__Group_1_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22979:1: ( rule__XImportDeclaration__Group_1_0__3__Impl ) + // InternalExport.g:22980:2: rule__XImportDeclaration__Group_1_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__3" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__3__Impl" + // InternalExport.g:22986:1: rule__XImportDeclaration__Group_1_0__3__Impl : ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:22990:1: ( ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ) + // InternalExport.g:22991:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) + { + // InternalExport.g:22991:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) + // InternalExport.g:22992:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); + } + // InternalExport.g:22993:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) + // InternalExport.g:22993:3: rule__XImportDeclaration__Alternatives_1_0_3 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Alternatives_1_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__3__Impl" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0" + // InternalExport.g:23002:1: rule__QualifiedNameInStaticImport__Group__0 : rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ; + public final void rule__QualifiedNameInStaticImport__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23006:1: ( rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ) + // InternalExport.g:23007:2: rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 + { + pushFollow(FOLLOW_62); + rule__QualifiedNameInStaticImport__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameInStaticImport__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0__Impl" + // InternalExport.g:23014:1: rule__QualifiedNameInStaticImport__Group__0__Impl : ( ruleValidID ) ; + public final void rule__QualifiedNameInStaticImport__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23018:1: ( ( ruleValidID ) ) + // InternalExport.g:23019:1: ( ruleValidID ) + { + // InternalExport.g:23019:1: ( ruleValidID ) + // InternalExport.g:23020:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1" + // InternalExport.g:23029:1: rule__QualifiedNameInStaticImport__Group__1 : rule__QualifiedNameInStaticImport__Group__1__Impl ; + public final void rule__QualifiedNameInStaticImport__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23033:1: ( rule__QualifiedNameInStaticImport__Group__1__Impl ) + // InternalExport.g:23034:2: rule__QualifiedNameInStaticImport__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedNameInStaticImport__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1__Impl" + // InternalExport.g:23040:1: rule__QualifiedNameInStaticImport__Group__1__Impl : ( '.' ) ; + public final void rule__QualifiedNameInStaticImport__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23044:1: ( ( '.' ) ) + // InternalExport.g:23045:1: ( '.' ) + { + // InternalExport.g:23045:1: ( '.' ) + // InternalExport.g:23046:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1__Impl" + + + // $ANTLR start "rule__ExportModel__ExtensionAssignment_0_1" + // InternalExport.g:23056:1: rule__ExportModel__ExtensionAssignment_0_1 : ( ( 'extension' ) ) ; + public final void rule__ExportModel__ExtensionAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23060:1: ( ( ( 'extension' ) ) ) + // InternalExport.g:23061:2: ( ( 'extension' ) ) + { + // InternalExport.g:23061:2: ( ( 'extension' ) ) + // InternalExport.g:23062:3: ( 'extension' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); + } + // InternalExport.g:23063:3: ( 'extension' ) + // InternalExport.g:23064:4: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__ExtensionAssignment_0_1" + + + // $ANTLR start "rule__ExportModel__NameAssignment_0_2" + // InternalExport.g:23075:1: rule__ExportModel__NameAssignment_0_2 : ( RULE_ID ) ; + public final void rule__ExportModel__NameAssignment_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23079:1: ( ( RULE_ID ) ) + // InternalExport.g:23080:2: ( RULE_ID ) + { + // InternalExport.g:23080:2: ( RULE_ID ) + // InternalExport.g:23081:3: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getNameIDTerminalRuleCall_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__NameAssignment_0_2" + + + // $ANTLR start "rule__ExportModel__TargetGrammarAssignment_0_4" + // InternalExport.g:23090:1: rule__ExportModel__TargetGrammarAssignment_0_4 : ( ( ruleQualifiedID ) ) ; + public final void rule__ExportModel__TargetGrammarAssignment_0_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23094:1: ( ( ( ruleQualifiedID ) ) ) + // InternalExport.g:23095:2: ( ( ruleQualifiedID ) ) + { + // InternalExport.g:23095:2: ( ( ruleQualifiedID ) ) + // InternalExport.g:23096:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); + } + // InternalExport.g:23097:3: ( ruleQualifiedID ) + // InternalExport.g:23098:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarQualifiedIDParserRuleCall_0_4_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getTargetGrammarGrammarCrossReference_0_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__TargetGrammarAssignment_0_4" + + + // $ANTLR start "rule__ExportModel__ImportsAssignment_1" + // InternalExport.g:23109:1: rule__ExportModel__ImportsAssignment_1 : ( ruleImport ) ; + public final void rule__ExportModel__ImportsAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23113:1: ( ( ruleImport ) ) + // InternalExport.g:23114:2: ( ruleImport ) + { + // InternalExport.g:23114:2: ( ruleImport ) + // InternalExport.g:23115:3: ruleImport + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getImportsImportParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__ImportsAssignment_1" + + + // $ANTLR start "rule__ExportModel__ExtensionsAssignment_2" + // InternalExport.g:23124:1: rule__ExportModel__ExtensionsAssignment_2 : ( ruleExtension ) ; + public final void rule__ExportModel__ExtensionsAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23128:1: ( ( ruleExtension ) ) + // InternalExport.g:23129:2: ( ruleExtension ) + { + // InternalExport.g:23129:2: ( ruleExtension ) + // InternalExport.g:23130:3: ruleExtension + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleExtension(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getExtensionsExtensionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__ExtensionsAssignment_2" + + + // $ANTLR start "rule__ExportModel__InterfacesAssignment_3_2" + // InternalExport.g:23139:1: rule__ExportModel__InterfacesAssignment_3_2 : ( ruleInterface ) ; + public final void rule__ExportModel__InterfacesAssignment_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23143:1: ( ( ruleInterface ) ) + // InternalExport.g:23144:2: ( ruleInterface ) + { + // InternalExport.g:23144:2: ( ruleInterface ) + // InternalExport.g:23145:3: ruleInterface + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); + } + pushFollow(FOLLOW_2); + ruleInterface(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getInterfacesInterfaceParserRuleCall_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__InterfacesAssignment_3_2" + + + // $ANTLR start "rule__ExportModel__ExportsAssignment_4" + // InternalExport.g:23154:1: rule__ExportModel__ExportsAssignment_4 : ( ruleExport ) ; + public final void rule__ExportModel__ExportsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23158:1: ( ( ruleExport ) ) + // InternalExport.g:23159:2: ( ruleExport ) + { + // InternalExport.g:23159:2: ( ruleExport ) + // InternalExport.g:23160:3: ruleExport + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleExport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportModelAccess().getExportsExportParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ExportModel__ExportsAssignment_4" + + + // $ANTLR start "rule__Import__PackageAssignment_1" + // InternalExport.g:23169:1: rule__Import__PackageAssignment_1 : ( ( RULE_STRING ) ) ; + public final void rule__Import__PackageAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23173:1: ( ( ( RULE_STRING ) ) ) + // InternalExport.g:23174:2: ( ( RULE_STRING ) ) + { + // InternalExport.g:23174:2: ( ( RULE_STRING ) ) + // InternalExport.g:23175:3: ( RULE_STRING ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); + } + // InternalExport.g:23176:3: ( RULE_STRING ) + // InternalExport.g:23177:4: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Import__PackageAssignment_1" + + + // $ANTLR start "rule__Import__NameAssignment_2_1" + // InternalExport.g:23188:1: rule__Import__NameAssignment_2_1 : ( RULE_ID ) ; + public final void rule__Import__NameAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23192:1: ( ( RULE_ID ) ) + // InternalExport.g:23193:2: ( RULE_ID ) + { + // InternalExport.g:23193:2: ( RULE_ID ) + // InternalExport.g:23194:3: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImportAccess().getNameIDTerminalRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Import__NameAssignment_2_1" + + + // $ANTLR start "rule__Extension__ExtensionAssignment_1" + // InternalExport.g:23203:1: rule__Extension__ExtensionAssignment_1 : ( ruleQualifiedID ) ; + public final void rule__Extension__ExtensionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23207:1: ( ( ruleQualifiedID ) ) + // InternalExport.g:23208:2: ( ruleQualifiedID ) + { + // InternalExport.g:23208:2: ( ruleQualifiedID ) + // InternalExport.g:23209:3: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Extension__ExtensionAssignment_1" + + + // $ANTLR start "rule__Interface__TypeAssignment_0" + // InternalExport.g:23218:1: rule__Interface__TypeAssignment_0 : ( ( ruleQualifiedID ) ) ; + public final void rule__Interface__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23222:1: ( ( ( ruleQualifiedID ) ) ) + // InternalExport.g:23223:2: ( ( ruleQualifiedID ) ) + { + // InternalExport.g:23223:2: ( ( ruleQualifiedID ) ) + // InternalExport.g:23224:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); + } + // InternalExport.g:23225:3: ( ruleQualifiedID ) + // InternalExport.g:23226:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceAccess().getTypeEClassCrossReference_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Interface__TypeAssignment_0" + + + // $ANTLR start "rule__Interface__GuardAssignment_1_1" + // InternalExport.g:23237:1: rule__Interface__GuardAssignment_1_1 : ( ruleExpression ) ; + public final void rule__Interface__GuardAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23241:1: ( ( ruleExpression ) ) + // InternalExport.g:23242:2: ( ruleExpression ) + { + // InternalExport.g:23242:2: ( ruleExpression ) + // InternalExport.g:23243:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceAccess().getGuardExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Interface__GuardAssignment_1_1" + + + // $ANTLR start "rule__Interface__ItemsAssignment_2_1" + // InternalExport.g:23252:1: rule__Interface__ItemsAssignment_2_1 : ( ruleInterfaceItem ) ; + public final void rule__Interface__ItemsAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23256:1: ( ( ruleInterfaceItem ) ) + // InternalExport.g:23257:2: ( ruleInterfaceItem ) + { + // InternalExport.g:23257:2: ( ruleInterfaceItem ) + // InternalExport.g:23258:3: ruleInterfaceItem + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleInterfaceItem(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Interface__ItemsAssignment_2_1" + + + // $ANTLR start "rule__Interface__ItemsAssignment_2_2_1" + // InternalExport.g:23267:1: rule__Interface__ItemsAssignment_2_2_1 : ( ruleInterfaceItem ) ; + public final void rule__Interface__ItemsAssignment_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23271:1: ( ( ruleInterfaceItem ) ) + // InternalExport.g:23272:2: ( ruleInterfaceItem ) + { + // InternalExport.g:23272:2: ( ruleInterfaceItem ) + // InternalExport.g:23273:3: ruleInterfaceItem + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleInterfaceItem(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceAccess().getItemsInterfaceItemParserRuleCall_2_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Interface__ItemsAssignment_2_2_1" + + + // $ANTLR start "rule__InterfaceField__UnorderedAssignment_0" + // InternalExport.g:23282:1: rule__InterfaceField__UnorderedAssignment_0 : ( ( '+' ) ) ; + public final void rule__InterfaceField__UnorderedAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23286:1: ( ( ( '+' ) ) ) + // InternalExport.g:23287:2: ( ( '+' ) ) + { + // InternalExport.g:23287:2: ( ( '+' ) ) + // InternalExport.g:23288:3: ( '+' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); + } + // InternalExport.g:23289:3: ( '+' ) + // InternalExport.g:23290:4: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceField__UnorderedAssignment_0" + + + // $ANTLR start "rule__InterfaceField__FieldAssignment_1" + // InternalExport.g:23301:1: rule__InterfaceField__FieldAssignment_1 : ( ( RULE_ID ) ) ; + public final void rule__InterfaceField__FieldAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23305:1: ( ( ( RULE_ID ) ) ) + // InternalExport.g:23306:2: ( ( RULE_ID ) ) + { + // InternalExport.g:23306:2: ( ( RULE_ID ) ) + // InternalExport.g:23307:3: ( RULE_ID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); + } + // InternalExport.g:23308:3: ( RULE_ID ) + // InternalExport.g:23309:4: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureIDTerminalRuleCall_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceFieldAccess().getFieldEStructuralFeatureCrossReference_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceField__FieldAssignment_1" + + + // $ANTLR start "rule__InterfaceNavigation__UnorderedAssignment_1" + // InternalExport.g:23320:1: rule__InterfaceNavigation__UnorderedAssignment_1 : ( ( '+' ) ) ; + public final void rule__InterfaceNavigation__UnorderedAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23324:1: ( ( ( '+' ) ) ) + // InternalExport.g:23325:2: ( ( '+' ) ) + { + // InternalExport.g:23325:2: ( ( '+' ) ) + // InternalExport.g:23326:3: ( '+' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); + } + // InternalExport.g:23327:3: ( '+' ) + // InternalExport.g:23328:4: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceNavigation__UnorderedAssignment_1" + + + // $ANTLR start "rule__InterfaceNavigation__RefAssignment_2" + // InternalExport.g:23339:1: rule__InterfaceNavigation__RefAssignment_2 : ( ( RULE_ID ) ) ; + public final void rule__InterfaceNavigation__RefAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23343:1: ( ( ( RULE_ID ) ) ) + // InternalExport.g:23344:2: ( ( RULE_ID ) ) + { + // InternalExport.g:23344:2: ( ( RULE_ID ) ) + // InternalExport.g:23345:3: ( RULE_ID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); + } + // InternalExport.g:23346:3: ( RULE_ID ) + // InternalExport.g:23347:4: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceIDTerminalRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceNavigationAccess().getRefEReferenceCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceNavigation__RefAssignment_2" + + + // $ANTLR start "rule__InterfaceExpression__RefAssignment_1" + // InternalExport.g:23358:1: rule__InterfaceExpression__RefAssignment_1 : ( ( '@' ) ) ; + public final void rule__InterfaceExpression__RefAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23362:1: ( ( ( '@' ) ) ) + // InternalExport.g:23363:2: ( ( '@' ) ) + { + // InternalExport.g:23363:2: ( ( '@' ) ) + // InternalExport.g:23364:3: ( '@' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); + } + // InternalExport.g:23365:3: ( '@' ) + // InternalExport.g:23366:4: '@' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); + } + match(input,75,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceExpression__RefAssignment_1" + + + // $ANTLR start "rule__InterfaceExpression__UnorderedAssignment_2" + // InternalExport.g:23377:1: rule__InterfaceExpression__UnorderedAssignment_2 : ( ( '+' ) ) ; + public final void rule__InterfaceExpression__UnorderedAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23381:1: ( ( ( '+' ) ) ) + // InternalExport.g:23382:2: ( ( '+' ) ) + { + // InternalExport.g:23382:2: ( ( '+' ) ) + // InternalExport.g:23383:3: ( '+' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); + } + // InternalExport.g:23384:3: ( '+' ) + // InternalExport.g:23385:4: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceExpression__UnorderedAssignment_2" + + + // $ANTLR start "rule__InterfaceExpression__ExprAssignment_4" + // InternalExport.g:23396:1: rule__InterfaceExpression__ExprAssignment_4 : ( ruleExpression ) ; + public final void rule__InterfaceExpression__ExprAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23400:1: ( ( ruleExpression ) ) + // InternalExport.g:23401:2: ( ruleExpression ) + { + // InternalExport.g:23401:2: ( ruleExpression ) + // InternalExport.g:23402:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInterfaceExpressionAccess().getExprExpressionParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InterfaceExpression__ExprAssignment_4" + + + // $ANTLR start "rule__Export__LookupAssignment_1_0" + // InternalExport.g:23411:1: rule__Export__LookupAssignment_1_0 : ( ( 'lookup' ) ) ; + public final void rule__Export__LookupAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23415:1: ( ( ( 'lookup' ) ) ) + // InternalExport.g:23416:2: ( ( 'lookup' ) ) + { + // InternalExport.g:23416:2: ( ( 'lookup' ) ) + // InternalExport.g:23417:3: ( 'lookup' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); + } + // InternalExport.g:23418:3: ( 'lookup' ) + // InternalExport.g:23419:4: 'lookup' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); + } + match(input,109,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__LookupAssignment_1_0" + + + // $ANTLR start "rule__Export__LookupPredicateAssignment_1_1_1" + // InternalExport.g:23430:1: rule__Export__LookupPredicateAssignment_1_1_1 : ( ruleExpression ) ; + public final void rule__Export__LookupPredicateAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23434:1: ( ( ruleExpression ) ) + // InternalExport.g:23435:2: ( ruleExpression ) + { + // InternalExport.g:23435:2: ( ruleExpression ) + // InternalExport.g:23436:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getLookupPredicateExpressionParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__LookupPredicateAssignment_1_1_1" + + + // $ANTLR start "rule__Export__TypeAssignment_2" + // InternalExport.g:23445:1: rule__Export__TypeAssignment_2 : ( ( ruleQualifiedID ) ) ; + public final void rule__Export__TypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23449:1: ( ( ( ruleQualifiedID ) ) ) + // InternalExport.g:23450:2: ( ( ruleQualifiedID ) ) + { + // InternalExport.g:23450:2: ( ( ruleQualifiedID ) ) + // InternalExport.g:23451:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); + } + // InternalExport.g:23452:3: ( ruleQualifiedID ) + // InternalExport.g:23453:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getTypeEClassCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__TypeAssignment_2" + + + // $ANTLR start "rule__Export__QualifiedNameAssignment_3_1" + // InternalExport.g:23464:1: rule__Export__QualifiedNameAssignment_3_1 : ( ( 'qualified' ) ) ; + public final void rule__Export__QualifiedNameAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23468:1: ( ( ( 'qualified' ) ) ) + // InternalExport.g:23469:2: ( ( 'qualified' ) ) + { + // InternalExport.g:23469:2: ( ( 'qualified' ) ) + // InternalExport.g:23470:3: ( 'qualified' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); + } + // InternalExport.g:23471:3: ( 'qualified' ) + // InternalExport.g:23472:4: 'qualified' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); + } + match(input,110,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__QualifiedNameAssignment_3_1" + + + // $ANTLR start "rule__Export__NamingAssignment_3_2" + // InternalExport.g:23483:1: rule__Export__NamingAssignment_3_2 : ( ruleExpression ) ; + public final void rule__Export__NamingAssignment_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23487:1: ( ( ruleExpression ) ) + // InternalExport.g:23488:2: ( ruleExpression ) + { + // InternalExport.g:23488:2: ( ruleExpression ) + // InternalExport.g:23489:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getNamingExpressionParserRuleCall_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__NamingAssignment_3_2" + + + // $ANTLR start "rule__Export__GuardAssignment_4_1" + // InternalExport.g:23498:1: rule__Export__GuardAssignment_4_1 : ( ruleExpression ) ; + public final void rule__Export__GuardAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23502:1: ( ( ruleExpression ) ) + // InternalExport.g:23503:2: ( ruleExpression ) + { + // InternalExport.g:23503:2: ( ruleExpression ) + // InternalExport.g:23504:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getGuardExpressionParserRuleCall_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__GuardAssignment_4_1" + + + // $ANTLR start "rule__Export__FragmentUniqueAssignment_6_2" + // InternalExport.g:23513:1: rule__Export__FragmentUniqueAssignment_6_2 : ( ( 'unique' ) ) ; + public final void rule__Export__FragmentUniqueAssignment_6_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23517:1: ( ( ( 'unique' ) ) ) + // InternalExport.g:23518:2: ( ( 'unique' ) ) + { + // InternalExport.g:23518:2: ( ( 'unique' ) ) + // InternalExport.g:23519:3: ( 'unique' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); + } + // InternalExport.g:23520:3: ( 'unique' ) + // InternalExport.g:23521:4: 'unique' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); + } + match(input,111,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__FragmentUniqueAssignment_6_2" + + + // $ANTLR start "rule__Export__FragmentAttributeAssignment_6_5" + // InternalExport.g:23532:1: rule__Export__FragmentAttributeAssignment_6_5 : ( ( RULE_ID ) ) ; + public final void rule__Export__FragmentAttributeAssignment_6_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23536:1: ( ( ( RULE_ID ) ) ) + // InternalExport.g:23537:2: ( ( RULE_ID ) ) + { + // InternalExport.g:23537:2: ( ( RULE_ID ) ) + // InternalExport.g:23538:3: ( RULE_ID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); + } + // InternalExport.g:23539:3: ( RULE_ID ) + // InternalExport.g:23540:4: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeIDTerminalRuleCall_6_5_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFragmentAttributeEAttributeCrossReference_6_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__FragmentAttributeAssignment_6_5" + + + // $ANTLR start "rule__Export__FingerprintAssignment_7_0_0" + // InternalExport.g:23551:1: rule__Export__FingerprintAssignment_7_0_0 : ( ( 'object-fingerprint' ) ) ; + public final void rule__Export__FingerprintAssignment_7_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23555:1: ( ( ( 'object-fingerprint' ) ) ) + // InternalExport.g:23556:2: ( ( 'object-fingerprint' ) ) + { + // InternalExport.g:23556:2: ( ( 'object-fingerprint' ) ) + // InternalExport.g:23557:3: ( 'object-fingerprint' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); + } + // InternalExport.g:23558:3: ( 'object-fingerprint' ) + // InternalExport.g:23559:4: 'object-fingerprint' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); + } + match(input,112,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__FingerprintAssignment_7_0_0" + + + // $ANTLR start "rule__Export__ResourceFingerprintAssignment_7_0_1" + // InternalExport.g:23570:1: rule__Export__ResourceFingerprintAssignment_7_0_1 : ( ( 'resource-fingerprint' ) ) ; + public final void rule__Export__ResourceFingerprintAssignment_7_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23574:1: ( ( ( 'resource-fingerprint' ) ) ) + // InternalExport.g:23575:2: ( ( 'resource-fingerprint' ) ) + { + // InternalExport.g:23575:2: ( ( 'resource-fingerprint' ) ) + // InternalExport.g:23576:3: ( 'resource-fingerprint' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); + } + // InternalExport.g:23577:3: ( 'resource-fingerprint' ) + // InternalExport.g:23578:4: 'resource-fingerprint' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); + } + match(input,113,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__ResourceFingerprintAssignment_7_0_1" + + + // $ANTLR start "rule__Export__AttributesAssignment_8_0_1" + // InternalExport.g:23589:1: rule__Export__AttributesAssignment_8_0_1 : ( ruleAttribute ) ; + public final void rule__Export__AttributesAssignment_8_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23593:1: ( ( ruleAttribute ) ) + // InternalExport.g:23594:2: ( ruleAttribute ) + { + // InternalExport.g:23594:2: ( ruleAttribute ) + // InternalExport.g:23595:3: ruleAttribute + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleAttribute(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__AttributesAssignment_8_0_1" + + + // $ANTLR start "rule__Export__AttributesAssignment_8_0_2_1" + // InternalExport.g:23604:1: rule__Export__AttributesAssignment_8_0_2_1 : ( ruleAttribute ) ; + public final void rule__Export__AttributesAssignment_8_0_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23608:1: ( ( ruleAttribute ) ) + // InternalExport.g:23609:2: ( ruleAttribute ) + { + // InternalExport.g:23609:2: ( ruleAttribute ) + // InternalExport.g:23610:3: ruleAttribute + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleAttribute(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getAttributesAttributeParserRuleCall_8_0_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__AttributesAssignment_8_0_2_1" + + + // $ANTLR start "rule__Export__UserDataAssignment_8_1_1" + // InternalExport.g:23619:1: rule__Export__UserDataAssignment_8_1_1 : ( ruleUserData ) ; + public final void rule__Export__UserDataAssignment_8_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23623:1: ( ( ruleUserData ) ) + // InternalExport.g:23624:2: ( ruleUserData ) + { + // InternalExport.g:23624:2: ( ruleUserData ) + // InternalExport.g:23625:3: ruleUserData + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleUserData(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__UserDataAssignment_8_1_1" + + + // $ANTLR start "rule__Export__UserDataAssignment_8_1_2_1" + // InternalExport.g:23634:1: rule__Export__UserDataAssignment_8_1_2_1 : ( ruleUserData ) ; + public final void rule__Export__UserDataAssignment_8_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23638:1: ( ( ruleUserData ) ) + // InternalExport.g:23639:2: ( ruleUserData ) + { + // InternalExport.g:23639:2: ( ruleUserData ) + // InternalExport.g:23640:3: ruleUserData + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleUserData(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExportAccess().getUserDataUserDataParserRuleCall_8_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Export__UserDataAssignment_8_1_2_1" + + + // $ANTLR start "rule__UserData__NameAssignment_0" + // InternalExport.g:23649:1: rule__UserData__NameAssignment_0 : ( RULE_ID ) ; + public final void rule__UserData__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23653:1: ( ( RULE_ID ) ) + // InternalExport.g:23654:2: ( RULE_ID ) + { + // InternalExport.g:23654:2: ( RULE_ID ) + // InternalExport.g:23655:3: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUserDataAccess().getNameIDTerminalRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UserData__NameAssignment_0" + + + // $ANTLR start "rule__UserData__ExprAssignment_2" + // InternalExport.g:23664:1: rule__UserData__ExprAssignment_2 : ( ruleExpression ) ; + public final void rule__UserData__ExprAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23668:1: ( ( ruleExpression ) ) + // InternalExport.g:23669:2: ( ruleExpression ) + { + // InternalExport.g:23669:2: ( ruleExpression ) + // InternalExport.g:23670:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUserDataAccess().getExprExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UserData__ExprAssignment_2" + + + // $ANTLR start "rule__Attribute__AttributeAssignment" + // InternalExport.g:23679:1: rule__Attribute__AttributeAssignment : ( ( RULE_ID ) ) ; + public final void rule__Attribute__AttributeAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23683:1: ( ( ( RULE_ID ) ) ) + // InternalExport.g:23684:2: ( ( RULE_ID ) ) + { + // InternalExport.g:23684:2: ( ( RULE_ID ) ) + // InternalExport.g:23685:3: ( RULE_ID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); + } + // InternalExport.g:23686:3: ( RULE_ID ) + // InternalExport.g:23687:4: RULE_ID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); + } + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAttributeAccess().getAttributeEAttributeIDTerminalRuleCall_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAttributeAccess().getAttributeEAttributeCrossReference_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Attribute__AttributeAssignment" + + + // $ANTLR start "rule__LetExpression__IdentifierAssignment_1" + // InternalExport.g:23698:1: rule__LetExpression__IdentifierAssignment_1 : ( ruleIdentifier ) ; + public final void rule__LetExpression__IdentifierAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23702:1: ( ( ruleIdentifier ) ) + // InternalExport.g:23703:2: ( ruleIdentifier ) + { + // InternalExport.g:23703:2: ( ruleIdentifier ) + // InternalExport.g:23704:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__IdentifierAssignment_1" + + + // $ANTLR start "rule__LetExpression__VarExprAssignment_3" + // InternalExport.g:23713:1: rule__LetExpression__VarExprAssignment_3 : ( ruleExpression ) ; + public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23717:1: ( ( ruleExpression ) ) + // InternalExport.g:23718:2: ( ruleExpression ) + { + // InternalExport.g:23718:2: ( ruleExpression ) + // InternalExport.g:23719:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__VarExprAssignment_3" + + + // $ANTLR start "rule__LetExpression__TargetAssignment_5" + // InternalExport.g:23728:1: rule__LetExpression__TargetAssignment_5 : ( ruleExpression ) ; + public final void rule__LetExpression__TargetAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23732:1: ( ( ruleExpression ) ) + // InternalExport.g:23733:2: ( ruleExpression ) + { + // InternalExport.g:23733:2: ( ruleExpression ) + // InternalExport.g:23734:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__TargetAssignment_5" + + + // $ANTLR start "rule__CastedExpression__TypeAssignment_1" + // InternalExport.g:23743:1: rule__CastedExpression__TypeAssignment_1 : ( ruleType ) ; + public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23747:1: ( ( ruleType ) ) + // InternalExport.g:23748:2: ( ruleType ) + { + // InternalExport.g:23748:2: ( ruleType ) + // InternalExport.g:23749:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__TypeAssignment_1" + + + // $ANTLR start "rule__CastedExpression__TargetAssignment_3" + // InternalExport.g:23758:1: rule__CastedExpression__TargetAssignment_3 : ( ruleExpression ) ; + public final void rule__CastedExpression__TargetAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23762:1: ( ( ruleExpression ) ) + // InternalExport.g:23763:2: ( ruleExpression ) + { + // InternalExport.g:23763:2: ( ruleExpression ) + // InternalExport.g:23764:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__TargetAssignment_3" + + + // $ANTLR start "rule__ChainExpression__NextAssignment_1_2" + // InternalExport.g:23773:1: rule__ChainExpression__NextAssignment_1_2 : ( ruleChainedExpression ) ; + public final void rule__ChainExpression__NextAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23777:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:23778:2: ( ruleChainedExpression ) + { + // InternalExport.g:23778:2: ( ruleChainedExpression ) + // InternalExport.g:23779:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ChainExpression__NextAssignment_1_2" + + + // $ANTLR start "rule__IfExpressionTri__ThenPartAssignment_1_2" + // InternalExport.g:23788:1: rule__IfExpressionTri__ThenPartAssignment_1_2 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23792:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:23793:2: ( ruleChainedExpression ) + { + // InternalExport.g:23793:2: ( ruleChainedExpression ) + // InternalExport.g:23794:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__ThenPartAssignment_1_2" + + + // $ANTLR start "rule__IfExpressionTri__ElsePartAssignment_1_4" + // InternalExport.g:23803:1: rule__IfExpressionTri__ElsePartAssignment_1_4 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23807:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:23808:2: ( ruleChainedExpression ) + { + // InternalExport.g:23808:2: ( ruleChainedExpression ) + // InternalExport.g:23809:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__ElsePartAssignment_1_4" + + + // $ANTLR start "rule__IfExpressionKw__ConditionAssignment_1" + // InternalExport.g:23818:1: rule__IfExpressionKw__ConditionAssignment_1 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ConditionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23822:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:23823:2: ( ruleChainedExpression ) + { + // InternalExport.g:23823:2: ( ruleChainedExpression ) + // InternalExport.g:23824:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ConditionAssignment_1" + + + // $ANTLR start "rule__IfExpressionKw__ThenPartAssignment_3" + // InternalExport.g:23833:1: rule__IfExpressionKw__ThenPartAssignment_3 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ThenPartAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23837:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:23838:2: ( ruleChainedExpression ) + { + // InternalExport.g:23838:2: ( ruleChainedExpression ) + // InternalExport.g:23839:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ThenPartAssignment_3" + + + // $ANTLR start "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + // InternalExport.g:23848:1: rule__IfExpressionKw__ElsePartAssignment_4_0_1 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23852:1: ( ( ruleChainedExpression ) ) + // InternalExport.g:23853:2: ( ruleChainedExpression ) + { + // InternalExport.g:23853:2: ( ruleChainedExpression ) + // InternalExport.g:23854:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + + + // $ANTLR start "rule__SwitchExpression__SwitchExprAssignment_1_1" + // InternalExport.g:23863:1: rule__SwitchExpression__SwitchExprAssignment_1_1 : ( ruleOrExpression ) ; + public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23867:1: ( ( ruleOrExpression ) ) + // InternalExport.g:23868:2: ( ruleOrExpression ) + { + // InternalExport.g:23868:2: ( ruleOrExpression ) + // InternalExport.g:23869:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__SwitchExprAssignment_1_1" + + + // $ANTLR start "rule__SwitchExpression__CaseAssignment_3" + // InternalExport.g:23878:1: rule__SwitchExpression__CaseAssignment_3 : ( ruleCase ) ; + public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23882:1: ( ( ruleCase ) ) + // InternalExport.g:23883:2: ( ruleCase ) + { + // InternalExport.g:23883:2: ( ruleCase ) + // InternalExport.g:23884:3: ruleCase + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleCase(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__CaseAssignment_3" + + + // $ANTLR start "rule__SwitchExpression__DefaultExprAssignment_6" + // InternalExport.g:23893:1: rule__SwitchExpression__DefaultExprAssignment_6 : ( ruleOrExpression ) ; + public final void rule__SwitchExpression__DefaultExprAssignment_6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23897:1: ( ( ruleOrExpression ) ) + // InternalExport.g:23898:2: ( ruleOrExpression ) + { + // InternalExport.g:23898:2: ( ruleOrExpression ) + // InternalExport.g:23899:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__DefaultExprAssignment_6" + + + // $ANTLR start "rule__Case__ConditionAssignment_1" + // InternalExport.g:23908:1: rule__Case__ConditionAssignment_1 : ( ruleOrExpression ) ; + public final void rule__Case__ConditionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23912:1: ( ( ruleOrExpression ) ) + // InternalExport.g:23913:2: ( ruleOrExpression ) + { + // InternalExport.g:23913:2: ( ruleOrExpression ) + // InternalExport.g:23914:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Case__ConditionAssignment_1" + + + // $ANTLR start "rule__Case__ThenParAssignment_3" + // InternalExport.g:23923:1: rule__Case__ThenParAssignment_3 : ( ruleOrExpression ) ; + public final void rule__Case__ThenParAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23927:1: ( ( ruleOrExpression ) ) + // InternalExport.g:23928:2: ( ruleOrExpression ) + { + // InternalExport.g:23928:2: ( ruleOrExpression ) + // InternalExport.g:23929:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Case__ThenParAssignment_3" + + + // $ANTLR start "rule__OrExpression__OperatorAssignment_1_1" + // InternalExport.g:23938:1: rule__OrExpression__OperatorAssignment_1_1 : ( ( '||' ) ) ; + public final void rule__OrExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23942:1: ( ( ( '||' ) ) ) + // InternalExport.g:23943:2: ( ( '||' ) ) + { + // InternalExport.g:23943:2: ( ( '||' ) ) + // InternalExport.g:23944:3: ( '||' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + // InternalExport.g:23945:3: ( '||' ) + // InternalExport.g:23946:4: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + match(input,15,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OrExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__OrExpression__RightAssignment_1_2" + // InternalExport.g:23957:1: rule__OrExpression__RightAssignment_1_2 : ( ruleAndExpression ) ; + public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23961:1: ( ( ruleAndExpression ) ) + // InternalExport.g:23962:2: ( ruleAndExpression ) + { + // InternalExport.g:23962:2: ( ruleAndExpression ) + // InternalExport.g:23963:3: ruleAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OrExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__AndExpression__OperatorAssignment_1_1" + // InternalExport.g:23972:1: rule__AndExpression__OperatorAssignment_1_1 : ( ( '&&' ) ) ; + public final void rule__AndExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23976:1: ( ( ( '&&' ) ) ) + // InternalExport.g:23977:2: ( ( '&&' ) ) + { + // InternalExport.g:23977:2: ( ( '&&' ) ) + // InternalExport.g:23978:3: ( '&&' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + // InternalExport.g:23979:3: ( '&&' ) + // InternalExport.g:23980:4: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + match(input,16,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AndExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__AndExpression__RightAssignment_1_2" + // InternalExport.g:23991:1: rule__AndExpression__RightAssignment_1_2 : ( ruleImpliesExpression ) ; + public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:23995:1: ( ( ruleImpliesExpression ) ) + // InternalExport.g:23996:2: ( ruleImpliesExpression ) + { + // InternalExport.g:23996:2: ( ruleImpliesExpression ) + // InternalExport.g:23997:3: ruleImpliesExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleImpliesExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AndExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__ImpliesExpression__OperatorAssignment_1_1" + // InternalExport.g:24006:1: rule__ImpliesExpression__OperatorAssignment_1_1 : ( ( 'implies' ) ) ; + public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24010:1: ( ( ( 'implies' ) ) ) + // InternalExport.g:24011:2: ( ( 'implies' ) ) + { + // InternalExport.g:24011:2: ( ( 'implies' ) ) + // InternalExport.g:24012:3: ( 'implies' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + // InternalExport.g:24013:3: ( 'implies' ) + // InternalExport.g:24014:4: 'implies' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + match(input,114,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ImpliesExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__ImpliesExpression__RightAssignment_1_2" + // InternalExport.g:24025:1: rule__ImpliesExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; + public final void rule__ImpliesExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24029:1: ( ( ruleRelationalExpression ) ) + // InternalExport.g:24030:2: ( ruleRelationalExpression ) + { + // InternalExport.g:24030:2: ( ruleRelationalExpression ) + // InternalExport.g:24031:3: ruleRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ImpliesExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" + // InternalExport.g:24040:1: rule__RelationalExpression__OperatorAssignment_1_1 : ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ; + public final void rule__RelationalExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24044:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) + // InternalExport.g:24045:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + { + // InternalExport.g:24045:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalExport.g:24046:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + } + // InternalExport.g:24047:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalExport.g:24047:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__RelationalExpression__OperatorAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" + // InternalExport.g:24055:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; + public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24059:1: ( ( ruleAdditiveExpression ) ) + // InternalExport.g:24060:2: ( ruleAdditiveExpression ) + { + // InternalExport.g:24060:2: ( ruleAdditiveExpression ) + // InternalExport.g:24061:3: ruleAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__AdditiveExpression__NameAssignment_1_1" + // InternalExport.g:24070:1: rule__AdditiveExpression__NameAssignment_1_1 : ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ; + public final void rule__AdditiveExpression__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24074:1: ( ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ) + // InternalExport.g:24075:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + { + // InternalExport.g:24075:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + // InternalExport.g:24076:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + } + // InternalExport.g:24077:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + // InternalExport.g:24077:4: rule__AdditiveExpression__NameAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__AdditiveExpression__NameAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__NameAssignment_1_1" + + + // $ANTLR start "rule__AdditiveExpression__ParamsAssignment_1_2" + // InternalExport.g:24085:1: rule__AdditiveExpression__ParamsAssignment_1_2 : ( ruleMultiplicativeExpression ) ; + public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24089:1: ( ( ruleMultiplicativeExpression ) ) + // InternalExport.g:24090:2: ( ruleMultiplicativeExpression ) + { + // InternalExport.g:24090:2: ( ruleMultiplicativeExpression ) + // InternalExport.g:24091:3: ruleMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__ParamsAssignment_1_2" + + + // $ANTLR start "rule__MultiplicativeExpression__NameAssignment_1_1" + // InternalExport.g:24100:1: rule__MultiplicativeExpression__NameAssignment_1_1 : ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ; + public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24104:1: ( ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ) + // InternalExport.g:24105:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + { + // InternalExport.g:24105:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + // InternalExport.g:24106:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + } + // InternalExport.g:24107:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + // InternalExport.g:24107:4: rule__MultiplicativeExpression__NameAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__NameAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__NameAssignment_1_1" + + + // $ANTLR start "rule__MultiplicativeExpression__ParamsAssignment_1_2" + // InternalExport.g:24115:1: rule__MultiplicativeExpression__ParamsAssignment_1_2 : ( ruleUnaryOrInfixExpression ) ; + public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24119:1: ( ( ruleUnaryOrInfixExpression ) ) + // InternalExport.g:24120:2: ( ruleUnaryOrInfixExpression ) + { + // InternalExport.g:24120:2: ( ruleUnaryOrInfixExpression ) + // InternalExport.g:24121:3: ruleUnaryOrInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleUnaryOrInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__ParamsAssignment_1_2" + + + // $ANTLR start "rule__UnaryExpression__NameAssignment_0" + // InternalExport.g:24130:1: rule__UnaryExpression__NameAssignment_0 : ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ; + public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24134:1: ( ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ) + // InternalExport.g:24135:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + { + // InternalExport.g:24135:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + // InternalExport.g:24136:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + } + // InternalExport.g:24137:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + // InternalExport.g:24137:4: rule__UnaryExpression__NameAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__UnaryExpression__NameAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__NameAssignment_0" + + + // $ANTLR start "rule__UnaryExpression__ParamsAssignment_1" + // InternalExport.g:24145:1: rule__UnaryExpression__ParamsAssignment_1 : ( ruleInfixExpression ) ; + public final void rule__UnaryExpression__ParamsAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24149:1: ( ( ruleInfixExpression ) ) + // InternalExport.g:24150:2: ( ruleInfixExpression ) + { + // InternalExport.g:24150:2: ( ruleInfixExpression ) + // InternalExport.g:24151:3: ruleInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__ParamsAssignment_1" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_0_2" + // InternalExport.g:24160:1: rule__InfixExpression__NameAssignment_1_0_2 : ( ruleIdentifier ) ; + public final void rule__InfixExpression__NameAssignment_1_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24164:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24165:2: ( ruleIdentifier ) + { + // InternalExport.g:24165:2: ( ruleIdentifier ) + // InternalExport.g:24166:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_0_2" + + + // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_0" + // InternalExport.g:24175:1: rule__InfixExpression__ParamsAssignment_1_0_4_0 : ( ruleExpression ) ; + public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24179:1: ( ( ruleExpression ) ) + // InternalExport.g:24180:2: ( ruleExpression ) + { + // InternalExport.g:24180:2: ( ruleExpression ) + // InternalExport.g:24181:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_0" + + + // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + // InternalExport.g:24190:1: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 : ( ruleExpression ) ; + public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24194:1: ( ( ruleExpression ) ) + // InternalExport.g:24195:2: ( ruleExpression ) + { + // InternalExport.g:24195:2: ( ruleExpression ) + // InternalExport.g:24196:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + + + // $ANTLR start "rule__InfixExpression__TypeAssignment_1_1_2" + // InternalExport.g:24205:1: rule__InfixExpression__TypeAssignment_1_1_2 : ( ruleType ) ; + public final void rule__InfixExpression__TypeAssignment_1_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24209:1: ( ( ruleType ) ) + // InternalExport.g:24210:2: ( ruleType ) + { + // InternalExport.g:24210:2: ( ruleType ) + // InternalExport.g:24211:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__TypeAssignment_1_1_2" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_2_2" + // InternalExport.g:24220:1: rule__InfixExpression__NameAssignment_1_2_2 : ( ( 'typeSelect' ) ) ; + public final void rule__InfixExpression__NameAssignment_1_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24224:1: ( ( ( 'typeSelect' ) ) ) + // InternalExport.g:24225:2: ( ( 'typeSelect' ) ) + { + // InternalExport.g:24225:2: ( ( 'typeSelect' ) ) + // InternalExport.g:24226:3: ( 'typeSelect' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + // InternalExport.g:24227:3: ( 'typeSelect' ) + // InternalExport.g:24228:4: 'typeSelect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + match(input,115,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_2_2" + + + // $ANTLR start "rule__InfixExpression__TypeAssignment_1_2_4" + // InternalExport.g:24239:1: rule__InfixExpression__TypeAssignment_1_2_4 : ( ruleType ) ; + public final void rule__InfixExpression__TypeAssignment_1_2_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24243:1: ( ( ruleType ) ) + // InternalExport.g:24244:2: ( ruleType ) + { + // InternalExport.g:24244:2: ( ruleType ) + // InternalExport.g:24245:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__TypeAssignment_1_2_4" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_3_2" + // InternalExport.g:24254:1: rule__InfixExpression__NameAssignment_1_3_2 : ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ; + public final void rule__InfixExpression__NameAssignment_1_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24258:1: ( ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ) + // InternalExport.g:24259:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + { + // InternalExport.g:24259:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + // InternalExport.g:24260:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + } + // InternalExport.g:24261:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + // InternalExport.g:24261:4: rule__InfixExpression__NameAlternatives_1_3_2_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAlternatives_1_3_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_3_2" + + + // $ANTLR start "rule__InfixExpression__VarAssignment_1_3_4_0" + // InternalExport.g:24269:1: rule__InfixExpression__VarAssignment_1_3_4_0 : ( ruleIdentifier ) ; + public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24273:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24274:2: ( ruleIdentifier ) + { + // InternalExport.g:24274:2: ( ruleIdentifier ) + // InternalExport.g:24275:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__VarAssignment_1_3_4_0" + + + // $ANTLR start "rule__InfixExpression__ExpAssignment_1_3_5" + // InternalExport.g:24284:1: rule__InfixExpression__ExpAssignment_1_3_5 : ( ruleExpression ) ; + public final void rule__InfixExpression__ExpAssignment_1_3_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24288:1: ( ( ruleExpression ) ) + // InternalExport.g:24289:2: ( ruleExpression ) + { + // InternalExport.g:24289:2: ( ruleExpression ) + // InternalExport.g:24290:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ExpAssignment_1_3_5" + + + // $ANTLR start "rule__BooleanLiteral__ValAssignment" + // InternalExport.g:24299:1: rule__BooleanLiteral__ValAssignment : ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ; + public final void rule__BooleanLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24303:1: ( ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ) + // InternalExport.g:24304:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + { + // InternalExport.g:24304:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + // InternalExport.g:24305:3: ( rule__BooleanLiteral__ValAlternatives_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); + } + // InternalExport.g:24306:3: ( rule__BooleanLiteral__ValAlternatives_0 ) + // InternalExport.g:24306:4: rule__BooleanLiteral__ValAlternatives_0 + { + pushFollow(FOLLOW_2); + rule__BooleanLiteral__ValAlternatives_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BooleanLiteral__ValAssignment" + + + // $ANTLR start "rule__IntegerLiteral__ValAssignment" + // InternalExport.g:24314:1: rule__IntegerLiteral__ValAssignment : ( RULE_INT ) ; + public final void rule__IntegerLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24318:1: ( ( RULE_INT ) ) + // InternalExport.g:24319:2: ( RULE_INT ) + { + // InternalExport.g:24319:2: ( RULE_INT ) + // InternalExport.g:24320:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IntegerLiteral__ValAssignment" + + + // $ANTLR start "rule__NullLiteral__ValAssignment" + // InternalExport.g:24329:1: rule__NullLiteral__ValAssignment : ( ( 'null' ) ) ; + public final void rule__NullLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24333:1: ( ( ( 'null' ) ) ) + // InternalExport.g:24334:2: ( ( 'null' ) ) + { + // InternalExport.g:24334:2: ( ( 'null' ) ) + // InternalExport.g:24335:3: ( 'null' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + // InternalExport.g:24336:3: ( 'null' ) + // InternalExport.g:24337:4: 'null' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + match(input,100,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NullLiteral__ValAssignment" + + + // $ANTLR start "rule__RealLiteral__ValAssignment" + // InternalExport.g:24348:1: rule__RealLiteral__ValAssignment : ( RULE_REAL ) ; + public final void rule__RealLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24352:1: ( ( RULE_REAL ) ) + // InternalExport.g:24353:2: ( RULE_REAL ) + { + // InternalExport.g:24353:2: ( RULE_REAL ) + // InternalExport.g:24354:3: RULE_REAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + } + match(input,RULE_REAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RealLiteral__ValAssignment" + + + // $ANTLR start "rule__StringLiteral__ValAssignment" + // InternalExport.g:24363:1: rule__StringLiteral__ValAssignment : ( RULE_STRING ) ; + public final void rule__StringLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24367:1: ( ( RULE_STRING ) ) + // InternalExport.g:24368:2: ( RULE_STRING ) + { + // InternalExport.g:24368:2: ( RULE_STRING ) + // InternalExport.g:24369:3: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__StringLiteral__ValAssignment" + + + // $ANTLR start "rule__GlobalVarExpression__NameAssignment_1" + // InternalExport.g:24378:1: rule__GlobalVarExpression__NameAssignment_1 : ( ruleIdentifier ) ; + public final void rule__GlobalVarExpression__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24382:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24383:2: ( ruleIdentifier ) + { + // InternalExport.g:24383:2: ( ruleIdentifier ) + // InternalExport.g:24384:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__NameAssignment_1" + + + // $ANTLR start "rule__FeatureCall__TypeAssignment_1" + // InternalExport.g:24393:1: rule__FeatureCall__TypeAssignment_1 : ( ruleType ) ; + public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24397:1: ( ( ruleType ) ) + // InternalExport.g:24398:2: ( ruleType ) + { + // InternalExport.g:24398:2: ( ruleType ) + // InternalExport.g:24399:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FeatureCall__TypeAssignment_1" + + + // $ANTLR start "rule__OperationCall__NameAssignment_0" + // InternalExport.g:24408:1: rule__OperationCall__NameAssignment_0 : ( ruleIdentifier ) ; + public final void rule__OperationCall__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24412:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24413:2: ( ruleIdentifier ) + { + // InternalExport.g:24413:2: ( ruleIdentifier ) + // InternalExport.g:24414:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__NameAssignment_0" + + + // $ANTLR start "rule__OperationCall__ParamsAssignment_2_0" + // InternalExport.g:24423:1: rule__OperationCall__ParamsAssignment_2_0 : ( ruleExpression ) ; + public final void rule__OperationCall__ParamsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24427:1: ( ( ruleExpression ) ) + // InternalExport.g:24428:2: ( ruleExpression ) + { + // InternalExport.g:24428:2: ( ruleExpression ) + // InternalExport.g:24429:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__ParamsAssignment_2_0" + + + // $ANTLR start "rule__OperationCall__ParamsAssignment_2_1_1" + // InternalExport.g:24438:1: rule__OperationCall__ParamsAssignment_2_1_1 : ( ruleExpression ) ; + public final void rule__OperationCall__ParamsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24442:1: ( ( ruleExpression ) ) + // InternalExport.g:24443:2: ( ruleExpression ) + { + // InternalExport.g:24443:2: ( ruleExpression ) + // InternalExport.g:24444:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__ParamsAssignment_2_1_1" + + + // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_0" + // InternalExport.g:24453:1: rule__ListLiteral__ElementsAssignment_2_0 : ( ruleExpression ) ; + public final void rule__ListLiteral__ElementsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24457:1: ( ( ruleExpression ) ) + // InternalExport.g:24458:2: ( ruleExpression ) + { + // InternalExport.g:24458:2: ( ruleExpression ) + // InternalExport.g:24459:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_0" + + + // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_1_1" + // InternalExport.g:24468:1: rule__ListLiteral__ElementsAssignment_2_1_1 : ( ruleExpression ) ; + public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24472:1: ( ( ruleExpression ) ) + // InternalExport.g:24473:2: ( ruleExpression ) + { + // InternalExport.g:24473:2: ( ruleExpression ) + // InternalExport.g:24474:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_1_1" + + + // $ANTLR start "rule__ConstructorCallExpression__TypeAssignment_1" + // InternalExport.g:24483:1: rule__ConstructorCallExpression__TypeAssignment_1 : ( ruleSimpleType ) ; + public final void rule__ConstructorCallExpression__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24487:1: ( ( ruleSimpleType ) ) + // InternalExport.g:24488:2: ( ruleSimpleType ) + { + // InternalExport.g:24488:2: ( ruleSimpleType ) + // InternalExport.g:24489:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__TypeAssignment_1" + + + // $ANTLR start "rule__TypeSelectExpression__NameAssignment_0" + // InternalExport.g:24498:1: rule__TypeSelectExpression__NameAssignment_0 : ( ( 'typeSelect' ) ) ; + public final void rule__TypeSelectExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24502:1: ( ( ( 'typeSelect' ) ) ) + // InternalExport.g:24503:2: ( ( 'typeSelect' ) ) + { + // InternalExport.g:24503:2: ( ( 'typeSelect' ) ) + // InternalExport.g:24504:3: ( 'typeSelect' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + // InternalExport.g:24505:3: ( 'typeSelect' ) + // InternalExport.g:24506:4: 'typeSelect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + match(input,115,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__NameAssignment_0" + + + // $ANTLR start "rule__TypeSelectExpression__TypeAssignment_2" + // InternalExport.g:24517:1: rule__TypeSelectExpression__TypeAssignment_2 : ( ruleType ) ; + public final void rule__TypeSelectExpression__TypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24521:1: ( ( ruleType ) ) + // InternalExport.g:24522:2: ( ruleType ) + { + // InternalExport.g:24522:2: ( ruleType ) + // InternalExport.g:24523:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__TypeAssignment_2" + + + // $ANTLR start "rule__CollectionExpression__NameAssignment_0" + // InternalExport.g:24532:1: rule__CollectionExpression__NameAssignment_0 : ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ; + public final void rule__CollectionExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24536:1: ( ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ) + // InternalExport.g:24537:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + { + // InternalExport.g:24537:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + // InternalExport.g:24538:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + } + // InternalExport.g:24539:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + // InternalExport.g:24539:4: rule__CollectionExpression__NameAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__NameAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__NameAssignment_0" + + + // $ANTLR start "rule__CollectionExpression__VarAssignment_2_0" + // InternalExport.g:24547:1: rule__CollectionExpression__VarAssignment_2_0 : ( ruleIdentifier ) ; + public final void rule__CollectionExpression__VarAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24551:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24552:2: ( ruleIdentifier ) + { + // InternalExport.g:24552:2: ( ruleIdentifier ) + // InternalExport.g:24553:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__VarAssignment_2_0" + + + // $ANTLR start "rule__CollectionExpression__ExpAssignment_3" + // InternalExport.g:24562:1: rule__CollectionExpression__ExpAssignment_3 : ( ruleExpression ) ; + public final void rule__CollectionExpression__ExpAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24566:1: ( ( ruleExpression ) ) + // InternalExport.g:24567:2: ( ruleExpression ) + { + // InternalExport.g:24567:2: ( ruleExpression ) + // InternalExport.g:24568:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__ExpAssignment_3" + + + // $ANTLR start "rule__CollectionType__ClAssignment_0" + // InternalExport.g:24577:1: rule__CollectionType__ClAssignment_0 : ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ; + public final void rule__CollectionType__ClAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24581:1: ( ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ) + // InternalExport.g:24582:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) + { + // InternalExport.g:24582:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) + // InternalExport.g:24583:3: ( rule__CollectionType__ClAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); + } + // InternalExport.g:24584:3: ( rule__CollectionType__ClAlternatives_0_0 ) + // InternalExport.g:24584:4: rule__CollectionType__ClAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__CollectionType__ClAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__ClAssignment_0" + + + // $ANTLR start "rule__CollectionType__Id1Assignment_2" + // InternalExport.g:24592:1: rule__CollectionType__Id1Assignment_2 : ( ruleSimpleType ) ; + public final void rule__CollectionType__Id1Assignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24596:1: ( ( ruleSimpleType ) ) + // InternalExport.g:24597:2: ( ruleSimpleType ) + { + // InternalExport.g:24597:2: ( ruleSimpleType ) + // InternalExport.g:24598:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Id1Assignment_2" + + + // $ANTLR start "rule__SimpleType__IdAssignment_0" + // InternalExport.g:24607:1: rule__SimpleType__IdAssignment_0 : ( ruleIdentifier ) ; + public final void rule__SimpleType__IdAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24611:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24612:2: ( ruleIdentifier ) + { + // InternalExport.g:24612:2: ( ruleIdentifier ) + // InternalExport.g:24613:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__IdAssignment_0" + + + // $ANTLR start "rule__SimpleType__IdAssignment_1_1" + // InternalExport.g:24622:1: rule__SimpleType__IdAssignment_1_1 : ( ruleIdentifier ) ; + public final void rule__SimpleType__IdAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24626:1: ( ( ruleIdentifier ) ) + // InternalExport.g:24627:2: ( ruleIdentifier ) + { + // InternalExport.g:24627:2: ( ruleIdentifier ) + // InternalExport.g:24628:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__IdAssignment_1_1" + + + // $ANTLR start "rule__XAssignment__FeatureAssignment_0_1" + // InternalExport.g:24637:1: rule__XAssignment__FeatureAssignment_0_1 : ( ( ruleFeatureCallID ) ) ; + public final void rule__XAssignment__FeatureAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24641:1: ( ( ( ruleFeatureCallID ) ) ) + // InternalExport.g:24642:2: ( ( ruleFeatureCallID ) ) + { + // InternalExport.g:24642:2: ( ( ruleFeatureCallID ) ) + // InternalExport.g:24643:3: ( ruleFeatureCallID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + // InternalExport.g:24644:3: ( ruleFeatureCallID ) + // InternalExport.g:24645:4: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__FeatureAssignment_0_1" + + + // $ANTLR start "rule__XAssignment__ValueAssignment_0_3" + // InternalExport.g:24656:1: rule__XAssignment__ValueAssignment_0_3 : ( ruleXAssignment ) ; + public final void rule__XAssignment__ValueAssignment_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24660:1: ( ( ruleXAssignment ) ) + // InternalExport.g:24661:2: ( ruleXAssignment ) + { + // InternalExport.g:24661:2: ( ruleXAssignment ) + // InternalExport.g:24662:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__ValueAssignment_0_3" + + + // $ANTLR start "rule__XAssignment__FeatureAssignment_1_1_0_0_1" + // InternalExport.g:24671:1: rule__XAssignment__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpMultiAssign ) ) ; + public final void rule__XAssignment__FeatureAssignment_1_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24675:1: ( ( ( ruleOpMultiAssign ) ) ) + // InternalExport.g:24676:2: ( ( ruleOpMultiAssign ) ) + { + // InternalExport.g:24676:2: ( ( ruleOpMultiAssign ) ) + // InternalExport.g:24677:3: ( ruleOpMultiAssign ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + // InternalExport.g:24678:3: ( ruleOpMultiAssign ) + // InternalExport.g:24679:4: ruleOpMultiAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__FeatureAssignment_1_1_0_0_1" + + + // $ANTLR start "rule__XAssignment__RightOperandAssignment_1_1_1" + // InternalExport.g:24690:1: rule__XAssignment__RightOperandAssignment_1_1_1 : ( ruleXAssignment ) ; + public final void rule__XAssignment__RightOperandAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24694:1: ( ( ruleXAssignment ) ) + // InternalExport.g:24695:2: ( ruleXAssignment ) + { + // InternalExport.g:24695:2: ( ruleXAssignment ) + // InternalExport.g:24696:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__RightOperandAssignment_1_1_1" + + + // $ANTLR start "rule__XOrExpression__FeatureAssignment_1_0_0_1" + // InternalExport.g:24705:1: rule__XOrExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOr ) ) ; + public final void rule__XOrExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24709:1: ( ( ( ruleOpOr ) ) ) + // InternalExport.g:24710:2: ( ( ruleOpOr ) ) + { + // InternalExport.g:24710:2: ( ( ruleOpOr ) ) + // InternalExport.g:24711:3: ( ruleOpOr ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExport.g:24712:3: ( ruleOpOr ) + // InternalExport.g:24713:4: ruleOpOr + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XOrExpression__RightOperandAssignment_1_1" + // InternalExport.g:24724:1: rule__XOrExpression__RightOperandAssignment_1_1 : ( ruleXAndExpression ) ; + public final void rule__XOrExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24728:1: ( ( ruleXAndExpression ) ) + // InternalExport.g:24729:2: ( ruleXAndExpression ) + { + // InternalExport.g:24729:2: ( ruleXAndExpression ) + // InternalExport.g:24730:3: ruleXAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XAndExpression__FeatureAssignment_1_0_0_1" + // InternalExport.g:24739:1: rule__XAndExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAnd ) ) ; + public final void rule__XAndExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24743:1: ( ( ( ruleOpAnd ) ) ) + // InternalExport.g:24744:2: ( ( ruleOpAnd ) ) + { + // InternalExport.g:24744:2: ( ( ruleOpAnd ) ) + // InternalExport.g:24745:3: ( ruleOpAnd ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExport.g:24746:3: ( ruleOpAnd ) + // InternalExport.g:24747:4: ruleOpAnd + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XAndExpression__RightOperandAssignment_1_1" + // InternalExport.g:24758:1: rule__XAndExpression__RightOperandAssignment_1_1 : ( ruleXEqualityExpression ) ; + public final void rule__XAndExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24762:1: ( ( ruleXEqualityExpression ) ) + // InternalExport.g:24763:2: ( ruleXEqualityExpression ) + { + // InternalExport.g:24763:2: ( ruleXEqualityExpression ) + // InternalExport.g:24764:3: ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XEqualityExpression__FeatureAssignment_1_0_0_1" + // InternalExport.g:24773:1: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpEquality ) ) ; + public final void rule__XEqualityExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24777:1: ( ( ( ruleOpEquality ) ) ) + // InternalExport.g:24778:2: ( ( ruleOpEquality ) ) + { + // InternalExport.g:24778:2: ( ( ruleOpEquality ) ) + // InternalExport.g:24779:3: ( ruleOpEquality ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExport.g:24780:3: ( ruleOpEquality ) + // InternalExport.g:24781:4: ruleOpEquality + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XEqualityExpression__RightOperandAssignment_1_1" + // InternalExport.g:24792:1: rule__XEqualityExpression__RightOperandAssignment_1_1 : ( ruleXRelationalExpression ) ; + public final void rule__XEqualityExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24796:1: ( ( ruleXRelationalExpression ) ) + // InternalExport.g:24797:2: ( ruleXRelationalExpression ) + { + // InternalExport.g:24797:2: ( ruleXRelationalExpression ) + // InternalExport.g:24798:3: ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XRelationalExpression__TypeAssignment_1_0_1" + // InternalExport.g:24807:1: rule__XRelationalExpression__TypeAssignment_1_0_1 : ( ruleJvmTypeReference ) ; + public final void rule__XRelationalExpression__TypeAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24811:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:24812:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:24812:2: ( ruleJvmTypeReference ) + // InternalExport.g:24813:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__TypeAssignment_1_0_1" + + + // $ANTLR start "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1" + // InternalExport.g:24822:1: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpCompare ) ) ; + public final void rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24826:1: ( ( ( ruleOpCompare ) ) ) + // InternalExport.g:24827:2: ( ( ruleOpCompare ) ) + { + // InternalExport.g:24827:2: ( ( ruleOpCompare ) ) + // InternalExport.g:24828:3: ( ruleOpCompare ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + // InternalExport.g:24829:3: ( ruleOpCompare ) + // InternalExport.g:24830:4: ruleOpCompare + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1" + + + // $ANTLR start "rule__XRelationalExpression__RightOperandAssignment_1_1_1" + // InternalExport.g:24841:1: rule__XRelationalExpression__RightOperandAssignment_1_1_1 : ( ruleXOtherOperatorExpression ) ; + public final void rule__XRelationalExpression__RightOperandAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24845:1: ( ( ruleXOtherOperatorExpression ) ) + // InternalExport.g:24846:2: ( ruleXOtherOperatorExpression ) + { + // InternalExport.g:24846:2: ( ruleXOtherOperatorExpression ) + // InternalExport.g:24847:3: ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__RightOperandAssignment_1_1_1" + + + // $ANTLR start "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1" + // InternalExport.g:24856:1: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOther ) ) ; + public final void rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24860:1: ( ( ( ruleOpOther ) ) ) + // InternalExport.g:24861:2: ( ( ruleOpOther ) ) + { + // InternalExport.g:24861:2: ( ( ruleOpOther ) ) + // InternalExport.g:24862:3: ( ruleOpOther ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExport.g:24863:3: ( ruleOpOther ) + // InternalExport.g:24864:4: ruleOpOther + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XOtherOperatorExpression__RightOperandAssignment_1_1" + // InternalExport.g:24875:1: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 : ( ruleXAdditiveExpression ) ; + public final void rule__XOtherOperatorExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24879:1: ( ( ruleXAdditiveExpression ) ) + // InternalExport.g:24880:2: ( ruleXAdditiveExpression ) + { + // InternalExport.g:24880:2: ( ruleXAdditiveExpression ) + // InternalExport.g:24881:3: ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1" + // InternalExport.g:24890:1: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAdd ) ) ; + public final void rule__XAdditiveExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24894:1: ( ( ( ruleOpAdd ) ) ) + // InternalExport.g:24895:2: ( ( ruleOpAdd ) ) + { + // InternalExport.g:24895:2: ( ( ruleOpAdd ) ) + // InternalExport.g:24896:3: ( ruleOpAdd ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExport.g:24897:3: ( ruleOpAdd ) + // InternalExport.g:24898:4: ruleOpAdd + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XAdditiveExpression__RightOperandAssignment_1_1" + // InternalExport.g:24909:1: rule__XAdditiveExpression__RightOperandAssignment_1_1 : ( ruleXMultiplicativeExpression ) ; + public final void rule__XAdditiveExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24913:1: ( ( ruleXMultiplicativeExpression ) ) + // InternalExport.g:24914:2: ( ruleXMultiplicativeExpression ) + { + // InternalExport.g:24914:2: ( ruleXMultiplicativeExpression ) + // InternalExport.g:24915:3: ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1" + // InternalExport.g:24924:1: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpMulti ) ) ; + public final void rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24928:1: ( ( ( ruleOpMulti ) ) ) + // InternalExport.g:24929:2: ( ( ruleOpMulti ) ) + { + // InternalExport.g:24929:2: ( ( ruleOpMulti ) ) + // InternalExport.g:24930:3: ( ruleOpMulti ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExport.g:24931:3: ( ruleOpMulti ) + // InternalExport.g:24932:4: ruleOpMulti + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XMultiplicativeExpression__RightOperandAssignment_1_1" + // InternalExport.g:24943:1: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 : ( ruleXUnaryOperation ) ; + public final void rule__XMultiplicativeExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24947:1: ( ( ruleXUnaryOperation ) ) + // InternalExport.g:24948:2: ( ruleXUnaryOperation ) + { + // InternalExport.g:24948:2: ( ruleXUnaryOperation ) + // InternalExport.g:24949:3: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XUnaryOperation__FeatureAssignment_0_1" + // InternalExport.g:24958:1: rule__XUnaryOperation__FeatureAssignment_0_1 : ( ( ruleOpUnary ) ) ; + public final void rule__XUnaryOperation__FeatureAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24962:1: ( ( ( ruleOpUnary ) ) ) + // InternalExport.g:24963:2: ( ( ruleOpUnary ) ) + { + // InternalExport.g:24963:2: ( ( ruleOpUnary ) ) + // InternalExport.g:24964:3: ( ruleOpUnary ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + // InternalExport.g:24965:3: ( ruleOpUnary ) + // InternalExport.g:24966:4: ruleOpUnary + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__FeatureAssignment_0_1" + + + // $ANTLR start "rule__XUnaryOperation__OperandAssignment_0_2" + // InternalExport.g:24977:1: rule__XUnaryOperation__OperandAssignment_0_2 : ( ruleXUnaryOperation ) ; + public final void rule__XUnaryOperation__OperandAssignment_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24981:1: ( ( ruleXUnaryOperation ) ) + // InternalExport.g:24982:2: ( ruleXUnaryOperation ) + { + // InternalExport.g:24982:2: ( ruleXUnaryOperation ) + // InternalExport.g:24983:3: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__OperandAssignment_0_2" + + + // $ANTLR start "rule__XCastedExpression__TypeAssignment_1_1" + // InternalExport.g:24992:1: rule__XCastedExpression__TypeAssignment_1_1 : ( ruleJvmTypeReference ) ; + public final void rule__XCastedExpression__TypeAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:24996:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:24997:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:24997:2: ( ruleJvmTypeReference ) + // InternalExport.g:24998:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__TypeAssignment_1_1" + + + // $ANTLR start "rule__XPostfixOperation__FeatureAssignment_1_0_1" + // InternalExport.g:25007:1: rule__XPostfixOperation__FeatureAssignment_1_0_1 : ( ( ruleOpPostfix ) ) ; + public final void rule__XPostfixOperation__FeatureAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25011:1: ( ( ( ruleOpPostfix ) ) ) + // InternalExport.g:25012:2: ( ( ruleOpPostfix ) ) + { + // InternalExport.g:25012:2: ( ( ruleOpPostfix ) ) + // InternalExport.g:25013:3: ( ruleOpPostfix ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + // InternalExport.g:25014:3: ( ruleOpPostfix ) + // InternalExport.g:25015:4: ruleOpPostfix + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__FeatureAssignment_1_0_1" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1" + // InternalExport.g:25026:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 : ( ( '::' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25030:1: ( ( ( '::' ) ) ) + // InternalExport.g:25031:2: ( ( '::' ) ) + { + // InternalExport.g:25031:2: ( ( '::' ) ) + // InternalExport.g:25032:3: ( '::' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + // InternalExport.g:25033:3: ( '::' ) + // InternalExport.g:25034:4: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2" + // InternalExport.g:25045:1: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 : ( ( ruleFeatureCallID ) ) ; + public final void rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25049:1: ( ( ( ruleFeatureCallID ) ) ) + // InternalExport.g:25050:2: ( ( ruleFeatureCallID ) ) + { + // InternalExport.g:25050:2: ( ( ruleFeatureCallID ) ) + // InternalExport.g:25051:3: ( ruleFeatureCallID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + // InternalExport.g:25052:3: ( ruleFeatureCallID ) + // InternalExport.g:25053:4: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2" + + + // $ANTLR start "rule__XMemberFeatureCall__ValueAssignment_1_0_1" + // InternalExport.g:25064:1: rule__XMemberFeatureCall__ValueAssignment_1_0_1 : ( ruleXAssignment ) ; + public final void rule__XMemberFeatureCall__ValueAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25068:1: ( ( ruleXAssignment ) ) + // InternalExport.g:25069:2: ( ruleXAssignment ) + { + // InternalExport.g:25069:2: ( ruleXAssignment ) + // InternalExport.g:25070:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ValueAssignment_1_0_1" + + + // $ANTLR start "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1" + // InternalExport.g:25079:1: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 : ( ( '?.' ) ) ; + public final void rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25083:1: ( ( ( '?.' ) ) ) + // InternalExport.g:25084:2: ( ( '?.' ) ) + { + // InternalExport.g:25084:2: ( ( '?.' ) ) + // InternalExport.g:25085:3: ( '?.' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + // InternalExport.g:25086:3: ( '?.' ) + // InternalExport.g:25087:4: '?.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + match(input,116,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2" + // InternalExport.g:25098:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 : ( ( '::' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25102:1: ( ( ( '::' ) ) ) + // InternalExport.g:25103:2: ( ( '::' ) ) + { + // InternalExport.g:25103:2: ( ( '::' ) ) + // InternalExport.g:25104:3: ( '::' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + // InternalExport.g:25105:3: ( '::' ) + // InternalExport.g:25106:4: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2" + + + // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1" + // InternalExport.g:25117:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25121:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:25122:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:25122:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:25123:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1" + // InternalExport.g:25132:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25136:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:25137:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:25137:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:25138:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1" + + + // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_1_2" + // InternalExport.g:25147:1: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 : ( ( ruleIdOrSuper ) ) ; + public final void rule__XMemberFeatureCall__FeatureAssignment_1_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25151:1: ( ( ( ruleIdOrSuper ) ) ) + // InternalExport.g:25152:2: ( ( ruleIdOrSuper ) ) + { + // InternalExport.g:25152:2: ( ( ruleIdOrSuper ) ) + // InternalExport.g:25153:3: ( ruleIdOrSuper ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + // InternalExport.g:25154:3: ( ruleIdOrSuper ) + // InternalExport.g:25155:4: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_1_2" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0" + // InternalExport.g:25166:1: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 : ( ( '(' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25170:1: ( ( ( '(' ) ) ) + // InternalExport.g:25171:2: ( ( '(' ) ) + { + // InternalExport.g:25171:2: ( ( '(' ) ) + // InternalExport.g:25172:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + // InternalExport.g:25173:3: ( '(' ) + // InternalExport.g:25174:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0" + // InternalExport.g:25185:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 : ( ruleXShortClosure ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25189:1: ( ( ruleXShortClosure ) ) + // InternalExport.g:25190:2: ( ruleXShortClosure ) + { + // InternalExport.g:25190:2: ( ruleXShortClosure ) + // InternalExport.g:25191:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0" + // InternalExport.g:25200:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 : ( ruleXExpression ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25204:1: ( ( ruleXExpression ) ) + // InternalExport.g:25205:2: ( ruleXExpression ) + { + // InternalExport.g:25205:2: ( ruleXExpression ) + // InternalExport.g:25206:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1" + // InternalExport.g:25215:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25219:1: ( ( ruleXExpression ) ) + // InternalExport.g:25220:2: ( ruleXExpression ) + { + // InternalExport.g:25220:2: ( ruleXExpression ) + // InternalExport.g:25221:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4" + // InternalExport.g:25230:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 : ( ruleXClosure ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25234:1: ( ( ruleXClosure ) ) + // InternalExport.g:25235:2: ( ruleXClosure ) + { + // InternalExport.g:25235:2: ( ruleXClosure ) + // InternalExport.g:25236:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4" + + + // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_0" + // InternalExport.g:25245:1: rule__XSetLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ; + public final void rule__XSetLiteral__ElementsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25249:1: ( ( ruleXExpression ) ) + // InternalExport.g:25250:2: ( ruleXExpression ) + { + // InternalExport.g:25250:2: ( ruleXExpression ) + // InternalExport.g:25251:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_0" + + + // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_1_1" + // InternalExport.g:25260:1: rule__XSetLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XSetLiteral__ElementsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25264:1: ( ( ruleXExpression ) ) + // InternalExport.g:25265:2: ( ruleXExpression ) + { + // InternalExport.g:25265:2: ( ruleXExpression ) + // InternalExport.g:25266:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_1_1" + + + // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_0" + // InternalExport.g:25275:1: rule__XListLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ; + public final void rule__XListLiteral__ElementsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25279:1: ( ( ruleXExpression ) ) + // InternalExport.g:25280:2: ( ruleXExpression ) + { + // InternalExport.g:25280:2: ( ruleXExpression ) + // InternalExport.g:25281:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_0" + + + // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_1_1" + // InternalExport.g:25290:1: rule__XListLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XListLiteral__ElementsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25294:1: ( ( ruleXExpression ) ) + // InternalExport.g:25295:2: ( ruleXExpression ) + { + // InternalExport.g:25295:2: ( ruleXExpression ) + // InternalExport.g:25296:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_1_1" + + + // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0" + // InternalExport.g:25305:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25309:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25310:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25310:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25311:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0" + + + // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1" + // InternalExport.g:25320:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25324:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25325:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25325:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25326:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1" + + + // $ANTLR start "rule__XClosure__ExplicitSyntaxAssignment_1_0_1" + // InternalExport.g:25335:1: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 : ( ( '|' ) ) ; + public final void rule__XClosure__ExplicitSyntaxAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25339:1: ( ( ( '|' ) ) ) + // InternalExport.g:25340:2: ( ( '|' ) ) + { + // InternalExport.g:25340:2: ( ( '|' ) ) + // InternalExport.g:25341:3: ( '|' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + // InternalExport.g:25342:3: ( '|' ) + // InternalExport.g:25343:4: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__ExplicitSyntaxAssignment_1_0_1" + + + // $ANTLR start "rule__XClosure__ExpressionAssignment_2" + // InternalExport.g:25354:1: rule__XClosure__ExpressionAssignment_2 : ( ruleXExpressionInClosure ) ; + public final void rule__XClosure__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25358:1: ( ( ruleXExpressionInClosure ) ) + // InternalExport.g:25359:2: ( ruleXExpressionInClosure ) + { + // InternalExport.g:25359:2: ( ruleXExpressionInClosure ) + // InternalExport.g:25360:3: ruleXExpressionInClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__ExpressionAssignment_2" + + + // $ANTLR start "rule__XExpressionInClosure__ExpressionsAssignment_1_0" + // InternalExport.g:25369:1: rule__XExpressionInClosure__ExpressionsAssignment_1_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XExpressionInClosure__ExpressionsAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25373:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:25374:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:25374:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExport.g:25375:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__ExpressionsAssignment_1_0" + + + // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0" + // InternalExport.g:25384:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25388:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25389:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25389:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25390:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0" + + + // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1" + // InternalExport.g:25399:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25403:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25404:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25404:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25405:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1" + + + // $ANTLR start "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2" + // InternalExport.g:25414:1: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 : ( ( '|' ) ) ; + public final void rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25418:1: ( ( ( '|' ) ) ) + // InternalExport.g:25419:2: ( ( '|' ) ) + { + // InternalExport.g:25419:2: ( ( '|' ) ) + // InternalExport.g:25420:3: ( '|' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + // InternalExport.g:25421:3: ( '|' ) + // InternalExport.g:25422:4: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2" + + + // $ANTLR start "rule__XShortClosure__ExpressionAssignment_1" + // InternalExport.g:25433:1: rule__XShortClosure__ExpressionAssignment_1 : ( ruleXExpression ) ; + public final void rule__XShortClosure__ExpressionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25437:1: ( ( ruleXExpression ) ) + // InternalExport.g:25438:2: ( ruleXExpression ) + { + // InternalExport.g:25438:2: ( ruleXExpression ) + // InternalExport.g:25439:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__ExpressionAssignment_1" + + + // $ANTLR start "rule__XIfExpression__IfAssignment_3" + // InternalExport.g:25448:1: rule__XIfExpression__IfAssignment_3 : ( ruleXExpression ) ; + public final void rule__XIfExpression__IfAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25452:1: ( ( ruleXExpression ) ) + // InternalExport.g:25453:2: ( ruleXExpression ) + { + // InternalExport.g:25453:2: ( ruleXExpression ) + // InternalExport.g:25454:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__IfAssignment_3" + + + // $ANTLR start "rule__XIfExpression__ThenAssignment_5" + // InternalExport.g:25463:1: rule__XIfExpression__ThenAssignment_5 : ( ruleXExpression ) ; + public final void rule__XIfExpression__ThenAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25467:1: ( ( ruleXExpression ) ) + // InternalExport.g:25468:2: ( ruleXExpression ) + { + // InternalExport.g:25468:2: ( ruleXExpression ) + // InternalExport.g:25469:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__ThenAssignment_5" + + + // $ANTLR start "rule__XIfExpression__ElseAssignment_6_1" + // InternalExport.g:25478:1: rule__XIfExpression__ElseAssignment_6_1 : ( ruleXExpression ) ; + public final void rule__XIfExpression__ElseAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25482:1: ( ( ruleXExpression ) ) + // InternalExport.g:25483:2: ( ruleXExpression ) + { + // InternalExport.g:25483:2: ( ruleXExpression ) + // InternalExport.g:25484:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__ElseAssignment_6_1" + + + // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1" + // InternalExport.g:25493:1: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25497:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25498:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25498:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25499:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1" + + + // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_0_1" + // InternalExport.g:25508:1: rule__XSwitchExpression__SwitchAssignment_2_0_1 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__SwitchAssignment_2_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25512:1: ( ( ruleXExpression ) ) + // InternalExport.g:25513:2: ( ruleXExpression ) + { + // InternalExport.g:25513:2: ( ruleXExpression ) + // InternalExport.g:25514:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_0_1" + + + // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0" + // InternalExport.g:25523:1: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25527:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25528:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25528:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25529:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0" + + + // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_1_1" + // InternalExport.g:25538:1: rule__XSwitchExpression__SwitchAssignment_2_1_1 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__SwitchAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25542:1: ( ( ruleXExpression ) ) + // InternalExport.g:25543:2: ( ruleXExpression ) + { + // InternalExport.g:25543:2: ( ruleXExpression ) + // InternalExport.g:25544:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_1_1" + + + // $ANTLR start "rule__XSwitchExpression__CasesAssignment_4" + // InternalExport.g:25553:1: rule__XSwitchExpression__CasesAssignment_4 : ( ruleXCasePart ) ; + public final void rule__XSwitchExpression__CasesAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25557:1: ( ( ruleXCasePart ) ) + // InternalExport.g:25558:2: ( ruleXCasePart ) + { + // InternalExport.g:25558:2: ( ruleXCasePart ) + // InternalExport.g:25559:3: ruleXCasePart + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXCasePart(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__CasesAssignment_4" + + + // $ANTLR start "rule__XSwitchExpression__DefaultAssignment_5_2" + // InternalExport.g:25568:1: rule__XSwitchExpression__DefaultAssignment_5_2 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__DefaultAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25572:1: ( ( ruleXExpression ) ) + // InternalExport.g:25573:2: ( ruleXExpression ) + { + // InternalExport.g:25573:2: ( ruleXExpression ) + // InternalExport.g:25574:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DefaultAssignment_5_2" + + + // $ANTLR start "rule__XCasePart__TypeGuardAssignment_1" + // InternalExport.g:25583:1: rule__XCasePart__TypeGuardAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__XCasePart__TypeGuardAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25587:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:25588:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:25588:2: ( ruleJvmTypeReference ) + // InternalExport.g:25589:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__TypeGuardAssignment_1" + + + // $ANTLR start "rule__XCasePart__CaseAssignment_2_1" + // InternalExport.g:25598:1: rule__XCasePart__CaseAssignment_2_1 : ( ruleXExpression ) ; + public final void rule__XCasePart__CaseAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25602:1: ( ( ruleXExpression ) ) + // InternalExport.g:25603:2: ( ruleXExpression ) + { + // InternalExport.g:25603:2: ( ruleXExpression ) + // InternalExport.g:25604:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__CaseAssignment_2_1" + + + // $ANTLR start "rule__XCasePart__ThenAssignment_3_0_1" + // InternalExport.g:25613:1: rule__XCasePart__ThenAssignment_3_0_1 : ( ruleXExpression ) ; + public final void rule__XCasePart__ThenAssignment_3_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25617:1: ( ( ruleXExpression ) ) + // InternalExport.g:25618:2: ( ruleXExpression ) + { + // InternalExport.g:25618:2: ( ruleXExpression ) + // InternalExport.g:25619:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__ThenAssignment_3_0_1" + + + // $ANTLR start "rule__XCasePart__FallThroughAssignment_3_1" + // InternalExport.g:25628:1: rule__XCasePart__FallThroughAssignment_3_1 : ( ( ',' ) ) ; + public final void rule__XCasePart__FallThroughAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25632:1: ( ( ( ',' ) ) ) + // InternalExport.g:25633:2: ( ( ',' ) ) + { + // InternalExport.g:25633:2: ( ( ',' ) ) + // InternalExport.g:25634:3: ( ',' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + // InternalExport.g:25635:3: ( ',' ) + // InternalExport.g:25636:4: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__FallThroughAssignment_3_1" + + + // $ANTLR start "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3" + // InternalExport.g:25647:1: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 : ( ruleJvmFormalParameter ) ; + public final void rule__XForLoopExpression__DeclaredParamAssignment_0_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25651:1: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:25652:2: ( ruleJvmFormalParameter ) + { + // InternalExport.g:25652:2: ( ruleJvmFormalParameter ) + // InternalExport.g:25653:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3" + + + // $ANTLR start "rule__XForLoopExpression__ForExpressionAssignment_1" + // InternalExport.g:25662:1: rule__XForLoopExpression__ForExpressionAssignment_1 : ( ruleXExpression ) ; + public final void rule__XForLoopExpression__ForExpressionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25666:1: ( ( ruleXExpression ) ) + // InternalExport.g:25667:2: ( ruleXExpression ) + { + // InternalExport.g:25667:2: ( ruleXExpression ) + // InternalExport.g:25668:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__ForExpressionAssignment_1" + + + // $ANTLR start "rule__XForLoopExpression__EachExpressionAssignment_3" + // InternalExport.g:25677:1: rule__XForLoopExpression__EachExpressionAssignment_3 : ( ruleXExpression ) ; + public final void rule__XForLoopExpression__EachExpressionAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25681:1: ( ( ruleXExpression ) ) + // InternalExport.g:25682:2: ( ruleXExpression ) + { + // InternalExport.g:25682:2: ( ruleXExpression ) + // InternalExport.g:25683:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__EachExpressionAssignment_3" + + + // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0" + // InternalExport.g:25692:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25696:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:25697:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:25697:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExport.g:25698:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0" + + + // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1" + // InternalExport.g:25707:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25711:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:25712:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:25712:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExport.g:25713:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1" + + + // $ANTLR start "rule__XBasicForLoopExpression__ExpressionAssignment_5" + // InternalExport.g:25722:1: rule__XBasicForLoopExpression__ExpressionAssignment_5 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__ExpressionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25726:1: ( ( ruleXExpression ) ) + // InternalExport.g:25727:2: ( ruleXExpression ) + { + // InternalExport.g:25727:2: ( ruleXExpression ) + // InternalExport.g:25728:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__ExpressionAssignment_5" + + + // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0" + // InternalExport.g:25737:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25741:1: ( ( ruleXExpression ) ) + // InternalExport.g:25742:2: ( ruleXExpression ) + { + // InternalExport.g:25742:2: ( ruleXExpression ) + // InternalExport.g:25743:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0" + + + // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1" + // InternalExport.g:25752:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25756:1: ( ( ruleXExpression ) ) + // InternalExport.g:25757:2: ( ruleXExpression ) + { + // InternalExport.g:25757:2: ( ruleXExpression ) + // InternalExport.g:25758:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1" + + + // $ANTLR start "rule__XBasicForLoopExpression__EachExpressionAssignment_9" + // InternalExport.g:25767:1: rule__XBasicForLoopExpression__EachExpressionAssignment_9 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__EachExpressionAssignment_9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25771:1: ( ( ruleXExpression ) ) + // InternalExport.g:25772:2: ( ruleXExpression ) + { + // InternalExport.g:25772:2: ( ruleXExpression ) + // InternalExport.g:25773:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__EachExpressionAssignment_9" + + + // $ANTLR start "rule__XWhileExpression__PredicateAssignment_3" + // InternalExport.g:25782:1: rule__XWhileExpression__PredicateAssignment_3 : ( ruleXExpression ) ; + public final void rule__XWhileExpression__PredicateAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25786:1: ( ( ruleXExpression ) ) + // InternalExport.g:25787:2: ( ruleXExpression ) + { + // InternalExport.g:25787:2: ( ruleXExpression ) + // InternalExport.g:25788:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__PredicateAssignment_3" + + + // $ANTLR start "rule__XWhileExpression__BodyAssignment_5" + // InternalExport.g:25797:1: rule__XWhileExpression__BodyAssignment_5 : ( ruleXExpression ) ; + public final void rule__XWhileExpression__BodyAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25801:1: ( ( ruleXExpression ) ) + // InternalExport.g:25802:2: ( ruleXExpression ) + { + // InternalExport.g:25802:2: ( ruleXExpression ) + // InternalExport.g:25803:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__BodyAssignment_5" + + + // $ANTLR start "rule__XDoWhileExpression__BodyAssignment_2" + // InternalExport.g:25812:1: rule__XDoWhileExpression__BodyAssignment_2 : ( ruleXExpression ) ; + public final void rule__XDoWhileExpression__BodyAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25816:1: ( ( ruleXExpression ) ) + // InternalExport.g:25817:2: ( ruleXExpression ) + { + // InternalExport.g:25817:2: ( ruleXExpression ) + // InternalExport.g:25818:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__BodyAssignment_2" + + + // $ANTLR start "rule__XDoWhileExpression__PredicateAssignment_5" + // InternalExport.g:25827:1: rule__XDoWhileExpression__PredicateAssignment_5 : ( ruleXExpression ) ; + public final void rule__XDoWhileExpression__PredicateAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25831:1: ( ( ruleXExpression ) ) + // InternalExport.g:25832:2: ( ruleXExpression ) + { + // InternalExport.g:25832:2: ( ruleXExpression ) + // InternalExport.g:25833:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__PredicateAssignment_5" + + + // $ANTLR start "rule__XBlockExpression__ExpressionsAssignment_2_0" + // InternalExport.g:25842:1: rule__XBlockExpression__ExpressionsAssignment_2_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBlockExpression__ExpressionsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25846:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:25847:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:25847:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExport.g:25848:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__ExpressionsAssignment_2_0" + + + // $ANTLR start "rule__XVariableDeclaration__WriteableAssignment_1_0" + // InternalExport.g:25857:1: rule__XVariableDeclaration__WriteableAssignment_1_0 : ( ( 'var' ) ) ; + public final void rule__XVariableDeclaration__WriteableAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25861:1: ( ( ( 'var' ) ) ) + // InternalExport.g:25862:2: ( ( 'var' ) ) + { + // InternalExport.g:25862:2: ( ( 'var' ) ) + // InternalExport.g:25863:3: ( 'var' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + // InternalExport.g:25864:3: ( 'var' ) + // InternalExport.g:25865:4: 'var' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + match(input,117,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__WriteableAssignment_1_0" + + + // $ANTLR start "rule__XVariableDeclaration__TypeAssignment_2_0_0_0" + // InternalExport.g:25876:1: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 : ( ruleJvmTypeReference ) ; + public final void rule__XVariableDeclaration__TypeAssignment_2_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25880:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:25881:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:25881:2: ( ruleJvmTypeReference ) + // InternalExport.g:25882:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__TypeAssignment_2_0_0_0" + + + // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_0_0_1" + // InternalExport.g:25891:1: rule__XVariableDeclaration__NameAssignment_2_0_0_1 : ( ruleValidID ) ; + public final void rule__XVariableDeclaration__NameAssignment_2_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25895:1: ( ( ruleValidID ) ) + // InternalExport.g:25896:2: ( ruleValidID ) + { + // InternalExport.g:25896:2: ( ruleValidID ) + // InternalExport.g:25897:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_0_0_1" + + + // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_1" + // InternalExport.g:25906:1: rule__XVariableDeclaration__NameAssignment_2_1 : ( ruleValidID ) ; + public final void rule__XVariableDeclaration__NameAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25910:1: ( ( ruleValidID ) ) + // InternalExport.g:25911:2: ( ruleValidID ) + { + // InternalExport.g:25911:2: ( ruleValidID ) + // InternalExport.g:25912:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_1" + + + // $ANTLR start "rule__XVariableDeclaration__RightAssignment_3_1" + // InternalExport.g:25921:1: rule__XVariableDeclaration__RightAssignment_3_1 : ( ruleXExpression ) ; + public final void rule__XVariableDeclaration__RightAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25925:1: ( ( ruleXExpression ) ) + // InternalExport.g:25926:2: ( ruleXExpression ) + { + // InternalExport.g:25926:2: ( ruleXExpression ) + // InternalExport.g:25927:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__RightAssignment_3_1" + + + // $ANTLR start "rule__JvmFormalParameter__ParameterTypeAssignment_0" + // InternalExport.g:25936:1: rule__JvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ; + public final void rule__JvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25940:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:25941:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:25941:2: ( ruleJvmTypeReference ) + // InternalExport.g:25942:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__JvmFormalParameter__NameAssignment_1" + // InternalExport.g:25951:1: rule__JvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ; + public final void rule__JvmFormalParameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25955:1: ( ( ruleValidID ) ) + // InternalExport.g:25956:2: ( ruleValidID ) + { + // InternalExport.g:25956:2: ( ruleValidID ) + // InternalExport.g:25957:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__NameAssignment_1" + + + // $ANTLR start "rule__FullJvmFormalParameter__ParameterTypeAssignment_0" + // InternalExport.g:25966:1: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ; + public final void rule__FullJvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25970:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:25971:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:25971:2: ( ruleJvmTypeReference ) + // InternalExport.g:25972:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__FullJvmFormalParameter__NameAssignment_1" + // InternalExport.g:25981:1: rule__FullJvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ; + public final void rule__FullJvmFormalParameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:25985:1: ( ( ruleValidID ) ) + // InternalExport.g:25986:2: ( ruleValidID ) + { + // InternalExport.g:25986:2: ( ruleValidID ) + // InternalExport.g:25987:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__NameAssignment_1" + + + // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_1" + // InternalExport.g:25996:1: rule__XFeatureCall__TypeArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XFeatureCall__TypeArgumentsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26000:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26001:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26001:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26002:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_1" + + + // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1" + // InternalExport.g:26011:1: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XFeatureCall__TypeArgumentsAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26015:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26016:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26016:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26017:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1" + + + // $ANTLR start "rule__XFeatureCall__FeatureAssignment_2" + // InternalExport.g:26026:1: rule__XFeatureCall__FeatureAssignment_2 : ( ( ruleIdOrSuper ) ) ; + public final void rule__XFeatureCall__FeatureAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26030:1: ( ( ( ruleIdOrSuper ) ) ) + // InternalExport.g:26031:2: ( ( ruleIdOrSuper ) ) + { + // InternalExport.g:26031:2: ( ( ruleIdOrSuper ) ) + // InternalExport.g:26032:3: ( ruleIdOrSuper ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + // InternalExport.g:26033:3: ( ruleIdOrSuper ) + // InternalExport.g:26034:4: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureAssignment_2" + + + // $ANTLR start "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0" + // InternalExport.g:26045:1: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 : ( ( '(' ) ) ; + public final void rule__XFeatureCall__ExplicitOperationCallAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26049:1: ( ( ( '(' ) ) ) + // InternalExport.g:26050:2: ( ( '(' ) ) + { + // InternalExport.g:26050:2: ( ( '(' ) ) + // InternalExport.g:26051:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + // InternalExport.g:26052:3: ( '(' ) + // InternalExport.g:26053:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0" + // InternalExport.g:26064:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 : ( ruleXShortClosure ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26068:1: ( ( ruleXShortClosure ) ) + // InternalExport.g:26069:2: ( ruleXShortClosure ) + { + // InternalExport.g:26069:2: ( ruleXShortClosure ) + // InternalExport.g:26070:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0" + // InternalExport.g:26079:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 : ( ruleXExpression ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26083:1: ( ( ruleXExpression ) ) + // InternalExport.g:26084:2: ( ruleXExpression ) + { + // InternalExport.g:26084:2: ( ruleXExpression ) + // InternalExport.g:26085:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1" + // InternalExport.g:26094:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26098:1: ( ( ruleXExpression ) ) + // InternalExport.g:26099:2: ( ruleXExpression ) + { + // InternalExport.g:26099:2: ( ruleXExpression ) + // InternalExport.g:26100:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_4" + // InternalExport.g:26109:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 : ( ruleXClosure ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26113:1: ( ( ruleXClosure ) ) + // InternalExport.g:26114:2: ( ruleXClosure ) + { + // InternalExport.g:26114:2: ( ruleXClosure ) + // InternalExport.g:26115:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_4" + + + // $ANTLR start "rule__XConstructorCall__ConstructorAssignment_2" + // InternalExport.g:26124:1: rule__XConstructorCall__ConstructorAssignment_2 : ( ( ruleQualifiedName ) ) ; + public final void rule__XConstructorCall__ConstructorAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26128:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExport.g:26129:2: ( ( ruleQualifiedName ) ) + { + // InternalExport.g:26129:2: ( ( ruleQualifiedName ) ) + // InternalExport.g:26130:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + // InternalExport.g:26131:3: ( ruleQualifiedName ) + // InternalExport.g:26132:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ConstructorAssignment_2" + + + // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_1" + // InternalExport.g:26143:1: rule__XConstructorCall__TypeArgumentsAssignment_3_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XConstructorCall__TypeArgumentsAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26147:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26148:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26148:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26149:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_1" + + + // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1" + // InternalExport.g:26158:1: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XConstructorCall__TypeArgumentsAssignment_3_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26162:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26163:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26163:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26164:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1" + + + // $ANTLR start "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0" + // InternalExport.g:26173:1: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 : ( ( '(' ) ) ; + public final void rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26177:1: ( ( ( '(' ) ) ) + // InternalExport.g:26178:2: ( ( '(' ) ) + { + // InternalExport.g:26178:2: ( ( '(' ) ) + // InternalExport.g:26179:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + // InternalExport.g:26180:3: ( '(' ) + // InternalExport.g:26181:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_0" + // InternalExport.g:26192:1: rule__XConstructorCall__ArgumentsAssignment_4_1_0 : ( ruleXShortClosure ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26196:1: ( ( ruleXShortClosure ) ) + // InternalExport.g:26197:2: ( ruleXShortClosure ) + { + // InternalExport.g:26197:2: ( ruleXShortClosure ) + // InternalExport.g:26198:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0" + // InternalExport.g:26207:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 : ( ruleXExpression ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26211:1: ( ( ruleXExpression ) ) + // InternalExport.g:26212:2: ( ruleXExpression ) + { + // InternalExport.g:26212:2: ( ruleXExpression ) + // InternalExport.g:26213:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1" + // InternalExport.g:26222:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26226:1: ( ( ruleXExpression ) ) + // InternalExport.g:26227:2: ( ruleXExpression ) + { + // InternalExport.g:26227:2: ( ruleXExpression ) + // InternalExport.g:26228:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_5" + // InternalExport.g:26237:1: rule__XConstructorCall__ArgumentsAssignment_5 : ( ruleXClosure ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26241:1: ( ( ruleXClosure ) ) + // InternalExport.g:26242:2: ( ruleXClosure ) + { + // InternalExport.g:26242:2: ( ruleXClosure ) + // InternalExport.g:26243:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_5" + + + // $ANTLR start "rule__XBooleanLiteral__IsTrueAssignment_1_1" + // InternalExport.g:26252:1: rule__XBooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ; + public final void rule__XBooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26256:1: ( ( ( 'true' ) ) ) + // InternalExport.g:26257:2: ( ( 'true' ) ) + { + // InternalExport.g:26257:2: ( ( 'true' ) ) + // InternalExport.g:26258:3: ( 'true' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + // InternalExport.g:26259:3: ( 'true' ) + // InternalExport.g:26260:4: 'true' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + match(input,36,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__IsTrueAssignment_1_1" + + + // $ANTLR start "rule__XNumberLiteral__ValueAssignment_1" + // InternalExport.g:26271:1: rule__XNumberLiteral__ValueAssignment_1 : ( ruleNumber ) ; + public final void rule__XNumberLiteral__ValueAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26275:1: ( ( ruleNumber ) ) + // InternalExport.g:26276:2: ( ruleNumber ) + { + // InternalExport.g:26276:2: ( ruleNumber ) + // InternalExport.g:26277:3: ruleNumber + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleNumber(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__ValueAssignment_1" + + + // $ANTLR start "rule__XStringLiteral__ValueAssignment_1" + // InternalExport.g:26286:1: rule__XStringLiteral__ValueAssignment_1 : ( RULE_STRING ) ; + public final void rule__XStringLiteral__ValueAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26290:1: ( ( RULE_STRING ) ) + // InternalExport.g:26291:2: ( RULE_STRING ) + { + // InternalExport.g:26291:2: ( RULE_STRING ) + // InternalExport.g:26292:3: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__ValueAssignment_1" + + + // $ANTLR start "rule__XTypeLiteral__TypeAssignment_3" + // InternalExport.g:26301:1: rule__XTypeLiteral__TypeAssignment_3 : ( ( ruleQualifiedName ) ) ; + public final void rule__XTypeLiteral__TypeAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26305:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExport.g:26306:2: ( ( ruleQualifiedName ) ) + { + // InternalExport.g:26306:2: ( ( ruleQualifiedName ) ) + // InternalExport.g:26307:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + // InternalExport.g:26308:3: ( ruleQualifiedName ) + // InternalExport.g:26309:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__TypeAssignment_3" + + + // $ANTLR start "rule__XTypeLiteral__ArrayDimensionsAssignment_4" + // InternalExport.g:26320:1: rule__XTypeLiteral__ArrayDimensionsAssignment_4 : ( ruleArrayBrackets ) ; + public final void rule__XTypeLiteral__ArrayDimensionsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26324:1: ( ( ruleArrayBrackets ) ) + // InternalExport.g:26325:2: ( ruleArrayBrackets ) + { + // InternalExport.g:26325:2: ( ruleArrayBrackets ) + // InternalExport.g:26326:3: ruleArrayBrackets + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__ArrayDimensionsAssignment_4" + + + // $ANTLR start "rule__XThrowExpression__ExpressionAssignment_2" + // InternalExport.g:26335:1: rule__XThrowExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XThrowExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26339:1: ( ( ruleXExpression ) ) + // InternalExport.g:26340:2: ( ruleXExpression ) + { + // InternalExport.g:26340:2: ( ruleXExpression ) + // InternalExport.g:26341:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XReturnExpression__ExpressionAssignment_2" + // InternalExport.g:26350:1: rule__XReturnExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XReturnExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26354:1: ( ( ruleXExpression ) ) + // InternalExport.g:26355:2: ( ruleXExpression ) + { + // InternalExport.g:26355:2: ( ruleXExpression ) + // InternalExport.g:26356:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__ExpressionAssignment_2" + // InternalExport.g:26365:1: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26369:1: ( ( ruleXExpression ) ) + // InternalExport.g:26370:2: ( ruleXExpression ) + { + // InternalExport.g:26370:2: ( ruleXExpression ) + // InternalExport.g:26371:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0" + // InternalExport.g:26380:1: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 : ( ruleXCatchClause ) ; + public final void rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26384:1: ( ( ruleXCatchClause ) ) + // InternalExport.g:26385:2: ( ruleXCatchClause ) + { + // InternalExport.g:26385:2: ( ruleXCatchClause ) + // InternalExport.g:26386:3: ruleXCatchClause + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleXCatchClause(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1" + // InternalExport.g:26395:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26399:1: ( ( ruleXExpression ) ) + // InternalExport.g:26400:2: ( ruleXExpression ) + { + // InternalExport.g:26400:2: ( ruleXExpression ) + // InternalExport.g:26401:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1" + // InternalExport.g:26410:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26414:1: ( ( ruleXExpression ) ) + // InternalExport.g:26415:2: ( ruleXExpression ) + { + // InternalExport.g:26415:2: ( ruleXExpression ) + // InternalExport.g:26416:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1" + + + // $ANTLR start "rule__XSynchronizedExpression__ParamAssignment_1" + // InternalExport.g:26425:1: rule__XSynchronizedExpression__ParamAssignment_1 : ( ruleXExpression ) ; + public final void rule__XSynchronizedExpression__ParamAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26429:1: ( ( ruleXExpression ) ) + // InternalExport.g:26430:2: ( ruleXExpression ) + { + // InternalExport.g:26430:2: ( ruleXExpression ) + // InternalExport.g:26431:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__ParamAssignment_1" + + + // $ANTLR start "rule__XSynchronizedExpression__ExpressionAssignment_3" + // InternalExport.g:26440:1: rule__XSynchronizedExpression__ExpressionAssignment_3 : ( ruleXExpression ) ; + public final void rule__XSynchronizedExpression__ExpressionAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26444:1: ( ( ruleXExpression ) ) + // InternalExport.g:26445:2: ( ruleXExpression ) + { + // InternalExport.g:26445:2: ( ruleXExpression ) + // InternalExport.g:26446:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__ExpressionAssignment_3" + + + // $ANTLR start "rule__XCatchClause__DeclaredParamAssignment_2" + // InternalExport.g:26455:1: rule__XCatchClause__DeclaredParamAssignment_2 : ( ruleFullJvmFormalParameter ) ; + public final void rule__XCatchClause__DeclaredParamAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26459:1: ( ( ruleFullJvmFormalParameter ) ) + // InternalExport.g:26460:2: ( ruleFullJvmFormalParameter ) + { + // InternalExport.g:26460:2: ( ruleFullJvmFormalParameter ) + // InternalExport.g:26461:3: ruleFullJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__DeclaredParamAssignment_2" + + + // $ANTLR start "rule__XCatchClause__ExpressionAssignment_4" + // InternalExport.g:26470:1: rule__XCatchClause__ExpressionAssignment_4 : ( ruleXExpression ) ; + public final void rule__XCatchClause__ExpressionAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26474:1: ( ( ruleXExpression ) ) + // InternalExport.g:26475:2: ( ruleXExpression ) + { + // InternalExport.g:26475:2: ( ruleXExpression ) + // InternalExport.g:26476:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__ExpressionAssignment_4" + + + // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" + // InternalExport.g:26485:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26489:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26490:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26490:2: ( ruleJvmTypeReference ) + // InternalExport.g:26491:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" + + + // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" + // InternalExport.g:26500:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26504:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26505:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26505:2: ( ruleJvmTypeReference ) + // InternalExport.g:26506:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" + + + // $ANTLR start "rule__XFunctionTypeRef__ReturnTypeAssignment_2" + // InternalExport.g:26515:1: rule__XFunctionTypeRef__ReturnTypeAssignment_2 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ReturnTypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26519:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26520:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26520:2: ( ruleJvmTypeReference ) + // InternalExport.g:26521:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ReturnTypeAssignment_2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_0" + // InternalExport.g:26530:1: rule__JvmParameterizedTypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__JvmParameterizedTypeReference__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26534:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExport.g:26535:2: ( ( ruleQualifiedName ) ) + { + // InternalExport.g:26535:2: ( ( ruleQualifiedName ) ) + // InternalExport.g:26536:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + // InternalExport.g:26537:3: ( ruleQualifiedName ) + // InternalExport.g:26538:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" + // InternalExport.g:26549:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26553:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26554:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26554:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26555:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" + // InternalExport.g:26564:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26568:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26569:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26569:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26570:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" + // InternalExport.g:26579:1: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 : ( ( ruleValidID ) ) ; + public final void rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26583:1: ( ( ( ruleValidID ) ) ) + // InternalExport.g:26584:2: ( ( ruleValidID ) ) + { + // InternalExport.g:26584:2: ( ( ruleValidID ) ) + // InternalExport.g:26585:3: ( ruleValidID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + // InternalExport.g:26586:3: ( ruleValidID ) + // InternalExport.g:26587:4: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" + // InternalExport.g:26598:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26602:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26603:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26603:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26604:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" + // InternalExport.g:26613:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26617:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExport.g:26618:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExport.g:26618:2: ( ruleJvmArgumentTypeReference ) + // InternalExport.g:26619:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" + // InternalExport.g:26628:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 : ( ruleJvmUpperBound ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26632:1: ( ( ruleJvmUpperBound ) ) + // InternalExport.g:26633:2: ( ruleJvmUpperBound ) + { + // InternalExport.g:26633:2: ( ruleJvmUpperBound ) + // InternalExport.g:26634:3: ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" + // InternalExport.g:26643:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 : ( ruleJvmUpperBoundAnded ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26647:1: ( ( ruleJvmUpperBoundAnded ) ) + // InternalExport.g:26648:2: ( ruleJvmUpperBoundAnded ) + { + // InternalExport.g:26648:2: ( ruleJvmUpperBoundAnded ) + // InternalExport.g:26649:3: ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" + // InternalExport.g:26658:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 : ( ruleJvmLowerBound ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26662:1: ( ( ruleJvmLowerBound ) ) + // InternalExport.g:26663:2: ( ruleJvmLowerBound ) + { + // InternalExport.g:26663:2: ( ruleJvmLowerBound ) + // InternalExport.g:26664:3: ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" + // InternalExport.g:26673:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 : ( ruleJvmLowerBoundAnded ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26677:1: ( ( ruleJvmLowerBoundAnded ) ) + // InternalExport.g:26678:2: ( ruleJvmLowerBoundAnded ) + { + // InternalExport.g:26678:2: ( ruleJvmLowerBoundAnded ) + // InternalExport.g:26679:3: ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" + + + // $ANTLR start "rule__JvmUpperBound__TypeReferenceAssignment_1" + // InternalExport.g:26688:1: rule__JvmUpperBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmUpperBound__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26692:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26693:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26693:2: ( ruleJvmTypeReference ) + // InternalExport.g:26694:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" + // InternalExport.g:26703:1: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmUpperBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26707:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26708:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26708:2: ( ruleJvmTypeReference ) + // InternalExport.g:26709:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmLowerBound__TypeReferenceAssignment_1" + // InternalExport.g:26718:1: rule__JvmLowerBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmLowerBound__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26722:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26723:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26723:2: ( ruleJvmTypeReference ) + // InternalExport.g:26724:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" + // InternalExport.g:26733:1: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmLowerBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26737:1: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:26738:2: ( ruleJvmTypeReference ) + { + // InternalExport.g:26738:2: ( ruleJvmTypeReference ) + // InternalExport.g:26739:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__XImportDeclaration__StaticAssignment_1_0_0" + // InternalExport.g:26748:1: rule__XImportDeclaration__StaticAssignment_1_0_0 : ( ( 'static' ) ) ; + public final void rule__XImportDeclaration__StaticAssignment_1_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26752:1: ( ( ( 'static' ) ) ) + // InternalExport.g:26753:2: ( ( 'static' ) ) + { + // InternalExport.g:26753:2: ( ( 'static' ) ) + // InternalExport.g:26754:3: ( 'static' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + // InternalExport.g:26755:3: ( 'static' ) + // InternalExport.g:26756:4: 'static' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + match(input,61,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__StaticAssignment_1_0_0" + + + // $ANTLR start "rule__XImportDeclaration__ExtensionAssignment_1_0_1" + // InternalExport.g:26767:1: rule__XImportDeclaration__ExtensionAssignment_1_0_1 : ( ( 'extension' ) ) ; + public final void rule__XImportDeclaration__ExtensionAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26771:1: ( ( ( 'extension' ) ) ) + // InternalExport.g:26772:2: ( ( 'extension' ) ) + { + // InternalExport.g:26772:2: ( ( 'extension' ) ) + // InternalExport.g:26773:3: ( 'extension' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + // InternalExport.g:26774:3: ( 'extension' ) + // InternalExport.g:26775:4: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ExtensionAssignment_1_0_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" + // InternalExport.g:26786:1: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 : ( ( ruleQualifiedNameInStaticImport ) ) ; + public final void rule__XImportDeclaration__ImportedTypeAssignment_1_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26790:1: ( ( ( ruleQualifiedNameInStaticImport ) ) ) + // InternalExport.g:26791:2: ( ( ruleQualifiedNameInStaticImport ) ) + { + // InternalExport.g:26791:2: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalExport.g:26792:3: ( ruleQualifiedNameInStaticImport ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + // InternalExport.g:26793:3: ( ruleQualifiedNameInStaticImport ) + // InternalExport.g:26794:4: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" + + + // $ANTLR start "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" + // InternalExport.g:26805:1: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 : ( ( '*' ) ) ; + public final void rule__XImportDeclaration__WildcardAssignment_1_0_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26809:1: ( ( ( '*' ) ) ) + // InternalExport.g:26810:2: ( ( '*' ) ) + { + // InternalExport.g:26810:2: ( ( '*' ) ) + // InternalExport.g:26811:3: ( '*' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + // InternalExport.g:26812:3: ( '*' ) + // InternalExport.g:26813:4: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" + + + // $ANTLR start "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" + // InternalExport.g:26824:1: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 : ( ruleValidID ) ; + public final void rule__XImportDeclaration__MemberNameAssignment_1_0_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26828:1: ( ( ruleValidID ) ) + // InternalExport.g:26829:2: ( ruleValidID ) + { + // InternalExport.g:26829:2: ( ruleValidID ) + // InternalExport.g:26830:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_1" + // InternalExport.g:26839:1: rule__XImportDeclaration__ImportedTypeAssignment_1_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__XImportDeclaration__ImportedTypeAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26843:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExport.g:26844:2: ( ( ruleQualifiedName ) ) + { + // InternalExport.g:26844:2: ( ( ruleQualifiedName ) ) + // InternalExport.g:26845:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + // InternalExport.g:26846:3: ( ruleQualifiedName ) + // InternalExport.g:26847:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" + // InternalExport.g:26858:1: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 : ( ruleQualifiedNameWithWildcard ) ; + public final void rule__XImportDeclaration__ImportedNamespaceAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExport.g:26862:1: ( ( ruleQualifiedNameWithWildcard ) ) + // InternalExport.g:26863:2: ( ruleQualifiedNameWithWildcard ) + { + // InternalExport.g:26863:2: ( ruleQualifiedNameWithWildcard ) + // InternalExport.g:26864:3: ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" + + // $ANTLR start synpred7_InternalExport + public final void synpred7_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:3248:2: ( ( ( ruleCastedExpression ) ) ) + // InternalExport.g:3248:2: ( ( ruleCastedExpression ) ) + { + // InternalExport.g:3248:2: ( ( ruleCastedExpression ) ) + // InternalExport.g:3249:3: ( ruleCastedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } + // InternalExport.g:3250:3: ( ruleCastedExpression ) + // InternalExport.g:3250:4: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred7_InternalExport + + // $ANTLR start synpred75_InternalExport + public final void synpred75_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4001:2: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) ) + // InternalExport.g:4001:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // InternalExport.g:4001:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // InternalExport.g:4002:3: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // InternalExport.g:4003:3: ( rule__OpOther__Group_6_1_0__0 ) + // InternalExport.g:4003:4: rule__OpOther__Group_6_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred75_InternalExport + + // $ANTLR start synpred76_InternalExport + public final void synpred76_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4007:2: ( ( '<' ) ) + // InternalExport.g:4007:2: ( '<' ) + { + // InternalExport.g:4007:2: ( '<' ) + // InternalExport.g:4008:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred76_InternalExport + + // $ANTLR start synpred89_InternalExport + public final void synpred89_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4220:2: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) ) + // InternalExport.g:4220:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + { + // InternalExport.g:4220:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + // InternalExport.g:4221:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + // InternalExport.g:4222:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + // InternalExport.g:4222:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred89_InternalExport + + // $ANTLR start synpred97_InternalExport + public final void synpred97_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4283:2: ( ( ( ruleXForLoopExpression ) ) ) + // InternalExport.g:4283:2: ( ( ruleXForLoopExpression ) ) + { + // InternalExport.g:4283:2: ( ( ruleXForLoopExpression ) ) + // InternalExport.g:4284:3: ( ruleXForLoopExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + // InternalExport.g:4285:3: ( ruleXForLoopExpression ) + // InternalExport.g:4285:4: ruleXForLoopExpression + { + pushFollow(FOLLOW_2); + ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred97_InternalExport + + // $ANTLR start synpred98_InternalExport + public final void synpred98_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4289:2: ( ( ruleXBasicForLoopExpression ) ) + // InternalExport.g:4289:2: ( ruleXBasicForLoopExpression ) + { + // InternalExport.g:4289:2: ( ruleXBasicForLoopExpression ) + // InternalExport.g:4290:3: ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + pushFollow(FOLLOW_2); + ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred98_InternalExport + + // $ANTLR start synpred111_InternalExport + public final void synpred111_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4412:2: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) ) + // InternalExport.g:4412:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + { + // InternalExport.g:4412:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + // InternalExport.g:4413:3: ( rule__XSwitchExpression__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + // InternalExport.g:4414:3: ( rule__XSwitchExpression__Group_2_0__0 ) + // InternalExport.g:4414:4: rule__XSwitchExpression__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred111_InternalExport + + // $ANTLR start synpred115_InternalExport + public final void synpred115_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4496:2: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) ) + // InternalExport.g:4496:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + { + // InternalExport.g:4496:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + // InternalExport.g:4497:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + // InternalExport.g:4498:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + // InternalExport.g:4498:4: rule__XVariableDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred115_InternalExport + + // $ANTLR start synpred116_InternalExport + public final void synpred116_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4517:2: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) ) + // InternalExport.g:4517:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + { + // InternalExport.g:4517:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + // InternalExport.g:4518:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + // InternalExport.g:4519:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + // InternalExport.g:4519:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred116_InternalExport + + // $ANTLR start synpred122_InternalExport + public final void synpred122_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4598:2: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) ) + // InternalExport.g:4598:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + { + // InternalExport.g:4598:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + // InternalExport.g:4599:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + // InternalExport.g:4600:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + // InternalExport.g:4600:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred122_InternalExport + + // $ANTLR start synpred163_InternalExport + public final void synpred163_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8109:3: ( rule__IfExpressionKw__Group_4__0 ) + // InternalExport.g:8109:3: rule__IfExpressionKw__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred163_InternalExport + + // $ANTLR start synpred182_InternalExport + public final void synpred182_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:11565:3: ( rule__XAssignment__Group_1_1__0 ) + // InternalExport.g:11565:3: rule__XAssignment__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred182_InternalExport + + // $ANTLR start synpred184_InternalExport + public final void synpred184_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:11916:3: ( rule__XOrExpression__Group_1__0 ) + // InternalExport.g:11916:3: rule__XOrExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred184_InternalExport + + // $ANTLR start synpred185_InternalExport + public final void synpred185_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:12105:3: ( rule__XAndExpression__Group_1__0 ) + // InternalExport.g:12105:3: rule__XAndExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred185_InternalExport + + // $ANTLR start synpred186_InternalExport + public final void synpred186_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:12294:3: ( rule__XEqualityExpression__Group_1__0 ) + // InternalExport.g:12294:3: rule__XEqualityExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred186_InternalExport + + // $ANTLR start synpred187_InternalExport + public final void synpred187_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:12483:3: ( rule__XRelationalExpression__Alternatives_1 ) + // InternalExport.g:12483:3: rule__XRelationalExpression__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred187_InternalExport + + // $ANTLR start synpred188_InternalExport + public final void synpred188_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:12861:3: ( rule__XOtherOperatorExpression__Group_1__0 ) + // InternalExport.g:12861:3: rule__XOtherOperatorExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred188_InternalExport + + // $ANTLR start synpred189_InternalExport + public final void synpred189_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:13374:3: ( rule__XAdditiveExpression__Group_1__0 ) + // InternalExport.g:13374:3: rule__XAdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred189_InternalExport + + // $ANTLR start synpred190_InternalExport + public final void synpred190_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:13563:3: ( rule__XMultiplicativeExpression__Group_1__0 ) + // InternalExport.g:13563:3: rule__XMultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred190_InternalExport + + // $ANTLR start synpred191_InternalExport + public final void synpred191_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:13833:3: ( rule__XCastedExpression__Group_1__0 ) + // InternalExport.g:13833:3: rule__XCastedExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred191_InternalExport + + // $ANTLR start synpred192_InternalExport + public final void synpred192_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:14022:3: ( rule__XPostfixOperation__Group_1__0 ) + // InternalExport.g:14022:3: rule__XPostfixOperation__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred192_InternalExport + + // $ANTLR start synpred193_InternalExport + public final void synpred193_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:14157:3: ( rule__XMemberFeatureCall__Alternatives_1 ) + // InternalExport.g:14157:3: rule__XMemberFeatureCall__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred193_InternalExport + + // $ANTLR start synpred195_InternalExport + public final void synpred195_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:14455:3: ( rule__XMemberFeatureCall__Group_1_1_3__0 ) + // InternalExport.g:14455:3: rule__XMemberFeatureCall__Group_1_1_3__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred195_InternalExport + + // $ANTLR start synpred196_InternalExport + public final void synpred196_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:14481:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 ) + // InternalExport.g:14481:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred196_InternalExport + + // $ANTLR start synpred204_InternalExport + public final void synpred204_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:15454:3: ( rule__XClosure__Group_1__0 ) + // InternalExport.g:15454:3: rule__XClosure__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred204_InternalExport + + // $ANTLR start synpred211_InternalExport + public final void synpred211_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:16425:3: ( rule__XIfExpression__Group_6__0 ) + // InternalExport.g:16425:3: rule__XIfExpression__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred211_InternalExport + + // $ANTLR start synpred214_InternalExport + public final void synpred214_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:16885:3: ( rule__XSwitchExpression__Group_2_1_0__0 ) + // InternalExport.g:16885:3: rule__XSwitchExpression__Group_2_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred214_InternalExport + + // $ANTLR start synpred227_InternalExport + public final void synpred227_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:19018:3: ( rule__XFeatureCall__Group_3__0 ) + // InternalExport.g:19018:3: rule__XFeatureCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred227_InternalExport + + // $ANTLR start synpred228_InternalExport + public final void synpred228_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:19044:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 ) + // InternalExport.g:19044:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred228_InternalExport + + // $ANTLR start synpred232_InternalExport + public final void synpred232_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:19504:3: ( rule__XConstructorCall__Group_3__0 ) + // InternalExport.g:19504:3: rule__XConstructorCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred232_InternalExport + + // $ANTLR start synpred233_InternalExport + public final void synpred233_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:19531:3: ( rule__XConstructorCall__Group_4__0 ) + // InternalExport.g:19531:3: rule__XConstructorCall__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred233_InternalExport + + // $ANTLR start synpred234_InternalExport + public final void synpred234_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:19557:3: ( rule__XConstructorCall__ArgumentsAssignment_5 ) + // InternalExport.g:19557:3: rule__XConstructorCall__ArgumentsAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred234_InternalExport + + // $ANTLR start synpred239_InternalExport + public final void synpred239_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:20448:3: ( rule__XReturnExpression__ExpressionAssignment_2 ) + // InternalExport.g:20448:3: rule__XReturnExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred239_InternalExport + + // $ANTLR start synpred240_InternalExport + public final void synpred240_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:20590:4: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + // InternalExport.g:20590:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred240_InternalExport + + // $ANTLR start synpred241_InternalExport + public final void synpred241_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:20617:3: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 ) + // InternalExport.g:20617:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred241_InternalExport + + // $ANTLR start synpred242_InternalExport + public final void synpred242_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:21130:3: ( rule__QualifiedName__Group_1__0 ) + // InternalExport.g:21130:3: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred242_InternalExport + + // $ANTLR start synpred244_InternalExport + public final void synpred244_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:21346:3: ( rule__JvmTypeReference__Group_0_1__0 ) + // InternalExport.g:21346:3: rule__JvmTypeReference__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred244_InternalExport + + // $ANTLR start synpred248_InternalExport + public final void synpred248_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:21805:3: ( rule__JvmParameterizedTypeReference__Group_1__0 ) + // InternalExport.g:21805:3: rule__JvmParameterizedTypeReference__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred248_InternalExport + + // $ANTLR start synpred250_InternalExport + public final void synpred250_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:21940:3: ( rule__JvmParameterizedTypeReference__Group_1_4__0 ) + // InternalExport.g:21940:3: rule__JvmParameterizedTypeReference__Group_1_4__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred250_InternalExport + + // $ANTLR start synpred251_InternalExport + public final void synpred251_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:22075:3: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 ) + // InternalExport.g:22075:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred251_InternalExport + + // Delegated rules + + public final boolean synpred122_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred122_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred239_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred239_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred251_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred251_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred186_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred186_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred182_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred182_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred195_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred195_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred234_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred234_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred204_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred204_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred185_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred185_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred7_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred7_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred241_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred241_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred76_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred76_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred242_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred242_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred250_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred250_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred89_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred89_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred98_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred98_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred190_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred190_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred233_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred233_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred192_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred192_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred189_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred189_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred75_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred75_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred184_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred184_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred211_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred211_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred111_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred111_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred240_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred240_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred228_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred228_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred97_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred97_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred116_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred116_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred191_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred191_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred232_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred232_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred163_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred163_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred193_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred193_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred115_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred115_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred214_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred214_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred244_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred244_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred227_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred227_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred187_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred187_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred248_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred248_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred188_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred188_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred196_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred196_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA5 dfa5 = new DFA5(this); + protected DFA26 dfa26 = new DFA26(this); + protected DFA34 dfa34 = new DFA34(this); + protected DFA37 dfa37 = new DFA37(this); + protected DFA38 dfa38 = new DFA38(this); + protected DFA41 dfa41 = new DFA41(this); + protected DFA46 dfa46 = new DFA46(this); + protected DFA49 dfa49 = new DFA49(this); + protected DFA58 dfa58 = new DFA58(this); + protected DFA108 dfa108 = new DFA108(this); + protected DFA114 dfa114 = new DFA114(this); + protected DFA121 dfa121 = new DFA121(this); + protected DFA122 dfa122 = new DFA122(this); + protected DFA130 dfa130 = new DFA130(this); + protected DFA140 dfa140 = new DFA140(this); + protected DFA153 dfa153 = new DFA153(this); + protected DFA154 dfa154 = new DFA154(this); + protected DFA158 dfa158 = new DFA158(this); + protected DFA159 dfa159 = new DFA159(this); + protected DFA160 dfa160 = new DFA160(this); + protected DFA165 dfa165 = new DFA165(this); + protected DFA174 dfa174 = new DFA174(this); + protected DFA177 dfa177 = new DFA177(this); + static final String dfa_1s = "\36\uffff"; + static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; + static final String dfa_3s = "\1\163\1\uffff\1\0\33\uffff"; + static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; + static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; + static final String[] dfa_6s = { + "\1\3\1\uffff\1\3\1\uffff\2\3\16\uffff\1\3\2\uffff\16\3\33\uffff\1\3\10\uffff\1\2\6\uffff\1\1\2\uffff\1\3\2\uffff\1\3\3\uffff\2\3\4\uffff\1\3\16\uffff\1\3", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA5 extends DFA { + + public DFA5(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 5; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "3237:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA5_2 = input.LA(1); + + + int index5_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred7_InternalExport()) ) {s = 29;} + + else if ( (true) ) {s = 3;} + + + input.seek(index5_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 5, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_7s = "\13\uffff"; + static final String dfa_8s = "\1\25\2\uffff\1\25\7\uffff"; + static final String dfa_9s = "\1\65\2\uffff\1\62\7\uffff"; + static final String dfa_10s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\6\1\3"; + static final String dfa_11s = "\13\uffff}>"; + static final String[] dfa_12s = { + "\1\3\1\6\31\uffff\1\1\1\2\1\4\1\5\1\7\1\10", + "", + "", + "\1\11\34\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); + static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); + static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); + static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); + static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); + static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); + + class DFA26 extends DFA { + + public DFA26(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 26; + this.eot = dfa_7; + this.eof = dfa_7; + this.min = dfa_8; + this.max = dfa_9; + this.accept = dfa_10; + this.special = dfa_11; + this.transition = dfa_12; + } + public String getDescription() { + return "3912:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );"; + } + } + static final String dfa_13s = "\12\uffff"; + static final String dfa_14s = "\4\uffff\5\3\1\uffff"; + static final String dfa_15s = "\1\72\2\4\1\uffff\5\4\1\uffff"; + static final String dfa_16s = "\1\164\2\100\1\uffff\5\165\1\uffff"; + static final String dfa_17s = "\3\uffff\1\2\5\uffff\1\1"; + static final String dfa_18s = "\12\uffff}>"; + static final String[] dfa_19s = { + "\1\1\30\uffff\1\2\40\uffff\1\3", + "\1\4\21\uffff\1\3\45\uffff\1\5\1\6\1\7\1\10\1\3", + "\1\4\21\uffff\1\3\45\uffff\1\5\1\6\1\7\1\10\1\3", + "", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\1\3\1\uffff\7\3\2\uffff\2\3\4\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\4\3\2\uffff\15\3\10\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\1\3\1\uffff\7\3\2\uffff\2\3\4\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\4\3\2\uffff\15\3\10\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\1\3\1\uffff\7\3\2\uffff\2\3\4\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\4\3\2\uffff\15\3\10\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\1\3\1\uffff\7\3\2\uffff\2\3\4\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\4\3\2\uffff\15\3\10\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\1\3\1\uffff\7\3\2\uffff\2\3\4\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\4\3\2\uffff\15\3\10\uffff\2\3", + "" + }; + + static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); + static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); + static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); + static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); + static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); + static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); + static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s); + + class DFA34 extends DFA { + + public DFA34(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 34; + this.eot = dfa_13; + this.eof = dfa_14; + this.min = dfa_15; + this.max = dfa_16; + this.accept = dfa_17; + this.special = dfa_18; + this.transition = dfa_19; + } + public String getDescription() { + return "4146:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );"; + } + } + static final String dfa_20s = "\43\uffff"; + static final String dfa_21s = "\1\4\2\0\40\uffff"; + static final String dfa_22s = "\1\152\2\0\40\uffff"; + static final String dfa_23s = "\3\uffff\1\1\1\uffff\1\2\35\uffff"; + static final String dfa_24s = "\1\uffff\1\0\1\1\40\uffff}>"; + static final String[] dfa_25s = { + "\1\1\4\5\15\uffff\3\5\2\uffff\1\5\10\uffff\2\5\15\uffff\1\3\10\uffff\5\5\1\uffff\1\5\1\uffff\1\5\3\uffff\1\5\4\uffff\1\2\11\uffff\1\5\2\uffff\1\5\2\uffff\1\3\1\uffff\1\5\1\uffff\10\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); + static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); + static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); + static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); + static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); + static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); + + class DFA37 extends DFA { + + public DFA37(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 37; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4215:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA37_1 = input.LA(1); + + + int index37_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred89_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index37_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA37_2 = input.LA(1); + + + int index37_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred89_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index37_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 37, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_26s = "\40\uffff"; + static final String dfa_27s = "\1\4\26\uffff\1\0\10\uffff"; + static final String dfa_28s = "\1\152\26\uffff\1\0\10\uffff"; + static final String dfa_29s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11"; + static final String dfa_30s = "\27\uffff\1\0\10\uffff}>"; + static final String[] dfa_31s = { + "\1\5\4\14\15\uffff\1\5\15\uffff\2\14\26\uffff\5\5\1\uffff\1\27\1\uffff\1\2\3\uffff\1\14\4\uffff\1\35\11\uffff\1\26\2\uffff\1\3\4\uffff\1\1\1\uffff\1\14\1\30\1\31\2\14\1\32\1\33\1\34\1\uffff\1\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s); + static final char[] dfa_27 = DFA.unpackEncodedStringToUnsignedChars(dfa_27s); + static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s); + static final short[] dfa_29 = DFA.unpackEncodedString(dfa_29s); + static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s); + static final short[][] dfa_31 = unpackEncodedStringArray(dfa_31s); + + class DFA38 extends DFA { + + public DFA38(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 38; + this.eot = dfa_26; + this.eof = dfa_26; + this.min = dfa_27; + this.max = dfa_28; + this.accept = dfa_29; + this.special = dfa_30; + this.transition = dfa_31; + } + public String getDescription() { + return "4236:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA38_23 = input.LA(1); + + + int index38_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred97_InternalExport()) ) {s = 30;} + + else if ( (synpred98_InternalExport()) ) {s = 31;} + + + input.seek(index38_23); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 38, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_32s = "\1\4\1\0\41\uffff"; + static final String dfa_33s = "\1\152\1\0\41\uffff"; + static final String dfa_34s = "\2\uffff\1\2\37\uffff\1\1"; + static final String dfa_35s = "\1\uffff\1\0\41\uffff}>"; + static final String[] dfa_36s = { + "\5\2\15\uffff\3\2\2\uffff\1\2\10\uffff\2\2\15\uffff\1\2\10\uffff\5\2\1\uffff\1\2\1\uffff\1\2\3\uffff\1\2\4\uffff\1\1\11\uffff\1\2\2\uffff\1\2\4\uffff\1\2\1\uffff\10\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_32 = DFA.unpackEncodedStringToUnsignedChars(dfa_32s); + static final char[] dfa_33 = DFA.unpackEncodedStringToUnsignedChars(dfa_33s); + static final short[] dfa_34 = DFA.unpackEncodedString(dfa_34s); + static final short[] dfa_35 = DFA.unpackEncodedString(dfa_35s); + static final short[][] dfa_36 = unpackEncodedStringArray(dfa_36s); + + class DFA41 extends DFA { + + public DFA41(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 41; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_32; + this.max = dfa_33; + this.accept = dfa_34; + this.special = dfa_35; + this.transition = dfa_36; + } + public String getDescription() { + return "4407:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA41_1 = input.LA(1); + + + int index41_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred111_InternalExport()) ) {s = 34;} + + else if ( (true) ) {s = 2;} + + + input.seek(index41_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 41, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA46 extends DFA { + + public DFA46(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 46; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4512:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA46_1 = input.LA(1); + + + int index46_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred116_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index46_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA46_2 = input.LA(1); + + + int index46_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred116_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index46_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 46, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA49 extends DFA { + + public DFA49(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 49; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4593:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA49_1 = input.LA(1); + + + int index49_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred122_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index49_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA49_2 = input.LA(1); + + + int index49_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred122_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index49_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 49, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_37s = "\7\uffff"; + static final String dfa_38s = "\2\uffff\1\4\3\uffff\1\4"; + static final String dfa_39s = "\1\4\1\uffff\1\72\1\4\2\uffff\1\72"; + static final String dfa_40s = "\1\75\1\uffff\1\107\1\31\2\uffff\1\107"; + static final String dfa_41s = "\1\uffff\1\1\2\uffff\1\2\1\3\1\uffff"; + static final String dfa_42s = "\7\uffff}>"; + static final String[] dfa_43s = { + "\1\2\70\uffff\1\1", + "", + "\1\3\14\uffff\1\4", + "\1\6\24\uffff\1\5", + "", + "", + "\1\3\14\uffff\1\4" + }; + + static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s); + static final short[] dfa_38 = DFA.unpackEncodedString(dfa_38s); + static final char[] dfa_39 = DFA.unpackEncodedStringToUnsignedChars(dfa_39s); + static final char[] dfa_40 = DFA.unpackEncodedStringToUnsignedChars(dfa_40s); + static final short[] dfa_41 = DFA.unpackEncodedString(dfa_41s); + static final short[] dfa_42 = DFA.unpackEncodedString(dfa_42s); + static final short[][] dfa_43 = unpackEncodedStringArray(dfa_43s); + + class DFA58 extends DFA { + + public DFA58(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 58; + this.eot = dfa_37; + this.eof = dfa_38; + this.min = dfa_39; + this.max = dfa_40; + this.accept = dfa_41; + this.special = dfa_42; + this.transition = dfa_43; + } + public String getDescription() { + return "4782:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) );"; + } + } + static final String dfa_44s = "\1\10\11\uffff"; + static final String dfa_45s = "\1\4\7\0\2\uffff"; + static final String dfa_46s = "\1\165\7\0\2\uffff"; + static final String dfa_47s = "\10\uffff\1\2\1\1"; + static final String dfa_48s = "\1\uffff\1\5\1\2\1\1\1\0\1\6\1\3\1\4\2\uffff}>"; + static final String[] dfa_49s = { + "\5\10\6\uffff\5\10\1\uffff\1\7\1\6\5\10\10\uffff\2\10\3\uffff\1\1\1\2\1\3\1\4\1\5\23\10\1\uffff\1\10\1\uffff\7\10\2\uffff\2\10\4\uffff\1\10\1\uffff\1\10\1\uffff\1\10\1\uffff\4\10\2\uffff\15\10\10\uffff\2\10", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s); + static final char[] dfa_45 = DFA.unpackEncodedStringToUnsignedChars(dfa_45s); + static final char[] dfa_46 = DFA.unpackEncodedStringToUnsignedChars(dfa_46s); + static final short[] dfa_47 = DFA.unpackEncodedString(dfa_47s); + static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s); + static final short[][] dfa_49 = unpackEncodedStringArray(dfa_49s); + + class DFA108 extends DFA { + + public DFA108(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 108; + this.eot = dfa_13; + this.eof = dfa_44; + this.min = dfa_45; + this.max = dfa_46; + this.accept = dfa_47; + this.special = dfa_48; + this.transition = dfa_49; + } + public String getDescription() { + return "11565:2: ( rule__XAssignment__Group_1_1__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA108_4 = input.LA(1); + + + int index108_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_4); + if ( s>=0 ) return s; + break; + case 1 : + int LA108_3 = input.LA(1); + + + int index108_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_3); + if ( s>=0 ) return s; + break; + case 2 : + int LA108_2 = input.LA(1); + + + int index108_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA108_6 = input.LA(1); + + + int index108_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_6); + if ( s>=0 ) return s; + break; + case 4 : + int LA108_7 = input.LA(1); + + + int index108_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_7); + if ( s>=0 ) return s; + break; + case 5 : + int LA108_1 = input.LA(1); + + + int index108_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_1); + if ( s>=0 ) return s; + break; + case 6 : + int LA108_5 = input.LA(1); + + + int index108_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred182_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index108_5); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 108, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_50s = "\1\1\12\uffff"; + static final String dfa_51s = "\1\4\1\uffff\10\0\1\uffff"; + static final String dfa_52s = "\1\165\1\uffff\10\0\1\uffff"; + static final String dfa_53s = "\1\uffff\1\2\10\uffff\1\1"; + static final String dfa_54s = "\2\uffff\1\2\1\5\1\0\1\6\1\4\1\3\1\1\1\7\1\uffff}>"; + static final String[] dfa_55s = { + "\5\1\6\uffff\5\1\1\uffff\1\3\1\2\5\1\10\uffff\2\1\3\uffff\7\1\1\4\1\5\1\6\1\7\1\10\1\11\13\1\1\uffff\1\1\1\uffff\7\1\2\uffff\2\1\4\uffff\1\1\1\uffff\1\1\1\uffff\1\1\1\uffff\4\1\2\uffff\15\1\10\uffff\2\1", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "" + }; + static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s); + static final char[] dfa_51 = DFA.unpackEncodedStringToUnsignedChars(dfa_51s); + static final char[] dfa_52 = DFA.unpackEncodedStringToUnsignedChars(dfa_52s); + static final short[] dfa_53 = DFA.unpackEncodedString(dfa_53s); + static final short[] dfa_54 = DFA.unpackEncodedString(dfa_54s); + static final short[][] dfa_55 = unpackEncodedStringArray(dfa_55s); + + class DFA114 extends DFA { + + public DFA114(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 114; + this.eot = dfa_7; + this.eof = dfa_50; + this.min = dfa_51; + this.max = dfa_52; + this.accept = dfa_53; + this.special = dfa_54; + this.transition = dfa_55; + } + public String getDescription() { + return "()* loopback of 12861:2: ( rule__XOtherOperatorExpression__Group_1__0 )*"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA114_4 = input.LA(1); + + + int index114_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_4); + if ( s>=0 ) return s; + break; + case 1 : + int LA114_8 = input.LA(1); + + + int index114_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_8); + if ( s>=0 ) return s; + break; + case 2 : + int LA114_2 = input.LA(1); + + + int index114_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA114_7 = input.LA(1); + + + int index114_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_7); + if ( s>=0 ) return s; + break; + case 4 : + int LA114_6 = input.LA(1); + + + int index114_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_6); + if ( s>=0 ) return s; + break; + case 5 : + int LA114_3 = input.LA(1); + + + int index114_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_3); + if ( s>=0 ) return s; + break; + case 6 : + int LA114_5 = input.LA(1); + + + int index114_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_5); + if ( s>=0 ) return s; + break; + case 7 : + int LA114_9 = input.LA(1); + + + int index114_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred188_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index114_9); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 114, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_56s = "\116\uffff"; + static final String dfa_57s = "\1\2\115\uffff"; + static final String dfa_58s = "\1\4\1\0\114\uffff"; + static final String dfa_59s = "\1\165\1\0\114\uffff"; + static final String dfa_60s = "\2\uffff\1\2\112\uffff\1\1"; + static final String dfa_61s = "\1\uffff\1\0\114\uffff}>"; + static final String[] dfa_62s = { + "\5\2\6\uffff\5\2\1\uffff\7\2\10\uffff\2\2\3\uffff\30\2\1\uffff\1\2\1\uffff\7\2\2\uffff\1\1\1\2\4\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\4\2\2\uffff\15\2\10\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s); + static final short[] dfa_57 = DFA.unpackEncodedString(dfa_57s); + static final char[] dfa_58 = DFA.unpackEncodedStringToUnsignedChars(dfa_58s); + static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s); + static final short[] dfa_60 = DFA.unpackEncodedString(dfa_60s); + static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); + static final short[][] dfa_62 = unpackEncodedStringArray(dfa_62s); + + class DFA121 extends DFA { + + public DFA121(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 121; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "14455:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA121_1 = input.LA(1); + + + int index121_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred195_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index121_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 121, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_63s = { + "\5\2\6\uffff\5\2\1\uffff\7\2\10\uffff\2\2\3\uffff\30\2\1\uffff\1\2\1\uffff\4\2\1\1\2\2\2\uffff\2\2\4\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\4\2\2\uffff\15\2\10\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_63 = unpackEncodedStringArray(dfa_63s); + + class DFA122 extends DFA { + + public DFA122(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 122; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_63; + } + public String getDescription() { + return "14481:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA122_1 = input.LA(1); + + + int index122_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index122_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 122, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_64s = "\46\uffff"; + static final String dfa_65s = "\1\4\2\0\43\uffff"; + static final String dfa_66s = "\1\165\2\0\43\uffff"; + static final String dfa_67s = "\3\uffff\1\1\1\uffff\1\2\40\uffff"; + static final String dfa_68s = "\1\uffff\1\0\1\1\43\uffff}>"; + static final String[] dfa_69s = { + "\1\1\4\5\15\uffff\3\5\2\uffff\1\5\10\uffff\2\5\15\uffff\1\3\7\uffff\6\5\1\uffff\1\5\1\uffff\1\5\3\uffff\2\5\3\uffff\1\2\11\uffff\1\5\2\uffff\1\5\2\uffff\1\3\1\uffff\1\5\1\uffff\10\5\1\uffff\1\5\12\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_64 = DFA.unpackEncodedString(dfa_64s); + static final char[] dfa_65 = DFA.unpackEncodedStringToUnsignedChars(dfa_65s); + static final char[] dfa_66 = DFA.unpackEncodedStringToUnsignedChars(dfa_66s); + static final short[] dfa_67 = DFA.unpackEncodedString(dfa_67s); + static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s); + static final short[][] dfa_69 = unpackEncodedStringArray(dfa_69s); + + class DFA130 extends DFA { + + public DFA130(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 130; + this.eot = dfa_64; + this.eof = dfa_64; + this.min = dfa_65; + this.max = dfa_66; + this.accept = dfa_67; + this.special = dfa_68; + this.transition = dfa_69; + } + public String getDescription() { + return "15454:2: ( rule__XClosure__Group_1__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA130_1 = input.LA(1); + + + int index130_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred204_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index130_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA130_2 = input.LA(1); + + + int index130_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred204_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index130_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 130, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_70s = "\42\uffff"; + static final String dfa_71s = "\1\4\2\0\37\uffff"; + static final String dfa_72s = "\1\152\2\0\37\uffff"; + static final String dfa_73s = "\3\uffff\1\1\1\2\35\uffff"; + static final String dfa_74s = "\1\uffff\1\0\1\1\37\uffff}>"; + static final String[] dfa_75s = { + "\1\1\4\4\15\uffff\3\4\2\uffff\1\4\10\uffff\2\4\15\uffff\1\3\10\uffff\5\4\1\uffff\1\4\1\uffff\1\4\3\uffff\1\4\4\uffff\1\2\11\uffff\1\4\2\uffff\1\4\4\uffff\1\4\1\uffff\10\4\1\uffff\1\4", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_70 = DFA.unpackEncodedString(dfa_70s); + static final char[] dfa_71 = DFA.unpackEncodedStringToUnsignedChars(dfa_71s); + static final char[] dfa_72 = DFA.unpackEncodedStringToUnsignedChars(dfa_72s); + static final short[] dfa_73 = DFA.unpackEncodedString(dfa_73s); + static final short[] dfa_74 = DFA.unpackEncodedString(dfa_74s); + static final short[][] dfa_75 = unpackEncodedStringArray(dfa_75s); + + class DFA140 extends DFA { + + public DFA140(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 140; + this.eot = dfa_70; + this.eof = dfa_70; + this.min = dfa_71; + this.max = dfa_72; + this.accept = dfa_73; + this.special = dfa_74; + this.transition = dfa_75; + } + public String getDescription() { + return "16885:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA140_1 = input.LA(1); + + + int index140_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred214_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index140_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA140_2 = input.LA(1); + + + int index140_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred214_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index140_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 140, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA153 extends DFA { + + public DFA153(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 153; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "19018:2: ( rule__XFeatureCall__Group_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA153_1 = input.LA(1); + + + int index153_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred227_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index153_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 153, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA154 extends DFA { + + public DFA154(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 154; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_63; + } + public String getDescription() { + return "19044:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA154_1 = input.LA(1); + + + int index154_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred228_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index154_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 154, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_76s = { + "\5\2\6\uffff\5\2\1\uffff\1\2\1\1\5\2\10\uffff\2\2\3\uffff\30\2\1\uffff\1\2\1\uffff\7\2\2\uffff\2\2\4\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\4\2\2\uffff\15\2\10\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_76 = unpackEncodedStringArray(dfa_76s); + + class DFA158 extends DFA { + + public DFA158(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 158; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_76; + } + public String getDescription() { + return "19504:2: ( rule__XConstructorCall__Group_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA158_1 = input.LA(1); + + + int index158_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred232_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index158_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 158, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA159 extends DFA { + + public DFA159(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 159; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "19531:2: ( rule__XConstructorCall__Group_4__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA159_1 = input.LA(1); + + + int index159_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred233_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index159_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 159, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA160 extends DFA { + + public DFA160(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 160; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_63; + } + public String getDescription() { + return "19557:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA160_1 = input.LA(1); + + + int index160_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred234_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index160_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 160, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_77s = "\1\41\115\uffff"; + static final String dfa_78s = "\1\4\40\0\55\uffff"; + static final String dfa_79s = "\1\165\40\0\55\uffff"; + static final String dfa_80s = "\41\uffff\1\2\53\uffff\1\1"; + static final String dfa_81s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>"; + static final String[] dfa_82s = { + "\1\1\1\23\1\24\1\25\1\27\6\uffff\5\41\1\uffff\1\41\1\15\1\10\1\7\2\41\1\6\10\uffff\1\22\1\21\3\uffff\23\41\1\2\1\3\1\4\1\5\1\16\1\uffff\1\32\1\uffff\1\12\3\41\1\20\2\41\2\uffff\1\40\1\41\4\uffff\1\41\1\uffff\1\41\1\uffff\1\31\1\uffff\1\41\1\13\2\41\2\uffff\1\11\1\41\1\17\1\33\1\34\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41\10\uffff\2\41", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[] dfa_77 = DFA.unpackEncodedString(dfa_77s); + static final char[] dfa_78 = DFA.unpackEncodedStringToUnsignedChars(dfa_78s); + static final char[] dfa_79 = DFA.unpackEncodedStringToUnsignedChars(dfa_79s); + static final short[] dfa_80 = DFA.unpackEncodedString(dfa_80s); + static final short[] dfa_81 = DFA.unpackEncodedString(dfa_81s); + static final short[][] dfa_82 = unpackEncodedStringArray(dfa_82s); + + class DFA165 extends DFA { + + public DFA165(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 165; + this.eot = dfa_56; + this.eof = dfa_77; + this.min = dfa_78; + this.max = dfa_79; + this.accept = dfa_80; + this.special = dfa_81; + this.transition = dfa_82; + } + public String getDescription() { + return "20448:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA165_1 = input.LA(1); + + + int index165_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index165_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA165_2 = input.LA(1); + + + int index165_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index165_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA165_3 = input.LA(1); + + + int index165_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index165_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA165_4 = input.LA(1); + + + int index165_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index165_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA165_5 = input.LA(1); + + + int index165_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index165_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA165_6 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); - } + + int index165_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index165_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA165_7 = input.LA(1); - } + + int index165_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index165_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA165_8 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CollectionExpression__NameAssignment_0" + + int index165_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + else if ( (true) ) {s = 33;} - // $ANTLR start "rule__CollectionExpression__VarAssignment_2_0" - // InternalExport.g:9936:1: rule__CollectionExpression__VarAssignment_2_0 : ( ruleIdentifier ) ; - public final void rule__CollectionExpression__VarAssignment_2_0() throws RecognitionException { + + input.seek(index165_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA165_9 = input.LA(1); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:9940:1: ( ( ruleIdentifier ) ) - // InternalExport.g:9941:2: ( ruleIdentifier ) - { - // InternalExport.g:9941:2: ( ruleIdentifier ) - // InternalExport.g:9942:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + + int index165_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); - } + else if ( (true) ) {s = 33;} - } + + input.seek(index165_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA165_10 = input.LA(1); + + int index165_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + input.seek(index165_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA165_11 = input.LA(1); - restoreStackSize(stackSize); + + int index165_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } - return ; - } - // $ANTLR end "rule__CollectionExpression__VarAssignment_2_0" + else if ( (true) ) {s = 33;} + + input.seek(index165_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA165_12 = input.LA(1); - // $ANTLR start "rule__CollectionExpression__ExpAssignment_3" - // InternalExport.g:9951:1: rule__CollectionExpression__ExpAssignment_3 : ( ruleExpression ) ; - public final void rule__CollectionExpression__ExpAssignment_3() throws RecognitionException { + + int index165_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - int stackSize = keepStackSize(); - - try { - // InternalExport.g:9955:1: ( ( ruleExpression ) ) - // InternalExport.g:9956:2: ( ruleExpression ) - { - // InternalExport.g:9956:2: ( ruleExpression ) - // InternalExport.g:9957:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); - } + + input.seek(index165_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA165_13 = input.LA(1); - } + + int index165_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index165_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA165_14 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index165_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__CollectionExpression__ExpAssignment_3" + + input.seek(index165_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA165_15 = input.LA(1); + + int index165_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - // $ANTLR start "rule__CollectionType__ClAssignment_0" - // InternalExport.g:9966:1: rule__CollectionType__ClAssignment_0 : ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ; - public final void rule__CollectionType__ClAssignment_0() throws RecognitionException { + else if ( (true) ) {s = 33;} - int stackSize = keepStackSize(); - - try { - // InternalExport.g:9970:1: ( ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ) - // InternalExport.g:9971:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) - { - // InternalExport.g:9971:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) - // InternalExport.g:9972:3: ( rule__CollectionType__ClAlternatives_0_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); - } - // InternalExport.g:9973:3: ( rule__CollectionType__ClAlternatives_0_0 ) - // InternalExport.g:9973:4: rule__CollectionType__ClAlternatives_0_0 - { - pushFollow(FOLLOW_2); - rule__CollectionType__ClAlternatives_0_0(); + + input.seek(index165_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA165_16 = input.LA(1); - state._fsp--; - if (state.failed) return ; + + int index165_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); - } + + input.seek(index165_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA165_17 = input.LA(1); - } + + int index165_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index165_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA165_18 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index165_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__CollectionType__ClAssignment_0" + + input.seek(index165_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA165_19 = input.LA(1); + + int index165_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - // $ANTLR start "rule__CollectionType__Id1Assignment_2" - // InternalExport.g:9981:1: rule__CollectionType__Id1Assignment_2 : ( ruleSimpleType ) ; - public final void rule__CollectionType__Id1Assignment_2() throws RecognitionException { + else if ( (true) ) {s = 33;} - int stackSize = keepStackSize(); - - try { - // InternalExport.g:9985:1: ( ( ruleSimpleType ) ) - // InternalExport.g:9986:2: ( ruleSimpleType ) - { - // InternalExport.g:9986:2: ( ruleSimpleType ) - // InternalExport.g:9987:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); + + input.seek(index165_19); + if ( s>=0 ) return s; + break; + case 19 : + int LA165_20 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); - } + + int index165_20 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index165_20); + if ( s>=0 ) return s; + break; + case 20 : + int LA165_21 = input.LA(1); - } + + int index165_21 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index165_21); + if ( s>=0 ) return s; + break; + case 21 : + int LA165_22 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CollectionType__Id1Assignment_2" + + int index165_22 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + else if ( (true) ) {s = 33;} - // $ANTLR start "rule__SimpleType__IdAssignment_0" - // InternalExport.g:9996:1: rule__SimpleType__IdAssignment_0 : ( ruleIdentifier ) ; - public final void rule__SimpleType__IdAssignment_0() throws RecognitionException { + + input.seek(index165_22); + if ( s>=0 ) return s; + break; + case 22 : + int LA165_23 = input.LA(1); - int stackSize = keepStackSize(); - - try { - // InternalExport.g:10000:1: ( ( ruleIdentifier ) ) - // InternalExport.g:10001:2: ( ruleIdentifier ) - { - // InternalExport.g:10001:2: ( ruleIdentifier ) - // InternalExport.g:10002:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + + int index165_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); - } + else if ( (true) ) {s = 33;} - } + + input.seek(index165_23); + if ( s>=0 ) return s; + break; + case 23 : + int LA165_24 = input.LA(1); + + int index165_24 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + input.seek(index165_24); + if ( s>=0 ) return s; + break; + case 24 : + int LA165_25 = input.LA(1); - restoreStackSize(stackSize); + + int index165_25 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } - return ; - } - // $ANTLR end "rule__SimpleType__IdAssignment_0" + else if ( (true) ) {s = 33;} + + input.seek(index165_25); + if ( s>=0 ) return s; + break; + case 25 : + int LA165_26 = input.LA(1); - // $ANTLR start "rule__SimpleType__IdAssignment_1_1" - // InternalExport.g:10011:1: rule__SimpleType__IdAssignment_1_1 : ( ruleIdentifier ) ; - public final void rule__SimpleType__IdAssignment_1_1() throws RecognitionException { + + int index165_26 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - int stackSize = keepStackSize(); - - try { - // InternalExport.g:10015:1: ( ( ruleIdentifier ) ) - // InternalExport.g:10016:2: ( ruleIdentifier ) - { - // InternalExport.g:10016:2: ( ruleIdentifier ) - // InternalExport.g:10017:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); - } + + input.seek(index165_26); + if ( s>=0 ) return s; + break; + case 26 : + int LA165_27 = input.LA(1); - } + + int index165_27 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index165_27); + if ( s>=0 ) return s; + break; + case 27 : + int LA165_28 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index165_28 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__SimpleType__IdAssignment_1_1" + + input.seek(index165_28); + if ( s>=0 ) return s; + break; + case 28 : + int LA165_29 = input.LA(1); - // $ANTLR start synpred6_InternalExport - public final void synpred6_InternalExport_fragment() throws RecognitionException { - // InternalExport.g:1358:2: ( ( ( ruleCastedExpression ) ) ) - // InternalExport.g:1358:2: ( ( ruleCastedExpression ) ) - { - // InternalExport.g:1358:2: ( ( ruleCastedExpression ) ) - // InternalExport.g:1359:3: ( ruleCastedExpression ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - // InternalExport.g:1360:3: ( ruleCastedExpression ) - // InternalExport.g:1360:4: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + + int index165_29 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; + else if ( (true) ) {s = 33;} - } + + input.seek(index165_29); + if ( s>=0 ) return s; + break; + case 29 : + int LA165_30 = input.LA(1); + + int index165_30 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index165_30); + if ( s>=0 ) return s; + break; + case 30 : + int LA165_31 = input.LA(1); - } - } - // $ANTLR end synpred6_InternalExport + + int index165_31 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - // $ANTLR start synpred80_InternalExport - public final void synpred80_InternalExport_fragment() throws RecognitionException { - // InternalExport.g:5142:3: ( rule__IfExpressionKw__Group_4__0 ) - // InternalExport.g:5142:3: rule__IfExpressionKw__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; + + input.seek(index165_31); + if ( s>=0 ) return s; + break; + case 31 : + int LA165_32 = input.LA(1); - } - } - // $ANTLR end synpred80_InternalExport + + int index165_32 = input.index(); + input.rewind(); + s = -1; + if ( (synpred239_InternalExport()) ) {s = 77;} - // Delegated rules + else if ( (true) ) {s = 33;} - public final boolean synpred80_InternalExport() { - state.backtracking++; - int start = input.mark(); - try { - synpred80_InternalExport_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred6_InternalExport() { - state.backtracking++; - int start = input.mark(); - try { - synpred6_InternalExport_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); + + input.seek(index165_32); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 165, _s, input); + error(nvae); + throw nvae; } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; } - - - protected DFA4 dfa4 = new DFA4(this); - static final String dfa_1s = "\36\uffff"; - static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; - static final String dfa_3s = "\1\121\1\uffff\1\0\33\uffff"; - static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; - static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; - static final String[] dfa_6s = { - "\4\3\13\uffff\1\3\2\uffff\16\3\3\uffff\1\3\13\uffff\1\2\6\uffff\1\1\3\uffff\1\3\2\uffff\1\3\4\uffff\2\3\10\uffff\2\3", - "", + static final String dfa_83s = "\117\uffff"; + static final String dfa_84s = "\1\2\116\uffff"; + static final String dfa_85s = "\1\4\1\0\115\uffff"; + static final String dfa_86s = "\1\165\1\0\115\uffff"; + static final String dfa_87s = "\2\uffff\1\2\113\uffff\1\1"; + static final String dfa_88s = "\1\uffff\1\0\115\uffff}>"; + static final String[] dfa_89s = { + "\5\2\6\uffff\5\2\1\uffff\1\2\1\1\5\2\10\uffff\2\2\3\uffff\30\2\1\uffff\1\2\1\uffff\7\2\2\uffff\2\2\4\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\4\2\2\uffff\16\2\7\uffff\2\2", "\1\uffff", "", "", @@ -32609,55 +91018,150 @@ public final boolean synpred6_InternalExport() { "", "", "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", "" }; - static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); - static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); - static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); - static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); - static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); - static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s); + static final short[] dfa_84 = DFA.unpackEncodedString(dfa_84s); + static final char[] dfa_85 = DFA.unpackEncodedStringToUnsignedChars(dfa_85s); + static final char[] dfa_86 = DFA.unpackEncodedStringToUnsignedChars(dfa_86s); + static final short[] dfa_87 = DFA.unpackEncodedString(dfa_87s); + static final short[] dfa_88 = DFA.unpackEncodedString(dfa_88s); + static final short[][] dfa_89 = unpackEncodedStringArray(dfa_89s); - class DFA4 extends DFA { + class DFA174 extends DFA { - public DFA4(BaseRecognizer recognizer) { + public DFA174(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 4; - this.eot = dfa_1; - this.eof = dfa_1; - this.min = dfa_2; - this.max = dfa_3; - this.accept = dfa_4; - this.special = dfa_5; - this.transition = dfa_6; + this.decisionNumber = 174; + this.eot = dfa_83; + this.eof = dfa_84; + this.min = dfa_85; + this.max = dfa_86; + this.accept = dfa_87; + this.special = dfa_88; + this.transition = dfa_89; } public String getDescription() { - return "1347:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) );"; + return "21805:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA4_2 = input.LA(1); + int LA174_1 = input.LA(1); - int index4_2 = input.index(); + int index174_1 = input.index(); input.rewind(); s = -1; - if ( (synpred6_InternalExport()) ) {s = 29;} + if ( (synpred248_InternalExport()) ) {s = 78;} - else if ( (true) ) {s = 3;} + else if ( (true) ) {s = 2;} + + + input.seek(index174_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 174, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA177 extends DFA { + + public DFA177(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 177; + this.eot = dfa_83; + this.eof = dfa_84; + this.min = dfa_85; + this.max = dfa_86; + this.accept = dfa_87; + this.special = dfa_88; + this.transition = dfa_89; + } + public String getDescription() { + return "22075:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA177_1 = input.LA(1); + + + int index177_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred251_InternalExport()) ) {s = 78;} + + else if ( (true) ) {s = 2;} - input.seek(index4_2); + input.seek(index177_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 4, _s, input); + new NoViableAltException(getDescription(), 177, _s, input); error(nvae); throw nvae; } @@ -32666,71 +91170,141 @@ public int specialStateTransition(int s, IntStream _input) throws NoViableAltExc public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000020000000000L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000085000000000L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000020000000002L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000080000000002L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000085000000002L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000080000000010L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000002000000000L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000008000000000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000010000000000L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000012L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000020L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000040000000000L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000B00000000000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000800000000002L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x4408008FFFC800F0L,0x00000000000300C2L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000400000000000L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0006000000040010L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0001000000000000L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0001000000000002L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000040010L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x000A000000040000L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0010000000000000L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000100L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000248000000000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x01A0010000000000L,0x0000000000001800L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0180000000000002L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x4408008FFFC800F0L,0x00000000000302C2L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000800000000000L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0040000000000000L,0x0000000000000400L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0008000000000000L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0001100000000000L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0200000000000000L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0200000000000002L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0800000000000000L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000E00000010L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x1000000000000000L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x1000000000000002L}); - public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x2000000000000000L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x8000000000000000L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); - public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0008008000000000L}); - public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x000000000000000CL}); - public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000008L}); - public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0008008FFFC800F0L,0x00000000000300C0L}); - public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); - public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L}); - public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); - public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); - public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000002L,0x0000000000008000L}); - public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x000000000003F000L}); - public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x000000000003F002L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x00000000000C0000L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x00000000000C0002L}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000300000L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000300002L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000010L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x4418008FFFC800F0L,0x00000000000300C2L}); - public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); - public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x000000007F800000L}); - public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); - public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x4408018FFFC800F0L,0x00000000000300C2L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000012L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x8000000000000000L,0x000000000000000AL}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x4000000000000002L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x8000000000000002L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x8000000000000002L,0x000000000000000AL}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x8000000000000010L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000100L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000004000L,0x0000000000000180L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000004002L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x000001FFF9000350L,0x00080010C4902010L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000800010L,0x0000000000001800L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000400L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000800010L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000800000L,0x0000000000002800L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000000010L,0x0000200000000000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000150L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000000L,0x0003000000068020L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000002L,0x0000000000060000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x000001FFF9000350L,0x00084010C4902010L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000004000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000000000L,0x0000800000010000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000480L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x000001C000000010L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0001000000000000L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0001000000000002L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002010L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000000018000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000002L,0x0000000010000000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x000001FFF9000350L,0x00080010C0002010L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000008002L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000010002L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000002L,0x0004000000000000L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x00000000007E0000L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x00000000007E0002L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000001800000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000001800002L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000006000000L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000006000002L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0400000000000000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0400000000000002L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x000001FFF9000350L,0x00080010C4906010L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0008000000000000L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000FF0000000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x000001FFF9000350L,0x00080010C4902030L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0xF000000000000010L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0xF000003009C001F0L,0x000005FE84802115L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x00003E0000600000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000280000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000C00000060000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000C00000060002L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000680000L,0x0000000100000000L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000680002L,0x0000000100000000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0008000000000010L,0x0000000000002000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x003F000000600000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x003F000000600002L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0004000000000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0008000000400000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x00C0000006000000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x00C0000006000002L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000009800000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0300000000000000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0400000000000000L,0x0010000000080000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0400000000000002L,0x0010000000080000L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0400000000000000L,0x0000000000080000L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0xF000000000400010L,0x0000000000000001L}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002100L}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0008000000000010L,0x0000000000402000L}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000400L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0xF008003009C001F0L,0x000005FEA4806115L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0xF008003009C001F0L,0x000005FEA4802115L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); + public static final BitSet FOLLOW_100 = new BitSet(new long[]{0xF008003009C001F0L,0x000005FEA4802135L}); + public static final BitSet FOLLOW_101 = new BitSet(new long[]{0xF008003009C001F0L,0x000005FEA4802315L}); + public static final BitSet FOLLOW_102 = new BitSet(new long[]{0xF808003009C001F0L,0x002005FEA4802115L}); + public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0008000000000010L,0x0000000020002000L}); + public static final BitSet FOLLOW_104 = new BitSet(new long[]{0xF808003009C001F2L,0x002005FEA4802115L}); + public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0008000000000010L,0x0000000018202420L}); + public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0008000000000012L,0x0000000010202400L}); + public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0008000000000010L,0x0000000010202400L}); + public static final BitSet FOLLOW_110 = new BitSet(new long[]{0xF808003009C001F0L,0x002005FEA4802195L}); + public static final BitSet FOLLOW_111 = new BitSet(new long[]{0xF008003009C001F0L,0x000005FEA4802195L}); + public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); + public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); + public static final BitSet FOLLOW_114 = new BitSet(new long[]{0xF808003009C001F0L,0x002005FEA4802135L}); + public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0800000000000000L,0x0020000000000000L}); + public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L}); + public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000400000L,0x0000000000002100L}); + public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000003000000000L}); + public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x00000000000000E0L}); + public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x00000030000001E0L,0x0000003200000100L}); + public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004100L}); + public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L}); + public static final BitSet FOLLOW_124 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_125 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); + public static final BitSet FOLLOW_126 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L}); + public static final BitSet FOLLOW_127 = new BitSet(new long[]{0x0000000000000000L,0x00000A0000000000L}); + public static final BitSet FOLLOW_128 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L}); + public static final BitSet FOLLOW_129 = new BitSet(new long[]{0x0000000000000002L,0x0000080000000000L}); + public static final BitSet FOLLOW_130 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_131 = new BitSet(new long[]{0x00000000000000C0L}); + public static final BitSet FOLLOW_132 = new BitSet(new long[]{0x0008000000000010L,0x0000000000006000L}); + public static final BitSet FOLLOW_133 = new BitSet(new long[]{0x1000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_134 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L}); + public static final BitSet FOLLOW_135 = new BitSet(new long[]{0x0000000000000002L,0x0000100000000000L}); + public static final BitSet FOLLOW_136 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_137 = new BitSet(new long[]{0x2000000000000010L}); + public static final BitSet FOLLOW_138 = new BitSet(new long[]{0x0000000002000010L}); } \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.export.ui/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.export.ui/META-INF/MANIFEST.MF index bf63d35ad2..e7a4d390ca 100644 --- a/com.avaloq.tools.ddk.xtext.export.ui/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.export.ui/META-INF/MANIFEST.MF @@ -20,8 +20,12 @@ Require-Bundle: org.eclipse.xtext.ui, com.avaloq.tools.ddk.xtext.expression, com.avaloq.tools.ddk.xtext.ui, org.eclipse.compare, - org.eclipse.jdt.ui + org.eclipse.jdt.ui, + org.eclipse.xtext.xbase.ui, + org.eclipse.jdt.debug.ui, + org.eclipse.xtext.common.types.ui Import-Package: org.apache.log4j, org.apache.logging.log4j Export-Package: com.avaloq.tools.ddk.xtext.export.ui.contentassist, - com.avaloq.tools.ddk.xtext.export.ui.quickfix + com.avaloq.tools.ddk.xtext.export.ui.quickfix, + com.avaloq.tools.ddk.xtext.export.ui.editor Automatic-Module-Name: com.avaloq.tools.ddk.xtext.export.ui diff --git a/com.avaloq.tools.ddk.xtext.export.ui/plugin.xml_gen b/com.avaloq.tools.ddk.xtext.export.ui/plugin.xml_gen index 888426aa02..13ba0ed22d 100644 --- a/com.avaloq.tools.ddk.xtext.export.ui/plugin.xml_gen +++ b/com.avaloq.tools.ddk.xtext.export.ui/plugin.xml_gen @@ -9,6 +9,7 @@ default="true" extensions="export" id="com.avaloq.tools.ddk.xtext.export.Export" + matchingStrategy="com.avaloq.tools.ddk.xtext.export.ui.ExportExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher" name="Export Editor"> @@ -310,6 +311,164 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + provideIAllContainersState() { return Access.getJavaProjectsState(); } + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Class bindXtextDocumentProvider() { + return XbaseDocumentProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Class bindOpenGeneratedFileHandler() { + return XbaseOpenGeneratedFileHandler.class; + } + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 public Class bindIProposalConflictHelper() { return AntlrProposalConflictHelper.class; @@ -111,11 +155,6 @@ public void configureContentAssistLexerProvider(Binder binder) { binder.bind(InternalExportLexer.class).toProvider(LexerProvider.create(InternalExportLexer.class)); } - // contributed by org.eclipse.xtext.xtext.generator.exporting.SimpleNamesFragment2 - public Class bindIDependentElementsCalculator() { - return DefaultDependentElementsCalculator.class; - } - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 public void configureIResourceDescriptionsBuilderScope(Binder binder) { binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(CurrentDescriptions.ResourceSetAware.class); @@ -171,6 +210,84 @@ public Class bindIContentProposalProvider() return ExportProposalProvider.class; } + // contributed by org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 + public Class bindPrefixMatcher() { + return FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindFindReferencesHandler() { + return JvmModelFindReferenceHandler.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindReferenceQueryExecutor() { + return JvmModelReferenceQueryExecutor.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIDependentElementsCalculator() { + return JvmModelDependentElementsCalculator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameRefactoringProvider() { + return CombinedJvmJdtRenameRefactoringProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIReferenceUpdater() { + return XbaseReferenceUpdater.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameContextFactory() { + return CombinedJvmJdtRenameContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameStrategy() { + return DefaultJvmModelRenameStrategy.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindJdtRenameParticipant$ContextFactory() { + return JvmModelJdtRenameParticipantContext.ContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindOutlineNodeElementOpener() { + return JvmOutlineNodeElementOpener.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindGlobalURIEditorOpener() { + return GlobalDerivedMemberAwareURIEditorOpener.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIJavaSearchParticipation() { + return IJavaSearchParticipation.No.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public void configureLanguageSpecificURIEditorOpener(Binder binder) { + if (PlatformUI.isWorkbenchRunning()) { + binder.bind(IURIEditorOpener.class).annotatedWith(LanguageSpecific.class).to(DerivedMemberAwareEditorOpener.class); + binder.bind(IDerivedMemberAwareEditorOpener.class).to(DerivedMemberAwareEditorOpener.class); + } + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindJavaTypeQuickfixes() { + return JavaTypeQuickfixesNoImportSection.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindXtextEditor() { + return ExportEditor.class; + } + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 public Class bindIXtextBuilderParticipant() { return BuilderParticipant.class; diff --git a/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/editor/ExportEditor.java b/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/editor/ExportEditor.java new file mode 100644 index 0000000000..7b049f074b --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/editor/ExportEditor.java @@ -0,0 +1,13 @@ +/* + * generated by Xtext + */ +package com.avaloq.tools.ddk.xtext.export.ui.editor; + +import org.eclipse.xtext.xbase.ui.editor.XbaseEditor; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class ExportEditor extends XbaseEditor { +} diff --git a/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/internal/ExportActivator.java b/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/internal/ExportActivator.java index 42a9452b14..8fa387a526 100644 --- a/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/internal/ExportActivator.java +++ b/com.avaloq.tools.ddk.xtext.export.ui/src-gen/com/avaloq/tools/ddk/xtext/export/ui/internal/ExportActivator.java @@ -5,10 +5,10 @@ import com.avaloq.tools.ddk.xtext.export.ExportRuntimeModule; import com.avaloq.tools.ddk.xtext.export.ui.ExportUiModule; -import com.google.common.collect.Maps; import com.google.inject.Guice; import com.google.inject.Injector; import java.util.Collections; +import java.util.HashMap; import java.util.Map; import org.apache.log4j.Logger; import org.eclipse.ui.plugin.AbstractUIPlugin; @@ -29,7 +29,7 @@ public class ExportActivator extends AbstractUIPlugin { private static ExportActivator INSTANCE; - private Map injectors = Collections.synchronizedMap(Maps. newHashMapWithExpectedSize(1)); + private Map injectors = Collections.synchronizedMap(new HashMap<>(2)); @Override public void start(BundleContext context) throws Exception { diff --git a/com.avaloq.tools.ddk.xtext.export/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.export/META-INF/MANIFEST.MF index ccebb87794..6efa3066e1 100644 --- a/com.avaloq.tools.ddk.xtext.export/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.export/META-INF/MANIFEST.MF @@ -7,8 +7,6 @@ Bundle-Vendor: Avaloq Group AG Bundle-RequiredExecutionEnvironment: JavaSE-21 Bundle-ActivationPolicy: lazy Require-Bundle: org.eclipse.xtext, - org.eclipse.xtend, - org.eclipse.xtend.typesystem.emf, org.eclipse.xtext.xtext.generator, org.apache.commons.logging;resolution:=optional, org.eclipse.emf.codegen.ecore;resolution:=optional, @@ -24,7 +22,10 @@ Require-Bundle: org.eclipse.xtext, org.eclipse.core.resources, org.eclipse.core.runtime, org.eclipse.xtext.ui.codetemplates;resolution:=optional, - org.eclipse.xtext.xbase.lib + org.eclipse.xtext.xbase, + org.eclipse.xtext.common.types, + org.eclipse.xtext.xbase.lib, + org.objectweb.asm Export-Package: com.avaloq.tools.ddk.xtext.export, com.avaloq.tools.ddk.xtext.export.export, com.avaloq.tools.ddk.xtext.export.export.impl, @@ -36,6 +37,7 @@ Export-Package: com.avaloq.tools.ddk.xtext.export, com.avaloq.tools.ddk.xtext.export.validation, com.avaloq.tools.ddk.xtext.export.formatting, com.avaloq.tools.ddk.xtext.export.serializer, - com.avaloq.tools.ddk.xtext.export.generator + com.avaloq.tools.ddk.xtext.export.generator, + com.avaloq.tools.ddk.xtext.export.jvmmodel Automatic-Module-Name: com.avaloq.tools.ddk.xtext.export - +Import-Package: org.apache.log4j diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/AbstractExportRuntimeModule.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/AbstractExportRuntimeModule.java index a3768f5850..4044d4fd51 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/AbstractExportRuntimeModule.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/AbstractExportRuntimeModule.java @@ -3,22 +3,11 @@ */ package com.avaloq.tools.ddk.xtext.export; -import com.avaloq.tools.ddk.xtext.export.generator.ExportGenerator; -import com.avaloq.tools.ddk.xtext.export.parser.antlr.ExportAntlrTokenFileProvider; -import com.avaloq.tools.ddk.xtext.export.parser.antlr.ExportParser; -import com.avaloq.tools.ddk.xtext.export.parser.antlr.internal.InternalExportLexer; -import com.avaloq.tools.ddk.xtext.export.scoping.ExportScopeProvider; -import com.avaloq.tools.ddk.xtext.export.serializer.ExportSemanticSequencer; -import com.avaloq.tools.ddk.xtext.export.serializer.ExportSyntacticSequencer; -import com.avaloq.tools.ddk.xtext.export.services.ExportGrammarAccess; -import com.avaloq.tools.ddk.xtext.export.validation.ExportValidator; -import com.google.inject.Binder; -import com.google.inject.Provider; -import com.google.inject.name.Names; import java.util.Properties; + import org.eclipse.xtext.Constants; import org.eclipse.xtext.IGrammarAccess; -import org.eclipse.xtext.generator.IGenerator2; +import org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider; import org.eclipse.xtext.naming.IQualifiedNameProvider; import org.eclipse.xtext.naming.SimpleNameProvider; import org.eclipse.xtext.parser.IParser; @@ -31,6 +20,7 @@ import org.eclipse.xtext.parser.antlr.LexerBindings; import org.eclipse.xtext.parser.antlr.LexerProvider; import org.eclipse.xtext.resource.IContainer; +import org.eclipse.xtext.resource.ILocationInFileProvider; import org.eclipse.xtext.resource.IResourceDescriptions; import org.eclipse.xtext.resource.containers.IAllContainersState; import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; @@ -41,154 +31,219 @@ import org.eclipse.xtext.scoping.IScopeProvider; import org.eclipse.xtext.scoping.IgnoreCaseLinking; import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; -import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider; -import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; import org.eclipse.xtext.serializer.ISerializer; import org.eclipse.xtext.serializer.impl.Serializer; import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; -import org.eclipse.xtext.service.DefaultRuntimeModule; import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.validation.IResourceValidator; +import org.eclipse.xtext.xbase.DefaultXbaseRuntimeModule; +import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator; +import org.eclipse.xtext.xbase.imports.RewritableImportSection; +import org.eclipse.xtext.xbase.jvmmodel.IJvmModelInferrer; +import org.eclipse.xtext.xbase.jvmmodel.JvmLocationInFileProvider; +import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider; +import org.eclipse.xtext.xbase.scoping.batch.IBatchScopeProvider; +import org.eclipse.xtext.xbase.typesystem.internal.DefaultBatchTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.DefaultReentrantTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareBatchTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareReentrantTypeResolver; +import org.eclipse.xtext.xbase.validation.FeatureNameValidator; +import org.eclipse.xtext.xbase.validation.LogicalContainerAwareFeatureNameValidator; + +import com.avaloq.tools.ddk.xtext.export.jvmmodel.ExportJvmModelInferrer; +import com.avaloq.tools.ddk.xtext.export.parser.antlr.ExportAntlrTokenFileProvider; +import com.avaloq.tools.ddk.xtext.export.parser.antlr.ExportParser; +import com.avaloq.tools.ddk.xtext.export.parser.antlr.internal.InternalExportLexer; +import com.avaloq.tools.ddk.xtext.export.scoping.ExportScopeProvider; +import com.avaloq.tools.ddk.xtext.export.serializer.ExportSemanticSequencer; +import com.avaloq.tools.ddk.xtext.export.serializer.ExportSyntacticSequencer; +import com.avaloq.tools.ddk.xtext.export.services.ExportGrammarAccess; +import com.avaloq.tools.ddk.xtext.export.validation.ExportValidator; +import com.google.inject.Binder; +import com.google.inject.Provider; +import com.google.inject.name.Names; + /** * Manual modifications go to {@link ExportRuntimeModule}. */ @SuppressWarnings("all") -public abstract class AbstractExportRuntimeModule extends DefaultRuntimeModule { - - protected Properties properties = null; - - @Override - public void configure(Binder binder) { - properties = tryBindProperties(binder, "com/avaloq/tools/ddk/xtext/export/Export.properties"); - super.configure(binder); - } - - public void configureLanguageName(Binder binder) { - binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("com.avaloq.tools.ddk.xtext.export.Export"); - } - - public void configureFileExtensions(Binder binder) { - if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null) - binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("export"); - } - - // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 - public ClassLoader bindClassLoaderToInstance() { - return getClass().getClassLoader(); - } - - // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 - public Class bindIGrammarAccess() { - return ExportGrammarAccess.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 - public Class bindISemanticSequencer() { - return ExportSemanticSequencer.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 - public Class bindISyntacticSequencer() { - return ExportSyntacticSequencer.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 - public Class bindISerializer() { - return Serializer.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public Class bindIParser() { - return ExportParser.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public Class bindITokenToStringConverter() { - return AntlrTokenToStringConverter.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public Class bindIAntlrTokenFileProvider() { - return ExportAntlrTokenFileProvider.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public Class bindLexer() { - return InternalExportLexer.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public Class bindITokenDefProvider() { - return AntlrTokenDefProvider.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public Provider provideInternalExportLexer() { - return LexerProvider.create(InternalExportLexer.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 - public void configureRuntimeLexer(Binder binder) { - binder.bind(Lexer.class) - .annotatedWith(Names.named(LexerBindings.RUNTIME)) - .to(InternalExportLexer.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 - @SingletonBinding(eager=true) - public Class bindExportValidator() { - return ExportValidator.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public Class bindIScopeProvider() { - return ExportScopeProvider.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public void configureIScopeProviderDelegate(Binder binder) { - binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public Class bindIGlobalScopeProvider() { - return DefaultGlobalScopeProvider.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public void configureIgnoreCaseLinking(Binder binder) { - binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false); - } - - // contributed by org.eclipse.xtext.xtext.generator.exporting.SimpleNamesFragment2 - public Class bindIQualifiedNameProvider() { - return SimpleNameProvider.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 - public Class bindIContainer$Manager() { - return StateBasedContainerManager.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 - public Class bindIAllContainersState$Provider() { - return ResourceSetBasedAllContainersStateProvider.class; - } - - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 - public void configureIResourceDescriptions(Binder binder) { - binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 - public void configureIResourceDescriptionsPersisted(Binder binder) { - binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 - public Class bindIGenerator2() { - return ExportGenerator.class; - } - +public abstract class AbstractExportRuntimeModule extends DefaultXbaseRuntimeModule { + + protected Properties properties = null; + + @Override + public void configure(final Binder binder) { + properties = tryBindProperties(binder, "com/avaloq/tools/ddk/xtext/export/Export.properties"); + super.configure(binder); + } + + public void configureLanguageName(final Binder binder) { + binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("com.avaloq.tools.ddk.xtext.export.Export"); + } + + public void configureFileExtensions(final Binder binder) { + if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null) { + binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("export"); + } + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + @Override + public ClassLoader bindClassLoaderToInstance() { + return getClass().getClassLoader(); + } + + // contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2 + public Class bindIGrammarAccess() { + return ExportGrammarAccess.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + @Override + public Class bindISemanticSequencer() { + return ExportSemanticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + public Class bindISyntacticSequencer() { + return ExportSyntacticSequencer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2 + @Override + public Class bindISerializer() { + return Serializer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIParser() { + return ExportParser.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + @Override + public Class bindITokenToStringConverter() { + return AntlrTokenToStringConverter.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindIAntlrTokenFileProvider() { + return ExportAntlrTokenFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Class bindLexer() { + return InternalExportLexer.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + @Override + public Class bindITokenDefProvider() { + return AntlrTokenDefProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public Provider provideInternalExportLexer() { + return LexerProvider.create(InternalExportLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 + public void configureRuntimeLexer(final Binder binder) { + binder.bind(Lexer.class).annotatedWith(Names.named(LexerBindings.RUNTIME)).to(InternalExportLexer.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2 + @SingletonBinding(eager = true) + public Class bindExportValidator() { + return ExportValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public Class bindIBatchScopeProvider() { + return ExportScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + @Override + public void configureIScopeProviderDelegate(final Binder binder) { + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(XImportSectionNamespaceScopeProvider.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 + public void configureIgnoreCaseLinking(final Binder binder) { + binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false); + } + + // contributed by org.eclipse.xtext.xtext.generator.exporting.SimpleNamesFragment2 + @Override + public Class bindIQualifiedNameProvider() { + return SimpleNameProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + @Override + public Class bindIContainer$Manager() { + return StateBasedContainerManager.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public Class bindIAllContainersState$Provider() { + return ResourceSetBasedAllContainersStateProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + @Override + public void configureIResourceDescriptions(final Binder binder) { + binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 + public void configureIResourceDescriptionsPersisted(final Binder binder) { + binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public void configureRewritableImportSectionEnablement(final Binder binder) { + binder.bind(Boolean.TYPE).annotatedWith(Names.named(RewritableImportSection.Factory.REWRITABLEIMPORTSECTION_ENABLEMENT)).toInstance(Boolean.FALSE); + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + @Override + public Class bindILocationInFileProvider() { + return JvmLocationInFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + @Override + public Class bindIGlobalScopeProvider() { + return TypesAwareDefaultGlobalScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindFeatureNameValidator() { + return LogicalContainerAwareFeatureNameValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindDefaultBatchTypeResolver() { + return LogicalContainerAwareBatchTypeResolver.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindDefaultReentrantTypeResolver() { + return LogicalContainerAwareReentrantTypeResolver.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIResourceValidator() { + return DerivedStateAwareResourceValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIJvmModelInferrer() { + return ExportJvmModelInferrer.class; + } + } diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/Export.xtextbin b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/Export.xtextbin index 02a60e0c1ed78cee68dddf8804762530a67d1ce1..20b2d0dec41c17cbc8fa7d1c02d16e01eb8296b6 100644 GIT binary patch literal 24147 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 diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.g b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.g index 195ceb1d18..af3cec93f2 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.g +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.g @@ -109,7 +109,7 @@ ruleExportModel returns [EObject current=null] $current, "name", lv_name_2_0, - "org.eclipse.xtext.common.Terminals.ID"); + "org.eclipse.xtext.xbase.Xtype.ID"); } ) ) @@ -279,7 +279,7 @@ ruleImport returns [EObject current=null] $current, "name", lv_name_3_0, - "org.eclipse.xtext.common.Terminals.ID"); + "org.eclipse.xtext.xbase.Xtype.ID"); } ) ) @@ -1057,7 +1057,7 @@ ruleUserData returns [EObject current=null] $current, "name", lv_name_0_0, - "org.eclipse.xtext.common.Terminals.ID"); + "org.eclipse.xtext.xbase.Xtype.ID"); } ) ) @@ -2976,7 +2976,7 @@ ruleIntegerLiteral returns [EObject current=null] $current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.INT"); + "org.eclipse.xtext.xbase.Xbase.INT"); } ) ) @@ -3077,7 +3077,7 @@ ruleStringLiteral returns [EObject current=null] $current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.STRING"); + "org.eclipse.xtext.xbase.Xtype.STRING"); } ) ) @@ -3870,13 +3870,6299 @@ ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToke } ; +// Entry rule entryRuleXExpression +entryRuleXExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionRule()); } + iv_ruleXExpression=ruleXExpression + { $current=$iv_ruleXExpression.current; } + EOF; + +// Rule XExpression +ruleXExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + { + newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + this_XAssignment_0=ruleXAssignment + { + $current = $this_XAssignment_0.current; + afterParserOrEnumRuleCall(); + } +; + +// Entry rule entryRuleXAssignment +entryRuleXAssignment returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAssignmentRule()); } + iv_ruleXAssignment=ruleXAssignment + { $current=$iv_ruleXAssignment.current; } + EOF; + +// Rule XAssignment +ruleXAssignment returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAssignmentRule()); + } + } + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + ruleFeatureCallID + { + afterParserOrEnumRuleCall(); + } + ) + ) + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + ruleOpSingleAssign + { + afterParserOrEnumRuleCall(); + } + ( + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + lv_value_3_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + $current, + "value", + lv_value_3_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + this_XOrExpression_4=ruleXOrExpression + { + $current = $this_XOrExpression_4.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpMultiAssign + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAssignmentRule()); + } + } + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + ruleOpMultiAssign + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + lv_rightOperand_7_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_7_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) + ) +; + +// Entry rule entryRuleOpSingleAssign +entryRuleOpSingleAssign returns [String current=null]: + { newCompositeNode(grammarAccess.getOpSingleAssignRule()); } + iv_ruleOpSingleAssign=ruleOpSingleAssign + { $current=$iv_ruleOpSingleAssign.current.getText(); } + EOF; + +// Rule OpSingleAssign +ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } +; + +// Entry rule entryRuleOpMultiAssign +entryRuleOpMultiAssign returns [String current=null]: + { newCompositeNode(grammarAccess.getOpMultiAssignRule()); } + iv_ruleOpMultiAssign=ruleOpMultiAssign + { $current=$iv_ruleOpMultiAssign.current.getText(); } + EOF; + +// Rule OpMultiAssign +ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='+=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + | + kw='-=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + | + kw='*=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + | + kw='/=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + | + kw='%=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + ) + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + )? + kw='>=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + ) + ) +; + +// Entry rule entryRuleXOrExpression +entryRuleXOrExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXOrExpressionRule()); } + iv_ruleXOrExpression=ruleXOrExpression + { $current=$iv_ruleXOrExpression.current; } + EOF; + +// Rule XOrExpression +ruleXOrExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + this_XAndExpression_0=ruleXAndExpression + { + $current = $this_XAndExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpOr + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXOrExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpOr + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXAndExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXOrExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAndExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpOr +entryRuleOpOr returns [String current=null]: + { newCompositeNode(grammarAccess.getOpOrRule()); } + iv_ruleOpOr=ruleOpOr + { $current=$iv_ruleOpOr.current.getText(); } + EOF; + +// Rule OpOr +ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='||' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + } +; + +// Entry rule entryRuleXAndExpression +entryRuleXAndExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAndExpressionRule()); } + iv_ruleXAndExpression=ruleXAndExpression + { $current=$iv_ruleXAndExpression.current; } + EOF; + +// Rule XAndExpression +ruleXAndExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + this_XEqualityExpression_0=ruleXEqualityExpression + { + $current = $this_XEqualityExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpAnd + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAndExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpAnd + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXEqualityExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAndExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XEqualityExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpAnd +entryRuleOpAnd returns [String current=null]: + { newCompositeNode(grammarAccess.getOpAndRule()); } + iv_ruleOpAnd=ruleOpAnd + { $current=$iv_ruleOpAnd.current.getText(); } + EOF; + +// Rule OpAnd +ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='&&' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } +; + +// Entry rule entryRuleXEqualityExpression +entryRuleXEqualityExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXEqualityExpressionRule()); } + iv_ruleXEqualityExpression=ruleXEqualityExpression + { $current=$iv_ruleXEqualityExpression.current; } + EOF; + +// Rule XEqualityExpression +ruleXEqualityExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + this_XRelationalExpression_0=ruleXRelationalExpression + { + $current = $this_XRelationalExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpEquality + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXEqualityExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpEquality + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXRelationalExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XRelationalExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpEquality +entryRuleOpEquality returns [String current=null]: + { newCompositeNode(grammarAccess.getOpEqualityRule()); } + iv_ruleOpEquality=ruleOpEquality + { $current=$iv_ruleOpEquality.current.getText(); } + EOF; + +// Rule OpEquality +ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='==' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + | + kw='!=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + | + kw='===' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + | + kw='!==' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXRelationalExpression +entryRuleXRelationalExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXRelationalExpressionRule()); } + iv_ruleXRelationalExpression=ruleXRelationalExpression + { $current=$iv_ruleXRelationalExpression.current; } + EOF; + +// Rule XRelationalExpression +ruleXRelationalExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression + { + $current = $this_XOtherOperatorExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + ( + (( + ( + ) + 'instanceof' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), + $current); + } + ) + otherlv_2='instanceof' + { + newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + (( + ( + ) + ( + ( + ruleOpCompare + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXRelationalExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + ruleOpCompare + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + lv_rightOperand_6_0=ruleXOtherOperatorExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_6_0, + "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + )* + ) +; + +// Entry rule entryRuleOpCompare +entryRuleOpCompare returns [String current=null]: + { newCompositeNode(grammarAccess.getOpCompareRule()); } + iv_ruleOpCompare=ruleOpCompare + { $current=$iv_ruleOpCompare.current.getText(); } + EOF; + +// Rule OpCompare +ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='>=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + ) + | + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + | + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXOtherOperatorExpression +entryRuleXOtherOperatorExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); } + iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression + { $current=$iv_ruleXOtherOperatorExpression.current; } + EOF; + +// Rule XOtherOperatorExpression +ruleXOtherOperatorExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + this_XAdditiveExpression_0=ruleXAdditiveExpression + { + $current = $this_XAdditiveExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpOther + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpOther + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXAdditiveExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpOther +entryRuleOpOther returns [String current=null]: + { newCompositeNode(grammarAccess.getOpOtherRule()); } + iv_ruleOpOther=ruleOpOther + { $current=$iv_ruleOpOther.current.getText(); } + EOF; + +// Rule OpOther +ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='->' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + | + kw='..<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + kw='..' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + ) + | + kw='..' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + | + kw='=>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + ( + ( + (( + '>' + '>' + ) + )=> + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + ) + ) + | + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + ) + ) + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + ( + ( + (( + '<' + '<' + ) + )=> + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + ) + ) + | + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + | + kw='=>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + ) + ) + | + kw='<>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + | + kw='?:' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + ) +; + +// Entry rule entryRuleXAdditiveExpression +entryRuleXAdditiveExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); } + iv_ruleXAdditiveExpression=ruleXAdditiveExpression + { $current=$iv_ruleXAdditiveExpression.current; } + EOF; + +// Rule XAdditiveExpression +ruleXAdditiveExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression + { + $current = $this_XMultiplicativeExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpAdd + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAdditiveExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpAdd + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXMultiplicativeExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpAdd +entryRuleOpAdd returns [String current=null]: + { newCompositeNode(grammarAccess.getOpAddRule()); } + iv_ruleOpAdd=ruleOpAdd + { $current=$iv_ruleOpAdd.current.getText(); } + EOF; + +// Rule OpAdd +ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='+' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + | + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + ) +; + +// Entry rule entryRuleXMultiplicativeExpression +entryRuleXMultiplicativeExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); } + iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression + { $current=$iv_ruleXMultiplicativeExpression.current; } + EOF; + +// Rule XMultiplicativeExpression +ruleXMultiplicativeExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + this_XUnaryOperation_0=ruleXUnaryOperation + { + $current = $this_XUnaryOperation_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpMulti + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpMulti + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXUnaryOperation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpMulti +entryRuleOpMulti returns [String current=null]: + { newCompositeNode(grammarAccess.getOpMultiRule()); } + iv_ruleOpMulti=ruleOpMulti + { $current=$iv_ruleOpMulti.current.getText(); } + EOF; + +// Rule OpMulti +ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + | + kw='**' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + | + kw='/' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + | + kw='%' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXUnaryOperation +entryRuleXUnaryOperation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXUnaryOperationRule()); } + iv_ruleXUnaryOperation=ruleXUnaryOperation + { $current=$iv_ruleXUnaryOperation.current; } + EOF; + +// Rule XUnaryOperation +ruleXUnaryOperation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXUnaryOperationRule()); + } + } + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + ruleOpUnary + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + lv_operand_2_0=ruleXUnaryOperation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXUnaryOperationRule()); + } + set( + $current, + "operand", + lv_operand_2_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + this_XCastedExpression_3=ruleXCastedExpression + { + $current = $this_XCastedExpression_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleOpUnary +entryRuleOpUnary returns [String current=null]: + { newCompositeNode(grammarAccess.getOpUnaryRule()); } + iv_ruleOpUnary=ruleOpUnary + { $current=$iv_ruleOpUnary.current.getText(); } + EOF; + +// Rule OpUnary +ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='!' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + | + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + | + kw='+' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + ) +; + +// Entry rule entryRuleXCastedExpression +entryRuleXCastedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCastedExpressionRule()); } + iv_ruleXCastedExpression=ruleXCastedExpression + { $current=$iv_ruleXCastedExpression.current; } + EOF; + +// Rule XCastedExpression +ruleXCastedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + this_XPostfixOperation_0=ruleXPostfixOperation + { + $current = $this_XPostfixOperation_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + 'as' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(), + $current); + } + ) + otherlv_2='as' + { + newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCastedExpressionRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleXPostfixOperation +entryRuleXPostfixOperation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXPostfixOperationRule()); } + iv_ruleXPostfixOperation=ruleXPostfixOperation + { $current=$iv_ruleXPostfixOperation.current; } + EOF; + +// Rule XPostfixOperation +ruleXPostfixOperation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + this_XMemberFeatureCall_0=ruleXMemberFeatureCall + { + $current = $this_XMemberFeatureCall_0.current; + afterParserOrEnumRuleCall(); + } + ( + (( + ( + ) + ( + ( + ruleOpPostfix + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXPostfixOperationRule()); + } + } + { + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + ruleOpPostfix + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + )? + ) +; + +// Entry rule entryRuleOpPostfix +entryRuleOpPostfix returns [String current=null]: + { newCompositeNode(grammarAccess.getOpPostfixRule()); } + iv_ruleOpPostfix=ruleOpPostfix + { $current=$iv_ruleOpPostfix.current.getText(); } + EOF; + +// Rule OpPostfix +ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='++' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + | + kw='--' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + ) +; + +// Entry rule entryRuleXMemberFeatureCall +entryRuleXMemberFeatureCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); } + iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall + { $current=$iv_ruleXMemberFeatureCall.current; } + EOF; + +// Rule XMemberFeatureCall +ruleXMemberFeatureCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + this_XPrimaryExpression_0=ruleXPrimaryExpression + { + $current = $this_XPrimaryExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + ( + (( + ( + ) + ( + '.' + | + ( + ( + '::' + ) + ) + ) + ( + ( + ruleFeatureCallID + ) + ) + ruleOpSingleAssign + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(), + $current); + } + ) + ( + otherlv_2='.' + { + newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + | + ( + ( + lv_explicitStatic_3_0='::' + { + newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitStatic", lv_explicitStatic_3_0 != null, "::"); + } + ) + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + ruleFeatureCallID + { + afterParserOrEnumRuleCall(); + } + ) + ) + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + ruleOpSingleAssign + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + lv_value_6_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + set( + $current, + "value", + lv_value_6_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + (( + ( + ) + ( + '.' + | + ( + ( + '?.' + ) + ) + | + ( + ( + '::' + ) + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), + $current); + } + ) + ( + otherlv_8='.' + { + newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + | + ( + ( + lv_nullSafe_9_0='?.' + { + newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "nullSafe", lv_nullSafe_9_0 != null, "?."); + } + ) + ) + | + ( + ( + lv_explicitStatic_10_0='::' + { + newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitStatic", lv_explicitStatic_10_0 != null, "::"); + } + ) + ) + ) + ) + ) + ( + otherlv_11='<' + { + newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + lv_typeArguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_13=',' + { + newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + lv_typeArguments_14_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_14_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15='>' + { + newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + ruleIdOrSuper + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitOperationCall_17_0='(' + { + newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitOperationCall", lv_explicitOperationCall_17_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + lv_memberCallArguments_18_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_18_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + lv_memberCallArguments_19_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_19_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_20=',' + { + newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + lv_memberCallArguments_21_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_21_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_22=')' + { + newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + lv_memberCallArguments_23_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_23_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) + )* + ) +; + +// Entry rule entryRuleXPrimaryExpression +entryRuleXPrimaryExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); } + iv_ruleXPrimaryExpression=ruleXPrimaryExpression + { $current=$iv_ruleXPrimaryExpression.current; } + EOF; + +// Rule XPrimaryExpression +ruleXPrimaryExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } + this_XConstructorCall_0=ruleXConstructorCall + { + $current = $this_XConstructorCall_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + this_XBlockExpression_1=ruleXBlockExpression + { + $current = $this_XBlockExpression_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + this_XSwitchExpression_2=ruleXSwitchExpression + { + $current = $this_XSwitchExpression_2.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + 'synchronized' + '(' + ) + )=> + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + this_XSynchronizedExpression_3=ruleXSynchronizedExpression + { + $current = $this_XSynchronizedExpression_3.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } + this_XFeatureCall_4=ruleXFeatureCall + { + $current = $this_XFeatureCall_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } + this_XLiteral_5=ruleXLiteral + { + $current = $this_XLiteral_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } + this_XIfExpression_6=ruleXIfExpression + { + $current = $this_XIfExpression_6.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + 'for' + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + this_XForLoopExpression_7=ruleXForLoopExpression + { + $current = $this_XForLoopExpression_7.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression + { + $current = $this_XBasicForLoopExpression_8.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } + this_XWhileExpression_9=ruleXWhileExpression + { + $current = $this_XWhileExpression_9.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } + this_XDoWhileExpression_10=ruleXDoWhileExpression + { + $current = $this_XDoWhileExpression_10.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } + this_XThrowExpression_11=ruleXThrowExpression + { + $current = $this_XThrowExpression_11.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + this_XReturnExpression_12=ruleXReturnExpression + { + $current = $this_XReturnExpression_12.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression + { + $current = $this_XTryCatchFinallyExpression_13.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + this_XParenthesizedExpression_14=ruleXParenthesizedExpression + { + $current = $this_XParenthesizedExpression_14.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXLiteral +entryRuleXLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXLiteralRule()); } + iv_ruleXLiteral=ruleXLiteral + { $current=$iv_ruleXLiteral.current; } + EOF; + +// Rule XLiteral +ruleXLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } + this_XCollectionLiteral_0=ruleXCollectionLiteral + { + $current = $this_XCollectionLiteral_0.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + '[' + ) + )=> + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } + this_XClosure_1=ruleXClosure + { + $current = $this_XClosure_1.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + this_XBooleanLiteral_2=ruleXBooleanLiteral + { + $current = $this_XBooleanLiteral_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + this_XNumberLiteral_3=ruleXNumberLiteral + { + $current = $this_XNumberLiteral_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + this_XNullLiteral_4=ruleXNullLiteral + { + $current = $this_XNullLiteral_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + this_XStringLiteral_5=ruleXStringLiteral + { + $current = $this_XStringLiteral_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + this_XTypeLiteral_6=ruleXTypeLiteral + { + $current = $this_XTypeLiteral_6.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXCollectionLiteral +entryRuleXCollectionLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCollectionLiteralRule()); } + iv_ruleXCollectionLiteral=ruleXCollectionLiteral + { $current=$iv_ruleXCollectionLiteral.current; } + EOF; + +// Rule XCollectionLiteral +ruleXCollectionLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + this_XSetLiteral_0=ruleXSetLiteral + { + $current = $this_XSetLiteral_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + this_XListLiteral_1=ruleXListLiteral + { + $current = $this_XListLiteral_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXSetLiteral +entryRuleXSetLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSetLiteralRule()); } + iv_ruleXSetLiteral=ruleXSetLiteral + { $current=$iv_ruleXSetLiteral.current; } + EOF; + +// Rule XSetLiteral +ruleXSetLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(), + $current); + } + ) + otherlv_1='#' + { + newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + otherlv_2='{' + { + newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + lv_elements_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + $current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + lv_elements_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + $current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6='}' + { + newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleXListLiteral +entryRuleXListLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXListLiteralRule()); } + iv_ruleXListLiteral=ruleXListLiteral + { $current=$iv_ruleXListLiteral.current; } + EOF; + +// Rule XListLiteral +ruleXListLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(), + $current); + } + ) + otherlv_1='#' + { + newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + otherlv_2='[' + { + newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + lv_elements_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + $current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + lv_elements_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + $current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=']' + { + newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleXClosure +entryRuleXClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXClosureRule()); } + iv_ruleXClosure=ruleXClosure + { $current=$iv_ruleXClosure.current; } + EOF; + +// Rule XClosure +ruleXClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + '[' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(), + $current); + } + ) + otherlv_1='[' + { + newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + ) + ) + ( + (( + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + lv_declaredFormalParameters_2_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_2_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + lv_declaredFormalParameters_4_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_4_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + lv_explicitSyntax_5_0='|' + { + newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXClosureRule()); + } + setWithLastConsumed($current, "explicitSyntax", lv_explicitSyntax_5_0 != null, "|"); + } + ) + ) + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + lv_expression_6_0=ruleXExpressionInClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + set( + $current, + "expression", + lv_expression_6_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_7=']' + { + newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + ) +; + +// Entry rule entryRuleXExpressionInClosure +entryRuleXExpressionInClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionInClosureRule()); } + iv_ruleXExpressionInClosure=ruleXExpressionInClosure + { $current=$iv_ruleXExpressionInClosure.current; } + EOF; + +// Rule XExpressionInClosure +ruleXExpressionInClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(), + $current); + } + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + lv_expressions_1_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule()); + } + add( + $current, + "expressions", + lv_expressions_1_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=';' + { + newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + )? + )* + ) +; + +// Entry rule entryRuleXShortClosure +entryRuleXShortClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXShortClosureRule()); } + iv_ruleXShortClosure=ruleXShortClosure + { $current=$iv_ruleXShortClosure.current; } + EOF; + +// Rule XShortClosure +ruleXShortClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(), + $current); + } + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + lv_declaredFormalParameters_1_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_1_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + lv_declaredFormalParameters_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + lv_explicitSyntax_4_0='|' + { + newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXShortClosureRule()); + } + setWithLastConsumed($current, "explicitSyntax", lv_explicitSyntax_4_0 != null, "|"); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + lv_expression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + set( + $current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXParenthesizedExpression +entryRuleXParenthesizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); } + iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression + { $current=$iv_ruleXParenthesizedExpression.current; } + EOF; + +// Rule XParenthesizedExpression +ruleXParenthesizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + { + newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + this_XExpression_1=ruleXExpression + { + $current = $this_XExpression_1.current; + afterParserOrEnumRuleCall(); + } + otherlv_2=')' + { + newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + ) +; + +// Entry rule entryRuleXIfExpression +entryRuleXIfExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXIfExpressionRule()); } + iv_ruleXIfExpression=ruleXIfExpression + { $current=$iv_ruleXIfExpression.current; } + EOF; + +// Rule XIfExpression +ruleXIfExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(), + $current); + } + ) + otherlv_1='if' + { + newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + lv_if_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "if", + lv_if_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + lv_then_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('else')=> + otherlv_6='else' + { + newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + lv_else_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "else", + lv_else_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleXSwitchExpression +entryRuleXSwitchExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSwitchExpressionRule()); } + iv_ruleXSwitchExpression=ruleXSwitchExpression + { $current=$iv_ruleXSwitchExpression.current; } + EOF; + +// Rule XSwitchExpression +ruleXSwitchExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(), + $current); + } + ) + otherlv_1='switch' + { + newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + ( + ( + ( + (( + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + lv_declaredParam_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + lv_switch_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "switch", + lv_switch_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + ) + | + ( + ( + (( + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + lv_declaredParam_7_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_7_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_8=':' + { + newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + lv_switch_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "switch", + lv_switch_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + otherlv_10='{' + { + newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + lv_cases_11_0=ruleXCasePart + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + add( + $current, + "cases", + lv_cases_11_0, + "org.eclipse.xtext.xbase.Xbase.XCasePart"); + afterParserOrEnumRuleCall(); + } + ) + )* + ( + otherlv_12='default' + { + newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + otherlv_13=':' + { + newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + lv_default_14_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "default", + lv_default_14_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + otherlv_15='}' + { + newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + ) +; + +// Entry rule entryRuleXCasePart +entryRuleXCasePart returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCasePartRule()); } + iv_ruleXCasePart=ruleXCasePart + { $current=$iv_ruleXCasePart.current; } + EOF; + +// Rule XCasePart +ruleXCasePart returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXCasePartAccess().getXCasePartAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeGuard_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "typeGuard", + lv_typeGuard_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + otherlv_2='case' + { + newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + lv_case_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "case", + lv_case_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + ( + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + lv_then_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + lv_fallThrough_6_0=',' + { + newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXCasePartRule()); + } + setWithLastConsumed($current, "fallThrough", lv_fallThrough_6_0 != null, ","); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleXForLoopExpression +entryRuleXForLoopExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXForLoopExpressionRule()); } + iv_ruleXForLoopExpression=ruleXForLoopExpression + { $current=$iv_ruleXForLoopExpression.current; } + EOF; + +// Rule XForLoopExpression +ruleXForLoopExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + 'for' + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(), + $current); + } + ) + otherlv_1='for' + { + newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + lv_declaredParam_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + lv_forExpression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "forExpression", + lv_forExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + lv_eachExpression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "eachExpression", + lv_eachExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXBasicForLoopExpression +entryRuleXBasicForLoopExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); } + iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression + { $current=$iv_ruleXBasicForLoopExpression.current; } + EOF; + +// Rule XBasicForLoopExpression +ruleXBasicForLoopExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(), + $current); + } + ) + otherlv_1='for' + { + newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "initExpressions", + lv_initExpressions_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "initExpressions", + lv_initExpressions_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=';' + { + newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + lv_expression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + $current, + "expression", + lv_expression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + )? + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + lv_updateExpressions_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "updateExpressions", + lv_updateExpressions_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_10=',' + { + newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + lv_updateExpressions_11_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "updateExpressions", + lv_updateExpressions_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_12=')' + { + newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + lv_eachExpression_13_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + $current, + "eachExpression", + lv_eachExpression_13_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXWhileExpression +entryRuleXWhileExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXWhileExpressionRule()); } + iv_ruleXWhileExpression=ruleXWhileExpression + { $current=$iv_ruleXWhileExpression.current; } + EOF; + +// Rule XWhileExpression +ruleXWhileExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(), + $current); + } + ) + otherlv_1='while' + { + newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + lv_predicate_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + $current, + "predicate", + lv_predicate_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + lv_body_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + $current, + "body", + lv_body_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXDoWhileExpression +entryRuleXDoWhileExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); } + iv_ruleXDoWhileExpression=ruleXDoWhileExpression + { $current=$iv_ruleXDoWhileExpression.current; } + EOF; + +// Rule XDoWhileExpression +ruleXDoWhileExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(), + $current); + } + ) + otherlv_1='do' + { + newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + lv_body_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + $current, + "body", + lv_body_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3='while' + { + newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + otherlv_4='(' + { + newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + lv_predicate_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + $current, + "predicate", + lv_predicate_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + ) +; + +// Entry rule entryRuleXBlockExpression +entryRuleXBlockExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBlockExpressionRule()); } + iv_ruleXBlockExpression=ruleXBlockExpression + { $current=$iv_ruleXBlockExpression.current; } + EOF; + +// Rule XBlockExpression +ruleXBlockExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(), + $current); + } + ) + otherlv_1='{' + { + newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + lv_expressions_2_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBlockExpressionRule()); + } + add( + $current, + "expressions", + lv_expressions_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=';' + { + newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + )? + )* + otherlv_4='}' + { + newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + ) +; + +// Entry rule entryRuleXExpressionOrVarDeclaration +entryRuleXExpressionOrVarDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); } + iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration + { $current=$iv_ruleXExpressionOrVarDeclaration.current; } + EOF; + +// Rule XExpressionOrVarDeclaration +ruleXExpressionOrVarDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } + this_XVariableDeclaration_0=ruleXVariableDeclaration + { + $current = $this_XVariableDeclaration_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } + this_XExpression_1=ruleXExpression + { + $current = $this_XExpression_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXVariableDeclaration +entryRuleXVariableDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXVariableDeclarationRule()); } + iv_ruleXVariableDeclaration=ruleXVariableDeclaration + { $current=$iv_ruleXVariableDeclaration.current; } + EOF; + +// Rule XVariableDeclaration +ruleXVariableDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(), + $current); + } + ) + ( + ( + ( + lv_writeable_1_0='var' + { + newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXVariableDeclarationRule()); + } + setWithLastConsumed($current, "writeable", lv_writeable_1_0 != null, "var"); + } + ) + ) + | + otherlv_2='val' + { + newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + ) + ( + ( + (( + ( + ( + ruleJvmTypeReference + ) + ) + ( + ( + ruleValidID + ) + ) + ) + )=> + ( + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + lv_name_4_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "name", + lv_name_4_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + lv_name_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "name", + lv_name_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_6='=' + { + newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + lv_right_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "right", + lv_right_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleJvmFormalParameter +entryRuleJvmFormalParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmFormalParameterRule()); } + iv_ruleJvmFormalParameter=ruleJvmFormalParameter + { $current=$iv_ruleJvmFormalParameter.current; } + EOF; + +// Rule JvmFormalParameter +ruleJvmFormalParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + lv_parameterType_0_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + $current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + lv_name_1_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleFullJvmFormalParameter +entryRuleFullJvmFormalParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); } + iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter + { $current=$iv_ruleFullJvmFormalParameter.current; } + EOF; + +// Rule FullJvmFormalParameter +ruleFullJvmFormalParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + lv_parameterType_0_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + $current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + lv_name_1_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXFeatureCall +entryRuleXFeatureCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFeatureCallRule()); } + iv_ruleXFeatureCall=ruleXFeatureCall + { $current=$iv_ruleXFeatureCall.current; } + EOF; + +// Rule XFeatureCall +ruleXFeatureCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(), + $current); + } + ) + ( + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_typeArguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_typeArguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + ruleIdOrSuper + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitOperationCall_7_0='(' + { + newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + setWithLastConsumed($current, "explicitOperationCall", lv_explicitOperationCall_7_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + lv_featureCallArguments_8_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_8_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + lv_featureCallArguments_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_10=',' + { + newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + lv_featureCallArguments_11_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_12=')' + { + newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + lv_featureCallArguments_13_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_13_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleFeatureCallID +entryRuleFeatureCallID returns [String current=null]: + { newCompositeNode(grammarAccess.getFeatureCallIDRule()); } + iv_ruleFeatureCallID=ruleFeatureCallID + { $current=$iv_ruleFeatureCallID.current.getText(); } + EOF; + +// Rule FeatureCallID +ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + | + kw='extends' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + | + kw='static' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + | + kw='import' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + | + kw='extension' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + ) +; + +// Entry rule entryRuleIdOrSuper +entryRuleIdOrSuper returns [String current=null]: + { newCompositeNode(grammarAccess.getIdOrSuperRule()); } + iv_ruleIdOrSuper=ruleIdOrSuper + { $current=$iv_ruleIdOrSuper.current.getText(); } + EOF; + +// Rule IdOrSuper +ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + this_FeatureCallID_0=ruleFeatureCallID + { + $current.merge(this_FeatureCallID_0); + } + { + afterParserOrEnumRuleCall(); + } + | + kw='super' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + ) +; + +// Entry rule entryRuleXConstructorCall +entryRuleXConstructorCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXConstructorCallRule()); } + iv_ruleXConstructorCall=ruleXConstructorCall + { $current=$iv_ruleXConstructorCall.current; } + EOF; + +// Rule XConstructorCall +ruleXConstructorCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(), + $current); + } + ) + otherlv_1='new' + { + newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_3='<' + { + newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + lv_typeArguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_5=',' + { + newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + lv_typeArguments_6_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_7='>' + { + newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + )? + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitConstructorCall_8_0='(' + { + newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + setWithLastConsumed($current, "explicitConstructorCall", lv_explicitConstructorCall_8_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + lv_arguments_9_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + lv_arguments_10_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + lv_arguments_12_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_13=')' + { + newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + lv_arguments_14_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_14_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleXBooleanLiteral +entryRuleXBooleanLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBooleanLiteralRule()); } + iv_ruleXBooleanLiteral=ruleXBooleanLiteral + { $current=$iv_ruleXBooleanLiteral.current; } + EOF; + +// Rule XBooleanLiteral +ruleXBooleanLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(), + $current); + } + ) + ( + otherlv_1='false' + { + newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + | + ( + ( + lv_isTrue_2_0='true' + { + newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXBooleanLiteralRule()); + } + setWithLastConsumed($current, "isTrue", lv_isTrue_2_0 != null, "true"); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleXNullLiteral +entryRuleXNullLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXNullLiteralRule()); } + iv_ruleXNullLiteral=ruleXNullLiteral + { $current=$iv_ruleXNullLiteral.current; } + EOF; + +// Rule XNullLiteral +ruleXNullLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(), + $current); + } + ) + otherlv_1='null' + { + newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + ) +; + +// Entry rule entryRuleXNumberLiteral +entryRuleXNumberLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXNumberLiteralRule()); } + iv_ruleXNumberLiteral=ruleXNumberLiteral + { $current=$iv_ruleXNumberLiteral.current; } + EOF; + +// Rule XNumberLiteral +ruleXNumberLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + lv_value_1_0=ruleNumber + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXNumberLiteralRule()); + } + set( + $current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xbase.Number"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXStringLiteral +entryRuleXStringLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXStringLiteralRule()); } + iv_ruleXStringLiteral=ruleXStringLiteral + { $current=$iv_ruleXStringLiteral.current; } + EOF; + +// Rule XStringLiteral +ruleXStringLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(), + $current); + } + ) + ( + ( + lv_value_1_0=RULE_STRING + { + newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXStringLiteralRule()); + } + setWithLastConsumed( + $current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + } + ) + ) + ) +; + +// Entry rule entryRuleXTypeLiteral +entryRuleXTypeLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXTypeLiteralRule()); } + iv_ruleXTypeLiteral=ruleXTypeLiteral + { $current=$iv_ruleXTypeLiteral.current; } + EOF; + +// Rule XTypeLiteral +ruleXTypeLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(), + $current); + } + ) + otherlv_1='typeof' + { + newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXTypeLiteralRule()); + } + } + { + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + lv_arrayDimensions_4_0=ruleArrayBrackets + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTypeLiteralRule()); + } + add( + $current, + "arrayDimensions", + lv_arrayDimensions_4_0, + "org.eclipse.xtext.xbase.Xtype.ArrayBrackets"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_5=')' + { + newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + ) +; + +// Entry rule entryRuleXThrowExpression +entryRuleXThrowExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXThrowExpressionRule()); } + iv_ruleXThrowExpression=ruleXThrowExpression + { $current=$iv_ruleXThrowExpression.current; } + EOF; + +// Rule XThrowExpression +ruleXThrowExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(), + $current); + } + ) + otherlv_1='throw' + { + newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXThrowExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXReturnExpression +entryRuleXReturnExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXReturnExpressionRule()); } + iv_ruleXReturnExpression=ruleXReturnExpression + { $current=$iv_ruleXReturnExpression.current; } + EOF; + +// Rule XReturnExpression +ruleXReturnExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(), + $current); + } + ) + otherlv_1='return' + { + newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + ( + ('extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING)=> + ( + { + newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXReturnExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleXTryCatchFinallyExpression +entryRuleXTryCatchFinallyExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); } + iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression + { $current=$iv_ruleXTryCatchFinallyExpression.current; } + EOF; + +// Rule XTryCatchFinallyExpression +ruleXTryCatchFinallyExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(), + $current); + } + ) + otherlv_1='try' + { + newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + ('catch')=> + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + lv_catchClauses_3_0=ruleXCatchClause + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + add( + $current, + "catchClauses", + lv_catchClauses_3_0, + "org.eclipse.xtext.xbase.Xbase.XCatchClause"); + afterParserOrEnumRuleCall(); + } + ) + )+ + ( + ( + ('finally')=> + otherlv_4='finally' + { + newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + lv_finallyExpression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "finallyExpression", + lv_finallyExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) + | + ( + otherlv_6='finally' + { + newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + lv_finallyExpression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "finallyExpression", + lv_finallyExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ) +; + +// Entry rule entryRuleXSynchronizedExpression +entryRuleXSynchronizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); } + iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression + { $current=$iv_ruleXSynchronizedExpression.current; } + EOF; + +// Rule XSynchronizedExpression +ruleXSynchronizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + 'synchronized' + '(' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(), + $current); + } + ) + otherlv_1='synchronized' + { + newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + lv_param_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + $current, + "param", + lv_param_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + lv_expression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + $current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXCatchClause +entryRuleXCatchClause returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCatchClauseRule()); } + iv_ruleXCatchClause=ruleXCatchClause + { $current=$iv_ruleXCatchClause.current; } + EOF; + +// Rule XCatchClause +ruleXCatchClause returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ('catch')=> + otherlv_0='catch' + { + newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + ) + otherlv_1='(' + { + newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + lv_declaredParam_2_0=ruleFullJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_2_0, + "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3=')' + { + newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + lv_expression_4_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + $current, + "expression", + lv_expression_4_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameRule()); } + iv_ruleQualifiedName=ruleQualifiedName + { $current=$iv_ruleQualifiedName.current.getText(); } + EOF; + +// Rule QualifiedName +ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + ( + ( + ('.')=> + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + ) + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + this_ValidID_2=ruleValidID + { + $current.merge(this_ValidID_2); + } + { + afterParserOrEnumRuleCall(); + } + )* + ) +; + +// Entry rule entryRuleNumber +entryRuleNumber returns [String current=null]@init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +}: + { newCompositeNode(grammarAccess.getNumberRule()); } + iv_ruleNumber=ruleNumber + { $current=$iv_ruleNumber.current.getText(); } + EOF; +finally { + myHiddenTokenState.restore(); +} + +// Rule Number +ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +} +@after { + leaveRule(); +}: + ( + this_HEX_0=RULE_HEX + { + $current.merge(this_HEX_0); + } + { + newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + | + ( + ( + this_INT_1=RULE_INT + { + $current.merge(this_INT_1); + } + { + newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + | + this_DECIMAL_2=RULE_DECIMAL + { + $current.merge(this_DECIMAL_2); + } + { + newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + ) + ( + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + ( + this_INT_4=RULE_INT + { + $current.merge(this_INT_4); + } + { + newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + | + this_DECIMAL_5=RULE_DECIMAL + { + $current.merge(this_DECIMAL_5); + } + { + newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + ) + )? + ) + ) +; +finally { + myHiddenTokenState.restore(); +} + +// Entry rule entryRuleJvmTypeReference +entryRuleJvmTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); } + iv_ruleJvmTypeReference=ruleJvmTypeReference + { $current=$iv_ruleJvmTypeReference.current; } + EOF; + +// Rule JvmTypeReference +ruleJvmTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference + { + $current = $this_JvmParameterizedTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + ( + (( + ( + ) + ruleArrayBrackets + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + $current); + } + ) + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + ruleArrayBrackets + { + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + this_XFunctionTypeRef_3=ruleXFunctionTypeRef + { + $current = $this_XFunctionTypeRef_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets returns [String current=null]: + { newCompositeNode(grammarAccess.getArrayBracketsRule()); } + iv_ruleArrayBrackets=ruleArrayBrackets + { $current=$iv_ruleArrayBrackets.current.getText(); } + EOF; + +// Rule ArrayBrackets +ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='[' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + kw=']' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + ) +; + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); } + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef + { $current=$iv_ruleXFunctionTypeRef.current; } + EOF; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + lv_paramTypes_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + lv_paramTypes_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + )? + otherlv_5='=>' + { + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + lv_returnType_6_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + $current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference + { $current=$iv_ruleJvmParameterizedTypeReference.current; } + EOF; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_arguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_arguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + ( + ( + (( + ( + ) + '.' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + $current); + } + ) + otherlv_7='.' + { + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + ruleValidID + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_9='<' + { + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + lv_arguments_10_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + lv_arguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_13='>' + { + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + )? + )* + )? + ) +; + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); } + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference + { $current=$iv_ruleJvmArgumentTypeReference.current; } + EOF; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + this_JvmTypeReference_0=ruleJvmTypeReference + { + $current = $this_JvmTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference + { + $current = $this_JvmWildcardTypeReference_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); } + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference + { $current=$iv_ruleJvmWildcardTypeReference.current; } + EOF; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + $current); + } + ) + otherlv_1='?' + { + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + lv_constraints_2_0=ruleJvmUpperBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + lv_constraints_3_0=ruleJvmUpperBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + lv_constraints_4_0=ruleJvmLowerBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + lv_constraints_5_0=ruleJvmLowerBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + )? + ) +; + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundRule()); } + iv_ruleJvmUpperBound=ruleJvmUpperBound + { $current=$iv_ruleJvmUpperBound.current; } + EOF; + +// Rule JvmUpperBound +ruleJvmUpperBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='extends' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); } + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded + { $current=$iv_ruleJvmUpperBoundAnded.current; } + EOF; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundRule()); } + iv_ruleJvmLowerBound=ruleJvmLowerBound + { $current=$iv_ruleJvmLowerBound.current; } + EOF; + +// Rule JvmLowerBound +ruleJvmLowerBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='super' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); } + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded + { $current=$iv_ruleJvmLowerBoundAnded.current; } + EOF; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); } + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard + { $current=$iv_ruleQualifiedNameWithWildcard.current.getText(); } + EOF; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + this_QualifiedName_0=ruleQualifiedName + { + $current.merge(this_QualifiedName_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + ) +; + +// Entry rule entryRuleValidID +entryRuleValidID returns [String current=null]: + { newCompositeNode(grammarAccess.getValidIDRule()); } + iv_ruleValidID=ruleValidID + { $current=$iv_ruleValidID.current.getText(); } + EOF; + +// Rule ValidID +ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_ID_0=RULE_ID + { + $current.merge(this_ID_0); + } + { + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + } +; + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXImportDeclarationRule()); } + iv_ruleXImportDeclaration=ruleXImportDeclaration + { $current=$iv_ruleXImportDeclaration.current; } + EOF; + +// Rule XImportDeclaration +ruleXImportDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='import' + { + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + ( + ( + ( + ( + lv_static_1_0='static' + { + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "static", lv_static_1_0 != null, "static"); + } + ) + ) + ( + ( + lv_extension_2_0='extension' + { + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "extension", lv_extension_2_0 != null, "extension"); + } + ) + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + ruleQualifiedNameInStaticImport + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + lv_wildcard_4_0='*' + { + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "wildcard", lv_wildcard_4_0 != null, "*"); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + lv_memberName_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + )? + ) +; + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); } + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport + { $current=$iv_ruleQualifiedNameInStaticImport.current.getText(); } + EOF; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + )+ +; + RULE_REAL : ('0'..'9')* '.' ('0'..'9')*; -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; +RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?; + +RULE_INT : '0'..'9' ('0'..'9'|'_')*; + +RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?; -RULE_INT : ('0'..'9')+; +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.tokens b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.tokens index b8d9e6885d..822a470036 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.tokens +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExport.tokens @@ -1,83 +1,135 @@ -'!'=62 -'!='=54 -'&&'=51 -'('=28 -')'=29 -'*'=60 -'+'=25 -','=23 -'-'=59 -'->'=42 -'.'=63 -'/'=61 -':'=41 -'::'=39 -';'=24 -'<'=58 -'<='=56 -'='=22 -'=='=53 -'>'=57 -'>='=55 -'?'=43 -'@'=26 -'Collection'=79 -'GLOBALVAR'=77 -'List'=80 -'Set'=81 -'['=20 -']'=21 -'as'=19 -'attribute'=34 -'case'=49 -'collect'=65 -'data'=38 -'default'=48 -'else'=46 -'eval'=27 -'exists'=69 -'export'=12 -'extension'=13 -'false'=75 -'field'=37 -'for'=14 -'forAll'=72 -'if'=44 -'implies'=52 -'import'=18 -'interface'=15 -'let'=40 -'lookup'=30 -'new'=78 -'notExists'=70 -'null'=76 -'object-fingerprint'=35 -'qualified'=31 -'reject'=68 -'resource-fingerprint'=36 -'select'=66 -'selectFirst'=67 -'sortBy'=71 -'switch'=47 -'then'=45 -'true'=74 -'typeSelect'=64 -'unique'=33 -'uri-fragment'=32 -'{'=16 -'|'=73 -'||'=50 -'}'=17 -RULE_ANY_OTHER=11 +'!'=64 +'!='=56 +'!=='=90 +'#'=102 +'%'=98 +'%='=88 +'&&'=53 +'&'=117 +'('=30 +')'=31 +'*'=62 +'**'=97 +'*='=86 +'+'=27 +'++'=99 +'+='=84 +','=25 +'-'=61 +'--'=100 +'-='=85 +'->'=44 +'.'=65 +'..'=93 +'..<'=92 +'/'=63 +'/='=87 +':'=43 +'::'=41 +';'=26 +'<'=60 +'<='=58 +'<>'=95 +'='=24 +'=='=55 +'==='=89 +'=>'=94 +'>'=59 +'>='=57 +'?'=45 +'?.'=101 +'?:'=96 +'@'=28 +'Collection'=81 +'GLOBALVAR'=79 +'List'=82 +'Set'=83 +'['=22 +']'=23 +'as'=21 +'attribute'=36 +'case'=51 +'catch'=116 +'collect'=67 +'data'=40 +'default'=50 +'do'=104 +'else'=48 +'eval'=29 +'exists'=71 +'export'=14 +'extends'=107 +'extension'=15 +'false'=77 +'field'=39 +'finally'=114 +'for'=16 +'forAll'=74 +'if'=46 +'implies'=54 +'import'=20 +'instanceof'=91 +'interface'=17 +'let'=42 +'lookup'=32 +'new'=80 +'notExists'=72 +'null'=78 +'object-fingerprint'=37 +'qualified'=33 +'reject'=70 +'resource-fingerprint'=38 +'return'=112 +'select'=68 +'selectFirst'=69 +'sortBy'=73 +'static'=108 +'super'=109 +'switch'=49 +'synchronized'=115 +'then'=47 +'throw'=111 +'true'=76 +'try'=113 +'typeSelect'=66 +'typeof'=110 +'unique'=35 +'uri-fragment'=34 +'val'=106 +'var'=105 +'while'=103 +'{'=18 +'|'=75 +'||'=52 +'}'=19 +RULE_ANY_OTHER=13 +RULE_DECIMAL=9 +RULE_HEX=8 RULE_ID=4 RULE_INT=6 -RULE_ML_COMMENT=8 +RULE_ML_COMMENT=10 RULE_REAL=7 -RULE_SL_COMMENT=9 +RULE_SL_COMMENT=11 RULE_STRING=5 -RULE_WS=10 -T__12=12 -T__13=13 +RULE_WS=12 +T__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 +T__105=105 +T__106=106 +T__107=107 +T__108=108 +T__109=109 +T__110=110 +T__111=111 +T__112=112 +T__113=113 +T__114=114 +T__115=115 +T__116=116 +T__117=117 T__14=14 T__15=15 T__16=16 @@ -146,3 +198,21 @@ T__78=78 T__79=79 T__80=80 T__81=81 +T__82=82 +T__83=83 +T__84=84 +T__85=85 +T__86=86 +T__87=87 +T__88=88 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportLexer.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportLexer.java index fda438468c..d233319e04 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportLexer.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportLexer.java @@ -12,19 +12,12 @@ @SuppressWarnings("all") public class InternalExportLexer extends Lexer { + public static final int RULE_HEX=8; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -34,53 +27,26 @@ public class InternalExportLexer extends Lexer { public static final int T__61=61; public static final int RULE_ID=4; public static final int RULE_REAL=7; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; public static final int RULE_INT=6; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=5; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -91,6 +57,76 @@ public class InternalExportLexer extends Lexer { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=5; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -105,57 +141,15 @@ public InternalExportLexer(CharStream input, RecognizerSharedState state) { } public String getGrammarFileName() { return "InternalExport.g"; } - // $ANTLR start "T__12" - public final void mT__12() throws RecognitionException { - try { - int _type = T__12; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:11:7: ( 'export' ) - // InternalExport.g:11:9: 'export' - { - match("export"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__12" - - // $ANTLR start "T__13" - public final void mT__13() throws RecognitionException { - try { - int _type = T__13; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:12:7: ( 'extension' ) - // InternalExport.g:12:9: 'extension' - { - match("extension"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__13" - // $ANTLR start "T__14" public final void mT__14() throws RecognitionException { try { int _type = T__14; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:13:7: ( 'for' ) - // InternalExport.g:13:9: 'for' + // InternalExport.g:11:7: ( 'export' ) + // InternalExport.g:11:9: 'export' { - match("for"); + match("export"); } @@ -173,10 +167,10 @@ public final void mT__15() throws RecognitionException { try { int _type = T__15; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:14:7: ( 'interface' ) - // InternalExport.g:14:9: 'interface' + // InternalExport.g:12:7: ( 'extension' ) + // InternalExport.g:12:9: 'extension' { - match("interface"); + match("extension"); } @@ -194,10 +188,11 @@ public final void mT__16() throws RecognitionException { try { int _type = T__16; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:15:7: ( '{' ) - // InternalExport.g:15:9: '{' + // InternalExport.g:13:7: ( 'for' ) + // InternalExport.g:13:9: 'for' { - match('{'); + match("for"); + } @@ -214,10 +209,11 @@ public final void mT__17() throws RecognitionException { try { int _type = T__17; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:16:7: ( '}' ) - // InternalExport.g:16:9: '}' + // InternalExport.g:14:7: ( 'interface' ) + // InternalExport.g:14:9: 'interface' { - match('}'); + match("interface"); + } @@ -234,11 +230,10 @@ public final void mT__18() throws RecognitionException { try { int _type = T__18; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:17:7: ( 'import' ) - // InternalExport.g:17:9: 'import' + // InternalExport.g:15:7: ( '{' ) + // InternalExport.g:15:9: '{' { - match("import"); - + match('{'); } @@ -255,11 +250,10 @@ public final void mT__19() throws RecognitionException { try { int _type = T__19; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:18:7: ( 'as' ) - // InternalExport.g:18:9: 'as' + // InternalExport.g:16:7: ( '}' ) + // InternalExport.g:16:9: '}' { - match("as"); - + match('}'); } @@ -276,10 +270,11 @@ public final void mT__20() throws RecognitionException { try { int _type = T__20; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:19:7: ( '[' ) - // InternalExport.g:19:9: '[' + // InternalExport.g:17:7: ( 'import' ) + // InternalExport.g:17:9: 'import' { - match('['); + match("import"); + } @@ -296,10 +291,11 @@ public final void mT__21() throws RecognitionException { try { int _type = T__21; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:20:7: ( ']' ) - // InternalExport.g:20:9: ']' + // InternalExport.g:18:7: ( 'as' ) + // InternalExport.g:18:9: 'as' { - match(']'); + match("as"); + } @@ -316,10 +312,10 @@ public final void mT__22() throws RecognitionException { try { int _type = T__22; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:21:7: ( '=' ) - // InternalExport.g:21:9: '=' + // InternalExport.g:19:7: ( '[' ) + // InternalExport.g:19:9: '[' { - match('='); + match('['); } @@ -336,10 +332,10 @@ public final void mT__23() throws RecognitionException { try { int _type = T__23; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:22:7: ( ',' ) - // InternalExport.g:22:9: ',' + // InternalExport.g:20:7: ( ']' ) + // InternalExport.g:20:9: ']' { - match(','); + match(']'); } @@ -356,10 +352,10 @@ public final void mT__24() throws RecognitionException { try { int _type = T__24; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:23:7: ( ';' ) - // InternalExport.g:23:9: ';' + // InternalExport.g:21:7: ( '=' ) + // InternalExport.g:21:9: '=' { - match(';'); + match('='); } @@ -376,10 +372,10 @@ public final void mT__25() throws RecognitionException { try { int _type = T__25; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:24:7: ( '+' ) - // InternalExport.g:24:9: '+' + // InternalExport.g:22:7: ( ',' ) + // InternalExport.g:22:9: ',' { - match('+'); + match(','); } @@ -396,10 +392,10 @@ public final void mT__26() throws RecognitionException { try { int _type = T__26; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:25:7: ( '@' ) - // InternalExport.g:25:9: '@' + // InternalExport.g:23:7: ( ';' ) + // InternalExport.g:23:9: ';' { - match('@'); + match(';'); } @@ -416,11 +412,10 @@ public final void mT__27() throws RecognitionException { try { int _type = T__27; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:26:7: ( 'eval' ) - // InternalExport.g:26:9: 'eval' + // InternalExport.g:24:7: ( '+' ) + // InternalExport.g:24:9: '+' { - match("eval"); - + match('+'); } @@ -437,10 +432,10 @@ public final void mT__28() throws RecognitionException { try { int _type = T__28; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:27:7: ( '(' ) - // InternalExport.g:27:9: '(' + // InternalExport.g:25:7: ( '@' ) + // InternalExport.g:25:9: '@' { - match('('); + match('@'); } @@ -457,10 +452,11 @@ public final void mT__29() throws RecognitionException { try { int _type = T__29; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:28:7: ( ')' ) - // InternalExport.g:28:9: ')' + // InternalExport.g:26:7: ( 'eval' ) + // InternalExport.g:26:9: 'eval' { - match(')'); + match("eval"); + } @@ -477,11 +473,10 @@ public final void mT__30() throws RecognitionException { try { int _type = T__30; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:29:7: ( 'lookup' ) - // InternalExport.g:29:9: 'lookup' + // InternalExport.g:27:7: ( '(' ) + // InternalExport.g:27:9: '(' { - match("lookup"); - + match('('); } @@ -498,11 +493,10 @@ public final void mT__31() throws RecognitionException { try { int _type = T__31; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:30:7: ( 'qualified' ) - // InternalExport.g:30:9: 'qualified' + // InternalExport.g:28:7: ( ')' ) + // InternalExport.g:28:9: ')' { - match("qualified"); - + match(')'); } @@ -519,10 +513,10 @@ public final void mT__32() throws RecognitionException { try { int _type = T__32; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:31:7: ( 'uri-fragment' ) - // InternalExport.g:31:9: 'uri-fragment' + // InternalExport.g:29:7: ( 'lookup' ) + // InternalExport.g:29:9: 'lookup' { - match("uri-fragment"); + match("lookup"); } @@ -540,10 +534,10 @@ public final void mT__33() throws RecognitionException { try { int _type = T__33; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:32:7: ( 'unique' ) - // InternalExport.g:32:9: 'unique' + // InternalExport.g:30:7: ( 'qualified' ) + // InternalExport.g:30:9: 'qualified' { - match("unique"); + match("qualified"); } @@ -561,10 +555,10 @@ public final void mT__34() throws RecognitionException { try { int _type = T__34; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:33:7: ( 'attribute' ) - // InternalExport.g:33:9: 'attribute' + // InternalExport.g:31:7: ( 'uri-fragment' ) + // InternalExport.g:31:9: 'uri-fragment' { - match("attribute"); + match("uri-fragment"); } @@ -582,10 +576,10 @@ public final void mT__35() throws RecognitionException { try { int _type = T__35; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:34:7: ( 'object-fingerprint' ) - // InternalExport.g:34:9: 'object-fingerprint' + // InternalExport.g:32:7: ( 'unique' ) + // InternalExport.g:32:9: 'unique' { - match("object-fingerprint"); + match("unique"); } @@ -603,10 +597,10 @@ public final void mT__36() throws RecognitionException { try { int _type = T__36; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:35:7: ( 'resource-fingerprint' ) - // InternalExport.g:35:9: 'resource-fingerprint' + // InternalExport.g:33:7: ( 'attribute' ) + // InternalExport.g:33:9: 'attribute' { - match("resource-fingerprint"); + match("attribute"); } @@ -624,10 +618,10 @@ public final void mT__37() throws RecognitionException { try { int _type = T__37; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:36:7: ( 'field' ) - // InternalExport.g:36:9: 'field' + // InternalExport.g:34:7: ( 'object-fingerprint' ) + // InternalExport.g:34:9: 'object-fingerprint' { - match("field"); + match("object-fingerprint"); } @@ -645,10 +639,10 @@ public final void mT__38() throws RecognitionException { try { int _type = T__38; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:37:7: ( 'data' ) - // InternalExport.g:37:9: 'data' + // InternalExport.g:35:7: ( 'resource-fingerprint' ) + // InternalExport.g:35:9: 'resource-fingerprint' { - match("data"); + match("resource-fingerprint"); } @@ -666,10 +660,10 @@ public final void mT__39() throws RecognitionException { try { int _type = T__39; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:38:7: ( '::' ) - // InternalExport.g:38:9: '::' + // InternalExport.g:36:7: ( 'field' ) + // InternalExport.g:36:9: 'field' { - match("::"); + match("field"); } @@ -687,10 +681,10 @@ public final void mT__40() throws RecognitionException { try { int _type = T__40; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:39:7: ( 'let' ) - // InternalExport.g:39:9: 'let' + // InternalExport.g:37:7: ( 'data' ) + // InternalExport.g:37:9: 'data' { - match("let"); + match("data"); } @@ -708,10 +702,11 @@ public final void mT__41() throws RecognitionException { try { int _type = T__41; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:40:7: ( ':' ) - // InternalExport.g:40:9: ':' + // InternalExport.g:38:7: ( '::' ) + // InternalExport.g:38:9: '::' { - match(':'); + match("::"); + } @@ -728,10 +723,10 @@ public final void mT__42() throws RecognitionException { try { int _type = T__42; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:41:7: ( '->' ) - // InternalExport.g:41:9: '->' + // InternalExport.g:39:7: ( 'let' ) + // InternalExport.g:39:9: 'let' { - match("->"); + match("let"); } @@ -749,10 +744,10 @@ public final void mT__43() throws RecognitionException { try { int _type = T__43; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:42:7: ( '?' ) - // InternalExport.g:42:9: '?' + // InternalExport.g:40:7: ( ':' ) + // InternalExport.g:40:9: ':' { - match('?'); + match(':'); } @@ -769,10 +764,10 @@ public final void mT__44() throws RecognitionException { try { int _type = T__44; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:43:7: ( 'if' ) - // InternalExport.g:43:9: 'if' + // InternalExport.g:41:7: ( '->' ) + // InternalExport.g:41:9: '->' { - match("if"); + match("->"); } @@ -790,11 +785,10 @@ public final void mT__45() throws RecognitionException { try { int _type = T__45; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:44:7: ( 'then' ) - // InternalExport.g:44:9: 'then' + // InternalExport.g:42:7: ( '?' ) + // InternalExport.g:42:9: '?' { - match("then"); - + match('?'); } @@ -811,10 +805,10 @@ public final void mT__46() throws RecognitionException { try { int _type = T__46; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:45:7: ( 'else' ) - // InternalExport.g:45:9: 'else' + // InternalExport.g:43:7: ( 'if' ) + // InternalExport.g:43:9: 'if' { - match("else"); + match("if"); } @@ -832,10 +826,10 @@ public final void mT__47() throws RecognitionException { try { int _type = T__47; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:46:7: ( 'switch' ) - // InternalExport.g:46:9: 'switch' + // InternalExport.g:44:7: ( 'then' ) + // InternalExport.g:44:9: 'then' { - match("switch"); + match("then"); } @@ -853,10 +847,10 @@ public final void mT__48() throws RecognitionException { try { int _type = T__48; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:47:7: ( 'default' ) - // InternalExport.g:47:9: 'default' + // InternalExport.g:45:7: ( 'else' ) + // InternalExport.g:45:9: 'else' { - match("default"); + match("else"); } @@ -874,10 +868,10 @@ public final void mT__49() throws RecognitionException { try { int _type = T__49; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:48:7: ( 'case' ) - // InternalExport.g:48:9: 'case' + // InternalExport.g:46:7: ( 'switch' ) + // InternalExport.g:46:9: 'switch' { - match("case"); + match("switch"); } @@ -895,10 +889,10 @@ public final void mT__50() throws RecognitionException { try { int _type = T__50; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:49:7: ( '||' ) - // InternalExport.g:49:9: '||' + // InternalExport.g:47:7: ( 'default' ) + // InternalExport.g:47:9: 'default' { - match("||"); + match("default"); } @@ -916,10 +910,10 @@ public final void mT__51() throws RecognitionException { try { int _type = T__51; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:50:7: ( '&&' ) - // InternalExport.g:50:9: '&&' + // InternalExport.g:48:7: ( 'case' ) + // InternalExport.g:48:9: 'case' { - match("&&"); + match("case"); } @@ -937,10 +931,10 @@ public final void mT__52() throws RecognitionException { try { int _type = T__52; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:51:7: ( 'implies' ) - // InternalExport.g:51:9: 'implies' + // InternalExport.g:49:7: ( '||' ) + // InternalExport.g:49:9: '||' { - match("implies"); + match("||"); } @@ -958,10 +952,10 @@ public final void mT__53() throws RecognitionException { try { int _type = T__53; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:52:7: ( '==' ) - // InternalExport.g:52:9: '==' + // InternalExport.g:50:7: ( '&&' ) + // InternalExport.g:50:9: '&&' { - match("=="); + match("&&"); } @@ -979,10 +973,10 @@ public final void mT__54() throws RecognitionException { try { int _type = T__54; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:53:7: ( '!=' ) - // InternalExport.g:53:9: '!=' + // InternalExport.g:51:7: ( 'implies' ) + // InternalExport.g:51:9: 'implies' { - match("!="); + match("implies"); } @@ -1000,10 +994,10 @@ public final void mT__55() throws RecognitionException { try { int _type = T__55; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:54:7: ( '>=' ) - // InternalExport.g:54:9: '>=' + // InternalExport.g:52:7: ( '==' ) + // InternalExport.g:52:9: '==' { - match(">="); + match("=="); } @@ -1021,10 +1015,10 @@ public final void mT__56() throws RecognitionException { try { int _type = T__56; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:55:7: ( '<=' ) - // InternalExport.g:55:9: '<=' + // InternalExport.g:53:7: ( '!=' ) + // InternalExport.g:53:9: '!=' { - match("<="); + match("!="); } @@ -1042,10 +1036,11 @@ public final void mT__57() throws RecognitionException { try { int _type = T__57; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:56:7: ( '>' ) - // InternalExport.g:56:9: '>' + // InternalExport.g:54:7: ( '>=' ) + // InternalExport.g:54:9: '>=' { - match('>'); + match(">="); + } @@ -1062,10 +1057,11 @@ public final void mT__58() throws RecognitionException { try { int _type = T__58; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:57:7: ( '<' ) - // InternalExport.g:57:9: '<' + // InternalExport.g:55:7: ( '<=' ) + // InternalExport.g:55:9: '<=' { - match('<'); + match("<="); + } @@ -1082,10 +1078,10 @@ public final void mT__59() throws RecognitionException { try { int _type = T__59; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:58:7: ( '-' ) - // InternalExport.g:58:9: '-' + // InternalExport.g:56:7: ( '>' ) + // InternalExport.g:56:9: '>' { - match('-'); + match('>'); } @@ -1102,10 +1098,10 @@ public final void mT__60() throws RecognitionException { try { int _type = T__60; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:59:7: ( '*' ) - // InternalExport.g:59:9: '*' + // InternalExport.g:57:7: ( '<' ) + // InternalExport.g:57:9: '<' { - match('*'); + match('<'); } @@ -1122,10 +1118,10 @@ public final void mT__61() throws RecognitionException { try { int _type = T__61; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:60:7: ( '/' ) - // InternalExport.g:60:9: '/' + // InternalExport.g:58:7: ( '-' ) + // InternalExport.g:58:9: '-' { - match('/'); + match('-'); } @@ -1142,10 +1138,10 @@ public final void mT__62() throws RecognitionException { try { int _type = T__62; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:61:7: ( '!' ) - // InternalExport.g:61:9: '!' + // InternalExport.g:59:7: ( '*' ) + // InternalExport.g:59:9: '*' { - match('!'); + match('*'); } @@ -1162,10 +1158,10 @@ public final void mT__63() throws RecognitionException { try { int _type = T__63; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:62:7: ( '.' ) - // InternalExport.g:62:9: '.' + // InternalExport.g:60:7: ( '/' ) + // InternalExport.g:60:9: '/' { - match('.'); + match('/'); } @@ -1182,11 +1178,10 @@ public final void mT__64() throws RecognitionException { try { int _type = T__64; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:63:7: ( 'typeSelect' ) - // InternalExport.g:63:9: 'typeSelect' + // InternalExport.g:61:7: ( '!' ) + // InternalExport.g:61:9: '!' { - match("typeSelect"); - + match('!'); } @@ -1203,11 +1198,10 @@ public final void mT__65() throws RecognitionException { try { int _type = T__65; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:64:7: ( 'collect' ) - // InternalExport.g:64:9: 'collect' + // InternalExport.g:62:7: ( '.' ) + // InternalExport.g:62:9: '.' { - match("collect"); - + match('.'); } @@ -1224,10 +1218,10 @@ public final void mT__66() throws RecognitionException { try { int _type = T__66; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:65:7: ( 'select' ) - // InternalExport.g:65:9: 'select' + // InternalExport.g:63:7: ( 'typeSelect' ) + // InternalExport.g:63:9: 'typeSelect' { - match("select"); + match("typeSelect"); } @@ -1245,10 +1239,10 @@ public final void mT__67() throws RecognitionException { try { int _type = T__67; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:66:7: ( 'selectFirst' ) - // InternalExport.g:66:9: 'selectFirst' + // InternalExport.g:64:7: ( 'collect' ) + // InternalExport.g:64:9: 'collect' { - match("selectFirst"); + match("collect"); } @@ -1266,10 +1260,10 @@ public final void mT__68() throws RecognitionException { try { int _type = T__68; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:67:7: ( 'reject' ) - // InternalExport.g:67:9: 'reject' + // InternalExport.g:65:7: ( 'select' ) + // InternalExport.g:65:9: 'select' { - match("reject"); + match("select"); } @@ -1287,10 +1281,10 @@ public final void mT__69() throws RecognitionException { try { int _type = T__69; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:68:7: ( 'exists' ) - // InternalExport.g:68:9: 'exists' + // InternalExport.g:66:7: ( 'selectFirst' ) + // InternalExport.g:66:9: 'selectFirst' { - match("exists"); + match("selectFirst"); } @@ -1308,10 +1302,10 @@ public final void mT__70() throws RecognitionException { try { int _type = T__70; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:69:7: ( 'notExists' ) - // InternalExport.g:69:9: 'notExists' + // InternalExport.g:67:7: ( 'reject' ) + // InternalExport.g:67:9: 'reject' { - match("notExists"); + match("reject"); } @@ -1329,10 +1323,10 @@ public final void mT__71() throws RecognitionException { try { int _type = T__71; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:70:7: ( 'sortBy' ) - // InternalExport.g:70:9: 'sortBy' + // InternalExport.g:68:7: ( 'exists' ) + // InternalExport.g:68:9: 'exists' { - match("sortBy"); + match("exists"); } @@ -1350,10 +1344,10 @@ public final void mT__72() throws RecognitionException { try { int _type = T__72; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:71:7: ( 'forAll' ) - // InternalExport.g:71:9: 'forAll' + // InternalExport.g:69:7: ( 'notExists' ) + // InternalExport.g:69:9: 'notExists' { - match("forAll"); + match("notExists"); } @@ -1371,10 +1365,11 @@ public final void mT__73() throws RecognitionException { try { int _type = T__73; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:72:7: ( '|' ) - // InternalExport.g:72:9: '|' + // InternalExport.g:70:7: ( 'sortBy' ) + // InternalExport.g:70:9: 'sortBy' { - match('|'); + match("sortBy"); + } @@ -1391,10 +1386,10 @@ public final void mT__74() throws RecognitionException { try { int _type = T__74; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:73:7: ( 'true' ) - // InternalExport.g:73:9: 'true' + // InternalExport.g:71:7: ( 'forAll' ) + // InternalExport.g:71:9: 'forAll' { - match("true"); + match("forAll"); } @@ -1412,11 +1407,10 @@ public final void mT__75() throws RecognitionException { try { int _type = T__75; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:74:7: ( 'false' ) - // InternalExport.g:74:9: 'false' + // InternalExport.g:72:7: ( '|' ) + // InternalExport.g:72:9: '|' { - match("false"); - + match('|'); } @@ -1433,10 +1427,10 @@ public final void mT__76() throws RecognitionException { try { int _type = T__76; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:75:7: ( 'null' ) - // InternalExport.g:75:9: 'null' + // InternalExport.g:73:7: ( 'true' ) + // InternalExport.g:73:9: 'true' { - match("null"); + match("true"); } @@ -1454,10 +1448,10 @@ public final void mT__77() throws RecognitionException { try { int _type = T__77; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:76:7: ( 'GLOBALVAR' ) - // InternalExport.g:76:9: 'GLOBALVAR' + // InternalExport.g:74:7: ( 'false' ) + // InternalExport.g:74:9: 'false' { - match("GLOBALVAR"); + match("false"); } @@ -1475,10 +1469,10 @@ public final void mT__78() throws RecognitionException { try { int _type = T__78; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:77:7: ( 'new' ) - // InternalExport.g:77:9: 'new' + // InternalExport.g:75:7: ( 'null' ) + // InternalExport.g:75:9: 'null' { - match("new"); + match("null"); } @@ -1496,10 +1490,10 @@ public final void mT__79() throws RecognitionException { try { int _type = T__79; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:78:7: ( 'Collection' ) - // InternalExport.g:78:9: 'Collection' + // InternalExport.g:76:7: ( 'GLOBALVAR' ) + // InternalExport.g:76:9: 'GLOBALVAR' { - match("Collection"); + match("GLOBALVAR"); } @@ -1517,8 +1511,50 @@ public final void mT__80() throws RecognitionException { try { int _type = T__80; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:79:7: ( 'List' ) - // InternalExport.g:79:9: 'List' + // InternalExport.g:77:7: ( 'new' ) + // InternalExport.g:77:9: 'new' + { + match("new"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__80" + + // $ANTLR start "T__81" + public final void mT__81() throws RecognitionException { + try { + int _type = T__81; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:78:7: ( 'Collection' ) + // InternalExport.g:78:9: 'Collection' + { + match("Collection"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__81" + + // $ANTLR start "T__82" + public final void mT__82() throws RecognitionException { + try { + int _type = T__82; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:79:7: ( 'List' ) + // InternalExport.g:79:9: 'List' { match("List"); @@ -1531,17 +1567,687 @@ public final void mT__80() throws RecognitionException { finally { } } - // $ANTLR end "T__80" + // $ANTLR end "T__82" + + // $ANTLR start "T__83" + public final void mT__83() throws RecognitionException { + try { + int _type = T__83; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:80:7: ( 'Set' ) + // InternalExport.g:80:9: 'Set' + { + match("Set"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__83" + + // $ANTLR start "T__84" + public final void mT__84() throws RecognitionException { + try { + int _type = T__84; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:81:7: ( '+=' ) + // InternalExport.g:81:9: '+=' + { + match("+="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__84" + + // $ANTLR start "T__85" + public final void mT__85() throws RecognitionException { + try { + int _type = T__85; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:82:7: ( '-=' ) + // InternalExport.g:82:9: '-=' + { + match("-="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__85" + + // $ANTLR start "T__86" + public final void mT__86() throws RecognitionException { + try { + int _type = T__86; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:83:7: ( '*=' ) + // InternalExport.g:83:9: '*=' + { + match("*="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__86" + + // $ANTLR start "T__87" + public final void mT__87() throws RecognitionException { + try { + int _type = T__87; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:84:7: ( '/=' ) + // InternalExport.g:84:9: '/=' + { + match("/="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__87" + + // $ANTLR start "T__88" + public final void mT__88() throws RecognitionException { + try { + int _type = T__88; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:85:7: ( '%=' ) + // InternalExport.g:85:9: '%=' + { + match("%="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:86:7: ( '===' ) + // InternalExport.g:86:9: '===' + { + match("==="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" + + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:87:7: ( '!==' ) + // InternalExport.g:87:9: '!==' + { + match("!=="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__90" + + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { + try { + int _type = T__91; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:88:7: ( 'instanceof' ) + // InternalExport.g:88:9: 'instanceof' + { + match("instanceof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" + + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:89:7: ( '..<' ) + // InternalExport.g:89:9: '..<' + { + match("..<"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" + + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:90:7: ( '..' ) + // InternalExport.g:90:9: '..' + { + match(".."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:91:7: ( '=>' ) + // InternalExport.g:91:9: '=>' + { + match("=>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:92:7: ( '<>' ) + // InternalExport.g:92:9: '<>' + { + match("<>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__95" + + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { + try { + int _type = T__96; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:93:7: ( '?:' ) + // InternalExport.g:93:9: '?:' + { + match("?:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" + + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:94:7: ( '**' ) + // InternalExport.g:94:9: '**' + { + match("**"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__97" + + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { + try { + int _type = T__98; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:95:7: ( '%' ) + // InternalExport.g:95:9: '%' + { + match('%'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:96:7: ( '++' ) + // InternalExport.g:96:9: '++' + { + match("++"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:97:8: ( '--' ) + // InternalExport.g:97:10: '--' + { + match("--"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:98:8: ( '?.' ) + // InternalExport.g:98:10: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:99:8: ( '#' ) + // InternalExport.g:99:10: '#' + { + match('#'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:100:8: ( 'while' ) + // InternalExport.g:100:10: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:101:8: ( 'do' ) + // InternalExport.g:101:10: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "T__105" + public final void mT__105() throws RecognitionException { + try { + int _type = T__105; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:102:8: ( 'var' ) + // InternalExport.g:102:10: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__105" + + // $ANTLR start "T__106" + public final void mT__106() throws RecognitionException { + try { + int _type = T__106; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:103:8: ( 'val' ) + // InternalExport.g:103:10: 'val' + { + match("val"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__106" + + // $ANTLR start "T__107" + public final void mT__107() throws RecognitionException { + try { + int _type = T__107; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:104:8: ( 'extends' ) + // InternalExport.g:104:10: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__107" + + // $ANTLR start "T__108" + public final void mT__108() throws RecognitionException { + try { + int _type = T__108; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:105:8: ( 'static' ) + // InternalExport.g:105:10: 'static' + { + match("static"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__108" + + // $ANTLR start "T__109" + public final void mT__109() throws RecognitionException { + try { + int _type = T__109; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:106:8: ( 'super' ) + // InternalExport.g:106:10: 'super' + { + match("super"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__109" + + // $ANTLR start "T__110" + public final void mT__110() throws RecognitionException { + try { + int _type = T__110; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:107:8: ( 'typeof' ) + // InternalExport.g:107:10: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__110" + + // $ANTLR start "T__111" + public final void mT__111() throws RecognitionException { + try { + int _type = T__111; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:108:8: ( 'throw' ) + // InternalExport.g:108:10: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__111" + + // $ANTLR start "T__112" + public final void mT__112() throws RecognitionException { + try { + int _type = T__112; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:109:8: ( 'return' ) + // InternalExport.g:109:10: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__112" + + // $ANTLR start "T__113" + public final void mT__113() throws RecognitionException { + try { + int _type = T__113; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:110:8: ( 'try' ) + // InternalExport.g:110:10: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__113" + + // $ANTLR start "T__114" + public final void mT__114() throws RecognitionException { + try { + int _type = T__114; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:111:8: ( 'finally' ) + // InternalExport.g:111:10: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__114" - // $ANTLR start "T__81" - public final void mT__81() throws RecognitionException { + // $ANTLR start "T__115" + public final void mT__115() throws RecognitionException { try { - int _type = T__81; + int _type = T__115; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:80:7: ( 'Set' ) - // InternalExport.g:80:9: 'Set' + // InternalExport.g:112:8: ( 'synchronized' ) + // InternalExport.g:112:10: 'synchronized' { - match("Set"); + match("synchronized"); } @@ -1552,17 +2258,58 @@ public final void mT__81() throws RecognitionException { finally { } } - // $ANTLR end "T__81" + // $ANTLR end "T__115" + + // $ANTLR start "T__116" + public final void mT__116() throws RecognitionException { + try { + int _type = T__116; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:113:8: ( 'catch' ) + // InternalExport.g:113:10: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__116" + + // $ANTLR start "T__117" + public final void mT__117() throws RecognitionException { + try { + int _type = T__117; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:114:8: ( '&' ) + // InternalExport.g:114:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__117" // $ANTLR start "RULE_REAL" public final void mRULE_REAL() throws RecognitionException { try { int _type = RULE_REAL; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3873:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) - // InternalExport.g:3873:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + // InternalExport.g:10155:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) + // InternalExport.g:10155:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* { - // InternalExport.g:3873:13: ( '0' .. '9' )* + // InternalExport.g:10155:13: ( '0' .. '9' )* loop1: do { int alt1=2; @@ -1575,7 +2322,7 @@ public final void mRULE_REAL() throws RecognitionException { switch (alt1) { case 1 : - // InternalExport.g:3873:14: '0' .. '9' + // InternalExport.g:10155:14: '0' .. '9' { matchRange('0','9'); @@ -1588,7 +2335,7 @@ public final void mRULE_REAL() throws RecognitionException { } while (true); match('.'); - // InternalExport.g:3873:29: ( '0' .. '9' )* + // InternalExport.g:10155:29: ( '0' .. '9' )* loop2: do { int alt2=2; @@ -1601,7 +2348,7 @@ public final void mRULE_REAL() throws RecognitionException { switch (alt2) { case 1 : - // InternalExport.g:3873:30: '0' .. '9' + // InternalExport.g:10155:30: '0' .. '9' { matchRange('0','9'); @@ -1624,24 +2371,383 @@ public final void mRULE_REAL() throws RecognitionException { } // $ANTLR end "RULE_REAL" + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:10157:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // InternalExport.g:10157:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // InternalExport.g:10157:12: ( '0x' | '0X' ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='0') ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1=='x') ) { + alt3=1; + } + else if ( (LA3_1=='X') ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalExport.g:10157:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // InternalExport.g:10157:18: '0X' + { + match("0X"); + + + } + break; + + } + + // InternalExport.g:10157:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ + int cnt4=0; + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='f')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalExport.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt4 >= 1 ) break loop4; + EarlyExitException eee = + new EarlyExitException(4, input); + throw eee; + } + cnt4++; + } while (true); + + // InternalExport.g:10157:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='#') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalExport.g:10157:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // InternalExport.g:10157:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='B'||LA5_0=='b') ) { + alt5=1; + } + else if ( (LA5_0=='L'||LA5_0=='l') ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalExport.g:10157:64: ( 'b' | 'B' ) ( 'i' | 'I' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='I'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExport.g:10157:84: ( 'l' | 'L' ) + { + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_HEX" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:10159:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // InternalExport.g:10159:12: '0' .. '9' ( '0' .. '9' | '_' )* + { + matchRange('0','9'); + // InternalExport.g:10159:21: ( '0' .. '9' | '_' )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||LA7_0=='_') ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalExport.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_DECIMAL" + public final void mRULE_DECIMAL() throws RecognitionException { + try { + int _type = RULE_DECIMAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:10161:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // InternalExport.g:10161:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // InternalExport.g:10161:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='E'||LA9_0=='e') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalExport.g:10161:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalExport.g:10161:36: ( '+' | '-' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='+'||LA8_0=='-') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalExport.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_INT(); + + } + break; + + } + + // InternalExport.g:10161:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='B'||LA10_0=='b') ) { + alt10=1; + } + else if ( (LA10_0=='D'||LA10_0=='F'||LA10_0=='L'||LA10_0=='d'||LA10_0=='f'||LA10_0=='l') ) { + alt10=2; + } + switch (alt10) { + case 1 : + // InternalExport.g:10161:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExport.g:10161:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) + { + if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECIMAL" + // $ANTLR start "RULE_ID" public final void mRULE_ID() throws RecognitionException { try { int _type = RULE_ID; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3875:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalExport.g:3875:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalExport.g:10163:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalExport.g:10163:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* { - // InternalExport.g:3875:11: ( '^' )? - int alt3=2; - int LA3_0 = input.LA(1); + // InternalExport.g:10163:11: ( '^' )? + int alt11=2; + int LA11_0 = input.LA(1); - if ( (LA3_0=='^') ) { - alt3=1; + if ( (LA11_0=='^') ) { + alt11=1; } - switch (alt3) { + switch (alt11) { case 1 : - // InternalExport.g:3875:11: '^' + // InternalExport.g:10163:11: '^' { match('^'); @@ -1650,7 +2756,7 @@ public final void mRULE_ID() throws RecognitionException { } - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { input.consume(); } @@ -1659,22 +2765,22 @@ public final void mRULE_ID() throws RecognitionException { recover(mse); throw mse;} - // InternalExport.g:3875:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop4: + // InternalExport.g:10163:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop12: do { - int alt4=2; - int LA4_0 = input.LA(1); + int alt12=2; + int LA12_0 = input.LA(1); - if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { - alt4=1; + if ( (LA12_0=='$'||(LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) { + alt12=1; } - switch (alt4) { + switch (alt12) { case 1 : // InternalExport.g: { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { input.consume(); } @@ -1688,7 +2794,7 @@ public final void mRULE_ID() throws RecognitionException { break; default : - break loop4; + break loop12; } } while (true); @@ -1703,101 +2809,52 @@ public final void mRULE_ID() throws RecognitionException { } // $ANTLR end "RULE_ID" - // $ANTLR start "RULE_INT" - public final void mRULE_INT() throws RecognitionException { - try { - int _type = RULE_INT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3877:10: ( ( '0' .. '9' )+ ) - // InternalExport.g:3877:12: ( '0' .. '9' )+ - { - // InternalExport.g:3877:12: ( '0' .. '9' )+ - int cnt5=0; - loop5: - do { - int alt5=2; - int LA5_0 = input.LA(1); - - if ( ((LA5_0>='0' && LA5_0<='9')) ) { - alt5=1; - } - - - switch (alt5) { - case 1 : - // InternalExport.g:3877:13: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - if ( cnt5 >= 1 ) break loop5; - EarlyExitException eee = - new EarlyExitException(5, input); - throw eee; - } - cnt5++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_INT" - // $ANTLR start "RULE_STRING" public final void mRULE_STRING() throws RecognitionException { try { int _type = RULE_STRING; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3879:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalExport.g:3879:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalExport.g:10165:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalExport.g:10165:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) { - // InternalExport.g:3879:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt8=2; - int LA8_0 = input.LA(1); + // InternalExport.g:10165:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA8_0=='\"') ) { - alt8=1; + if ( (LA17_0=='\"') ) { + alt17=1; } - else if ( (LA8_0=='\'') ) { - alt8=2; + else if ( (LA17_0=='\'') ) { + alt17=2; } else { NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + new NoViableAltException("", 17, 0, input); throw nvae; } - switch (alt8) { + switch (alt17) { case 1 : - // InternalExport.g:3879:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + // InternalExport.g:10165:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? { match('\"'); - // InternalExport.g:3879:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop6: + // InternalExport.g:10165:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop13: do { - int alt6=3; - int LA6_0 = input.LA(1); + int alt13=3; + int LA13_0 = input.LA(1); - if ( (LA6_0=='\\') ) { - alt6=1; + if ( (LA13_0=='\\') ) { + alt13=1; } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; + else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) { + alt13=2; } - switch (alt6) { + switch (alt13) { case 1 : - // InternalExport.g:3879:21: '\\\\' . + // InternalExport.g:10165:21: '\\\\' . { match('\\'); matchAny(); @@ -1805,7 +2862,7 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= } break; case 2 : - // InternalExport.g:3879:28: ~ ( ( '\\\\' | '\"' ) ) + // InternalExport.g:10165:28: ~ ( ( '\\\\' | '\"' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1821,35 +2878,52 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= break; default : - break loop6; + break loop13; } } while (true); - match('\"'); + // InternalExport.g:10165:44: ( '\"' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\"') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalExport.g:10165:44: '\"' + { + match('\"'); + + } + break; + + } + } break; case 2 : - // InternalExport.g:3879:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + // InternalExport.g:10165:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? { match('\''); - // InternalExport.g:3879:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop7: + // InternalExport.g:10165:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop15: do { - int alt7=3; - int LA7_0 = input.LA(1); + int alt15=3; + int LA15_0 = input.LA(1); - if ( (LA7_0=='\\') ) { - alt7=1; + if ( (LA15_0=='\\') ) { + alt15=1; } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; + else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) { + alt15=2; } - switch (alt7) { + switch (alt15) { case 1 : - // InternalExport.g:3879:54: '\\\\' . + // InternalExport.g:10165:55: '\\\\' . { match('\\'); matchAny(); @@ -1857,7 +2931,7 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= } break; case 2 : - // InternalExport.g:3879:61: ~ ( ( '\\\\' | '\\'' ) ) + // InternalExport.g:10165:62: ~ ( ( '\\\\' | '\\'' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1873,11 +2947,28 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= break; default : - break loop7; + break loop15; } } while (true); - match('\''); + // InternalExport.g:10165:79: ( '\\'' )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalExport.g:10165:79: '\\'' + { + match('\''); + + } + break; + + } + } break; @@ -1900,37 +2991,37 @@ public final void mRULE_ML_COMMENT() throws RecognitionException { try { int _type = RULE_ML_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3881:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalExport.g:3881:19: '/*' ( options {greedy=false; } : . )* '*/' + // InternalExport.g:10167:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalExport.g:10167:19: '/*' ( options {greedy=false; } : . )* '*/' { match("/*"); - // InternalExport.g:3881:24: ( options {greedy=false; } : . )* - loop9: + // InternalExport.g:10167:24: ( options {greedy=false; } : . )* + loop18: do { - int alt9=2; - int LA9_0 = input.LA(1); + int alt18=2; + int LA18_0 = input.LA(1); - if ( (LA9_0=='*') ) { - int LA9_1 = input.LA(2); + if ( (LA18_0=='*') ) { + int LA18_1 = input.LA(2); - if ( (LA9_1=='/') ) { - alt9=2; + if ( (LA18_1=='/') ) { + alt18=2; } - else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) { + alt18=1; } } - else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) { + alt18=1; } - switch (alt9) { + switch (alt18) { case 1 : - // InternalExport.g:3881:52: . + // InternalExport.g:10167:52: . { matchAny(); @@ -1938,7 +3029,7 @@ else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { break; default : - break loop9; + break loop18; } } while (true); @@ -1960,25 +3051,25 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { try { int _type = RULE_SL_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3883:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalExport.g:3883:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + // InternalExport.g:10169:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalExport.g:10169:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? { match("//"); - // InternalExport.g:3883:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop10: + // InternalExport.g:10169:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop19: do { - int alt10=2; - int LA10_0 = input.LA(1); + int alt19=2; + int LA19_0 = input.LA(1); - if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\uFFFF')) ) { - alt10=1; + if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { + alt19=1; } - switch (alt10) { + switch (alt19) { case 1 : - // InternalExport.g:3883:24: ~ ( ( '\\n' | '\\r' ) ) + // InternalExport.g:10169:24: ~ ( ( '\\n' | '\\r' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1994,31 +3085,31 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { break; default : - break loop10; + break loop19; } } while (true); - // InternalExport.g:3883:40: ( ( '\\r' )? '\\n' )? - int alt12=2; - int LA12_0 = input.LA(1); + // InternalExport.g:10169:40: ( ( '\\r' )? '\\n' )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA12_0=='\n'||LA12_0=='\r') ) { - alt12=1; + if ( (LA21_0=='\n'||LA21_0=='\r') ) { + alt21=1; } - switch (alt12) { + switch (alt21) { case 1 : - // InternalExport.g:3883:41: ( '\\r' )? '\\n' + // InternalExport.g:10169:41: ( '\\r' )? '\\n' { - // InternalExport.g:3883:41: ( '\\r' )? - int alt11=2; - int LA11_0 = input.LA(1); + // InternalExport.g:10169:41: ( '\\r' )? + int alt20=2; + int LA20_0 = input.LA(1); - if ( (LA11_0=='\r') ) { - alt11=1; + if ( (LA20_0=='\r') ) { + alt20=1; } - switch (alt11) { + switch (alt20) { case 1 : - // InternalExport.g:3883:41: '\\r' + // InternalExport.g:10169:41: '\\r' { match('\r'); @@ -2037,637 +3128,889 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { } - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_SL_COMMENT" + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_SL_COMMENT" + + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:10171:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalExport.g:10171:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalExport.g:10171:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='\t' && LA22_0<='\n')||LA22_0=='\r'||LA22_0==' ') ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalExport.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExport.g:10173:16: ( . ) + // InternalExport.g:10173:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalExport.g:1:8: ( T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | T__115 | T__116 | T__117 | RULE_REAL | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt23=114; + alt23 = dfa23.predict(input); + switch (alt23) { + case 1 : + // InternalExport.g:1:10: T__14 + { + mT__14(); + + } + break; + case 2 : + // InternalExport.g:1:16: T__15 + { + mT__15(); + + } + break; + case 3 : + // InternalExport.g:1:22: T__16 + { + mT__16(); + + } + break; + case 4 : + // InternalExport.g:1:28: T__17 + { + mT__17(); + + } + break; + case 5 : + // InternalExport.g:1:34: T__18 + { + mT__18(); + + } + break; + case 6 : + // InternalExport.g:1:40: T__19 + { + mT__19(); + + } + break; + case 7 : + // InternalExport.g:1:46: T__20 + { + mT__20(); + + } + break; + case 8 : + // InternalExport.g:1:52: T__21 + { + mT__21(); + + } + break; + case 9 : + // InternalExport.g:1:58: T__22 + { + mT__22(); + + } + break; + case 10 : + // InternalExport.g:1:64: T__23 + { + mT__23(); + + } + break; + case 11 : + // InternalExport.g:1:70: T__24 + { + mT__24(); + + } + break; + case 12 : + // InternalExport.g:1:76: T__25 + { + mT__25(); + + } + break; + case 13 : + // InternalExport.g:1:82: T__26 + { + mT__26(); + + } + break; + case 14 : + // InternalExport.g:1:88: T__27 + { + mT__27(); + + } + break; + case 15 : + // InternalExport.g:1:94: T__28 + { + mT__28(); + + } + break; + case 16 : + // InternalExport.g:1:100: T__29 + { + mT__29(); + + } + break; + case 17 : + // InternalExport.g:1:106: T__30 + { + mT__30(); + + } + break; + case 18 : + // InternalExport.g:1:112: T__31 + { + mT__31(); + + } + break; + case 19 : + // InternalExport.g:1:118: T__32 + { + mT__32(); + + } + break; + case 20 : + // InternalExport.g:1:124: T__33 + { + mT__33(); + + } + break; + case 21 : + // InternalExport.g:1:130: T__34 + { + mT__34(); + + } + break; + case 22 : + // InternalExport.g:1:136: T__35 + { + mT__35(); - // $ANTLR start "RULE_WS" - public final void mRULE_WS() throws RecognitionException { - try { - int _type = RULE_WS; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3885:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalExport.g:3885:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - { - // InternalExport.g:3885:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt13=0; - loop13: - do { - int alt13=2; - int LA13_0 = input.LA(1); + } + break; + case 23 : + // InternalExport.g:1:142: T__36 + { + mT__36(); - if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) { - alt13=1; } + break; + case 24 : + // InternalExport.g:1:148: T__37 + { + mT__37(); + } + break; + case 25 : + // InternalExport.g:1:154: T__38 + { + mT__38(); - switch (alt13) { - case 1 : - // InternalExport.g: - { - if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { - input.consume(); + } + break; + case 26 : + // InternalExport.g:1:160: T__39 + { + mT__39(); - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + } + break; + case 27 : + // InternalExport.g:1:166: T__40 + { + mT__40(); + } + break; + case 28 : + // InternalExport.g:1:172: T__41 + { + mT__41(); - } - break; + } + break; + case 29 : + // InternalExport.g:1:178: T__42 + { + mT__42(); - default : - if ( cnt13 >= 1 ) break loop13; - EarlyExitException eee = - new EarlyExitException(13, input); - throw eee; } - cnt13++; - } while (true); + break; + case 30 : + // InternalExport.g:1:184: T__43 + { + mT__43(); + } + break; + case 31 : + // InternalExport.g:1:190: T__44 + { + mT__44(); - } + } + break; + case 32 : + // InternalExport.g:1:196: T__45 + { + mT__45(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_WS" + } + break; + case 33 : + // InternalExport.g:1:202: T__46 + { + mT__46(); - // $ANTLR start "RULE_ANY_OTHER" - public final void mRULE_ANY_OTHER() throws RecognitionException { - try { - int _type = RULE_ANY_OTHER; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExport.g:3887:16: ( . ) - // InternalExport.g:3887:18: . - { - matchAny(); + } + break; + case 34 : + // InternalExport.g:1:208: T__47 + { + mT__47(); - } + } + break; + case 35 : + // InternalExport.g:1:214: T__48 + { + mT__48(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ANY_OTHER" + } + break; + case 36 : + // InternalExport.g:1:220: T__49 + { + mT__49(); - public void mTokens() throws RecognitionException { - // InternalExport.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | RULE_REAL | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt14=78; - alt14 = dfa14.predict(input); - switch (alt14) { - case 1 : - // InternalExport.g:1:10: T__12 + } + break; + case 37 : + // InternalExport.g:1:226: T__50 { - mT__12(); + mT__50(); } break; - case 2 : - // InternalExport.g:1:16: T__13 + case 38 : + // InternalExport.g:1:232: T__51 { - mT__13(); + mT__51(); } break; - case 3 : - // InternalExport.g:1:22: T__14 + case 39 : + // InternalExport.g:1:238: T__52 { - mT__14(); + mT__52(); } break; - case 4 : - // InternalExport.g:1:28: T__15 + case 40 : + // InternalExport.g:1:244: T__53 { - mT__15(); + mT__53(); } break; - case 5 : - // InternalExport.g:1:34: T__16 + case 41 : + // InternalExport.g:1:250: T__54 { - mT__16(); + mT__54(); } break; - case 6 : - // InternalExport.g:1:40: T__17 + case 42 : + // InternalExport.g:1:256: T__55 { - mT__17(); + mT__55(); } break; - case 7 : - // InternalExport.g:1:46: T__18 + case 43 : + // InternalExport.g:1:262: T__56 { - mT__18(); + mT__56(); } break; - case 8 : - // InternalExport.g:1:52: T__19 + case 44 : + // InternalExport.g:1:268: T__57 { - mT__19(); + mT__57(); } break; - case 9 : - // InternalExport.g:1:58: T__20 + case 45 : + // InternalExport.g:1:274: T__58 { - mT__20(); + mT__58(); } break; - case 10 : - // InternalExport.g:1:64: T__21 + case 46 : + // InternalExport.g:1:280: T__59 { - mT__21(); + mT__59(); } break; - case 11 : - // InternalExport.g:1:70: T__22 + case 47 : + // InternalExport.g:1:286: T__60 { - mT__22(); + mT__60(); } break; - case 12 : - // InternalExport.g:1:76: T__23 + case 48 : + // InternalExport.g:1:292: T__61 { - mT__23(); + mT__61(); } break; - case 13 : - // InternalExport.g:1:82: T__24 + case 49 : + // InternalExport.g:1:298: T__62 { - mT__24(); + mT__62(); } break; - case 14 : - // InternalExport.g:1:88: T__25 + case 50 : + // InternalExport.g:1:304: T__63 { - mT__25(); + mT__63(); } break; - case 15 : - // InternalExport.g:1:94: T__26 + case 51 : + // InternalExport.g:1:310: T__64 { - mT__26(); + mT__64(); } break; - case 16 : - // InternalExport.g:1:100: T__27 + case 52 : + // InternalExport.g:1:316: T__65 { - mT__27(); + mT__65(); } break; - case 17 : - // InternalExport.g:1:106: T__28 + case 53 : + // InternalExport.g:1:322: T__66 { - mT__28(); + mT__66(); } break; - case 18 : - // InternalExport.g:1:112: T__29 + case 54 : + // InternalExport.g:1:328: T__67 { - mT__29(); + mT__67(); } break; - case 19 : - // InternalExport.g:1:118: T__30 + case 55 : + // InternalExport.g:1:334: T__68 { - mT__30(); + mT__68(); } break; - case 20 : - // InternalExport.g:1:124: T__31 + case 56 : + // InternalExport.g:1:340: T__69 { - mT__31(); + mT__69(); } break; - case 21 : - // InternalExport.g:1:130: T__32 + case 57 : + // InternalExport.g:1:346: T__70 { - mT__32(); + mT__70(); } break; - case 22 : - // InternalExport.g:1:136: T__33 + case 58 : + // InternalExport.g:1:352: T__71 { - mT__33(); + mT__71(); } break; - case 23 : - // InternalExport.g:1:142: T__34 + case 59 : + // InternalExport.g:1:358: T__72 { - mT__34(); + mT__72(); } break; - case 24 : - // InternalExport.g:1:148: T__35 + case 60 : + // InternalExport.g:1:364: T__73 { - mT__35(); + mT__73(); } break; - case 25 : - // InternalExport.g:1:154: T__36 + case 61 : + // InternalExport.g:1:370: T__74 { - mT__36(); + mT__74(); } break; - case 26 : - // InternalExport.g:1:160: T__37 + case 62 : + // InternalExport.g:1:376: T__75 { - mT__37(); + mT__75(); } break; - case 27 : - // InternalExport.g:1:166: T__38 + case 63 : + // InternalExport.g:1:382: T__76 { - mT__38(); + mT__76(); } break; - case 28 : - // InternalExport.g:1:172: T__39 + case 64 : + // InternalExport.g:1:388: T__77 { - mT__39(); + mT__77(); } break; - case 29 : - // InternalExport.g:1:178: T__40 + case 65 : + // InternalExport.g:1:394: T__78 { - mT__40(); + mT__78(); } break; - case 30 : - // InternalExport.g:1:184: T__41 + case 66 : + // InternalExport.g:1:400: T__79 { - mT__41(); + mT__79(); } break; - case 31 : - // InternalExport.g:1:190: T__42 + case 67 : + // InternalExport.g:1:406: T__80 { - mT__42(); + mT__80(); } break; - case 32 : - // InternalExport.g:1:196: T__43 + case 68 : + // InternalExport.g:1:412: T__81 { - mT__43(); + mT__81(); } break; - case 33 : - // InternalExport.g:1:202: T__44 + case 69 : + // InternalExport.g:1:418: T__82 { - mT__44(); + mT__82(); } break; - case 34 : - // InternalExport.g:1:208: T__45 + case 70 : + // InternalExport.g:1:424: T__83 { - mT__45(); + mT__83(); } break; - case 35 : - // InternalExport.g:1:214: T__46 + case 71 : + // InternalExport.g:1:430: T__84 { - mT__46(); + mT__84(); } break; - case 36 : - // InternalExport.g:1:220: T__47 + case 72 : + // InternalExport.g:1:436: T__85 { - mT__47(); + mT__85(); } break; - case 37 : - // InternalExport.g:1:226: T__48 + case 73 : + // InternalExport.g:1:442: T__86 { - mT__48(); + mT__86(); } break; - case 38 : - // InternalExport.g:1:232: T__49 + case 74 : + // InternalExport.g:1:448: T__87 { - mT__49(); + mT__87(); } break; - case 39 : - // InternalExport.g:1:238: T__50 + case 75 : + // InternalExport.g:1:454: T__88 { - mT__50(); + mT__88(); } break; - case 40 : - // InternalExport.g:1:244: T__51 + case 76 : + // InternalExport.g:1:460: T__89 { - mT__51(); + mT__89(); } break; - case 41 : - // InternalExport.g:1:250: T__52 + case 77 : + // InternalExport.g:1:466: T__90 { - mT__52(); + mT__90(); } break; - case 42 : - // InternalExport.g:1:256: T__53 + case 78 : + // InternalExport.g:1:472: T__91 { - mT__53(); + mT__91(); } break; - case 43 : - // InternalExport.g:1:262: T__54 + case 79 : + // InternalExport.g:1:478: T__92 { - mT__54(); + mT__92(); } break; - case 44 : - // InternalExport.g:1:268: T__55 + case 80 : + // InternalExport.g:1:484: T__93 { - mT__55(); + mT__93(); } break; - case 45 : - // InternalExport.g:1:274: T__56 + case 81 : + // InternalExport.g:1:490: T__94 { - mT__56(); + mT__94(); } break; - case 46 : - // InternalExport.g:1:280: T__57 + case 82 : + // InternalExport.g:1:496: T__95 { - mT__57(); + mT__95(); } break; - case 47 : - // InternalExport.g:1:286: T__58 + case 83 : + // InternalExport.g:1:502: T__96 { - mT__58(); + mT__96(); } break; - case 48 : - // InternalExport.g:1:292: T__59 + case 84 : + // InternalExport.g:1:508: T__97 { - mT__59(); + mT__97(); } break; - case 49 : - // InternalExport.g:1:298: T__60 + case 85 : + // InternalExport.g:1:514: T__98 { - mT__60(); + mT__98(); } break; - case 50 : - // InternalExport.g:1:304: T__61 + case 86 : + // InternalExport.g:1:520: T__99 { - mT__61(); + mT__99(); } break; - case 51 : - // InternalExport.g:1:310: T__62 + case 87 : + // InternalExport.g:1:526: T__100 { - mT__62(); + mT__100(); } break; - case 52 : - // InternalExport.g:1:316: T__63 + case 88 : + // InternalExport.g:1:533: T__101 { - mT__63(); + mT__101(); } break; - case 53 : - // InternalExport.g:1:322: T__64 + case 89 : + // InternalExport.g:1:540: T__102 { - mT__64(); + mT__102(); } break; - case 54 : - // InternalExport.g:1:328: T__65 + case 90 : + // InternalExport.g:1:547: T__103 { - mT__65(); + mT__103(); } break; - case 55 : - // InternalExport.g:1:334: T__66 + case 91 : + // InternalExport.g:1:554: T__104 { - mT__66(); + mT__104(); } break; - case 56 : - // InternalExport.g:1:340: T__67 + case 92 : + // InternalExport.g:1:561: T__105 { - mT__67(); + mT__105(); } break; - case 57 : - // InternalExport.g:1:346: T__68 + case 93 : + // InternalExport.g:1:568: T__106 { - mT__68(); + mT__106(); } break; - case 58 : - // InternalExport.g:1:352: T__69 + case 94 : + // InternalExport.g:1:575: T__107 { - mT__69(); + mT__107(); } break; - case 59 : - // InternalExport.g:1:358: T__70 + case 95 : + // InternalExport.g:1:582: T__108 { - mT__70(); + mT__108(); } break; - case 60 : - // InternalExport.g:1:364: T__71 + case 96 : + // InternalExport.g:1:589: T__109 { - mT__71(); + mT__109(); } break; - case 61 : - // InternalExport.g:1:370: T__72 + case 97 : + // InternalExport.g:1:596: T__110 { - mT__72(); + mT__110(); } break; - case 62 : - // InternalExport.g:1:376: T__73 + case 98 : + // InternalExport.g:1:603: T__111 { - mT__73(); + mT__111(); } break; - case 63 : - // InternalExport.g:1:382: T__74 + case 99 : + // InternalExport.g:1:610: T__112 { - mT__74(); + mT__112(); } break; - case 64 : - // InternalExport.g:1:388: T__75 + case 100 : + // InternalExport.g:1:617: T__113 { - mT__75(); + mT__113(); } break; - case 65 : - // InternalExport.g:1:394: T__76 + case 101 : + // InternalExport.g:1:624: T__114 { - mT__76(); + mT__114(); } break; - case 66 : - // InternalExport.g:1:400: T__77 + case 102 : + // InternalExport.g:1:631: T__115 { - mT__77(); + mT__115(); } break; - case 67 : - // InternalExport.g:1:406: T__78 + case 103 : + // InternalExport.g:1:638: T__116 { - mT__78(); + mT__116(); } break; - case 68 : - // InternalExport.g:1:412: T__79 + case 104 : + // InternalExport.g:1:645: T__117 { - mT__79(); + mT__117(); } break; - case 69 : - // InternalExport.g:1:418: T__80 + case 105 : + // InternalExport.g:1:652: RULE_REAL { - mT__80(); + mRULE_REAL(); } break; - case 70 : - // InternalExport.g:1:424: T__81 + case 106 : + // InternalExport.g:1:662: RULE_HEX { - mT__81(); + mRULE_HEX(); } break; - case 71 : - // InternalExport.g:1:430: RULE_REAL + case 107 : + // InternalExport.g:1:671: RULE_INT { - mRULE_REAL(); + mRULE_INT(); } break; - case 72 : - // InternalExport.g:1:440: RULE_ID + case 108 : + // InternalExport.g:1:680: RULE_DECIMAL { - mRULE_ID(); + mRULE_DECIMAL(); } break; - case 73 : - // InternalExport.g:1:448: RULE_INT + case 109 : + // InternalExport.g:1:693: RULE_ID { - mRULE_INT(); + mRULE_ID(); } break; - case 74 : - // InternalExport.g:1:457: RULE_STRING + case 110 : + // InternalExport.g:1:701: RULE_STRING { mRULE_STRING(); } break; - case 75 : - // InternalExport.g:1:469: RULE_ML_COMMENT + case 111 : + // InternalExport.g:1:713: RULE_ML_COMMENT { mRULE_ML_COMMENT(); } break; - case 76 : - // InternalExport.g:1:485: RULE_SL_COMMENT + case 112 : + // InternalExport.g:1:729: RULE_SL_COMMENT { mRULE_SL_COMMENT(); } break; - case 77 : - // InternalExport.g:1:501: RULE_WS + case 113 : + // InternalExport.g:1:745: RULE_WS { mRULE_WS(); } break; - case 78 : - // InternalExport.g:1:509: RULE_ANY_OTHER + case 114 : + // InternalExport.g:1:753: RULE_ANY_OTHER { mRULE_ANY_OTHER(); @@ -2679,83 +4022,90 @@ public void mTokens() throws RecognitionException { } - protected DFA14 dfa14 = new DFA14(this); - static final String DFA14_eotS = - "\1\uffff\3\63\2\uffff\1\63\2\uffff\1\101\6\uffff\6\63\1\122\1\124\1\uffff\3\63\1\137\1\57\1\142\1\144\1\146\1\uffff\1\152\1\153\5\63\1\164\1\57\1\uffff\2\57\2\uffff\3\63\1\uffff\5\63\1\u0082\2\uffff\1\u0083\1\63\12\uffff\11\63\5\uffff\10\63\17\uffff\7\63\1\uffff\1\164\2\uffff\5\63\1\u00a4\4\63\2\uffff\2\63\1\u00ac\22\63\1\u00bf\3\63\1\u00c3\3\63\1\u00c7\1\u00c8\1\63\1\uffff\7\63\1\uffff\1\63\1\uffff\4\63\1\u00d6\1\63\1\u00d8\1\63\1\u00da\3\63\1\u00de\2\63\1\u00e1\1\uffff\2\63\1\u00e4\1\uffff\3\63\2\uffff\1\63\1\u00e9\1\u00ea\12\63\1\uffff\1\63\1\uffff\1\63\1\uffff\3\63\1\uffff\2\63\1\uffff\2\63\1\uffff\1\u00fe\1\63\1\u0100\1\u0101\2\uffff\1\63\1\u0103\2\63\1\u0106\1\63\1\u0108\2\63\1\u010b\2\63\1\u010e\1\u0110\1\u0111\4\63\1\uffff\1\63\2\uffff\1\63\1\uffff\1\u0118\1\63\1\uffff\1\63\2\uffff\1\63\1\uffff\1\u011c\1\63\1\uffff\1\63\2\uffff\1\u011f\5\63\1\uffff\3\63\1\uffff\2\63\1\uffff\3\63\1\u012d\1\u012e\1\u012f\1\u0130\1\uffff\2\63\1\u0133\1\u0134\1\63\4\uffff\1\u0136\1\63\2\uffff\1\u0138\1\uffff\1\u0139\2\uffff"; - static final String DFA14_eofS = - "\u013a\uffff"; - static final String DFA14_minS = - "\1\0\1\154\1\141\1\146\2\uffff\1\163\2\uffff\1\75\6\uffff\1\145\1\165\1\156\1\142\1\145\1\141\1\72\1\76\1\uffff\1\150\1\145\1\141\1\174\1\46\3\75\1\uffff\1\52\1\60\1\145\1\114\1\157\1\151\1\145\1\56\1\101\1\uffff\2\0\2\uffff\1\151\1\141\1\163\1\uffff\1\162\1\145\1\154\1\164\1\160\1\60\2\uffff\1\60\1\164\12\uffff\1\157\1\164\1\141\2\151\2\152\1\164\1\146\5\uffff\1\145\1\160\1\165\1\151\1\154\1\162\1\163\1\154\17\uffff\1\164\1\154\1\167\1\117\1\154\1\163\1\164\1\uffff\1\56\2\uffff\1\157\1\145\1\163\1\154\1\145\1\60\1\154\1\163\1\145\1\154\2\uffff\1\162\1\153\1\60\1\154\1\55\1\161\1\145\1\157\1\145\2\141\1\156\2\145\1\164\1\145\1\164\1\145\1\154\1\105\1\154\1\60\1\102\1\154\1\164\1\60\1\162\1\156\1\164\2\60\1\154\1\uffff\1\144\1\145\2\162\2\151\1\165\1\uffff\1\151\1\uffff\1\165\1\143\1\165\1\143\1\60\1\165\1\60\1\123\1\60\2\143\1\102\1\60\1\145\1\170\1\60\1\uffff\1\101\1\145\1\60\1\uffff\1\164\2\163\2\uffff\1\154\2\60\1\146\1\164\1\145\1\142\1\160\1\146\1\145\1\164\1\162\1\164\1\uffff\1\154\1\uffff\1\145\1\uffff\1\150\1\164\1\171\1\uffff\1\143\1\151\1\uffff\1\114\1\143\1\uffff\1\60\1\151\2\60\2\uffff\1\141\1\60\1\163\1\165\1\60\1\151\1\60\1\55\1\143\1\60\1\164\1\154\3\60\1\164\1\163\1\126\1\164\1\uffff\1\157\2\uffff\1\143\1\uffff\1\60\1\164\1\uffff\1\145\2\uffff\1\145\1\uffff\1\60\1\145\1\uffff\1\151\2\uffff\1\60\1\164\1\101\1\151\1\156\1\145\1\uffff\1\145\1\144\1\55\1\uffff\1\143\1\162\1\uffff\1\163\1\122\1\157\4\60\1\uffff\1\164\1\163\2\60\1\156\4\uffff\1\60\1\164\2\uffff\1\60\1\uffff\1\60\2\uffff"; - static final String DFA14_maxS = - "\1\uffff\1\170\1\157\1\156\2\uffff\1\164\2\uffff\1\75\6\uffff\1\157\1\165\1\162\1\142\2\145\1\72\1\76\1\uffff\1\171\1\167\1\157\1\174\1\46\3\75\1\uffff\1\57\1\71\1\165\1\114\1\157\1\151\1\145\1\71\1\172\1\uffff\2\uffff\2\uffff\1\164\1\141\1\163\1\uffff\1\162\1\145\1\154\1\164\1\160\1\172\2\uffff\1\172\1\164\12\uffff\1\157\1\164\1\141\2\151\1\152\1\163\1\164\1\146\5\uffff\1\145\1\160\1\165\1\151\1\154\1\162\1\163\1\154\17\uffff\1\164\1\154\1\167\1\117\1\154\1\163\1\164\1\uffff\1\71\2\uffff\1\157\1\145\1\163\1\154\1\145\1\172\1\154\1\163\1\145\1\157\2\uffff\1\162\1\153\1\172\1\154\1\55\1\161\1\145\1\157\1\145\2\141\1\156\2\145\1\164\1\145\1\164\1\145\1\154\1\105\1\154\1\172\1\102\1\154\1\164\1\172\1\162\1\156\1\164\2\172\1\154\1\uffff\1\144\1\145\2\162\2\151\1\165\1\uffff\1\151\1\uffff\1\165\1\143\1\165\1\143\1\172\1\165\1\172\1\123\1\172\2\143\1\102\1\172\1\145\1\170\1\172\1\uffff\1\101\1\145\1\172\1\uffff\1\164\2\163\2\uffff\1\154\2\172\1\146\1\164\1\145\1\142\1\160\1\146\1\145\1\164\1\162\1\164\1\uffff\1\154\1\uffff\1\145\1\uffff\1\150\1\164\1\171\1\uffff\1\143\1\151\1\uffff\1\114\1\143\1\uffff\1\172\1\151\2\172\2\uffff\1\141\1\172\1\163\1\165\1\172\1\151\1\172\1\55\1\143\1\172\1\164\1\154\3\172\1\164\1\163\1\126\1\164\1\uffff\1\157\2\uffff\1\143\1\uffff\1\172\1\164\1\uffff\1\145\2\uffff\1\145\1\uffff\1\172\1\145\1\uffff\1\151\2\uffff\1\172\1\164\1\101\1\151\1\156\1\145\1\uffff\1\145\1\144\1\55\1\uffff\1\143\1\162\1\uffff\1\163\1\122\1\157\4\172\1\uffff\1\164\1\163\2\172\1\156\4\uffff\1\172\1\164\2\uffff\1\172\1\uffff\1\172\2\uffff"; - static final String DFA14_acceptS = - "\4\uffff\1\5\1\6\1\uffff\1\11\1\12\1\uffff\1\14\1\15\1\16\1\17\1\21\1\22\10\uffff\1\40\10\uffff\1\61\11\uffff\1\110\2\uffff\1\115\1\116\3\uffff\1\110\6\uffff\1\5\1\6\2\uffff\1\11\1\12\1\52\1\13\1\14\1\15\1\16\1\17\1\21\1\22\11\uffff\1\34\1\36\1\37\1\60\1\40\10\uffff\1\47\1\76\1\50\1\53\1\63\1\54\1\56\1\55\1\57\1\61\1\113\1\114\1\62\1\64\1\107\7\uffff\1\111\1\uffff\1\112\1\115\12\uffff\1\41\1\10\40\uffff\1\3\7\uffff\1\35\1\uffff\1\25\20\uffff\1\103\3\uffff\1\106\3\uffff\1\20\1\43\15\uffff\1\33\1\uffff\1\42\1\uffff\1\77\3\uffff\1\46\2\uffff\1\101\2\uffff\1\105\4\uffff\1\32\1\100\23\uffff\1\1\1\uffff\1\72\1\75\1\uffff\1\7\2\uffff\1\23\1\uffff\1\26\1\30\1\uffff\1\71\2\uffff\1\44\1\uffff\1\67\1\74\6\uffff\1\51\3\uffff\1\45\2\uffff\1\66\7\uffff\1\31\5\uffff\1\2\1\4\1\27\1\24\2\uffff\1\73\1\102\1\uffff\1\65\1\uffff\1\104\1\70"; - static final String DFA14_specialS = - "\1\0\53\uffff\1\1\1\2\u010c\uffff}>"; - static final String[] DFA14_transitionS = { - "\11\57\2\56\2\57\1\56\22\57\1\56\1\36\1\54\3\57\1\35\1\55\1\16\1\17\1\41\1\14\1\12\1\27\1\43\1\42\12\51\1\26\1\13\1\40\1\11\1\37\1\30\1\15\2\53\1\46\3\53\1\45\4\53\1\47\6\53\1\50\7\53\1\7\1\57\1\10\1\52\1\53\1\57\1\6\1\53\1\33\1\25\1\1\1\2\2\53\1\3\2\53\1\20\1\53\1\44\1\23\1\53\1\21\1\24\1\32\1\31\1\22\5\53\1\4\1\34\1\5\uff82\57", - "\1\62\11\uffff\1\61\1\uffff\1\60", - "\1\66\7\uffff\1\65\5\uffff\1\64", - "\1\71\6\uffff\1\70\1\67", + protected DFA23 dfa23 = new DFA23(this); + static final String DFA23_eotS = + "\1\uffff\3\70\2\uffff\1\70\2\uffff\1\107\2\uffff\1\114\3\uffff\6\70\1\133\1\137\1\142\3\70\1\157\1\161\1\163\1\165\1\170\1\173\1\177\1\u0081\5\70\1\u008b\1\uffff\2\70\2\u0092\1\64\5\uffff\3\70\1\uffff\5\70\1\u00a2\2\uffff\1\u00a3\1\70\2\uffff\1\u00a6\12\uffff\11\70\1\u00b2\11\uffff\13\70\4\uffff\1\u00c2\15\uffff\1\u00c4\2\uffff\7\70\3\uffff\2\70\1\uffff\2\u0092\4\uffff\5\70\1\u00d5\6\70\2\uffff\1\70\2\uffff\1\70\1\u00df\11\70\1\uffff\4\70\1\u00ed\11\70\4\uffff\2\70\1\u00f9\3\70\1\u00fd\1\70\1\u00ff\1\u0100\3\70\1\u0104\1\u0105\1\70\1\uffff\11\70\1\uffff\1\70\1\uffff\5\70\1\u0116\1\70\1\u0118\2\70\1\u011c\1\uffff\6\70\1\u0123\3\70\1\u0127\1\uffff\2\70\1\u012a\1\uffff\1\70\2\uffff\3\70\2\uffff\1\70\1\u0131\1\70\1\u0133\14\70\1\uffff\1\70\1\uffff\1\u0141\2\70\1\uffff\4\70\1\u0148\1\70\1\uffff\1\u014a\2\70\1\uffff\2\70\1\uffff\1\u014f\1\u0150\2\70\1\u0153\1\u0154\1\uffff\1\70\1\uffff\2\70\1\u0158\2\70\1\u015b\1\70\1\u015d\2\70\1\u0160\1\u0161\1\70\1\uffff\1\70\1\u0164\1\u0165\1\u0167\1\u0168\1\u0169\1\uffff\1\70\1\uffff\4\70\2\uffff\1\70\1\u0170\2\uffff\1\u0171\2\70\1\uffff\1\u0174\1\70\1\uffff\1\70\2\uffff\1\70\2\uffff\1\u0178\1\70\2\uffff\1\70\3\uffff\1\70\1\u017c\4\70\2\uffff\2\70\1\uffff\3\70\1\uffff\3\70\1\uffff\3\70\1\u018c\1\u018d\1\70\1\u018f\1\u0190\1\uffff\3\70\1\u0194\1\u0195\1\70\2\uffff\1\u0197\2\uffff\1\u0198\2\70\2\uffff\1\u019b\2\uffff\1\u019c\1\70\2\uffff\1\u019e\1\uffff"; + static final String DFA23_eofS = + "\u019f\uffff"; + static final String DFA23_minS = + "\1\0\1\154\1\141\1\146\2\uffff\1\163\2\uffff\1\75\2\uffff\1\53\3\uffff\1\145\1\165\1\156\1\142\1\145\1\141\1\72\1\55\1\56\1\150\1\145\1\141\1\174\1\46\3\75\2\52\1\56\1\145\1\114\1\157\1\151\1\145\1\75\1\uffff\1\150\1\141\2\56\1\44\5\uffff\1\151\1\141\1\163\1\uffff\1\162\1\145\1\154\1\163\1\160\1\44\2\uffff\1\44\1\164\2\uffff\1\75\12\uffff\1\157\1\164\1\141\2\151\2\152\1\164\1\146\1\44\11\uffff\1\145\1\160\1\165\1\151\1\154\1\162\1\141\1\160\1\156\1\163\1\154\4\uffff\1\75\15\uffff\1\74\2\uffff\1\164\1\154\1\167\1\117\1\154\1\163\1\164\3\uffff\1\151\1\154\1\uffff\1\56\1\60\4\uffff\1\157\1\145\1\163\1\154\1\145\1\44\1\154\1\141\1\163\1\145\1\164\1\154\2\uffff\1\162\2\uffff\1\153\1\44\1\154\1\55\1\161\1\145\1\157\1\145\1\165\2\141\1\uffff\1\156\1\157\2\145\1\44\1\164\1\145\2\164\1\145\1\143\1\145\1\143\1\154\4\uffff\1\105\1\154\1\44\1\102\1\154\1\164\1\44\1\154\2\44\1\162\1\156\1\164\2\44\1\154\1\uffff\1\144\1\154\1\145\1\162\1\141\1\162\2\151\1\165\1\uffff\1\151\1\uffff\1\165\1\143\1\165\1\143\1\162\1\44\1\165\1\44\1\167\1\123\1\44\1\uffff\2\143\1\102\1\151\1\162\1\150\1\44\1\150\1\145\1\170\1\44\1\uffff\1\101\1\145\1\44\1\uffff\1\145\2\uffff\1\164\1\144\1\163\2\uffff\1\154\1\44\1\154\1\44\1\146\1\156\1\164\1\145\1\142\1\160\1\146\1\145\1\164\1\162\1\164\1\156\1\uffff\1\154\1\uffff\1\44\1\145\1\146\1\uffff\1\150\1\164\1\171\1\143\1\44\1\162\1\uffff\1\44\1\143\1\151\1\uffff\1\114\1\143\1\uffff\2\44\1\151\1\163\2\44\1\uffff\1\171\1\uffff\1\141\1\143\1\44\1\163\1\165\1\44\1\151\1\44\1\55\1\143\2\44\1\164\1\uffff\1\154\5\44\1\uffff\1\157\1\uffff\1\164\1\163\1\126\1\164\2\uffff\1\157\1\44\2\uffff\1\44\1\143\1\145\1\uffff\1\44\1\164\1\uffff\1\145\2\uffff\1\145\2\uffff\1\44\1\145\2\uffff\1\151\3\uffff\1\156\1\44\1\164\1\101\1\151\1\156\2\uffff\1\145\1\157\1\uffff\1\145\1\144\1\55\1\uffff\1\143\1\162\1\151\1\uffff\1\163\1\122\1\157\2\44\1\146\2\44\1\uffff\1\164\1\163\1\172\2\44\1\156\2\uffff\1\44\2\uffff\1\44\1\164\1\145\2\uffff\1\44\2\uffff\1\44\1\144\2\uffff\1\44\1\uffff"; + static final String DFA23_maxS = + "\1\uffff\1\170\1\157\1\156\2\uffff\1\164\2\uffff\1\76\2\uffff\1\75\3\uffff\1\157\1\165\1\162\1\142\1\145\1\157\1\72\1\76\1\72\2\171\1\157\1\174\1\46\2\75\1\76\2\75\1\71\1\165\1\114\1\157\1\151\1\145\1\75\1\uffff\1\150\1\141\1\170\1\154\1\172\5\uffff\1\164\1\141\1\163\1\uffff\1\162\1\156\1\154\1\164\1\160\1\172\2\uffff\1\172\1\164\2\uffff\1\75\12\uffff\1\157\1\164\1\141\2\151\1\152\2\164\1\146\1\172\11\uffff\1\162\1\160\1\171\1\151\1\154\1\162\1\141\1\160\1\156\1\164\1\154\4\uffff\1\75\15\uffff\1\74\2\uffff\1\164\1\154\1\167\1\117\1\154\1\163\1\164\3\uffff\1\151\1\162\1\uffff\2\154\4\uffff\1\157\1\145\1\163\1\154\1\145\1\172\1\154\1\141\1\163\1\145\1\164\1\157\2\uffff\1\162\2\uffff\1\153\1\172\1\154\1\55\1\161\1\145\1\157\1\145\1\165\2\141\1\uffff\1\156\1\157\2\145\1\172\1\164\1\145\2\164\1\145\1\143\1\145\1\143\1\154\4\uffff\1\105\1\154\1\172\1\102\1\154\1\164\1\172\1\154\2\172\1\162\1\156\1\164\2\172\1\154\1\uffff\1\144\1\154\1\145\1\162\1\141\1\162\2\151\1\165\1\uffff\1\151\1\uffff\1\165\1\143\1\165\1\143\1\162\1\172\1\165\1\172\1\167\1\157\1\172\1\uffff\2\143\1\102\1\151\1\162\1\150\1\172\1\150\1\145\1\170\1\172\1\uffff\1\101\1\145\1\172\1\uffff\1\145\2\uffff\1\164\2\163\2\uffff\1\154\1\172\1\154\1\172\1\146\1\156\1\164\1\145\1\142\1\160\1\146\1\145\1\164\1\162\1\164\1\156\1\uffff\1\154\1\uffff\1\172\1\145\1\146\1\uffff\1\150\1\164\1\171\1\143\1\172\1\162\1\uffff\1\172\1\143\1\151\1\uffff\1\114\1\143\1\uffff\2\172\1\151\1\163\2\172\1\uffff\1\171\1\uffff\1\141\1\143\1\172\1\163\1\165\1\172\1\151\1\172\1\55\1\143\2\172\1\164\1\uffff\1\154\5\172\1\uffff\1\157\1\uffff\1\164\1\163\1\126\1\164\2\uffff\1\157\1\172\2\uffff\1\172\1\143\1\145\1\uffff\1\172\1\164\1\uffff\1\145\2\uffff\1\145\2\uffff\1\172\1\145\2\uffff\1\151\3\uffff\1\156\1\172\1\164\1\101\1\151\1\156\2\uffff\1\145\1\157\1\uffff\1\145\1\144\1\55\1\uffff\1\143\1\162\1\151\1\uffff\1\163\1\122\1\157\2\172\1\146\2\172\1\uffff\1\164\1\163\3\172\1\156\2\uffff\1\172\2\uffff\1\172\1\164\1\145\2\uffff\1\172\2\uffff\1\172\1\144\2\uffff\1\172\1\uffff"; + static final String DFA23_acceptS = + "\4\uffff\1\5\1\6\1\uffff\1\11\1\12\1\uffff\1\14\1\15\1\uffff\1\17\1\21\1\22\32\uffff\1\131\5\uffff\1\155\2\156\1\161\1\162\3\uffff\1\155\6\uffff\1\5\1\6\2\uffff\1\11\1\12\1\uffff\1\121\1\13\1\14\1\15\1\107\1\126\1\16\1\17\1\21\1\22\12\uffff\1\34\1\36\1\37\1\110\1\127\1\60\1\123\1\130\1\40\13\uffff\1\47\1\76\1\50\1\150\1\uffff\1\63\1\54\1\56\1\55\1\122\1\57\1\111\1\124\1\61\1\112\1\157\1\160\1\62\1\uffff\1\64\1\151\7\uffff\1\113\1\125\1\131\2\uffff\1\152\2\uffff\1\153\1\154\1\156\1\161\14\uffff\1\41\1\10\1\uffff\1\114\1\52\13\uffff\1\133\16\uffff\1\115\1\53\1\117\1\120\20\uffff\1\3\11\uffff\1\35\1\uffff\1\25\13\uffff\1\144\13\uffff\1\103\3\uffff\1\106\1\uffff\1\134\1\135\3\uffff\1\20\1\43\20\uffff\1\33\1\uffff\1\42\3\uffff\1\77\6\uffff\1\46\3\uffff\1\101\2\uffff\1\105\6\uffff\1\32\1\uffff\1\100\15\uffff\1\142\6\uffff\1\140\1\uffff\1\147\4\uffff\1\132\1\1\2\uffff\1\72\1\75\3\uffff\1\7\2\uffff\1\23\1\uffff\1\26\1\30\1\uffff\1\71\1\143\2\uffff\1\141\1\44\1\uffff\1\67\1\74\1\137\6\uffff\1\136\1\145\2\uffff\1\51\3\uffff\1\45\3\uffff\1\66\10\uffff\1\31\6\uffff\1\2\1\4\1\uffff\1\27\1\24\3\uffff\1\73\1\102\1\uffff\1\116\1\65\2\uffff\1\104\1\70\1\uffff\1\146"; + static final String DFA23_specialS = + "\1\0\u019e\uffff}>"; + static final String[] DFA23_transitionS = { + "\11\64\2\63\2\64\1\63\22\64\1\63\1\36\1\61\1\52\1\60\1\51\1\35\1\62\1\16\1\17\1\41\1\14\1\12\1\27\1\43\1\42\1\55\11\56\1\26\1\13\1\40\1\11\1\37\1\30\1\15\2\60\1\46\3\60\1\45\4\60\1\47\6\60\1\50\7\60\1\7\1\64\1\10\1\57\1\60\1\64\1\6\1\60\1\33\1\25\1\1\1\2\2\60\1\3\2\60\1\20\1\60\1\44\1\23\1\60\1\21\1\24\1\32\1\31\1\22\1\54\1\53\3\60\1\4\1\34\1\5\uff82\64", + "\1\67\11\uffff\1\66\1\uffff\1\65", + "\1\73\7\uffff\1\72\5\uffff\1\71", + "\1\76\6\uffff\1\75\1\74", + "", "", + "\1\101\1\102", "", - "\1\74\1\75", "", + "\1\105\1\106", "", - "\1\100", "", + "\1\113\21\uffff\1\112", "", "", "", + "\1\121\11\uffff\1\120", + "\1\122", + "\1\124\3\uffff\1\123", + "\1\125", + "\1\126", + "\1\127\3\uffff\1\130\11\uffff\1\131", + "\1\132", + "\1\136\17\uffff\1\135\1\134", + "\1\141\13\uffff\1\140", + "\1\143\11\uffff\1\145\6\uffff\1\144", + "\1\147\11\uffff\1\150\4\uffff\1\151\1\152\1\uffff\1\146\1\uffff\1\153", + "\1\154\15\uffff\1\155", + "\1\156", + "\1\160", + "\1\162", + "\1\164", + "\1\166\1\167", + "\1\172\22\uffff\1\171", + "\1\175\4\uffff\1\176\15\uffff\1\174", + "\1\u0080\1\uffff\12\u0082", + "\1\u0085\11\uffff\1\u0083\5\uffff\1\u0084", + "\1\u0086", + "\1\u0087", + "\1\u0088", + "\1\u0089", + "\1\u008a", "", + "\1\u008d", + "\1\u008e", + "\1\u0082\1\uffff\12\u0090\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\13\uffff\1\u008f\6\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\13\uffff\1\u008f", + "\1\u0082\1\uffff\12\u0090\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\22\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093", + "\1\70\34\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", - "\1\111\11\uffff\1\110", - "\1\112", - "\1\114\3\uffff\1\113", - "\1\115", - "\1\116", - "\1\117\3\uffff\1\120", - "\1\121", - "\1\123", "", - "\1\126\11\uffff\1\130\6\uffff\1\127", - "\1\132\11\uffff\1\133\7\uffff\1\131", - "\1\134\15\uffff\1\135", - "\1\136", - "\1\140", - "\1\141", - "\1\143", - "\1\145", "", - "\1\150\4\uffff\1\151", - "\12\154", - "\1\157\11\uffff\1\155\5\uffff\1\156", - "\1\160", - "\1\161", - "\1\162", - "\1\163", - "\1\154\1\uffff\12\165", - "\32\63\4\uffff\1\63\1\uffff\32\63", "", - "\0\166", - "\0\166", "", + "\1\u0098\6\uffff\1\u0096\3\uffff\1\u0097", + "\1\u0099", + "\1\u009a", "", - "\1\172\6\uffff\1\170\3\uffff\1\171", - "\1\173", - "\1\174", + "\1\u009b", + "\1\u009c\10\uffff\1\u009d", + "\1\u009e", + "\1\u00a0\1\u009f", + "\1\u00a1", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", - "\1\175", - "\1\176", - "\1\177", - "\1\u0080", - "\1\u0081", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u00a4", "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u0084", "", + "\1\u00a5", "", "", "", @@ -2765,141 +4115,111 @@ public void mTokens() throws RecognitionException { "", "", "", - "\1\u0085", - "\1\u0086", - "\1\u0087", - "\1\u0088", - "\1\u0089", - "\1\u008a", - "\1\u008c\10\uffff\1\u008b", - "\1\u008d", - "\1\u008e", "", + "\1\u00a7", + "\1\u00a8", + "\1\u00a9", + "\1\u00aa", + "\1\u00ab", + "\1\u00ac", + "\1\u00ae\10\uffff\1\u00ad\1\u00af", + "\1\u00b0", + "\1\u00b1", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", "", "", "", - "\1\u008f", - "\1\u0090", - "\1\u0091", - "\1\u0092", - "\1\u0093", - "\1\u0094", - "\1\u0095", - "\1\u0096", "", "", "", "", "", + "\1\u00b3\14\uffff\1\u00b4", + "\1\u00b5", + "\1\u00b6\3\uffff\1\u00b7", + "\1\u00b8", + "\1\u00b9", + "\1\u00ba", + "\1\u00bb", + "\1\u00bc", + "\1\u00bd", + "\1\u00be\1\u00bf", + "\1\u00c0", "", "", "", "", + "\1\u00c1", "", "", "", "", "", "", - "\1\u0097", - "\1\u0098", - "\1\u0099", - "\1\u009a", - "\1\u009b", - "\1\u009c", - "\1\u009d", "", - "\1\154\1\uffff\12\165", "", "", - "\1\u009e", - "\1\u009f", - "\1\u00a0", - "\1\u00a1", - "\1\u00a2", - "\12\63\7\uffff\1\u00a3\31\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00a5", - "\1\u00a6", - "\1\u00a7", - "\1\u00a9\2\uffff\1\u00a8", "", "", - "\1\u00aa", - "\1\u00ab", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00ad", - "\1\u00ae", - "\1\u00af", - "\1\u00b0", - "\1\u00b1", - "\1\u00b2", - "\1\u00b3", - "\1\u00b4", - "\1\u00b5", - "\1\u00b6", - "\1\u00b7", - "\1\u00b8", - "\1\u00b9", - "\1\u00ba", - "\1\u00bb", - "\1\u00bc", - "\1\u00bd", - "\1\u00be", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00c0", - "\1\u00c1", - "\1\u00c2", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00c4", + "", + "", + "\1\u00c3", + "", + "", "\1\u00c5", "\1\u00c6", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u00c7", + "\1\u00c8", "\1\u00c9", - "", "\1\u00ca", "\1\u00cb", + "", + "", + "", "\1\u00cc", - "\1\u00cd", - "\1\u00ce", + "\1\u00ce\5\uffff\1\u00cd", + "", + "\1\u0082\1\uffff\12\u0090\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\22\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093", + "\12\u0091\10\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093\22\uffff\1\u0091\2\uffff\1\u0093\1\uffff\3\u0093\5\uffff\1\u0093", + "", + "", + "", + "", "\1\u00cf", "\1\u00d0", - "", "\1\u00d1", - "", "\1\u00d2", "\1\u00d3", - "\1\u00d4", - "\1\u00d5", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\70\13\uffff\12\70\7\uffff\1\u00d4\31\70\4\uffff\1\70\1\uffff\32\70", + "\1\u00d6", "\1\u00d7", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u00d8", "\1\u00d9", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00db", - "\1\u00dc", + "\1\u00da", + "\1\u00dc\2\uffff\1\u00db", + "", + "", "\1\u00dd", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00df", - "\1\u00e0", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", "", + "", + "\1\u00de", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u00e0", + "\1\u00e1", "\1\u00e2", "\1\u00e3", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "", + "\1\u00e4", "\1\u00e5", "\1\u00e6", "\1\u00e7", - "", - "", "\1\u00e8", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "", + "\1\u00e9", + "\1\u00ea", "\1\u00eb", "\1\u00ec", - "\1\u00ed", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "\1\u00ee", "\1\u00ef", "\1\u00f0", @@ -2907,267 +4227,381 @@ public void mTokens() throws RecognitionException { "\1\u00f2", "\1\u00f3", "\1\u00f4", - "", "\1\u00f5", - "", "\1\u00f6", "", + "", + "", + "", "\1\u00f7", "\1\u00f8", - "\1\u00f9", - "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "\1\u00fa", "\1\u00fb", - "", "\1\u00fc", - "\1\u00fd", - "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u00ff", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "", - "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u00fe", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0101", "\1\u0102", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u0104", - "\1\u0105", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u0103", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0106", + "", "\1\u0107", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u0108", "\1\u0109", "\1\u010a", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u010b", "\1\u010c", "\1\u010d", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\5\63\1\u010f\24\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u010e", + "\1\u010f", + "", + "\1\u0110", + "", + "\1\u0111", "\1\u0112", "\1\u0113", "\1\u0114", "\1\u0115", - "", - "\1\u0116", - "", - "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "\1\u0117", - "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "\1\u0119", + "\1\u011a\33\uffff\1\u011b", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", - "\1\u011a", - "", - "", - "\1\u011b", - "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", "\1\u011d", - "", "\1\u011e", - "", - "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u011f", "\1\u0120", "\1\u0121", "\1\u0122", - "\1\u0123", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "\1\u0124", - "", "\1\u0125", "\1\u0126", - "\1\u0127", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", "\1\u0128", "\1\u0129", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", - "\1\u012a", "\1\u012b", + "", + "", "\1\u012c", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\u012e\16\uffff\1\u012d", + "\1\u012f", "", - "\1\u0131", + "", + "\1\u0130", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "\1\u0132", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0134", "\1\u0135", + "\1\u0136", + "\1\u0137", + "\1\u0138", + "\1\u0139", + "\1\u013a", + "\1\u013b", + "\1\u013c", + "\1\u013d", + "\1\u013e", + "\1\u013f", "", + "\1\u0140", "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0142", + "\1\u0143", "", + "\1\u0144", + "\1\u0145", + "\1\u0146", + "\1\u0147", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0149", "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", - "\1\u0137", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u014b", + "\1\u014c", + "", + "\1\u014d", + "\1\u014e", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0151", + "\1\u0152", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "", + "\1\u0155", + "", + "\1\u0156", + "\1\u0157", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0159", + "\1\u015a", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u015c", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u015e", + "\1\u015f", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0162", + "", + "\1\u0163", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\5\70\1\u0166\24\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "", + "\1\u016a", + "", + "\1\u016b", + "\1\u016c", + "\1\u016d", + "\1\u016e", + "", + "", + "\1\u016f", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "", "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0172", + "\1\u0173", "", - "\12\63\7\uffff\32\63\4\uffff\1\63\1\uffff\32\63", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0175", "", + "\1\u0176", + "", + "", + "\1\u0177", + "", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0179", + "", + "", + "\1\u017a", + "", + "", + "", + "\1\u017b", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u017d", + "\1\u017e", + "\1\u017f", + "\1\u0180", + "", + "", + "\1\u0181", + "\1\u0182", + "", + "\1\u0183", + "\1\u0184", + "\1\u0185", + "", + "\1\u0186", + "\1\u0187", + "\1\u0188", + "", + "\1\u0189", + "\1\u018a", + "\1\u018b", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u018e", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "", + "\1\u0191", + "\1\u0192", + "\1\u0193", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0196", + "", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u0199", + "\1\u019a", + "", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", + "\1\u019d", + "", + "", + "\1\70\13\uffff\12\70\7\uffff\32\70\4\uffff\1\70\1\uffff\32\70", "" }; - static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); - static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); - static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); - static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); - static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); - static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); - static final short[][] DFA14_transition; + static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); + static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); + static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); + static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); + static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); + static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); + static final short[][] DFA23_transition; static { - int numStates = DFA14_transitionS.length; - DFA14_transition = new short[numStates][]; + int numStates = DFA23_transitionS.length; + DFA23_transition = new short[numStates][]; for (int i=0; i') ) {s = 31;} + else if ( (LA23_0=='!') ) {s = 30;} - else if ( (LA14_0=='<') ) {s = 32;} + else if ( (LA23_0=='>') ) {s = 31;} - else if ( (LA14_0=='*') ) {s = 33;} + else if ( (LA23_0=='<') ) {s = 32;} - else if ( (LA14_0=='/') ) {s = 34;} + else if ( (LA23_0=='*') ) {s = 33;} - else if ( (LA14_0=='.') ) {s = 35;} + else if ( (LA23_0=='/') ) {s = 34;} - else if ( (LA14_0=='n') ) {s = 36;} + else if ( (LA23_0=='.') ) {s = 35;} - else if ( (LA14_0=='G') ) {s = 37;} + else if ( (LA23_0=='n') ) {s = 36;} - else if ( (LA14_0=='C') ) {s = 38;} + else if ( (LA23_0=='G') ) {s = 37;} - else if ( (LA14_0=='L') ) {s = 39;} + else if ( (LA23_0=='C') ) {s = 38;} - else if ( (LA14_0=='S') ) {s = 40;} + else if ( (LA23_0=='L') ) {s = 39;} - else if ( ((LA14_0>='0' && LA14_0<='9')) ) {s = 41;} + else if ( (LA23_0=='S') ) {s = 40;} - else if ( (LA14_0=='^') ) {s = 42;} + else if ( (LA23_0=='%') ) {s = 41;} - else if ( ((LA14_0>='A' && LA14_0<='B')||(LA14_0>='D' && LA14_0<='F')||(LA14_0>='H' && LA14_0<='K')||(LA14_0>='M' && LA14_0<='R')||(LA14_0>='T' && LA14_0<='Z')||LA14_0=='_'||LA14_0=='b'||(LA14_0>='g' && LA14_0<='h')||(LA14_0>='j' && LA14_0<='k')||LA14_0=='m'||LA14_0=='p'||(LA14_0>='v' && LA14_0<='z')) ) {s = 43;} + else if ( (LA23_0=='#') ) {s = 42;} - else if ( (LA14_0=='\"') ) {s = 44;} + else if ( (LA23_0=='w') ) {s = 43;} - else if ( (LA14_0=='\'') ) {s = 45;} + else if ( (LA23_0=='v') ) {s = 44;} - else if ( ((LA14_0>='\t' && LA14_0<='\n')||LA14_0=='\r'||LA14_0==' ') ) {s = 46;} + else if ( (LA23_0=='0') ) {s = 45;} - else if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||(LA14_0>='#' && LA14_0<='%')||LA14_0=='\\'||LA14_0=='`'||(LA14_0>='~' && LA14_0<='\uFFFF')) ) {s = 47;} + else if ( ((LA23_0>='1' && LA23_0<='9')) ) {s = 46;} - if ( s>=0 ) return s; - break; - case 1 : - int LA14_44 = input.LA(1); + else if ( (LA23_0=='^') ) {s = 47;} - s = -1; - if ( ((LA14_44>='\u0000' && LA14_44<='\uFFFF')) ) {s = 118;} + else if ( (LA23_0=='$'||(LA23_0>='A' && LA23_0<='B')||(LA23_0>='D' && LA23_0<='F')||(LA23_0>='H' && LA23_0<='K')||(LA23_0>='M' && LA23_0<='R')||(LA23_0>='T' && LA23_0<='Z')||LA23_0=='_'||LA23_0=='b'||(LA23_0>='g' && LA23_0<='h')||(LA23_0>='j' && LA23_0<='k')||LA23_0=='m'||LA23_0=='p'||(LA23_0>='x' && LA23_0<='z')) ) {s = 48;} - else s = 47; + else if ( (LA23_0=='\"') ) {s = 49;} - if ( s>=0 ) return s; - break; - case 2 : - int LA14_45 = input.LA(1); + else if ( (LA23_0=='\'') ) {s = 50;} - s = -1; - if ( ((LA14_45>='\u0000' && LA14_45<='\uFFFF')) ) {s = 118;} + else if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {s = 51;} - else s = 47; + else if ( ((LA23_0>='\u0000' && LA23_0<='\b')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\u001F')||LA23_0=='\\'||LA23_0=='`'||(LA23_0>='~' && LA23_0<='\uFFFF')) ) {s = 52;} if ( s>=0 ) return s; break; } NoViableAltException nvae = - new NoViableAltException(getDescription(), 14, _s, input); + new NoViableAltException(getDescription(), 23, _s, input); error(nvae); throw nvae; } diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportParser.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportParser.java index bf59476186..a9387f3a92 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportParser.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/parser/antlr/internal/InternalExportParser.java @@ -22,21 +22,14 @@ @SuppressWarnings("all") public class InternalExportParser extends AbstractInternalAntlrParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_ID", "RULE_STRING", "RULE_INT", "RULE_REAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'export'", "'extension'", "'for'", "'interface'", "'{'", "'}'", "'import'", "'as'", "'['", "']'", "'='", "','", "';'", "'+'", "'@'", "'eval'", "'('", "')'", "'lookup'", "'qualified'", "'uri-fragment'", "'unique'", "'attribute'", "'object-fingerprint'", "'resource-fingerprint'", "'field'", "'data'", "'::'", "'let'", "':'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'case'", "'||'", "'&&'", "'implies'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'-'", "'*'", "'/'", "'!'", "'.'", "'typeSelect'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'|'", "'true'", "'false'", "'null'", "'GLOBALVAR'", "'new'", "'Collection'", "'List'", "'Set'" + "", "", "", "", "RULE_ID", "RULE_STRING", "RULE_INT", "RULE_REAL", "RULE_HEX", "RULE_DECIMAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'export'", "'extension'", "'for'", "'interface'", "'{'", "'}'", "'import'", "'as'", "'['", "']'", "'='", "','", "';'", "'+'", "'@'", "'eval'", "'('", "')'", "'lookup'", "'qualified'", "'uri-fragment'", "'unique'", "'attribute'", "'object-fingerprint'", "'resource-fingerprint'", "'field'", "'data'", "'::'", "'let'", "':'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'case'", "'||'", "'&&'", "'implies'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'-'", "'*'", "'/'", "'!'", "'.'", "'typeSelect'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'|'", "'true'", "'false'", "'null'", "'GLOBALVAR'", "'new'", "'Collection'", "'List'", "'Set'", "'+='", "'-='", "'*='", "'/='", "'%='", "'==='", "'!=='", "'instanceof'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'**'", "'%'", "'++'", "'--'", "'?.'", "'#'", "'while'", "'do'", "'var'", "'val'", "'extends'", "'static'", "'super'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'&'" }; + public static final int RULE_HEX=8; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -46,53 +39,26 @@ public class InternalExportParser extends AbstractInternalAntlrParser { public static final int T__61=61; public static final int RULE_ID=4; public static final int RULE_REAL=7; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; public static final int RULE_INT=6; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=5; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -103,6 +69,76 @@ public class InternalExportParser extends AbstractInternalAntlrParser { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=5; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -218,14 +254,14 @@ public final EObject ruleExportModel() throws RecognitionException { int alt2=2; int LA2_0 = input.LA(1); - if ( (LA2_0==12) ) { + if ( (LA2_0==14) ) { alt2=1; } switch (alt2) { case 1 : // InternalExport.g:80:4: otherlv_0= 'export' ( (lv_extension_1_0= 'extension' ) )? ( (lv_name_2_0= RULE_ID ) ) otherlv_3= 'for' ( ( ruleQualifiedID ) ) { - otherlv_0=(Token)match(input,12,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,14,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getExportModelAccess().getExportKeyword_0_0()); @@ -235,7 +271,7 @@ public final EObject ruleExportModel() throws RecognitionException { int alt1=2; int LA1_0 = input.LA(1); - if ( (LA1_0==13) ) { + if ( (LA1_0==15) ) { alt1=1; } switch (alt1) { @@ -245,7 +281,7 @@ public final EObject ruleExportModel() throws RecognitionException { // InternalExport.g:85:5: (lv_extension_1_0= 'extension' ) // InternalExport.g:86:6: lv_extension_1_0= 'extension' { - lv_extension_1_0=(Token)match(input,13,FOLLOW_4); if (state.failed) return current; + lv_extension_1_0=(Token)match(input,15,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_extension_1_0, grammarAccess.getExportModelAccess().getExtensionExtensionKeyword_0_1_0()); @@ -289,7 +325,7 @@ public final EObject ruleExportModel() throws RecognitionException { current, "name", lv_name_2_0, - "org.eclipse.xtext.common.Terminals.ID"); + "org.eclipse.xtext.xbase.Xtype.ID"); } @@ -298,7 +334,7 @@ public final EObject ruleExportModel() throws RecognitionException { } - otherlv_3=(Token)match(input,14,FOLLOW_4); if (state.failed) return current; + otherlv_3=(Token)match(input,16,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getExportModelAccess().getForKeyword_0_3()); @@ -351,7 +387,7 @@ public final EObject ruleExportModel() throws RecognitionException { int alt3=2; int LA3_0 = input.LA(1); - if ( (LA3_0==18) ) { + if ( (LA3_0==20) ) { alt3=1; } @@ -409,7 +445,7 @@ public final EObject ruleExportModel() throws RecognitionException { int alt4=2; int LA4_0 = input.LA(1); - if ( (LA4_0==13) ) { + if ( (LA4_0==15) ) { alt4=1; } @@ -460,20 +496,20 @@ public final EObject ruleExportModel() throws RecognitionException { int alt6=2; int LA6_0 = input.LA(1); - if ( (LA6_0==15) ) { + if ( (LA6_0==17) ) { alt6=1; } switch (alt6) { case 1 : // InternalExport.g:176:4: otherlv_7= 'interface' otherlv_8= '{' ( (lv_interfaces_9_0= ruleInterface ) )+ otherlv_10= '}' { - otherlv_7=(Token)match(input,15,FOLLOW_9); if (state.failed) return current; + otherlv_7=(Token)match(input,17,FOLLOW_9); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getExportModelAccess().getInterfaceKeyword_3_0()); } - otherlv_8=(Token)match(input,16,FOLLOW_4); if (state.failed) return current; + otherlv_8=(Token)match(input,18,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_8, grammarAccess.getExportModelAccess().getLeftCurlyBracketKeyword_3_1()); @@ -538,7 +574,7 @@ public final EObject ruleExportModel() throws RecognitionException { cnt5++; } while (true); - otherlv_10=(Token)match(input,17,FOLLOW_8); if (state.failed) return current; + otherlv_10=(Token)match(input,19,FOLLOW_8); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_10, grammarAccess.getExportModelAccess().getRightCurlyBracketKeyword_3_3()); @@ -557,7 +593,7 @@ public final EObject ruleExportModel() throws RecognitionException { int alt7=2; int LA7_0 = input.LA(1); - if ( (LA7_0==12) ) { + if ( (LA7_0==14) ) { alt7=1; } @@ -693,7 +729,7 @@ public final EObject ruleImport() throws RecognitionException { // InternalExport.g:245:2: (otherlv_0= 'import' ( (otherlv_1= RULE_STRING ) ) (otherlv_2= 'as' ( (lv_name_3_0= RULE_ID ) ) )? ) // InternalExport.g:246:3: otherlv_0= 'import' ( (otherlv_1= RULE_STRING ) ) (otherlv_2= 'as' ( (lv_name_3_0= RULE_ID ) ) )? { - otherlv_0=(Token)match(input,18,FOLLOW_12); if (state.failed) return current; + otherlv_0=(Token)match(input,20,FOLLOW_12); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getImportAccess().getImportKeyword_0()); @@ -728,14 +764,14 @@ public final EObject ruleImport() throws RecognitionException { int alt8=2; int LA8_0 = input.LA(1); - if ( (LA8_0==19) ) { + if ( (LA8_0==21) ) { alt8=1; } switch (alt8) { case 1 : // InternalExport.g:264:4: otherlv_2= 'as' ( (lv_name_3_0= RULE_ID ) ) { - otherlv_2=(Token)match(input,19,FOLLOW_4); if (state.failed) return current; + otherlv_2=(Token)match(input,21,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getImportAccess().getAsKeyword_2_0()); @@ -762,7 +798,7 @@ public final EObject ruleImport() throws RecognitionException { current, "name", lv_name_3_0, - "org.eclipse.xtext.common.Terminals.ID"); + "org.eclipse.xtext.xbase.Xtype.ID"); } @@ -860,7 +896,7 @@ public final EObject ruleExtension() throws RecognitionException { // InternalExport.g:305:2: (otherlv_0= 'extension' ( (lv_extension_1_0= ruleQualifiedID ) ) ) // InternalExport.g:306:3: otherlv_0= 'extension' ( (lv_extension_1_0= ruleQualifiedID ) ) { - otherlv_0=(Token)match(input,13,FOLLOW_4); if (state.failed) return current; + otherlv_0=(Token)match(input,15,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getExtensionAccess().getExtensionKeyword_0()); @@ -1030,14 +1066,14 @@ public final EObject ruleInterface() throws RecognitionException { int alt9=2; int LA9_0 = input.LA(1); - if ( (LA9_0==20) ) { + if ( (LA9_0==22) ) { alt9=1; } switch (alt9) { case 1 : // InternalExport.g:365:4: otherlv_1= '[' ( (lv_guard_2_0= ruleExpression ) ) otherlv_3= ']' { - otherlv_1=(Token)match(input,20,FOLLOW_15); if (state.failed) return current; + otherlv_1=(Token)match(input,22,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getInterfaceAccess().getLeftSquareBracketKeyword_1_0()); @@ -1078,7 +1114,7 @@ public final EObject ruleInterface() throws RecognitionException { } - otherlv_3=(Token)match(input,21,FOLLOW_17); if (state.failed) return current; + otherlv_3=(Token)match(input,23,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getInterfaceAccess().getRightSquareBracketKeyword_1_2()); @@ -1096,7 +1132,7 @@ public final EObject ruleInterface() throws RecognitionException { int alt11=2; int LA11_0 = input.LA(1); - if ( (LA11_0==22) ) { + if ( (LA11_0==24) ) { alt11=1; } @@ -1105,7 +1141,7 @@ public final EObject ruleInterface() throws RecognitionException { case 1 : // InternalExport.g:394:4: otherlv_4= '=' ( (lv_items_5_0= ruleInterfaceItem ) ) (otherlv_6= ',' ( (lv_items_7_0= ruleInterfaceItem ) ) )* { - otherlv_4=(Token)match(input,22,FOLLOW_18); if (state.failed) return current; + otherlv_4=(Token)match(input,24,FOLLOW_18); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getInterfaceAccess().getEqualsSignKeyword_2_0()); @@ -1152,7 +1188,7 @@ public final EObject ruleInterface() throws RecognitionException { int alt10=2; int LA10_0 = input.LA(1); - if ( (LA10_0==23) ) { + if ( (LA10_0==25) ) { alt10=1; } @@ -1161,7 +1197,7 @@ public final EObject ruleInterface() throws RecognitionException { case 1 : // InternalExport.g:418:5: otherlv_6= ',' ( (lv_items_7_0= ruleInterfaceItem ) ) { - otherlv_6=(Token)match(input,23,FOLLOW_18); if (state.failed) return current; + otherlv_6=(Token)match(input,25,FOLLOW_18); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getInterfaceAccess().getCommaKeyword_2_2_0()); @@ -1220,7 +1256,7 @@ public final EObject ruleInterface() throws RecognitionException { } } while (true); - otherlv_8=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + otherlv_8=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_8, grammarAccess.getInterfaceAccess().getSemicolonKeyword_3()); @@ -1313,17 +1349,17 @@ public final EObject ruleInterfaceItem() throws RecognitionException { int alt12=3; switch ( input.LA(1) ) { case RULE_ID: - case 25: + case 27: { alt12=1; } break; - case 26: + case 28: { alt12=2; } break; - case 27: + case 29: { alt12=3; } @@ -1489,7 +1525,7 @@ public final EObject ruleInterfaceField() throws RecognitionException { int alt13=2; int LA13_0 = input.LA(1); - if ( (LA13_0==25) ) { + if ( (LA13_0==27) ) { alt13=1; } switch (alt13) { @@ -1499,7 +1535,7 @@ public final EObject ruleInterfaceField() throws RecognitionException { // InternalExport.g:512:4: (lv_unordered_0_0= '+' ) // InternalExport.g:513:5: lv_unordered_0_0= '+' { - lv_unordered_0_0=(Token)match(input,25,FOLLOW_4); if (state.failed) return current; + lv_unordered_0_0=(Token)match(input,27,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_unordered_0_0, grammarAccess.getInterfaceFieldAccess().getUnorderedPlusSignKeyword_0_0()); @@ -1630,7 +1666,7 @@ public final EObject ruleInterfaceNavigation() throws RecognitionException { // InternalExport.g:556:2: (otherlv_0= '@' ( (lv_unordered_1_0= '+' ) )? ( (otherlv_2= RULE_ID ) ) ) // InternalExport.g:557:3: otherlv_0= '@' ( (lv_unordered_1_0= '+' ) )? ( (otherlv_2= RULE_ID ) ) { - otherlv_0=(Token)match(input,26,FOLLOW_20); if (state.failed) return current; + otherlv_0=(Token)match(input,28,FOLLOW_20); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getInterfaceNavigationAccess().getCommercialAtKeyword_0()); @@ -1640,7 +1676,7 @@ public final EObject ruleInterfaceNavigation() throws RecognitionException { int alt14=2; int LA14_0 = input.LA(1); - if ( (LA14_0==25) ) { + if ( (LA14_0==27) ) { alt14=1; } switch (alt14) { @@ -1650,7 +1686,7 @@ public final EObject ruleInterfaceNavigation() throws RecognitionException { // InternalExport.g:562:4: (lv_unordered_1_0= '+' ) // InternalExport.g:563:5: lv_unordered_1_0= '+' { - lv_unordered_1_0=(Token)match(input,25,FOLLOW_4); if (state.failed) return current; + lv_unordered_1_0=(Token)match(input,27,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_unordered_1_0, grammarAccess.getInterfaceNavigationAccess().getUnorderedPlusSignKeyword_1_0()); @@ -1785,7 +1821,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { // InternalExport.g:606:2: (otherlv_0= 'eval' ( (lv_ref_1_0= '@' ) )? ( (lv_unordered_2_0= '+' ) )? otherlv_3= '(' ( (lv_expr_4_0= ruleExpression ) ) otherlv_5= ')' ) // InternalExport.g:607:3: otherlv_0= 'eval' ( (lv_ref_1_0= '@' ) )? ( (lv_unordered_2_0= '+' ) )? otherlv_3= '(' ( (lv_expr_4_0= ruleExpression ) ) otherlv_5= ')' { - otherlv_0=(Token)match(input,27,FOLLOW_21); if (state.failed) return current; + otherlv_0=(Token)match(input,29,FOLLOW_21); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getInterfaceExpressionAccess().getEvalKeyword_0()); @@ -1795,7 +1831,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { int alt15=2; int LA15_0 = input.LA(1); - if ( (LA15_0==26) ) { + if ( (LA15_0==28) ) { alt15=1; } switch (alt15) { @@ -1805,7 +1841,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { // InternalExport.g:612:4: (lv_ref_1_0= '@' ) // InternalExport.g:613:5: lv_ref_1_0= '@' { - lv_ref_1_0=(Token)match(input,26,FOLLOW_22); if (state.failed) return current; + lv_ref_1_0=(Token)match(input,28,FOLLOW_22); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_ref_1_0, grammarAccess.getInterfaceExpressionAccess().getRefCommercialAtKeyword_1_0()); @@ -1832,7 +1868,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { int alt16=2; int LA16_0 = input.LA(1); - if ( (LA16_0==25) ) { + if ( (LA16_0==27) ) { alt16=1; } switch (alt16) { @@ -1842,7 +1878,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { // InternalExport.g:626:4: (lv_unordered_2_0= '+' ) // InternalExport.g:627:5: lv_unordered_2_0= '+' { - lv_unordered_2_0=(Token)match(input,25,FOLLOW_23); if (state.failed) return current; + lv_unordered_2_0=(Token)match(input,27,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_unordered_2_0, grammarAccess.getInterfaceExpressionAccess().getUnorderedPlusSignKeyword_2_0()); @@ -1865,7 +1901,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,28,FOLLOW_15); if (state.failed) return current; + otherlv_3=(Token)match(input,30,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getInterfaceExpressionAccess().getLeftParenthesisKeyword_3()); @@ -1906,7 +1942,7 @@ public final EObject ruleInterfaceExpression() throws RecognitionException { } - otherlv_5=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getInterfaceExpressionAccess().getRightParenthesisKeyword_5()); @@ -2033,7 +2069,7 @@ public final EObject ruleExport() throws RecognitionException { // InternalExport.g:684:2: (otherlv_0= 'export' ( ( (lv_lookup_1_0= 'lookup' ) ) (otherlv_2= '[' ( (lv_lookupPredicate_3_0= ruleExpression ) ) otherlv_4= ']' )? )? ( ( ruleQualifiedID ) ) (otherlv_6= 'as' ( (lv_qualifiedName_7_0= 'qualified' ) )? ( (lv_naming_8_0= ruleExpression ) ) )? (otherlv_9= '[' ( (lv_guard_10_0= ruleExpression ) ) otherlv_11= ']' )? otherlv_12= '{' (otherlv_13= 'uri-fragment' otherlv_14= '=' ( (lv_fragmentUnique_15_0= 'unique' ) )? otherlv_16= 'attribute' otherlv_17= '(' ( (otherlv_18= RULE_ID ) ) otherlv_19= ')' otherlv_20= ';' )? ( ( ( (lv_fingerprint_21_0= 'object-fingerprint' ) ) | ( (lv_resourceFingerprint_22_0= 'resource-fingerprint' ) ) ) otherlv_23= ';' )? ( (otherlv_24= 'field' ( (lv_attributes_25_0= ruleAttribute ) ) (otherlv_26= ',' ( (lv_attributes_27_0= ruleAttribute ) ) )* otherlv_28= ';' ) | (otherlv_29= 'data' ( (lv_userData_30_0= ruleUserData ) ) (otherlv_31= ',' ( (lv_userData_32_0= ruleUserData ) ) )* otherlv_33= ';' ) )* otherlv_34= '}' ) // InternalExport.g:685:3: otherlv_0= 'export' ( ( (lv_lookup_1_0= 'lookup' ) ) (otherlv_2= '[' ( (lv_lookupPredicate_3_0= ruleExpression ) ) otherlv_4= ']' )? )? ( ( ruleQualifiedID ) ) (otherlv_6= 'as' ( (lv_qualifiedName_7_0= 'qualified' ) )? ( (lv_naming_8_0= ruleExpression ) ) )? (otherlv_9= '[' ( (lv_guard_10_0= ruleExpression ) ) otherlv_11= ']' )? otherlv_12= '{' (otherlv_13= 'uri-fragment' otherlv_14= '=' ( (lv_fragmentUnique_15_0= 'unique' ) )? otherlv_16= 'attribute' otherlv_17= '(' ( (otherlv_18= RULE_ID ) ) otherlv_19= ')' otherlv_20= ';' )? ( ( ( (lv_fingerprint_21_0= 'object-fingerprint' ) ) | ( (lv_resourceFingerprint_22_0= 'resource-fingerprint' ) ) ) otherlv_23= ';' )? ( (otherlv_24= 'field' ( (lv_attributes_25_0= ruleAttribute ) ) (otherlv_26= ',' ( (lv_attributes_27_0= ruleAttribute ) ) )* otherlv_28= ';' ) | (otherlv_29= 'data' ( (lv_userData_30_0= ruleUserData ) ) (otherlv_31= ',' ( (lv_userData_32_0= ruleUserData ) ) )* otherlv_33= ';' ) )* otherlv_34= '}' { - otherlv_0=(Token)match(input,12,FOLLOW_25); if (state.failed) return current; + otherlv_0=(Token)match(input,14,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getExportAccess().getExportKeyword_0()); @@ -2043,7 +2079,7 @@ public final EObject ruleExport() throws RecognitionException { int alt18=2; int LA18_0 = input.LA(1); - if ( (LA18_0==30) ) { + if ( (LA18_0==32) ) { alt18=1; } switch (alt18) { @@ -2056,7 +2092,7 @@ public final EObject ruleExport() throws RecognitionException { // InternalExport.g:691:5: (lv_lookup_1_0= 'lookup' ) // InternalExport.g:692:6: lv_lookup_1_0= 'lookup' { - lv_lookup_1_0=(Token)match(input,30,FOLLOW_26); if (state.failed) return current; + lv_lookup_1_0=(Token)match(input,32,FOLLOW_26); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_lookup_1_0, grammarAccess.getExportAccess().getLookupLookupKeyword_1_0_0()); @@ -2080,14 +2116,14 @@ public final EObject ruleExport() throws RecognitionException { int alt17=2; int LA17_0 = input.LA(1); - if ( (LA17_0==20) ) { + if ( (LA17_0==22) ) { alt17=1; } switch (alt17) { case 1 : // InternalExport.g:705:5: otherlv_2= '[' ( (lv_lookupPredicate_3_0= ruleExpression ) ) otherlv_4= ']' { - otherlv_2=(Token)match(input,20,FOLLOW_15); if (state.failed) return current; + otherlv_2=(Token)match(input,22,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getExportAccess().getLeftSquareBracketKeyword_1_1_0()); @@ -2128,7 +2164,7 @@ public final EObject ruleExport() throws RecognitionException { } - otherlv_4=(Token)match(input,21,FOLLOW_4); if (state.failed) return current; + otherlv_4=(Token)match(input,23,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getExportAccess().getRightSquareBracketKeyword_1_1_2()); @@ -2184,14 +2220,14 @@ public final EObject ruleExport() throws RecognitionException { int alt20=2; int LA20_0 = input.LA(1); - if ( (LA20_0==19) ) { + if ( (LA20_0==21) ) { alt20=1; } switch (alt20) { case 1 : // InternalExport.g:751:4: otherlv_6= 'as' ( (lv_qualifiedName_7_0= 'qualified' ) )? ( (lv_naming_8_0= ruleExpression ) ) { - otherlv_6=(Token)match(input,19,FOLLOW_28); if (state.failed) return current; + otherlv_6=(Token)match(input,21,FOLLOW_28); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getExportAccess().getAsKeyword_3_0()); @@ -2201,7 +2237,7 @@ public final EObject ruleExport() throws RecognitionException { int alt19=2; int LA19_0 = input.LA(1); - if ( (LA19_0==31) ) { + if ( (LA19_0==33) ) { alt19=1; } switch (alt19) { @@ -2211,7 +2247,7 @@ public final EObject ruleExport() throws RecognitionException { // InternalExport.g:756:5: (lv_qualifiedName_7_0= 'qualified' ) // InternalExport.g:757:6: lv_qualifiedName_7_0= 'qualified' { - lv_qualifiedName_7_0=(Token)match(input,31,FOLLOW_15); if (state.failed) return current; + lv_qualifiedName_7_0=(Token)match(input,33,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_qualifiedName_7_0, grammarAccess.getExportAccess().getQualifiedNameQualifiedKeyword_3_1_0()); @@ -2279,14 +2315,14 @@ public final EObject ruleExport() throws RecognitionException { int alt21=2; int LA21_0 = input.LA(1); - if ( (LA21_0==20) ) { + if ( (LA21_0==22) ) { alt21=1; } switch (alt21) { case 1 : // InternalExport.g:790:4: otherlv_9= '[' ( (lv_guard_10_0= ruleExpression ) ) otherlv_11= ']' { - otherlv_9=(Token)match(input,20,FOLLOW_15); if (state.failed) return current; + otherlv_9=(Token)match(input,22,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_9, grammarAccess.getExportAccess().getLeftSquareBracketKeyword_4_0()); @@ -2327,7 +2363,7 @@ public final EObject ruleExport() throws RecognitionException { } - otherlv_11=(Token)match(input,21,FOLLOW_9); if (state.failed) return current; + otherlv_11=(Token)match(input,23,FOLLOW_9); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_11, grammarAccess.getExportAccess().getRightSquareBracketKeyword_4_2()); @@ -2339,7 +2375,7 @@ public final EObject ruleExport() throws RecognitionException { } - otherlv_12=(Token)match(input,16,FOLLOW_30); if (state.failed) return current; + otherlv_12=(Token)match(input,18,FOLLOW_30); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_12, grammarAccess.getExportAccess().getLeftCurlyBracketKeyword_5()); @@ -2349,20 +2385,20 @@ public final EObject ruleExport() throws RecognitionException { int alt23=2; int LA23_0 = input.LA(1); - if ( (LA23_0==32) ) { + if ( (LA23_0==34) ) { alt23=1; } switch (alt23) { case 1 : // InternalExport.g:823:4: otherlv_13= 'uri-fragment' otherlv_14= '=' ( (lv_fragmentUnique_15_0= 'unique' ) )? otherlv_16= 'attribute' otherlv_17= '(' ( (otherlv_18= RULE_ID ) ) otherlv_19= ')' otherlv_20= ';' { - otherlv_13=(Token)match(input,32,FOLLOW_31); if (state.failed) return current; + otherlv_13=(Token)match(input,34,FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_13, grammarAccess.getExportAccess().getUriFragmentKeyword_6_0()); } - otherlv_14=(Token)match(input,22,FOLLOW_32); if (state.failed) return current; + otherlv_14=(Token)match(input,24,FOLLOW_32); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_14, grammarAccess.getExportAccess().getEqualsSignKeyword_6_1()); @@ -2372,7 +2408,7 @@ public final EObject ruleExport() throws RecognitionException { int alt22=2; int LA22_0 = input.LA(1); - if ( (LA22_0==33) ) { + if ( (LA22_0==35) ) { alt22=1; } switch (alt22) { @@ -2382,7 +2418,7 @@ public final EObject ruleExport() throws RecognitionException { // InternalExport.g:832:5: (lv_fragmentUnique_15_0= 'unique' ) // InternalExport.g:833:6: lv_fragmentUnique_15_0= 'unique' { - lv_fragmentUnique_15_0=(Token)match(input,33,FOLLOW_33); if (state.failed) return current; + lv_fragmentUnique_15_0=(Token)match(input,35,FOLLOW_33); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_fragmentUnique_15_0, grammarAccess.getExportAccess().getFragmentUniqueUniqueKeyword_6_2_0()); @@ -2405,13 +2441,13 @@ public final EObject ruleExport() throws RecognitionException { } - otherlv_16=(Token)match(input,34,FOLLOW_23); if (state.failed) return current; + otherlv_16=(Token)match(input,36,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_16, grammarAccess.getExportAccess().getAttributeKeyword_6_3()); } - otherlv_17=(Token)match(input,28,FOLLOW_4); if (state.failed) return current; + otherlv_17=(Token)match(input,30,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_17, grammarAccess.getExportAccess().getLeftParenthesisKeyword_6_4()); @@ -2442,13 +2478,13 @@ public final EObject ruleExport() throws RecognitionException { } - otherlv_19=(Token)match(input,29,FOLLOW_34); if (state.failed) return current; + otherlv_19=(Token)match(input,31,FOLLOW_34); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_19, grammarAccess.getExportAccess().getRightParenthesisKeyword_6_6()); } - otherlv_20=(Token)match(input,24,FOLLOW_35); if (state.failed) return current; + otherlv_20=(Token)match(input,26,FOLLOW_35); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_20, grammarAccess.getExportAccess().getSemicolonKeyword_6_7()); @@ -2464,7 +2500,7 @@ public final EObject ruleExport() throws RecognitionException { int alt25=2; int LA25_0 = input.LA(1); - if ( ((LA25_0>=35 && LA25_0<=36)) ) { + if ( ((LA25_0>=37 && LA25_0<=38)) ) { alt25=1; } switch (alt25) { @@ -2475,10 +2511,10 @@ public final EObject ruleExport() throws RecognitionException { int alt24=2; int LA24_0 = input.LA(1); - if ( (LA24_0==35) ) { + if ( (LA24_0==37) ) { alt24=1; } - else if ( (LA24_0==36) ) { + else if ( (LA24_0==38) ) { alt24=2; } else { @@ -2498,7 +2534,7 @@ else if ( (LA24_0==36) ) { // InternalExport.g:878:6: (lv_fingerprint_21_0= 'object-fingerprint' ) // InternalExport.g:879:7: lv_fingerprint_21_0= 'object-fingerprint' { - lv_fingerprint_21_0=(Token)match(input,35,FOLLOW_34); if (state.failed) return current; + lv_fingerprint_21_0=(Token)match(input,37,FOLLOW_34); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_fingerprint_21_0, grammarAccess.getExportAccess().getFingerprintObjectFingerprintKeyword_7_0_0_0()); @@ -2530,7 +2566,7 @@ else if ( (LA24_0==36) ) { // InternalExport.g:893:6: (lv_resourceFingerprint_22_0= 'resource-fingerprint' ) // InternalExport.g:894:7: lv_resourceFingerprint_22_0= 'resource-fingerprint' { - lv_resourceFingerprint_22_0=(Token)match(input,36,FOLLOW_34); if (state.failed) return current; + lv_resourceFingerprint_22_0=(Token)match(input,38,FOLLOW_34); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_resourceFingerprint_22_0, grammarAccess.getExportAccess().getResourceFingerprintResourceFingerprintKeyword_7_0_1_0()); @@ -2556,7 +2592,7 @@ else if ( (LA24_0==36) ) { } - otherlv_23=(Token)match(input,24,FOLLOW_36); if (state.failed) return current; + otherlv_23=(Token)match(input,26,FOLLOW_36); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_23, grammarAccess.getExportAccess().getSemicolonKeyword_7_1()); @@ -2574,10 +2610,10 @@ else if ( (LA24_0==36) ) { int alt28=3; int LA28_0 = input.LA(1); - if ( (LA28_0==37) ) { + if ( (LA28_0==39) ) { alt28=1; } - else if ( (LA28_0==38) ) { + else if ( (LA28_0==40) ) { alt28=2; } @@ -2589,7 +2625,7 @@ else if ( (LA28_0==38) ) { // InternalExport.g:913:4: (otherlv_24= 'field' ( (lv_attributes_25_0= ruleAttribute ) ) (otherlv_26= ',' ( (lv_attributes_27_0= ruleAttribute ) ) )* otherlv_28= ';' ) // InternalExport.g:914:5: otherlv_24= 'field' ( (lv_attributes_25_0= ruleAttribute ) ) (otherlv_26= ',' ( (lv_attributes_27_0= ruleAttribute ) ) )* otherlv_28= ';' { - otherlv_24=(Token)match(input,37,FOLLOW_4); if (state.failed) return current; + otherlv_24=(Token)match(input,39,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_24, grammarAccess.getExportAccess().getFieldKeyword_8_0_0()); @@ -2636,7 +2672,7 @@ else if ( (LA28_0==38) ) { int alt26=2; int LA26_0 = input.LA(1); - if ( (LA26_0==23) ) { + if ( (LA26_0==25) ) { alt26=1; } @@ -2645,7 +2681,7 @@ else if ( (LA28_0==38) ) { case 1 : // InternalExport.g:938:6: otherlv_26= ',' ( (lv_attributes_27_0= ruleAttribute ) ) { - otherlv_26=(Token)match(input,23,FOLLOW_4); if (state.failed) return current; + otherlv_26=(Token)match(input,25,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_26, grammarAccess.getExportAccess().getCommaKeyword_8_0_2_0()); @@ -2695,7 +2731,7 @@ else if ( (LA28_0==38) ) { } } while (true); - otherlv_28=(Token)match(input,24,FOLLOW_36); if (state.failed) return current; + otherlv_28=(Token)match(input,26,FOLLOW_36); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_28, grammarAccess.getExportAccess().getSemicolonKeyword_8_0_3()); @@ -2713,7 +2749,7 @@ else if ( (LA28_0==38) ) { // InternalExport.g:968:4: (otherlv_29= 'data' ( (lv_userData_30_0= ruleUserData ) ) (otherlv_31= ',' ( (lv_userData_32_0= ruleUserData ) ) )* otherlv_33= ';' ) // InternalExport.g:969:5: otherlv_29= 'data' ( (lv_userData_30_0= ruleUserData ) ) (otherlv_31= ',' ( (lv_userData_32_0= ruleUserData ) ) )* otherlv_33= ';' { - otherlv_29=(Token)match(input,38,FOLLOW_4); if (state.failed) return current; + otherlv_29=(Token)match(input,40,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_29, grammarAccess.getExportAccess().getDataKeyword_8_1_0()); @@ -2760,7 +2796,7 @@ else if ( (LA28_0==38) ) { int alt27=2; int LA27_0 = input.LA(1); - if ( (LA27_0==23) ) { + if ( (LA27_0==25) ) { alt27=1; } @@ -2769,7 +2805,7 @@ else if ( (LA28_0==38) ) { case 1 : // InternalExport.g:993:6: otherlv_31= ',' ( (lv_userData_32_0= ruleUserData ) ) { - otherlv_31=(Token)match(input,23,FOLLOW_4); if (state.failed) return current; + otherlv_31=(Token)match(input,25,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_31, grammarAccess.getExportAccess().getCommaKeyword_8_1_2_0()); @@ -2819,7 +2855,7 @@ else if ( (LA28_0==38) ) { } } while (true); - otherlv_33=(Token)match(input,24,FOLLOW_36); if (state.failed) return current; + otherlv_33=(Token)match(input,26,FOLLOW_36); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_33, grammarAccess.getExportAccess().getSemicolonKeyword_8_1_3()); @@ -2837,7 +2873,7 @@ else if ( (LA28_0==38) ) { } } while (true); - otherlv_34=(Token)match(input,17,FOLLOW_2); if (state.failed) return current; + otherlv_34=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_34, grammarAccess.getExportAccess().getRightCurlyBracketKeyword_9()); @@ -2948,7 +2984,7 @@ public final EObject ruleUserData() throws RecognitionException { current, "name", lv_name_0_0, - "org.eclipse.xtext.common.Terminals.ID"); + "org.eclipse.xtext.xbase.Xtype.ID"); } @@ -2957,7 +2993,7 @@ public final EObject ruleUserData() throws RecognitionException { } - otherlv_1=(Token)match(input,22,FOLLOW_15); if (state.failed) return current; + otherlv_1=(Token)match(input,24,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getUserDataAccess().getEqualsSignKeyword_1()); @@ -3198,7 +3234,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedID() throws RecognitionExceptio int alt29=2; int LA29_0 = input.LA(1); - if ( (LA29_0==39) ) { + if ( (LA29_0==41) ) { alt29=1; } @@ -3207,7 +3243,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedID() throws RecognitionExceptio case 1 : // InternalExport.g:1144:4: kw= '::' this_ID_2= RULE_ID { - kw=(Token)match(input,39,FOLLOW_4); if (state.failed) return current; + kw=(Token)match(input,41,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -3482,7 +3518,7 @@ public final EObject ruleLetExpression() throws RecognitionException { // InternalExport.g:1223:2: (otherlv_0= 'let' ( (lv_identifier_1_0= ruleIdentifier ) ) otherlv_2= '=' ( (lv_varExpr_3_0= ruleExpression ) ) otherlv_4= ':' ( (lv_target_5_0= ruleExpression ) ) ) // InternalExport.g:1224:3: otherlv_0= 'let' ( (lv_identifier_1_0= ruleIdentifier ) ) otherlv_2= '=' ( (lv_varExpr_3_0= ruleExpression ) ) otherlv_4= ':' ( (lv_target_5_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,40,FOLLOW_4); if (state.failed) return current; + otherlv_0=(Token)match(input,42,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getLetExpressionAccess().getLetKeyword_0()); @@ -3523,7 +3559,7 @@ public final EObject ruleLetExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,22,FOLLOW_15); if (state.failed) return current; + otherlv_2=(Token)match(input,24,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); @@ -3564,7 +3600,7 @@ public final EObject ruleLetExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,41,FOLLOW_15); if (state.failed) return current; + otherlv_4=(Token)match(input,43,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getLetExpressionAccess().getColonKeyword_4()); @@ -3691,7 +3727,7 @@ public final EObject ruleCastedExpression() throws RecognitionException { // InternalExport.g:1311:2: (otherlv_0= '(' ( (lv_type_1_0= ruleType ) ) otherlv_2= ')' ( (lv_target_3_0= ruleExpression ) ) ) // InternalExport.g:1312:3: otherlv_0= '(' ( (lv_type_1_0= ruleType ) ) otherlv_2= ')' ( (lv_target_3_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,28,FOLLOW_40); if (state.failed) return current; + otherlv_0=(Token)match(input,30,FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -3732,7 +3768,7 @@ public final EObject ruleCastedExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,29,FOLLOW_15); if (state.failed) return current; + otherlv_2=(Token)match(input,31,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); @@ -3880,7 +3916,7 @@ public final EObject ruleChainExpression() throws RecognitionException { int alt31=2; int LA31_0 = input.LA(1); - if ( (LA31_0==42) ) { + if ( (LA31_0==44) ) { alt31=1; } @@ -3902,7 +3938,7 @@ public final EObject ruleChainExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,42,FOLLOW_15); if (state.failed) return current; + otherlv_2=(Token)match(input,44,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); @@ -4038,7 +4074,7 @@ public final EObject ruleChainedExpression() throws RecognitionException { // InternalExport.g:1435:2: (this_IfExpressionKw_0= ruleIfExpressionKw | this_IfExpressionTri_1= ruleIfExpressionTri | this_SwitchExpression_2= ruleSwitchExpression ) int alt32=3; switch ( input.LA(1) ) { - case 44: + case 46: { alt32=1; } @@ -4047,12 +4083,10 @@ public final EObject ruleChainedExpression() throws RecognitionException { case RULE_STRING: case RULE_INT: case RULE_REAL: - case 16: - case 28: - case 59: - case 62: + case 18: + case 30: + case 61: case 64: - case 65: case 66: case 67: case 68: @@ -4060,19 +4094,21 @@ public final EObject ruleChainedExpression() throws RecognitionException { case 70: case 71: case 72: + case 73: case 74: - case 75: case 76: case 77: case 78: case 79: case 80: case 81: + case 82: + case 83: { alt32=2; } break; - case 47: + case 49: { alt32=3; } @@ -4260,7 +4296,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { int alt33=2; int LA33_0 = input.LA(1); - if ( (LA33_0==43) ) { + if ( (LA33_0==45) ) { alt33=1; } switch (alt33) { @@ -4280,7 +4316,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { } - otherlv_2=(Token)match(input,43,FOLLOW_15); if (state.failed) return current; + otherlv_2=(Token)match(input,45,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); @@ -4321,7 +4357,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { } - otherlv_4=(Token)match(input,41,FOLLOW_15); if (state.failed) return current; + otherlv_4=(Token)match(input,43,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); @@ -4457,7 +4493,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { // InternalExport.g:1562:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleChainedExpression ) ) otherlv_2= 'then' ( (lv_thenPart_3_0= ruleChainedExpression ) ) ( ( 'else' )=> (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) )? ) // InternalExport.g:1563:3: otherlv_0= 'if' ( (lv_condition_1_0= ruleChainedExpression ) ) otherlv_2= 'then' ( (lv_thenPart_3_0= ruleChainedExpression ) ) ( ( 'else' )=> (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) )? { - otherlv_0=(Token)match(input,44,FOLLOW_15); if (state.failed) return current; + otherlv_0=(Token)match(input,46,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); @@ -4498,7 +4534,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { } - otherlv_2=(Token)match(input,45,FOLLOW_15); if (state.failed) return current; + otherlv_2=(Token)match(input,47,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); @@ -4543,7 +4579,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { int alt34=2; int LA34_0 = input.LA(1); - if ( (LA34_0==46) ) { + if ( (LA34_0==48) ) { int LA34_1 = input.LA(2); if ( (synpred2_InternalExport()) ) { @@ -4557,7 +4593,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { // InternalExport.g:1611:4: (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) // InternalExport.g:1612:5: otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) { - otherlv_4=(Token)match(input,46,FOLLOW_15); if (state.failed) return current; + otherlv_4=(Token)match(input,48,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); @@ -4700,7 +4736,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { // InternalExport.g:1655:2: (otherlv_0= 'switch' (otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' )? otherlv_4= '{' ( (lv_case_5_0= ruleCase ) )* otherlv_6= 'default' otherlv_7= ':' ( (lv_defaultExpr_8_0= ruleOrExpression ) ) otherlv_9= '}' ) // InternalExport.g:1656:3: otherlv_0= 'switch' (otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' )? otherlv_4= '{' ( (lv_case_5_0= ruleCase ) )* otherlv_6= 'default' otherlv_7= ':' ( (lv_defaultExpr_8_0= ruleOrExpression ) ) otherlv_9= '}' { - otherlv_0=(Token)match(input,47,FOLLOW_45); if (state.failed) return current; + otherlv_0=(Token)match(input,49,FOLLOW_45); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); @@ -4710,14 +4746,14 @@ public final EObject ruleSwitchExpression() throws RecognitionException { int alt35=2; int LA35_0 = input.LA(1); - if ( (LA35_0==28) ) { + if ( (LA35_0==30) ) { alt35=1; } switch (alt35) { case 1 : // InternalExport.g:1661:4: otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' { - otherlv_1=(Token)match(input,28,FOLLOW_46); if (state.failed) return current; + otherlv_1=(Token)match(input,30,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); @@ -4758,7 +4794,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,29,FOLLOW_9); if (state.failed) return current; + otherlv_3=(Token)match(input,31,FOLLOW_9); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); @@ -4770,7 +4806,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,16,FOLLOW_47); if (state.failed) return current; + otherlv_4=(Token)match(input,18,FOLLOW_47); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); @@ -4782,7 +4818,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { int alt36=2; int LA36_0 = input.LA(1); - if ( (LA36_0==49) ) { + if ( (LA36_0==51) ) { alt36=1; } @@ -4829,13 +4865,13 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } } while (true); - otherlv_6=(Token)match(input,48,FOLLOW_39); if (state.failed) return current; + otherlv_6=(Token)match(input,50,FOLLOW_39); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - otherlv_7=(Token)match(input,41,FOLLOW_46); if (state.failed) return current; + otherlv_7=(Token)match(input,43,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); @@ -4876,7 +4912,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_9=(Token)match(input,17,FOLLOW_2); if (state.failed) return current; + otherlv_9=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_9, grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); @@ -4968,7 +5004,7 @@ public final EObject ruleCase() throws RecognitionException { // InternalExport.g:1761:2: (otherlv_0= 'case' ( (lv_condition_1_0= ruleOrExpression ) ) otherlv_2= ':' ( (lv_thenPar_3_0= ruleOrExpression ) ) ) // InternalExport.g:1762:3: otherlv_0= 'case' ( (lv_condition_1_0= ruleOrExpression ) ) otherlv_2= ':' ( (lv_thenPar_3_0= ruleOrExpression ) ) { - otherlv_0=(Token)match(input,49,FOLLOW_46); if (state.failed) return current; + otherlv_0=(Token)match(input,51,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getCaseAccess().getCaseKeyword_0()); @@ -5009,7 +5045,7 @@ public final EObject ruleCase() throws RecognitionException { } - otherlv_2=(Token)match(input,41,FOLLOW_46); if (state.failed) return current; + otherlv_2=(Token)match(input,43,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getCaseAccess().getColonKeyword_2()); @@ -5157,7 +5193,7 @@ public final EObject ruleOrExpression() throws RecognitionException { int alt37=2; int LA37_0 = input.LA(1); - if ( (LA37_0==50) ) { + if ( (LA37_0==52) ) { alt37=1; } @@ -5185,7 +5221,7 @@ public final EObject ruleOrExpression() throws RecognitionException { // InternalExport.g:1844:5: (lv_operator_2_0= '||' ) // InternalExport.g:1845:6: lv_operator_2_0= '||' { - lv_operator_2_0=(Token)match(input,50,FOLLOW_46); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,52,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); @@ -5356,7 +5392,7 @@ public final EObject ruleAndExpression() throws RecognitionException { int alt38=2; int LA38_0 = input.LA(1); - if ( (LA38_0==51) ) { + if ( (LA38_0==53) ) { alt38=1; } @@ -5384,7 +5420,7 @@ public final EObject ruleAndExpression() throws RecognitionException { // InternalExport.g:1913:5: (lv_operator_2_0= '&&' ) // InternalExport.g:1914:6: lv_operator_2_0= '&&' { - lv_operator_2_0=(Token)match(input,51,FOLLOW_46); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,53,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); @@ -5555,7 +5591,7 @@ public final EObject ruleImpliesExpression() throws RecognitionException { int alt39=2; int LA39_0 = input.LA(1); - if ( (LA39_0==52) ) { + if ( (LA39_0==54) ) { alt39=1; } @@ -5583,7 +5619,7 @@ public final EObject ruleImpliesExpression() throws RecognitionException { // InternalExport.g:1982:5: (lv_operator_2_0= 'implies' ) // InternalExport.g:1983:6: lv_operator_2_0= 'implies' { - lv_operator_2_0=(Token)match(input,52,FOLLOW_46); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,54,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); @@ -5759,7 +5795,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { int alt41=2; int LA41_0 = input.LA(1); - if ( ((LA41_0>=53 && LA41_0<=58)) ) { + if ( ((LA41_0>=55 && LA41_0<=60)) ) { alt41=1; } @@ -5790,32 +5826,32 @@ public final EObject ruleRelationalExpression() throws RecognitionException { // InternalExport.g:2052:6: (lv_operator_2_1= '==' | lv_operator_2_2= '!=' | lv_operator_2_3= '>=' | lv_operator_2_4= '<=' | lv_operator_2_5= '>' | lv_operator_2_6= '<' ) int alt40=6; switch ( input.LA(1) ) { - case 53: + case 55: { alt40=1; } break; - case 54: + case 56: { alt40=2; } break; - case 55: + case 57: { alt40=3; } break; - case 56: + case 58: { alt40=4; } break; - case 57: + case 59: { alt40=5; } break; - case 58: + case 60: { alt40=6; } @@ -5832,7 +5868,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 1 : // InternalExport.g:2053:7: lv_operator_2_1= '==' { - lv_operator_2_1=(Token)match(input,53,FOLLOW_46); if (state.failed) return current; + lv_operator_2_1=(Token)match(input,55,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_1, grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); @@ -5852,7 +5888,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 2 : // InternalExport.g:2064:7: lv_operator_2_2= '!=' { - lv_operator_2_2=(Token)match(input,54,FOLLOW_46); if (state.failed) return current; + lv_operator_2_2=(Token)match(input,56,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_2, grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); @@ -5872,7 +5908,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 3 : // InternalExport.g:2075:7: lv_operator_2_3= '>=' { - lv_operator_2_3=(Token)match(input,55,FOLLOW_46); if (state.failed) return current; + lv_operator_2_3=(Token)match(input,57,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_3, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); @@ -5892,7 +5928,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 4 : // InternalExport.g:2086:7: lv_operator_2_4= '<=' { - lv_operator_2_4=(Token)match(input,56,FOLLOW_46); if (state.failed) return current; + lv_operator_2_4=(Token)match(input,58,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_4, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); @@ -5912,7 +5948,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 5 : // InternalExport.g:2097:7: lv_operator_2_5= '>' { - lv_operator_2_5=(Token)match(input,57,FOLLOW_46); if (state.failed) return current; + lv_operator_2_5=(Token)match(input,59,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_5, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); @@ -5932,7 +5968,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 6 : // InternalExport.g:2108:7: lv_operator_2_6= '<' { - lv_operator_2_6=(Token)match(input,58,FOLLOW_46); if (state.failed) return current; + lv_operator_2_6=(Token)match(input,60,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_6, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); @@ -6110,7 +6146,7 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { int alt43=2; int LA43_0 = input.LA(1); - if ( (LA43_0==25||LA43_0==59) ) { + if ( (LA43_0==27||LA43_0==61) ) { alt43=1; } @@ -6142,10 +6178,10 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { int alt42=2; int LA42_0 = input.LA(1); - if ( (LA42_0==25) ) { + if ( (LA42_0==27) ) { alt42=1; } - else if ( (LA42_0==59) ) { + else if ( (LA42_0==61) ) { alt42=2; } else { @@ -6159,7 +6195,7 @@ else if ( (LA42_0==59) ) { case 1 : // InternalExport.g:2179:7: lv_name_2_1= '+' { - lv_name_2_1=(Token)match(input,25,FOLLOW_46); if (state.failed) return current; + lv_name_2_1=(Token)match(input,27,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_1, grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); @@ -6179,7 +6215,7 @@ else if ( (LA42_0==59) ) { case 2 : // InternalExport.g:2190:7: lv_name_2_2= '-' { - lv_name_2_2=(Token)match(input,59,FOLLOW_46); if (state.failed) return current; + lv_name_2_2=(Token)match(input,61,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_2, grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); @@ -6357,7 +6393,7 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException int alt45=2; int LA45_0 = input.LA(1); - if ( ((LA45_0>=60 && LA45_0<=61)) ) { + if ( ((LA45_0>=62 && LA45_0<=63)) ) { alt45=1; } @@ -6389,10 +6425,10 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException int alt44=2; int LA44_0 = input.LA(1); - if ( (LA44_0==60) ) { + if ( (LA44_0==62) ) { alt44=1; } - else if ( (LA44_0==61) ) { + else if ( (LA44_0==63) ) { alt44=2; } else { @@ -6406,7 +6442,7 @@ else if ( (LA44_0==61) ) { case 1 : // InternalExport.g:2261:7: lv_name_2_1= '*' { - lv_name_2_1=(Token)match(input,60,FOLLOW_46); if (state.failed) return current; + lv_name_2_1=(Token)match(input,62,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_1, grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); @@ -6426,7 +6462,7 @@ else if ( (LA44_0==61) ) { case 2 : // InternalExport.g:2272:7: lv_name_2_2= '/' { - lv_name_2_2=(Token)match(input,61,FOLLOW_46); if (state.failed) return current; + lv_name_2_2=(Token)match(input,63,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_2, grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); @@ -6581,10 +6617,10 @@ public final EObject ruleUnaryOrInfixExpression() throws RecognitionException { int alt46=2; int LA46_0 = input.LA(1); - if ( (LA46_0==59||LA46_0==62) ) { + if ( (LA46_0==61||LA46_0==64) ) { alt46=1; } - else if ( ((LA46_0>=RULE_ID && LA46_0<=RULE_REAL)||LA46_0==16||LA46_0==28||(LA46_0>=64 && LA46_0<=72)||(LA46_0>=74 && LA46_0<=81)) ) { + else if ( ((LA46_0>=RULE_ID && LA46_0<=RULE_REAL)||LA46_0==18||LA46_0==30||(LA46_0>=66 && LA46_0<=74)||(LA46_0>=76 && LA46_0<=83)) ) { alt46=2; } else { @@ -6733,10 +6769,10 @@ public final EObject ruleUnaryExpression() throws RecognitionException { int alt47=2; int LA47_0 = input.LA(1); - if ( (LA47_0==62) ) { + if ( (LA47_0==64) ) { alt47=1; } - else if ( (LA47_0==59) ) { + else if ( (LA47_0==61) ) { alt47=2; } else { @@ -6750,7 +6786,7 @@ else if ( (LA47_0==59) ) { case 1 : // InternalExport.g:2363:6: lv_name_0_1= '!' { - lv_name_0_1=(Token)match(input,62,FOLLOW_46); if (state.failed) return current; + lv_name_0_1=(Token)match(input,64,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_1, grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); @@ -6770,7 +6806,7 @@ else if ( (LA47_0==59) ) { case 2 : // InternalExport.g:2374:6: lv_name_0_2= '-' { - lv_name_0_2=(Token)match(input,59,FOLLOW_46); if (state.failed) return current; + lv_name_0_2=(Token)match(input,61,FOLLOW_46); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_2, grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); @@ -6970,46 +7006,46 @@ public final EObject ruleInfixExpression() throws RecognitionException { int alt52=5; int LA52_0 = input.LA(1); - if ( (LA52_0==63) ) { + if ( (LA52_0==65) ) { switch ( input.LA(2) ) { + case 66: + { + alt52=3; + } + break; + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + { + alt52=4; + } + break; case RULE_ID: { - int LA52_3 = input.LA(3); + int LA52_5 = input.LA(3); - if ( (LA52_3==28) ) { + if ( (LA52_5==30) ) { alt52=1; } - else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)||(LA52_3>=23 && LA52_3<=25)||LA52_3==29||LA52_3==39||(LA52_3>=41 && LA52_3<=43)||(LA52_3>=45 && LA52_3<=46)||(LA52_3>=48 && LA52_3<=61)||LA52_3==63) ) { + else if ( (LA52_5==EOF||(LA52_5>=18 && LA52_5<=19)||(LA52_5>=22 && LA52_5<=23)||(LA52_5>=25 && LA52_5<=27)||LA52_5==31||LA52_5==41||(LA52_5>=43 && LA52_5<=45)||(LA52_5>=47 && LA52_5<=48)||(LA52_5>=50 && LA52_5<=63)||LA52_5==65) ) { alt52=2; } } break; - case 79: - case 80: case 81: + case 82: + case 83: { alt52=2; } break; - case 64: - { - alt52=3; - } - break; - case 65: - case 66: - case 67: - case 68: - case 69: - case 70: - case 71: - case 72: - { - alt52=4; - } - break; } @@ -7036,7 +7072,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_2=(Token)match(input,63,FOLLOW_4); if (state.failed) return current; + otherlv_2=(Token)match(input,65,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); @@ -7077,7 +7113,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_4=(Token)match(input,28,FOLLOW_56); if (state.failed) return current; + otherlv_4=(Token)match(input,30,FOLLOW_56); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); @@ -7087,7 +7123,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| int alt49=2; int LA49_0 = input.LA(1); - if ( ((LA49_0>=RULE_ID && LA49_0<=RULE_REAL)||LA49_0==16||LA49_0==28||LA49_0==40||LA49_0==44||LA49_0==47||LA49_0==59||LA49_0==62||(LA49_0>=64 && LA49_0<=72)||(LA49_0>=74 && LA49_0<=81)) ) { + if ( ((LA49_0>=RULE_ID && LA49_0<=RULE_REAL)||LA49_0==18||LA49_0==30||LA49_0==42||LA49_0==46||LA49_0==49||LA49_0==61||LA49_0==64||(LA49_0>=66 && LA49_0<=74)||(LA49_0>=76 && LA49_0<=83)) ) { alt49=1; } switch (alt49) { @@ -7135,7 +7171,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| int alt48=2; int LA48_0 = input.LA(1); - if ( (LA48_0==23) ) { + if ( (LA48_0==25) ) { alt48=1; } @@ -7144,7 +7180,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 1 : // InternalExport.g:2490:7: otherlv_6= ',' ( (lv_params_7_0= ruleExpression ) ) { - otherlv_6=(Token)match(input,23,FOLLOW_15); if (state.failed) return current; + otherlv_6=(Token)match(input,25,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); @@ -7200,7 +7236,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_8=(Token)match(input,29,FOLLOW_55); if (state.failed) return current; + otherlv_8=(Token)match(input,31,FOLLOW_55); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_8, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); @@ -7231,7 +7267,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_10=(Token)match(input,63,FOLLOW_40); if (state.failed) return current; + otherlv_10=(Token)match(input,65,FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_10, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); @@ -7297,7 +7333,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_13=(Token)match(input,63,FOLLOW_58); if (state.failed) return current; + otherlv_13=(Token)match(input,65,FOLLOW_58); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_13, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); @@ -7309,7 +7345,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| // InternalExport.g:2567:6: (lv_name_14_0= 'typeSelect' ) // InternalExport.g:2568:7: lv_name_14_0= 'typeSelect' { - lv_name_14_0=(Token)match(input,64,FOLLOW_23); if (state.failed) return current; + lv_name_14_0=(Token)match(input,66,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_14_0, grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); @@ -7329,7 +7365,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_15=(Token)match(input,28,FOLLOW_40); if (state.failed) return current; + otherlv_15=(Token)match(input,30,FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_15, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); @@ -7370,7 +7406,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_17=(Token)match(input,29,FOLLOW_55); if (state.failed) return current; + otherlv_17=(Token)match(input,31,FOLLOW_55); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_17, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); @@ -7401,7 +7437,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_19=(Token)match(input,63,FOLLOW_59); if (state.failed) return current; + otherlv_19=(Token)match(input,65,FOLLOW_59); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_19, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); @@ -7416,42 +7452,42 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| // InternalExport.g:2623:7: (lv_name_20_1= 'collect' | lv_name_20_2= 'select' | lv_name_20_3= 'selectFirst' | lv_name_20_4= 'reject' | lv_name_20_5= 'exists' | lv_name_20_6= 'notExists' | lv_name_20_7= 'sortBy' | lv_name_20_8= 'forAll' ) int alt50=8; switch ( input.LA(1) ) { - case 65: + case 67: { alt50=1; } break; - case 66: + case 68: { alt50=2; } break; - case 67: + case 69: { alt50=3; } break; - case 68: + case 70: { alt50=4; } break; - case 69: + case 71: { alt50=5; } break; - case 70: + case 72: { alt50=6; } break; - case 71: + case 73: { alt50=7; } break; - case 72: + case 74: { alt50=8; } @@ -7468,7 +7504,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 1 : // InternalExport.g:2624:8: lv_name_20_1= 'collect' { - lv_name_20_1=(Token)match(input,65,FOLLOW_23); if (state.failed) return current; + lv_name_20_1=(Token)match(input,67,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_1, grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); @@ -7488,7 +7524,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 2 : // InternalExport.g:2635:8: lv_name_20_2= 'select' { - lv_name_20_2=(Token)match(input,66,FOLLOW_23); if (state.failed) return current; + lv_name_20_2=(Token)match(input,68,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_2, grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); @@ -7508,7 +7544,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 3 : // InternalExport.g:2646:8: lv_name_20_3= 'selectFirst' { - lv_name_20_3=(Token)match(input,67,FOLLOW_23); if (state.failed) return current; + lv_name_20_3=(Token)match(input,69,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_3, grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); @@ -7528,7 +7564,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 4 : // InternalExport.g:2657:8: lv_name_20_4= 'reject' { - lv_name_20_4=(Token)match(input,68,FOLLOW_23); if (state.failed) return current; + lv_name_20_4=(Token)match(input,70,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_4, grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); @@ -7548,7 +7584,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 5 : // InternalExport.g:2668:8: lv_name_20_5= 'exists' { - lv_name_20_5=(Token)match(input,69,FOLLOW_23); if (state.failed) return current; + lv_name_20_5=(Token)match(input,71,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_5, grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); @@ -7568,7 +7604,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 6 : // InternalExport.g:2679:8: lv_name_20_6= 'notExists' { - lv_name_20_6=(Token)match(input,70,FOLLOW_23); if (state.failed) return current; + lv_name_20_6=(Token)match(input,72,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_6, grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); @@ -7588,7 +7624,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 7 : // InternalExport.g:2690:8: lv_name_20_7= 'sortBy' { - lv_name_20_7=(Token)match(input,71,FOLLOW_23); if (state.failed) return current; + lv_name_20_7=(Token)match(input,73,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_7, grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); @@ -7608,7 +7644,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| case 8 : // InternalExport.g:2701:8: lv_name_20_8= 'forAll' { - lv_name_20_8=(Token)match(input,72,FOLLOW_23); if (state.failed) return current; + lv_name_20_8=(Token)match(input,74,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_8, grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); @@ -7634,7 +7670,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_21=(Token)match(input,28,FOLLOW_15); if (state.failed) return current; + otherlv_21=(Token)match(input,30,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_21, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); @@ -7647,7 +7683,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| if ( (LA51_0==RULE_ID) ) { int LA51_1 = input.LA(2); - if ( (LA51_1==73) ) { + if ( (LA51_1==75) ) { alt51=1; } } @@ -7690,7 +7726,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_23=(Token)match(input,73,FOLLOW_15); if (state.failed) return current; + otherlv_23=(Token)match(input,75,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_23, grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); @@ -7737,7 +7773,7 @@ else if ( (LA52_3==EOF||(LA52_3>=16 && LA52_3<=17)||(LA52_3>=20 && LA52_3<=21)|| } - otherlv_25=(Token)match(input,29,FOLLOW_55); if (state.failed) return current; + otherlv_25=(Token)match(input,31,FOLLOW_55); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_25, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); @@ -7850,16 +7886,14 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case RULE_STRING: case RULE_INT: case RULE_REAL: - case 74: - case 75: case 76: + case 77: + case 78: { alt53=1; } break; case RULE_ID: - case 64: - case 65: case 66: case 67: case 68: @@ -7867,29 +7901,31 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case 70: case 71: case 72: - case 79: - case 80: + case 73: + case 74: case 81: + case 82: + case 83: { alt53=2; } break; - case 16: + case 18: { alt53=3; } break; - case 78: + case 80: { alt53=4; } break; - case 77: + case 79: { alt53=5; } break; - case 28: + case 30: { alt53=6; } @@ -8125,8 +8161,8 @@ public final EObject ruleLiteral() throws RecognitionException { // InternalExport.g:2858:2: (this_BooleanLiteral_0= ruleBooleanLiteral | this_IntegerLiteral_1= ruleIntegerLiteral | this_NullLiteral_2= ruleNullLiteral | this_RealLiteral_3= ruleRealLiteral | this_StringLiteral_4= ruleStringLiteral ) int alt54=5; switch ( input.LA(1) ) { - case 74: - case 75: + case 76: + case 77: { alt54=1; } @@ -8136,7 +8172,7 @@ public final EObject ruleLiteral() throws RecognitionException { alt54=2; } break; - case 76: + case 78: { alt54=3; } @@ -8359,10 +8395,10 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { int alt55=2; int LA55_0 = input.LA(1); - if ( (LA55_0==74) ) { + if ( (LA55_0==76) ) { alt55=1; } - else if ( (LA55_0==75) ) { + else if ( (LA55_0==77) ) { alt55=2; } else { @@ -8376,7 +8412,7 @@ else if ( (LA55_0==75) ) { case 1 : // InternalExport.g:2924:5: lv_val_0_1= 'true' { - lv_val_0_1=(Token)match(input,74,FOLLOW_2); if (state.failed) return current; + lv_val_0_1=(Token)match(input,76,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_1, grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); @@ -8396,7 +8432,7 @@ else if ( (LA55_0==75) ) { case 2 : // InternalExport.g:2935:5: lv_val_0_2= 'false' { - lv_val_0_2=(Token)match(input,75,FOLLOW_2); if (state.failed) return current; + lv_val_0_2=(Token)match(input,77,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_2, grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); @@ -8518,7 +8554,7 @@ public final EObject ruleIntegerLiteral() throws RecognitionException { current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.INT"); + "org.eclipse.xtext.xbase.Xbase.INT"); } @@ -8608,7 +8644,7 @@ public final EObject ruleNullLiteral() throws RecognitionException { // InternalExport.g:3001:3: (lv_val_0_0= 'null' ) // InternalExport.g:3002:4: lv_val_0_0= 'null' { - lv_val_0_0=(Token)match(input,76,FOLLOW_2); if (state.failed) return current; + lv_val_0_0=(Token)match(input,78,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_0, grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); @@ -8829,7 +8865,7 @@ public final EObject ruleStringLiteral() throws RecognitionException { current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.STRING"); + "org.eclipse.xtext.xbase.Xtype.STRING"); } @@ -8919,7 +8955,7 @@ public final EObject ruleParanthesizedExpression() throws RecognitionException { // InternalExport.g:3101:2: (otherlv_0= '(' this_Expression_1= ruleExpression otherlv_2= ')' ) // InternalExport.g:3102:3: otherlv_0= '(' this_Expression_1= ruleExpression otherlv_2= ')' { - otherlv_0=(Token)match(input,28,FOLLOW_15); if (state.failed) return current; + otherlv_0=(Token)match(input,30,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -8941,7 +8977,7 @@ public final EObject ruleParanthesizedExpression() throws RecognitionException { afterParserOrEnumRuleCall(); } - otherlv_2=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + otherlv_2=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); @@ -9030,7 +9066,7 @@ public final EObject ruleGlobalVarExpression() throws RecognitionException { // InternalExport.g:3136:2: (otherlv_0= 'GLOBALVAR' ( (lv_name_1_0= ruleIdentifier ) ) ) // InternalExport.g:3137:3: otherlv_0= 'GLOBALVAR' ( (lv_name_1_0= ruleIdentifier ) ) { - otherlv_0=(Token)match(input,77,FOLLOW_4); if (state.failed) return current; + otherlv_0=(Token)match(input,79,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); @@ -9163,10 +9199,10 @@ public final EObject ruleFeatureCall() throws RecognitionException { { int LA56_1 = input.LA(2); - if ( (LA56_1==EOF||(LA56_1>=16 && LA56_1<=17)||(LA56_1>=20 && LA56_1<=21)||(LA56_1>=23 && LA56_1<=25)||LA56_1==29||LA56_1==39||(LA56_1>=41 && LA56_1<=43)||(LA56_1>=45 && LA56_1<=46)||(LA56_1>=48 && LA56_1<=61)||LA56_1==63) ) { + if ( (LA56_1==EOF||(LA56_1>=18 && LA56_1<=19)||(LA56_1>=22 && LA56_1<=23)||(LA56_1>=25 && LA56_1<=27)||LA56_1==31||LA56_1==41||(LA56_1>=43 && LA56_1<=45)||(LA56_1>=47 && LA56_1<=48)||(LA56_1>=50 && LA56_1<=63)||LA56_1==65) ) { alt56=2; } - else if ( (LA56_1==28) ) { + else if ( (LA56_1==30) ) { alt56=1; } else { @@ -9178,26 +9214,26 @@ else if ( (LA56_1==28) ) { } } break; - case 79: - case 80: case 81: + case 82: + case 83: { alt56=2; } break; - case 65: - case 66: case 67: case 68: case 69: case 70: case 71: case 72: + case 73: + case 74: { alt56=3; } break; - case 64: + case 66: { alt56=4; } @@ -9442,7 +9478,7 @@ public final EObject ruleOperationCall() throws RecognitionException { } - otherlv_1=(Token)match(input,28,FOLLOW_56); if (state.failed) return current; + otherlv_1=(Token)match(input,30,FOLLOW_56); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); @@ -9452,7 +9488,7 @@ public final EObject ruleOperationCall() throws RecognitionException { int alt58=2; int LA58_0 = input.LA(1); - if ( ((LA58_0>=RULE_ID && LA58_0<=RULE_REAL)||LA58_0==16||LA58_0==28||LA58_0==40||LA58_0==44||LA58_0==47||LA58_0==59||LA58_0==62||(LA58_0>=64 && LA58_0<=72)||(LA58_0>=74 && LA58_0<=81)) ) { + if ( ((LA58_0>=RULE_ID && LA58_0<=RULE_REAL)||LA58_0==18||LA58_0==30||LA58_0==42||LA58_0==46||LA58_0==49||LA58_0==61||LA58_0==64||(LA58_0>=66 && LA58_0<=74)||(LA58_0>=76 && LA58_0<=83)) ) { alt58=1; } switch (alt58) { @@ -9500,7 +9536,7 @@ public final EObject ruleOperationCall() throws RecognitionException { int alt57=2; int LA57_0 = input.LA(1); - if ( (LA57_0==23) ) { + if ( (LA57_0==25) ) { alt57=1; } @@ -9509,7 +9545,7 @@ public final EObject ruleOperationCall() throws RecognitionException { case 1 : // InternalExport.g:3288:5: otherlv_3= ',' ( (lv_params_4_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,23,FOLLOW_15); if (state.failed) return current; + otherlv_3=(Token)match(input,25,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); @@ -9565,7 +9601,7 @@ public final EObject ruleOperationCall() throws RecognitionException { } - otherlv_5=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); @@ -9671,7 +9707,7 @@ public final EObject ruleListLiteral() throws RecognitionException { } - otherlv_1=(Token)match(input,16,FOLLOW_61); if (state.failed) return current; + otherlv_1=(Token)match(input,18,FOLLOW_61); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); @@ -9681,7 +9717,7 @@ public final EObject ruleListLiteral() throws RecognitionException { int alt60=2; int LA60_0 = input.LA(1); - if ( ((LA60_0>=RULE_ID && LA60_0<=RULE_REAL)||LA60_0==16||LA60_0==28||LA60_0==40||LA60_0==44||LA60_0==47||LA60_0==59||LA60_0==62||(LA60_0>=64 && LA60_0<=72)||(LA60_0>=74 && LA60_0<=81)) ) { + if ( ((LA60_0>=RULE_ID && LA60_0<=RULE_REAL)||LA60_0==18||LA60_0==30||LA60_0==42||LA60_0==46||LA60_0==49||LA60_0==61||LA60_0==64||(LA60_0>=66 && LA60_0<=74)||(LA60_0>=76 && LA60_0<=83)) ) { alt60=1; } switch (alt60) { @@ -9729,7 +9765,7 @@ public final EObject ruleListLiteral() throws RecognitionException { int alt59=2; int LA59_0 = input.LA(1); - if ( (LA59_0==23) ) { + if ( (LA59_0==25) ) { alt59=1; } @@ -9738,7 +9774,7 @@ public final EObject ruleListLiteral() throws RecognitionException { case 1 : // InternalExport.g:3368:5: otherlv_3= ',' ( (lv_elements_4_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,23,FOLLOW_15); if (state.failed) return current; + otherlv_3=(Token)match(input,25,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); @@ -9794,7 +9830,7 @@ public final EObject ruleListLiteral() throws RecognitionException { } - otherlv_5=(Token)match(input,17,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); @@ -9883,7 +9919,7 @@ public final EObject ruleConstructorCallExpression() throws RecognitionException // InternalExport.g:3415:2: (otherlv_0= 'new' ( (lv_type_1_0= ruleSimpleType ) ) ) // InternalExport.g:3416:3: otherlv_0= 'new' ( (lv_type_1_0= ruleSimpleType ) ) { - otherlv_0=(Token)match(input,78,FOLLOW_40); if (state.failed) return current; + otherlv_0=(Token)match(input,80,FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); @@ -10015,7 +10051,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { // InternalExport.g:3459:4: (lv_name_0_0= 'typeSelect' ) // InternalExport.g:3460:5: lv_name_0_0= 'typeSelect' { - lv_name_0_0=(Token)match(input,64,FOLLOW_23); if (state.failed) return current; + lv_name_0_0=(Token)match(input,66,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_0, grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); @@ -10035,7 +10071,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,28,FOLLOW_40); if (state.failed) return current; + otherlv_1=(Token)match(input,30,FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); @@ -10076,7 +10112,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); @@ -10186,42 +10222,42 @@ public final EObject ruleCollectionExpression() throws RecognitionException { // InternalExport.g:3520:5: (lv_name_0_1= 'collect' | lv_name_0_2= 'select' | lv_name_0_3= 'selectFirst' | lv_name_0_4= 'reject' | lv_name_0_5= 'exists' | lv_name_0_6= 'notExists' | lv_name_0_7= 'sortBy' | lv_name_0_8= 'forAll' ) int alt61=8; switch ( input.LA(1) ) { - case 65: + case 67: { alt61=1; } break; - case 66: + case 68: { alt61=2; } break; - case 67: + case 69: { alt61=3; } break; - case 68: + case 70: { alt61=4; } break; - case 69: + case 71: { alt61=5; } break; - case 70: + case 72: { alt61=6; } break; - case 71: + case 73: { alt61=7; } break; - case 72: + case 74: { alt61=8; } @@ -10238,7 +10274,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 1 : // InternalExport.g:3521:6: lv_name_0_1= 'collect' { - lv_name_0_1=(Token)match(input,65,FOLLOW_23); if (state.failed) return current; + lv_name_0_1=(Token)match(input,67,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_1, grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); @@ -10258,7 +10294,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 2 : // InternalExport.g:3532:6: lv_name_0_2= 'select' { - lv_name_0_2=(Token)match(input,66,FOLLOW_23); if (state.failed) return current; + lv_name_0_2=(Token)match(input,68,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_2, grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); @@ -10278,7 +10314,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 3 : // InternalExport.g:3543:6: lv_name_0_3= 'selectFirst' { - lv_name_0_3=(Token)match(input,67,FOLLOW_23); if (state.failed) return current; + lv_name_0_3=(Token)match(input,69,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_3, grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); @@ -10298,7 +10334,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 4 : // InternalExport.g:3554:6: lv_name_0_4= 'reject' { - lv_name_0_4=(Token)match(input,68,FOLLOW_23); if (state.failed) return current; + lv_name_0_4=(Token)match(input,70,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_4, grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); @@ -10318,7 +10354,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 5 : // InternalExport.g:3565:6: lv_name_0_5= 'exists' { - lv_name_0_5=(Token)match(input,69,FOLLOW_23); if (state.failed) return current; + lv_name_0_5=(Token)match(input,71,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_5, grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); @@ -10338,7 +10374,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 6 : // InternalExport.g:3576:6: lv_name_0_6= 'notExists' { - lv_name_0_6=(Token)match(input,70,FOLLOW_23); if (state.failed) return current; + lv_name_0_6=(Token)match(input,72,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_6, grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); @@ -10358,7 +10394,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 7 : // InternalExport.g:3587:6: lv_name_0_7= 'sortBy' { - lv_name_0_7=(Token)match(input,71,FOLLOW_23); if (state.failed) return current; + lv_name_0_7=(Token)match(input,73,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_7, grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); @@ -10378,7 +10414,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 8 : // InternalExport.g:3598:6: lv_name_0_8= 'forAll' { - lv_name_0_8=(Token)match(input,72,FOLLOW_23); if (state.failed) return current; + lv_name_0_8=(Token)match(input,74,FOLLOW_23); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_8, grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); @@ -10404,7 +10440,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,28,FOLLOW_15); if (state.failed) return current; + otherlv_1=(Token)match(input,30,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); @@ -10417,7 +10453,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { if ( (LA62_0==RULE_ID) ) { int LA62_1 = input.LA(2); - if ( (LA62_1==73) ) { + if ( (LA62_1==75) ) { alt62=1; } } @@ -10460,7 +10496,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,73,FOLLOW_15); if (state.failed) return current; + otherlv_3=(Token)match(input,75,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); @@ -10507,7 +10543,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_5=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); @@ -10598,7 +10634,7 @@ public final EObject ruleType() throws RecognitionException { int alt63=2; int LA63_0 = input.LA(1); - if ( ((LA63_0>=79 && LA63_0<=81)) ) { + if ( ((LA63_0>=81 && LA63_0<=83)) ) { alt63=1; } else if ( (LA63_0==RULE_ID) ) { @@ -10752,17 +10788,17 @@ public final EObject ruleCollectionType() throws RecognitionException { // InternalExport.g:3720:5: (lv_cl_0_1= 'Collection' | lv_cl_0_2= 'List' | lv_cl_0_3= 'Set' ) int alt64=3; switch ( input.LA(1) ) { - case 79: + case 81: { alt64=1; } break; - case 80: + case 82: { alt64=2; } break; - case 81: + case 83: { alt64=3; } @@ -10779,7 +10815,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 1 : // InternalExport.g:3721:6: lv_cl_0_1= 'Collection' { - lv_cl_0_1=(Token)match(input,79,FOLLOW_63); if (state.failed) return current; + lv_cl_0_1=(Token)match(input,81,FOLLOW_63); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_1, grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); @@ -10799,7 +10835,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 2 : // InternalExport.g:3732:6: lv_cl_0_2= 'List' { - lv_cl_0_2=(Token)match(input,80,FOLLOW_63); if (state.failed) return current; + lv_cl_0_2=(Token)match(input,82,FOLLOW_63); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_2, grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); @@ -10819,7 +10855,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 3 : // InternalExport.g:3743:6: lv_cl_0_3= 'Set' { - lv_cl_0_3=(Token)match(input,81,FOLLOW_63); if (state.failed) return current; + lv_cl_0_3=(Token)match(input,83,FOLLOW_63); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_3, grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); @@ -10845,7 +10881,7 @@ public final EObject ruleCollectionType() throws RecognitionException { } - otherlv_1=(Token)match(input,20,FOLLOW_40); if (state.failed) return current; + otherlv_1=(Token)match(input,22,FOLLOW_40); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); @@ -10886,7 +10922,7 @@ public final EObject ruleCollectionType() throws RecognitionException { } - otherlv_3=(Token)match(input,21,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); @@ -11018,7 +11054,7 @@ public final EObject ruleSimpleType() throws RecognitionException { int alt65=2; int LA65_0 = input.LA(1); - if ( (LA65_0==39) ) { + if ( (LA65_0==41) ) { alt65=1; } @@ -11027,7 +11063,7 @@ public final EObject ruleSimpleType() throws RecognitionException { case 1 : // InternalExport.g:3822:4: otherlv_1= '::' ( (lv_id_2_0= ruleIdentifier ) ) { - otherlv_1=(Token)match(input,39,FOLLOW_4); if (state.failed) return current; + otherlv_1=(Token)match(input,41,FOLLOW_4); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); @@ -11186,92 +11222,22108 @@ public final AntlrDatatypeRuleToken ruleIdentifier() throws RecognitionException } // $ANTLR end "ruleIdentifier" - // $ANTLR start synpred1_InternalExport - public final void synpred1_InternalExport_fragment() throws RecognitionException { - // InternalExport.g:1186:4: ( ruleCastedExpression ) - // InternalExport.g:1186:5: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); - state._fsp--; - if (state.failed) return ; + // $ANTLR start "entryRuleXExpression" + // InternalExport.g:3874:1: entryRuleXExpression returns [EObject current=null] : iv_ruleXExpression= ruleXExpression EOF ; + public final EObject entryRuleXExpression() throws RecognitionException { + EObject current = null; - } - } - // $ANTLR end synpred1_InternalExport + EObject iv_ruleXExpression = null; - // $ANTLR start synpred2_InternalExport - public final void synpred2_InternalExport_fragment() throws RecognitionException { - // InternalExport.g:1610:4: ( 'else' ) - // InternalExport.g:1610:5: 'else' - { - match(input,46,FOLLOW_2); if (state.failed) return ; - } - } - // $ANTLR end synpred2_InternalExport + try { + // InternalExport.g:3874:52: (iv_ruleXExpression= ruleXExpression EOF ) + // InternalExport.g:3875:2: iv_ruleXExpression= ruleXExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpression=ruleXExpression(); - // Delegated rules + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } - public final boolean synpred1_InternalExport() { - state.backtracking++; - int start = input.mark(); - try { - synpred1_InternalExport_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred2_InternalExport() { - state.backtracking++; - int start = input.mark(); - try { - synpred2_InternalExport_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; + return current; } + // $ANTLR end "entryRuleXExpression" - protected DFA30 dfa30 = new DFA30(this); - static final String dfa_1s = "\36\uffff"; - static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; - static final String dfa_3s = "\1\121\1\uffff\1\0\33\uffff"; - static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; - static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; - static final String[] dfa_6s = { - "\4\3\10\uffff\1\3\13\uffff\1\2\13\uffff\1\1\3\uffff\1\3\2\uffff\1\3\13\uffff\1\3\2\uffff\1\3\1\uffff\11\3\1\uffff\10\3", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", + // $ANTLR start "ruleXExpression" + // InternalExport.g:3881:1: ruleXExpression returns [EObject current=null] : this_XAssignment_0= ruleXAssignment ; + public final EObject ruleXExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAssignment_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:3887:2: (this_XAssignment_0= ruleXAssignment ) + // InternalExport.g:3888:2: this_XAssignment_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + + } + pushFollow(FOLLOW_2); + this_XAssignment_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAssignment_0; + afterParserOrEnumRuleCall(); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpression" + + + // $ANTLR start "entryRuleXAssignment" + // InternalExport.g:3899:1: entryRuleXAssignment returns [EObject current=null] : iv_ruleXAssignment= ruleXAssignment EOF ; + public final EObject entryRuleXAssignment() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAssignment = null; + + + try { + // InternalExport.g:3899:52: (iv_ruleXAssignment= ruleXAssignment EOF ) + // InternalExport.g:3900:2: iv_ruleXAssignment= ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAssignment=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAssignment; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAssignment" + + + // $ANTLR start "ruleXAssignment" + // InternalExport.g:3906:1: ruleXAssignment returns [EObject current=null] : ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ; + public final EObject ruleXAssignment() throws RecognitionException { + EObject current = null; + + EObject lv_value_3_0 = null; + + EObject this_XOrExpression_4 = null; + + EObject lv_rightOperand_7_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:3912:2: ( ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ) + // InternalExport.g:3913:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) + { + // InternalExport.g:3913:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) + int alt67=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA67_1 = input.LA(2); + + if ( (LA67_1==EOF||(LA67_1>=RULE_ID && LA67_1<=RULE_INT)||(LA67_1>=RULE_HEX && LA67_1<=RULE_DECIMAL)||(LA67_1>=15 && LA67_1<=16)||(LA67_1>=18 && LA67_1<=23)||(LA67_1>=25 && LA67_1<=27)||(LA67_1>=30 && LA67_1<=31)||LA67_1==41||(LA67_1>=43 && LA67_1<=44)||LA67_1==46||(LA67_1>=48 && LA67_1<=53)||(LA67_1>=55 && LA67_1<=57)||(LA67_1>=59 && LA67_1<=65)||(LA67_1>=76 && LA67_1<=78)||LA67_1==80||(LA67_1>=84 && LA67_1<=116)) ) { + alt67=2; + } + else if ( (LA67_1==24) ) { + alt67=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 1, input); + + throw nvae; + } + } + break; + case 107: + { + int LA67_2 = input.LA(2); + + if ( (LA67_2==24) ) { + alt67=1; + } + else if ( (LA67_2==EOF||(LA67_2>=RULE_ID && LA67_2<=RULE_INT)||(LA67_2>=RULE_HEX && LA67_2<=RULE_DECIMAL)||(LA67_2>=15 && LA67_2<=16)||(LA67_2>=18 && LA67_2<=23)||(LA67_2>=25 && LA67_2<=27)||(LA67_2>=30 && LA67_2<=31)||LA67_2==41||(LA67_2>=43 && LA67_2<=44)||LA67_2==46||(LA67_2>=48 && LA67_2<=53)||(LA67_2>=55 && LA67_2<=57)||(LA67_2>=59 && LA67_2<=65)||(LA67_2>=76 && LA67_2<=78)||LA67_2==80||(LA67_2>=84 && LA67_2<=116)) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 2, input); + + throw nvae; + } + } + break; + case 108: + { + int LA67_3 = input.LA(2); + + if ( (LA67_3==24) ) { + alt67=1; + } + else if ( (LA67_3==EOF||(LA67_3>=RULE_ID && LA67_3<=RULE_INT)||(LA67_3>=RULE_HEX && LA67_3<=RULE_DECIMAL)||(LA67_3>=15 && LA67_3<=16)||(LA67_3>=18 && LA67_3<=23)||(LA67_3>=25 && LA67_3<=27)||(LA67_3>=30 && LA67_3<=31)||LA67_3==41||(LA67_3>=43 && LA67_3<=44)||LA67_3==46||(LA67_3>=48 && LA67_3<=53)||(LA67_3>=55 && LA67_3<=57)||(LA67_3>=59 && LA67_3<=65)||(LA67_3>=76 && LA67_3<=78)||LA67_3==80||(LA67_3>=84 && LA67_3<=116)) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 3, input); + + throw nvae; + } + } + break; + case 20: + { + int LA67_4 = input.LA(2); + + if ( (LA67_4==24) ) { + alt67=1; + } + else if ( (LA67_4==EOF||(LA67_4>=RULE_ID && LA67_4<=RULE_INT)||(LA67_4>=RULE_HEX && LA67_4<=RULE_DECIMAL)||(LA67_4>=15 && LA67_4<=16)||(LA67_4>=18 && LA67_4<=23)||(LA67_4>=25 && LA67_4<=27)||(LA67_4>=30 && LA67_4<=31)||LA67_4==41||(LA67_4>=43 && LA67_4<=44)||LA67_4==46||(LA67_4>=48 && LA67_4<=53)||(LA67_4>=55 && LA67_4<=57)||(LA67_4>=59 && LA67_4<=65)||(LA67_4>=76 && LA67_4<=78)||LA67_4==80||(LA67_4>=84 && LA67_4<=116)) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 4, input); + + throw nvae; + } + } + break; + case 15: + { + int LA67_5 = input.LA(2); + + if ( (LA67_5==24) ) { + alt67=1; + } + else if ( (LA67_5==EOF||(LA67_5>=RULE_ID && LA67_5<=RULE_INT)||(LA67_5>=RULE_HEX && LA67_5<=RULE_DECIMAL)||(LA67_5>=15 && LA67_5<=16)||(LA67_5>=18 && LA67_5<=23)||(LA67_5>=25 && LA67_5<=27)||(LA67_5>=30 && LA67_5<=31)||LA67_5==41||(LA67_5>=43 && LA67_5<=44)||LA67_5==46||(LA67_5>=48 && LA67_5<=53)||(LA67_5>=55 && LA67_5<=57)||(LA67_5>=59 && LA67_5<=65)||(LA67_5>=76 && LA67_5<=78)||LA67_5==80||(LA67_5>=84 && LA67_5<=116)) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 5, input); + + throw nvae; + } + } + break; + case RULE_STRING: + case RULE_INT: + case RULE_HEX: + case RULE_DECIMAL: + case 16: + case 18: + case 22: + case 27: + case 30: + case 46: + case 49: + case 60: + case 61: + case 64: + case 76: + case 77: + case 78: + case 80: + case 102: + case 103: + case 104: + case 109: + case 110: + case 111: + case 112: + case 113: + case 115: + { + alt67=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 67, 0, input); + + throw nvae; + } + + switch (alt67) { + case 1 : + // InternalExport.g:3914:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) + { + // InternalExport.g:3914:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) + // InternalExport.g:3915:4: () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) + { + // InternalExport.g:3915:4: () + // InternalExport.g:3916:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(), + current); + + } + + } + + // InternalExport.g:3922:4: ( ( ruleFeatureCallID ) ) + // InternalExport.g:3923:5: ( ruleFeatureCallID ) + { + // InternalExport.g:3923:5: ( ruleFeatureCallID ) + // InternalExport.g:3924:6: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAssignmentRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + + } + pushFollow(FOLLOW_31); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + + } + pushFollow(FOLLOW_64); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:3945:4: ( (lv_value_3_0= ruleXAssignment ) ) + // InternalExport.g:3946:5: (lv_value_3_0= ruleXAssignment ) + { + // InternalExport.g:3946:5: (lv_value_3_0= ruleXAssignment ) + // InternalExport.g:3947:6: lv_value_3_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + + } + pushFollow(FOLLOW_2); + lv_value_3_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + current, + "value", + lv_value_3_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:3966:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) + { + // InternalExport.g:3966:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) + // InternalExport.g:3967:4: this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_65); + this_XOrExpression_4=ruleXOrExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XOrExpression_4; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:3975:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? + int alt66=2; + alt66 = dfa66.predict(input); + switch (alt66) { + case 1 : + // InternalExport.g:3976:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) + { + // InternalExport.g:3976:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) + // InternalExport.g:3977:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) + { + // InternalExport.g:3987:6: ( () ( ( ruleOpMultiAssign ) ) ) + // InternalExport.g:3988:7: () ( ( ruleOpMultiAssign ) ) + { + // InternalExport.g:3988:7: () + // InternalExport.g:3989:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:3995:7: ( ( ruleOpMultiAssign ) ) + // InternalExport.g:3996:8: ( ruleOpMultiAssign ) + { + // InternalExport.g:3996:8: ( ruleOpMultiAssign ) + // InternalExport.g:3997:9: ruleOpMultiAssign + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAssignmentRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4013:5: ( (lv_rightOperand_7_0= ruleXAssignment ) ) + // InternalExport.g:4014:6: (lv_rightOperand_7_0= ruleXAssignment ) + { + // InternalExport.g:4014:6: (lv_rightOperand_7_0= ruleXAssignment ) + // InternalExport.g:4015:7: lv_rightOperand_7_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_rightOperand_7_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_7_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAssignment" + + + // $ANTLR start "entryRuleOpSingleAssign" + // InternalExport.g:4038:1: entryRuleOpSingleAssign returns [String current=null] : iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ; + public final String entryRuleOpSingleAssign() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpSingleAssign = null; + + + try { + // InternalExport.g:4038:54: (iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ) + // InternalExport.g:4039:2: iv_ruleOpSingleAssign= ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpSingleAssignRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpSingleAssign=ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpSingleAssign.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpSingleAssign" + + + // $ANTLR start "ruleOpSingleAssign" + // InternalExport.g:4045:1: ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '=' ; + public final AntlrDatatypeRuleToken ruleOpSingleAssign() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4051:2: (kw= '=' ) + // InternalExport.g:4052:2: kw= '=' + { + kw=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpSingleAssign" + + + // $ANTLR start "entryRuleOpMultiAssign" + // InternalExport.g:4060:1: entryRuleOpMultiAssign returns [String current=null] : iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ; + public final String entryRuleOpMultiAssign() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpMultiAssign = null; + + + try { + // InternalExport.g:4060:53: (iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ) + // InternalExport.g:4061:2: iv_ruleOpMultiAssign= ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpMultiAssign=ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpMultiAssign.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpMultiAssign" + + + // $ANTLR start "ruleOpMultiAssign" + // InternalExport.g:4067:1: ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ; + public final AntlrDatatypeRuleToken ruleOpMultiAssign() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4073:2: ( (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ) + // InternalExport.g:4074:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) + { + // InternalExport.g:4074:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) + int alt69=7; + switch ( input.LA(1) ) { + case 84: + { + alt69=1; + } + break; + case 85: + { + alt69=2; + } + break; + case 86: + { + alt69=3; + } + break; + case 87: + { + alt69=4; + } + break; + case 88: + { + alt69=5; + } + break; + case 60: + { + alt69=6; + } + break; + case 59: + { + alt69=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 69, 0, input); + + throw nvae; + } + + switch (alt69) { + case 1 : + // InternalExport.g:4075:3: kw= '+=' + { + kw=(Token)match(input,84,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:4081:3: kw= '-=' + { + kw=(Token)match(input,85,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalExport.g:4087:3: kw= '*=' + { + kw=(Token)match(input,86,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalExport.g:4093:3: kw= '/=' + { + kw=(Token)match(input,87,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + + } + + } + break; + case 5 : + // InternalExport.g:4099:3: kw= '%=' + { + kw=(Token)match(input,88,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + + } + + } + break; + case 6 : + // InternalExport.g:4105:3: (kw= '<' kw= '<' kw= '=' ) + { + // InternalExport.g:4105:3: (kw= '<' kw= '<' kw= '=' ) + // InternalExport.g:4106:4: kw= '<' kw= '<' kw= '=' + { + kw=(Token)match(input,60,FOLLOW_66); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + + } + kw=(Token)match(input,60,FOLLOW_31); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + + } + kw=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + + } + + } + + + } + break; + case 7 : + // InternalExport.g:4123:3: (kw= '>' (kw= '>' )? kw= '>=' ) + { + // InternalExport.g:4123:3: (kw= '>' (kw= '>' )? kw= '>=' ) + // InternalExport.g:4124:4: kw= '>' (kw= '>' )? kw= '>=' + { + kw=(Token)match(input,59,FOLLOW_67); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + + } + // InternalExport.g:4129:4: (kw= '>' )? + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==59) ) { + alt68=1; + } + switch (alt68) { + case 1 : + // InternalExport.g:4130:5: kw= '>' + { + kw=(Token)match(input,59,FOLLOW_68); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + + } + + } + break; + + } + + kw=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + + } + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpMultiAssign" + + + // $ANTLR start "entryRuleXOrExpression" + // InternalExport.g:4146:1: entryRuleXOrExpression returns [EObject current=null] : iv_ruleXOrExpression= ruleXOrExpression EOF ; + public final EObject entryRuleXOrExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXOrExpression = null; + + + try { + // InternalExport.g:4146:54: (iv_ruleXOrExpression= ruleXOrExpression EOF ) + // InternalExport.g:4147:2: iv_ruleXOrExpression= ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXOrExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXOrExpression=ruleXOrExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXOrExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXOrExpression" + + + // $ANTLR start "ruleXOrExpression" + // InternalExport.g:4153:1: ruleXOrExpression returns [EObject current=null] : (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ; + public final EObject ruleXOrExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAndExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:4159:2: ( (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ) + // InternalExport.g:4160:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) + { + // InternalExport.g:4160:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) + // InternalExport.g:4161:3: this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_49); + this_XAndExpression_0=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAndExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:4169:3: ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* + loop70: + do { + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==52) ) { + int LA70_2 = input.LA(2); + + if ( (synpred4_InternalExport()) ) { + alt70=1; + } + + + } + + + switch (alt70) { + case 1 : + // InternalExport.g:4170:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) + { + // InternalExport.g:4170:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) + // InternalExport.g:4171:5: ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) + { + // InternalExport.g:4181:5: ( () ( ( ruleOpOr ) ) ) + // InternalExport.g:4182:6: () ( ( ruleOpOr ) ) + { + // InternalExport.g:4182:6: () + // InternalExport.g:4183:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:4189:6: ( ( ruleOpOr ) ) + // InternalExport.g:4190:7: ( ruleOpOr ) + { + // InternalExport.g:4190:7: ( ruleOpOr ) + // InternalExport.g:4191:8: ruleOpOr + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXOrExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpOr(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4207:4: ( (lv_rightOperand_3_0= ruleXAndExpression ) ) + // InternalExport.g:4208:5: (lv_rightOperand_3_0= ruleXAndExpression ) + { + // InternalExport.g:4208:5: (lv_rightOperand_3_0= ruleXAndExpression ) + // InternalExport.g:4209:6: lv_rightOperand_3_0= ruleXAndExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_49); + lv_rightOperand_3_0=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXOrExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAndExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop70; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXOrExpression" + + + // $ANTLR start "entryRuleOpOr" + // InternalExport.g:4231:1: entryRuleOpOr returns [String current=null] : iv_ruleOpOr= ruleOpOr EOF ; + public final String entryRuleOpOr() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpOr = null; + + + try { + // InternalExport.g:4231:44: (iv_ruleOpOr= ruleOpOr EOF ) + // InternalExport.g:4232:2: iv_ruleOpOr= ruleOpOr EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpOr=ruleOpOr(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpOr.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpOr" + + + // $ANTLR start "ruleOpOr" + // InternalExport.g:4238:1: ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '||' ; + public final AntlrDatatypeRuleToken ruleOpOr() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4244:2: (kw= '||' ) + // InternalExport.g:4245:2: kw= '||' + { + kw=(Token)match(input,52,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpOr" + + + // $ANTLR start "entryRuleXAndExpression" + // InternalExport.g:4253:1: entryRuleXAndExpression returns [EObject current=null] : iv_ruleXAndExpression= ruleXAndExpression EOF ; + public final EObject entryRuleXAndExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAndExpression = null; + + + try { + // InternalExport.g:4253:55: (iv_ruleXAndExpression= ruleXAndExpression EOF ) + // InternalExport.g:4254:2: iv_ruleXAndExpression= ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAndExpression=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAndExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAndExpression" + + + // $ANTLR start "ruleXAndExpression" + // InternalExport.g:4260:1: ruleXAndExpression returns [EObject current=null] : (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ; + public final EObject ruleXAndExpression() throws RecognitionException { + EObject current = null; + + EObject this_XEqualityExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:4266:2: ( (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ) + // InternalExport.g:4267:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) + { + // InternalExport.g:4267:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) + // InternalExport.g:4268:3: this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_50); + this_XEqualityExpression_0=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XEqualityExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:4276:3: ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* + loop71: + do { + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==53) ) { + int LA71_2 = input.LA(2); + + if ( (synpred5_InternalExport()) ) { + alt71=1; + } + + + } + + + switch (alt71) { + case 1 : + // InternalExport.g:4277:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) + { + // InternalExport.g:4277:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) + // InternalExport.g:4278:5: ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) + { + // InternalExport.g:4288:5: ( () ( ( ruleOpAnd ) ) ) + // InternalExport.g:4289:6: () ( ( ruleOpAnd ) ) + { + // InternalExport.g:4289:6: () + // InternalExport.g:4290:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:4296:6: ( ( ruleOpAnd ) ) + // InternalExport.g:4297:7: ( ruleOpAnd ) + { + // InternalExport.g:4297:7: ( ruleOpAnd ) + // InternalExport.g:4298:8: ruleOpAnd + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAndExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4314:4: ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) + // InternalExport.g:4315:5: (lv_rightOperand_3_0= ruleXEqualityExpression ) + { + // InternalExport.g:4315:5: (lv_rightOperand_3_0= ruleXEqualityExpression ) + // InternalExport.g:4316:6: lv_rightOperand_3_0= ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_50); + lv_rightOperand_3_0=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAndExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XEqualityExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop71; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAndExpression" + + + // $ANTLR start "entryRuleOpAnd" + // InternalExport.g:4338:1: entryRuleOpAnd returns [String current=null] : iv_ruleOpAnd= ruleOpAnd EOF ; + public final String entryRuleOpAnd() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpAnd = null; + + + try { + // InternalExport.g:4338:45: (iv_ruleOpAnd= ruleOpAnd EOF ) + // InternalExport.g:4339:2: iv_ruleOpAnd= ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpAnd=ruleOpAnd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpAnd.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpAnd" + + + // $ANTLR start "ruleOpAnd" + // InternalExport.g:4345:1: ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '&&' ; + public final AntlrDatatypeRuleToken ruleOpAnd() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4351:2: (kw= '&&' ) + // InternalExport.g:4352:2: kw= '&&' + { + kw=(Token)match(input,53,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpAnd" + + + // $ANTLR start "entryRuleXEqualityExpression" + // InternalExport.g:4360:1: entryRuleXEqualityExpression returns [EObject current=null] : iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ; + public final EObject entryRuleXEqualityExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXEqualityExpression = null; + + + try { + // InternalExport.g:4360:60: (iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ) + // InternalExport.g:4361:2: iv_ruleXEqualityExpression= ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXEqualityExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXEqualityExpression=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXEqualityExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXEqualityExpression" + + + // $ANTLR start "ruleXEqualityExpression" + // InternalExport.g:4367:1: ruleXEqualityExpression returns [EObject current=null] : (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ; + public final EObject ruleXEqualityExpression() throws RecognitionException { + EObject current = null; + + EObject this_XRelationalExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:4373:2: ( (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ) + // InternalExport.g:4374:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) + { + // InternalExport.g:4374:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) + // InternalExport.g:4375:3: this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_69); + this_XRelationalExpression_0=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XRelationalExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:4383:3: ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* + loop72: + do { + int alt72=2; + switch ( input.LA(1) ) { + case 55: + { + int LA72_2 = input.LA(2); + + if ( (synpred6_InternalExport()) ) { + alt72=1; + } + + + } + break; + case 56: + { + int LA72_3 = input.LA(2); + + if ( (synpred6_InternalExport()) ) { + alt72=1; + } + + + } + break; + case 89: + { + int LA72_4 = input.LA(2); + + if ( (synpred6_InternalExport()) ) { + alt72=1; + } + + + } + break; + case 90: + { + int LA72_5 = input.LA(2); + + if ( (synpred6_InternalExport()) ) { + alt72=1; + } + + + } + break; + + } + + switch (alt72) { + case 1 : + // InternalExport.g:4384:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) + { + // InternalExport.g:4384:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) + // InternalExport.g:4385:5: ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) + { + // InternalExport.g:4395:5: ( () ( ( ruleOpEquality ) ) ) + // InternalExport.g:4396:6: () ( ( ruleOpEquality ) ) + { + // InternalExport.g:4396:6: () + // InternalExport.g:4397:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:4403:6: ( ( ruleOpEquality ) ) + // InternalExport.g:4404:7: ( ruleOpEquality ) + { + // InternalExport.g:4404:7: ( ruleOpEquality ) + // InternalExport.g:4405:8: ruleOpEquality + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXEqualityExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4421:4: ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) + // InternalExport.g:4422:5: (lv_rightOperand_3_0= ruleXRelationalExpression ) + { + // InternalExport.g:4422:5: (lv_rightOperand_3_0= ruleXRelationalExpression ) + // InternalExport.g:4423:6: lv_rightOperand_3_0= ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_69); + lv_rightOperand_3_0=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XRelationalExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop72; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXEqualityExpression" + + + // $ANTLR start "entryRuleOpEquality" + // InternalExport.g:4445:1: entryRuleOpEquality returns [String current=null] : iv_ruleOpEquality= ruleOpEquality EOF ; + public final String entryRuleOpEquality() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpEquality = null; + + + try { + // InternalExport.g:4445:50: (iv_ruleOpEquality= ruleOpEquality EOF ) + // InternalExport.g:4446:2: iv_ruleOpEquality= ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpEquality=ruleOpEquality(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpEquality.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpEquality" + + + // $ANTLR start "ruleOpEquality" + // InternalExport.g:4452:1: ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ; + public final AntlrDatatypeRuleToken ruleOpEquality() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4458:2: ( (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ) + // InternalExport.g:4459:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) + { + // InternalExport.g:4459:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) + int alt73=4; + switch ( input.LA(1) ) { + case 55: + { + alt73=1; + } + break; + case 56: + { + alt73=2; + } + break; + case 89: + { + alt73=3; + } + break; + case 90: + { + alt73=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 0, input); + + throw nvae; + } + + switch (alt73) { + case 1 : + // InternalExport.g:4460:3: kw= '==' + { + kw=(Token)match(input,55,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:4466:3: kw= '!=' + { + kw=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalExport.g:4472:3: kw= '===' + { + kw=(Token)match(input,89,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalExport.g:4478:3: kw= '!==' + { + kw=(Token)match(input,90,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpEquality" + + + // $ANTLR start "entryRuleXRelationalExpression" + // InternalExport.g:4487:1: entryRuleXRelationalExpression returns [EObject current=null] : iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ; + public final EObject entryRuleXRelationalExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXRelationalExpression = null; + + + try { + // InternalExport.g:4487:62: (iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ) + // InternalExport.g:4488:2: iv_ruleXRelationalExpression= ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXRelationalExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXRelationalExpression=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXRelationalExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXRelationalExpression" + + + // $ANTLR start "ruleXRelationalExpression" + // InternalExport.g:4494:1: ruleXRelationalExpression returns [EObject current=null] : (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ; + public final EObject ruleXRelationalExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject this_XOtherOperatorExpression_0 = null; + + EObject lv_type_3_0 = null; + + EObject lv_rightOperand_6_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:4500:2: ( (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ) + // InternalExport.g:4501:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) + { + // InternalExport.g:4501:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) + // InternalExport.g:4502:3: this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_70); + this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XOtherOperatorExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:4510:3: ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* + loop74: + do { + int alt74=3; + switch ( input.LA(1) ) { + case 60: + { + int LA74_2 = input.LA(2); + + if ( (synpred8_InternalExport()) ) { + alt74=2; + } + + + } + break; + case 59: + { + int LA74_3 = input.LA(2); + + if ( (synpred8_InternalExport()) ) { + alt74=2; + } + + + } + break; + case 91: + { + int LA74_4 = input.LA(2); + + if ( (synpred7_InternalExport()) ) { + alt74=1; + } + + + } + break; + case 57: + { + int LA74_5 = input.LA(2); + + if ( (synpred8_InternalExport()) ) { + alt74=2; + } + + + } + break; + + } + + switch (alt74) { + case 1 : + // InternalExport.g:4511:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) + { + // InternalExport.g:4511:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) + // InternalExport.g:4512:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) + { + // InternalExport.g:4512:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) + // InternalExport.g:4513:6: ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) + { + // InternalExport.g:4519:6: ( () otherlv_2= 'instanceof' ) + // InternalExport.g:4520:7: () otherlv_2= 'instanceof' + { + // InternalExport.g:4520:7: () + // InternalExport.g:4521:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), + current); + + } + + } + + otherlv_2=(Token)match(input,91,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + + } + + } + + + } + + // InternalExport.g:4533:5: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalExport.g:4534:6: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalExport.g:4534:6: (lv_type_3_0= ruleJvmTypeReference ) + // InternalExport.g:4535:7: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + + } + pushFollow(FOLLOW_70); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:4554:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) + { + // InternalExport.g:4554:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) + // InternalExport.g:4555:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) + { + // InternalExport.g:4555:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) + // InternalExport.g:4556:6: ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) + { + // InternalExport.g:4566:6: ( () ( ( ruleOpCompare ) ) ) + // InternalExport.g:4567:7: () ( ( ruleOpCompare ) ) + { + // InternalExport.g:4567:7: () + // InternalExport.g:4568:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:4574:7: ( ( ruleOpCompare ) ) + // InternalExport.g:4575:8: ( ruleOpCompare ) + { + // InternalExport.g:4575:8: ( ruleOpCompare ) + // InternalExport.g:4576:9: ruleOpCompare + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXRelationalExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4592:5: ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) + // InternalExport.g:4593:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) + { + // InternalExport.g:4593:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) + // InternalExport.g:4594:7: lv_rightOperand_6_0= ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + + } + pushFollow(FOLLOW_70); + lv_rightOperand_6_0=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_6_0, + "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + default : + break loop74; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXRelationalExpression" + + + // $ANTLR start "entryRuleOpCompare" + // InternalExport.g:4617:1: entryRuleOpCompare returns [String current=null] : iv_ruleOpCompare= ruleOpCompare EOF ; + public final String entryRuleOpCompare() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpCompare = null; + + + try { + // InternalExport.g:4617:49: (iv_ruleOpCompare= ruleOpCompare EOF ) + // InternalExport.g:4618:2: iv_ruleOpCompare= ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpCompare=ruleOpCompare(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpCompare.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpCompare" + + + // $ANTLR start "ruleOpCompare" + // InternalExport.g:4624:1: ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ; + public final AntlrDatatypeRuleToken ruleOpCompare() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4630:2: ( (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ) + // InternalExport.g:4631:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) + { + // InternalExport.g:4631:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) + int alt75=4; + switch ( input.LA(1) ) { + case 57: + { + alt75=1; + } + break; + case 60: + { + int LA75_2 = input.LA(2); + + if ( (LA75_2==EOF||(LA75_2>=RULE_ID && LA75_2<=RULE_INT)||(LA75_2>=RULE_HEX && LA75_2<=RULE_DECIMAL)||(LA75_2>=15 && LA75_2<=16)||LA75_2==18||LA75_2==20||LA75_2==22||LA75_2==27||LA75_2==30||LA75_2==46||LA75_2==49||(LA75_2>=60 && LA75_2<=61)||LA75_2==64||(LA75_2>=76 && LA75_2<=78)||LA75_2==80||(LA75_2>=102 && LA75_2<=104)||(LA75_2>=107 && LA75_2<=113)||LA75_2==115) ) { + alt75=4; + } + else if ( (LA75_2==24) ) { + alt75=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 75, 2, input); + + throw nvae; + } + } + break; + case 59: + { + alt75=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 75, 0, input); + + throw nvae; + } + + switch (alt75) { + case 1 : + // InternalExport.g:4632:3: kw= '>=' + { + kw=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:4638:3: (kw= '<' kw= '=' ) + { + // InternalExport.g:4638:3: (kw= '<' kw= '=' ) + // InternalExport.g:4639:4: kw= '<' kw= '=' + { + kw=(Token)match(input,60,FOLLOW_31); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + + } + kw=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + + } + + } + + + } + break; + case 3 : + // InternalExport.g:4651:3: kw= '>' + { + kw=(Token)match(input,59,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalExport.g:4657:3: kw= '<' + { + kw=(Token)match(input,60,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpCompare" + + + // $ANTLR start "entryRuleXOtherOperatorExpression" + // InternalExport.g:4666:1: entryRuleXOtherOperatorExpression returns [EObject current=null] : iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ; + public final EObject entryRuleXOtherOperatorExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXOtherOperatorExpression = null; + + + try { + // InternalExport.g:4666:65: (iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ) + // InternalExport.g:4667:2: iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXOtherOperatorExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" + + + // $ANTLR start "ruleXOtherOperatorExpression" + // InternalExport.g:4673:1: ruleXOtherOperatorExpression returns [EObject current=null] : (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ; + public final EObject ruleXOtherOperatorExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAdditiveExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:4679:2: ( (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ) + // InternalExport.g:4680:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) + { + // InternalExport.g:4680:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) + // InternalExport.g:4681:3: this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_72); + this_XAdditiveExpression_0=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAdditiveExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:4689:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* + loop76: + do { + int alt76=2; + alt76 = dfa76.predict(input); + switch (alt76) { + case 1 : + // InternalExport.g:4690:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) + { + // InternalExport.g:4690:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) + // InternalExport.g:4691:5: ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) + { + // InternalExport.g:4701:5: ( () ( ( ruleOpOther ) ) ) + // InternalExport.g:4702:6: () ( ( ruleOpOther ) ) + { + // InternalExport.g:4702:6: () + // InternalExport.g:4703:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:4709:6: ( ( ruleOpOther ) ) + // InternalExport.g:4710:7: ( ruleOpOther ) + { + // InternalExport.g:4710:7: ( ruleOpOther ) + // InternalExport.g:4711:8: ruleOpOther + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpOther(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4727:4: ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) + // InternalExport.g:4728:5: (lv_rightOperand_3_0= ruleXAdditiveExpression ) + { + // InternalExport.g:4728:5: (lv_rightOperand_3_0= ruleXAdditiveExpression ) + // InternalExport.g:4729:6: lv_rightOperand_3_0= ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_72); + lv_rightOperand_3_0=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop76; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXOtherOperatorExpression" + + + // $ANTLR start "entryRuleOpOther" + // InternalExport.g:4751:1: entryRuleOpOther returns [String current=null] : iv_ruleOpOther= ruleOpOther EOF ; + public final String entryRuleOpOther() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpOther = null; + + + try { + // InternalExport.g:4751:47: (iv_ruleOpOther= ruleOpOther EOF ) + // InternalExport.g:4752:2: iv_ruleOpOther= ruleOpOther EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpOtherRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpOther=ruleOpOther(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpOther.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpOther" + + + // $ANTLR start "ruleOpOther" + // InternalExport.g:4758:1: ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ; + public final AntlrDatatypeRuleToken ruleOpOther() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4764:2: ( (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ) + // InternalExport.g:4765:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) + { + // InternalExport.g:4765:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) + int alt79=9; + alt79 = dfa79.predict(input); + switch (alt79) { + case 1 : + // InternalExport.g:4766:3: kw= '->' + { + kw=(Token)match(input,44,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:4772:3: kw= '..<' + { + kw=(Token)match(input,92,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalExport.g:4778:3: (kw= '>' kw= '..' ) + { + // InternalExport.g:4778:3: (kw= '>' kw= '..' ) + // InternalExport.g:4779:4: kw= '>' kw= '..' + { + kw=(Token)match(input,59,FOLLOW_73); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + + } + kw=(Token)match(input,93,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + + } + + } + + + } + break; + case 4 : + // InternalExport.g:4791:3: kw= '..' + { + kw=(Token)match(input,93,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + + } + + } + break; + case 5 : + // InternalExport.g:4797:3: kw= '=>' + { + kw=(Token)match(input,94,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + + } + + } + break; + case 6 : + // InternalExport.g:4803:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) + { + // InternalExport.g:4803:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) + // InternalExport.g:4804:4: kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) + { + kw=(Token)match(input,59,FOLLOW_74); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + + } + // InternalExport.g:4809:4: ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==59) ) { + int LA77_1 = input.LA(2); + + if ( (LA77_1==EOF||(LA77_1>=RULE_ID && LA77_1<=RULE_INT)||(LA77_1>=RULE_HEX && LA77_1<=RULE_DECIMAL)||(LA77_1>=15 && LA77_1<=16)||LA77_1==18||LA77_1==20||LA77_1==22||LA77_1==27||LA77_1==30||LA77_1==46||LA77_1==49||(LA77_1>=60 && LA77_1<=61)||LA77_1==64||(LA77_1>=76 && LA77_1<=78)||LA77_1==80||(LA77_1>=102 && LA77_1<=104)||(LA77_1>=107 && LA77_1<=113)||LA77_1==115) ) { + alt77=2; + } + else if ( (LA77_1==59) && (synpred10_InternalExport())) { + alt77=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 77, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 77, 0, input); + + throw nvae; + } + switch (alt77) { + case 1 : + // InternalExport.g:4810:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) + { + // InternalExport.g:4810:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) + // InternalExport.g:4811:6: ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) + { + // InternalExport.g:4816:6: (kw= '>' kw= '>' ) + // InternalExport.g:4817:7: kw= '>' kw= '>' + { + kw=(Token)match(input,59,FOLLOW_74); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + + } + kw=(Token)match(input,59,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:4830:5: kw= '>' + { + kw=(Token)match(input,59,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + + } + + } + break; + + } + + + } + + + } + break; + case 7 : + // InternalExport.g:4838:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) + { + // InternalExport.g:4838:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) + // InternalExport.g:4839:4: kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) + { + kw=(Token)match(input,60,FOLLOW_75); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + + } + // InternalExport.g:4844:4: ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) + int alt78=3; + int LA78_0 = input.LA(1); + + if ( (LA78_0==60) ) { + int LA78_1 = input.LA(2); + + if ( (synpred11_InternalExport()) ) { + alt78=1; + } + else if ( (true) ) { + alt78=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 78, 1, input); + + throw nvae; + } + } + else if ( (LA78_0==94) ) { + alt78=3; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 78, 0, input); + + throw nvae; + } + switch (alt78) { + case 1 : + // InternalExport.g:4845:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) + { + // InternalExport.g:4845:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) + // InternalExport.g:4846:6: ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) + { + // InternalExport.g:4851:6: (kw= '<' kw= '<' ) + // InternalExport.g:4852:7: kw= '<' kw= '<' + { + kw=(Token)match(input,60,FOLLOW_66); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + + } + kw=(Token)match(input,60,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:4865:5: kw= '<' + { + kw=(Token)match(input,60,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + + } + + } + break; + case 3 : + // InternalExport.g:4871:5: kw= '=>' + { + kw=(Token)match(input,94,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + + } + + } + break; + + } + + + } + + + } + break; + case 8 : + // InternalExport.g:4879:3: kw= '<>' + { + kw=(Token)match(input,95,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + + } + + } + break; + case 9 : + // InternalExport.g:4885:3: kw= '?:' + { + kw=(Token)match(input,96,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpOther" + + + // $ANTLR start "entryRuleXAdditiveExpression" + // InternalExport.g:4894:1: entryRuleXAdditiveExpression returns [EObject current=null] : iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ; + public final EObject entryRuleXAdditiveExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAdditiveExpression = null; + + + try { + // InternalExport.g:4894:60: (iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ) + // InternalExport.g:4895:2: iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAdditiveExpression=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAdditiveExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAdditiveExpression" + + + // $ANTLR start "ruleXAdditiveExpression" + // InternalExport.g:4901:1: ruleXAdditiveExpression returns [EObject current=null] : (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ; + public final EObject ruleXAdditiveExpression() throws RecognitionException { + EObject current = null; + + EObject this_XMultiplicativeExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:4907:2: ( (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ) + // InternalExport.g:4908:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) + { + // InternalExport.g:4908:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) + // InternalExport.g:4909:3: this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_53); + this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XMultiplicativeExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:4917:3: ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* + loop80: + do { + int alt80=2; + int LA80_0 = input.LA(1); + + if ( (LA80_0==27) ) { + int LA80_2 = input.LA(2); + + if ( (synpred12_InternalExport()) ) { + alt80=1; + } + + + } + else if ( (LA80_0==61) ) { + int LA80_3 = input.LA(2); + + if ( (synpred12_InternalExport()) ) { + alt80=1; + } + + + } + + + switch (alt80) { + case 1 : + // InternalExport.g:4918:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) + { + // InternalExport.g:4918:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) + // InternalExport.g:4919:5: ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) + { + // InternalExport.g:4929:5: ( () ( ( ruleOpAdd ) ) ) + // InternalExport.g:4930:6: () ( ( ruleOpAdd ) ) + { + // InternalExport.g:4930:6: () + // InternalExport.g:4931:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:4937:6: ( ( ruleOpAdd ) ) + // InternalExport.g:4938:7: ( ruleOpAdd ) + { + // InternalExport.g:4938:7: ( ruleOpAdd ) + // InternalExport.g:4939:8: ruleOpAdd + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAdditiveExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:4955:4: ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) + // InternalExport.g:4956:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) + { + // InternalExport.g:4956:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) + // InternalExport.g:4957:6: lv_rightOperand_3_0= ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_53); + lv_rightOperand_3_0=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop80; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAdditiveExpression" + + + // $ANTLR start "entryRuleOpAdd" + // InternalExport.g:4979:1: entryRuleOpAdd returns [String current=null] : iv_ruleOpAdd= ruleOpAdd EOF ; + public final String entryRuleOpAdd() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpAdd = null; + + + try { + // InternalExport.g:4979:45: (iv_ruleOpAdd= ruleOpAdd EOF ) + // InternalExport.g:4980:2: iv_ruleOpAdd= ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpAdd=ruleOpAdd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpAdd.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpAdd" + + + // $ANTLR start "ruleOpAdd" + // InternalExport.g:4986:1: ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+' | kw= '-' ) ; + public final AntlrDatatypeRuleToken ruleOpAdd() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:4992:2: ( (kw= '+' | kw= '-' ) ) + // InternalExport.g:4993:2: (kw= '+' | kw= '-' ) + { + // InternalExport.g:4993:2: (kw= '+' | kw= '-' ) + int alt81=2; + int LA81_0 = input.LA(1); + + if ( (LA81_0==27) ) { + alt81=1; + } + else if ( (LA81_0==61) ) { + alt81=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 81, 0, input); + + throw nvae; + } + switch (alt81) { + case 1 : + // InternalExport.g:4994:3: kw= '+' + { + kw=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:5000:3: kw= '-' + { + kw=(Token)match(input,61,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpAdd" + + + // $ANTLR start "entryRuleXMultiplicativeExpression" + // InternalExport.g:5009:1: entryRuleXMultiplicativeExpression returns [EObject current=null] : iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ; + public final EObject entryRuleXMultiplicativeExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXMultiplicativeExpression = null; + + + try { + // InternalExport.g:5009:66: (iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ) + // InternalExport.g:5010:2: iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXMultiplicativeExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // InternalExport.g:5016:1: ruleXMultiplicativeExpression returns [EObject current=null] : (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ; + public final EObject ruleXMultiplicativeExpression() throws RecognitionException { + EObject current = null; + + EObject this_XUnaryOperation_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:5022:2: ( (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ) + // InternalExport.g:5023:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) + { + // InternalExport.g:5023:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) + // InternalExport.g:5024:3: this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + + } + pushFollow(FOLLOW_76); + this_XUnaryOperation_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XUnaryOperation_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:5032:3: ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* + loop82: + do { + int alt82=2; + switch ( input.LA(1) ) { + case 62: + { + int LA82_2 = input.LA(2); + + if ( (synpred13_InternalExport()) ) { + alt82=1; + } + + + } + break; + case 97: + { + int LA82_3 = input.LA(2); + + if ( (synpred13_InternalExport()) ) { + alt82=1; + } + + + } + break; + case 63: + { + int LA82_4 = input.LA(2); + + if ( (synpred13_InternalExport()) ) { + alt82=1; + } + + + } + break; + case 98: + { + int LA82_5 = input.LA(2); + + if ( (synpred13_InternalExport()) ) { + alt82=1; + } + + + } + break; + + } + + switch (alt82) { + case 1 : + // InternalExport.g:5033:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) + { + // InternalExport.g:5033:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) + // InternalExport.g:5034:5: ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) + { + // InternalExport.g:5044:5: ( () ( ( ruleOpMulti ) ) ) + // InternalExport.g:5045:6: () ( ( ruleOpMulti ) ) + { + // InternalExport.g:5045:6: () + // InternalExport.g:5046:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:5052:6: ( ( ruleOpMulti ) ) + // InternalExport.g:5053:7: ( ruleOpMulti ) + { + // InternalExport.g:5053:7: ( ruleOpMulti ) + // InternalExport.g:5054:8: ruleOpMulti + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:5070:4: ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) + // InternalExport.g:5071:5: (lv_rightOperand_3_0= ruleXUnaryOperation ) + { + // InternalExport.g:5071:5: (lv_rightOperand_3_0= ruleXUnaryOperation ) + // InternalExport.g:5072:6: lv_rightOperand_3_0= ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_76); + lv_rightOperand_3_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop82; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXMultiplicativeExpression" + + + // $ANTLR start "entryRuleOpMulti" + // InternalExport.g:5094:1: entryRuleOpMulti returns [String current=null] : iv_ruleOpMulti= ruleOpMulti EOF ; + public final String entryRuleOpMulti() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpMulti = null; + + + try { + // InternalExport.g:5094:47: (iv_ruleOpMulti= ruleOpMulti EOF ) + // InternalExport.g:5095:2: iv_ruleOpMulti= ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpMulti=ruleOpMulti(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpMulti.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpMulti" + + + // $ANTLR start "ruleOpMulti" + // InternalExport.g:5101:1: ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ; + public final AntlrDatatypeRuleToken ruleOpMulti() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:5107:2: ( (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ) + // InternalExport.g:5108:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) + { + // InternalExport.g:5108:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) + int alt83=4; + switch ( input.LA(1) ) { + case 62: + { + alt83=1; + } + break; + case 97: + { + alt83=2; + } + break; + case 63: + { + alt83=3; + } + break; + case 98: + { + alt83=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 83, 0, input); + + throw nvae; + } + + switch (alt83) { + case 1 : + // InternalExport.g:5109:3: kw= '*' + { + kw=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:5115:3: kw= '**' + { + kw=(Token)match(input,97,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + + } + + } + break; + case 3 : + // InternalExport.g:5121:3: kw= '/' + { + kw=(Token)match(input,63,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + + } + + } + break; + case 4 : + // InternalExport.g:5127:3: kw= '%' + { + kw=(Token)match(input,98,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpMulti" + + + // $ANTLR start "entryRuleXUnaryOperation" + // InternalExport.g:5136:1: entryRuleXUnaryOperation returns [EObject current=null] : iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ; + public final EObject entryRuleXUnaryOperation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXUnaryOperation = null; + + + try { + // InternalExport.g:5136:56: (iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ) + // InternalExport.g:5137:2: iv_ruleXUnaryOperation= ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXUnaryOperation=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXUnaryOperation; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXUnaryOperation" + + + // $ANTLR start "ruleXUnaryOperation" + // InternalExport.g:5143:1: ruleXUnaryOperation returns [EObject current=null] : ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ; + public final EObject ruleXUnaryOperation() throws RecognitionException { + EObject current = null; + + EObject lv_operand_2_0 = null; + + EObject this_XCastedExpression_3 = null; + + + + enterRule(); + + try { + // InternalExport.g:5149:2: ( ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ) + // InternalExport.g:5150:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) + { + // InternalExport.g:5150:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) + int alt84=2; + int LA84_0 = input.LA(1); + + if ( (LA84_0==27||LA84_0==61||LA84_0==64) ) { + alt84=1; + } + else if ( ((LA84_0>=RULE_ID && LA84_0<=RULE_INT)||(LA84_0>=RULE_HEX && LA84_0<=RULE_DECIMAL)||(LA84_0>=15 && LA84_0<=16)||LA84_0==18||LA84_0==20||LA84_0==22||LA84_0==30||LA84_0==46||LA84_0==49||LA84_0==60||(LA84_0>=76 && LA84_0<=78)||LA84_0==80||(LA84_0>=102 && LA84_0<=104)||(LA84_0>=107 && LA84_0<=113)||LA84_0==115) ) { + alt84=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 84, 0, input); + + throw nvae; + } + switch (alt84) { + case 1 : + // InternalExport.g:5151:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) + { + // InternalExport.g:5151:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) + // InternalExport.g:5152:4: () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) + { + // InternalExport.g:5152:4: () + // InternalExport.g:5153:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(), + current); + + } + + } + + // InternalExport.g:5159:4: ( ( ruleOpUnary ) ) + // InternalExport.g:5160:5: ( ruleOpUnary ) + { + // InternalExport.g:5160:5: ( ruleOpUnary ) + // InternalExport.g:5161:6: ruleOpUnary + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXUnaryOperationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + + } + pushFollow(FOLLOW_64); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:5175:4: ( (lv_operand_2_0= ruleXUnaryOperation ) ) + // InternalExport.g:5176:5: (lv_operand_2_0= ruleXUnaryOperation ) + { + // InternalExport.g:5176:5: (lv_operand_2_0= ruleXUnaryOperation ) + // InternalExport.g:5177:6: lv_operand_2_0= ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + + } + pushFollow(FOLLOW_2); + lv_operand_2_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXUnaryOperationRule()); + } + set( + current, + "operand", + lv_operand_2_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:5196:3: this_XCastedExpression_3= ruleXCastedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XCastedExpression_3=ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XCastedExpression_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXUnaryOperation" + + + // $ANTLR start "entryRuleOpUnary" + // InternalExport.g:5208:1: entryRuleOpUnary returns [String current=null] : iv_ruleOpUnary= ruleOpUnary EOF ; + public final String entryRuleOpUnary() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpUnary = null; + + + try { + // InternalExport.g:5208:47: (iv_ruleOpUnary= ruleOpUnary EOF ) + // InternalExport.g:5209:2: iv_ruleOpUnary= ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpUnary=ruleOpUnary(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpUnary.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpUnary" + + + // $ANTLR start "ruleOpUnary" + // InternalExport.g:5215:1: ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '!' | kw= '-' | kw= '+' ) ; + public final AntlrDatatypeRuleToken ruleOpUnary() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:5221:2: ( (kw= '!' | kw= '-' | kw= '+' ) ) + // InternalExport.g:5222:2: (kw= '!' | kw= '-' | kw= '+' ) + { + // InternalExport.g:5222:2: (kw= '!' | kw= '-' | kw= '+' ) + int alt85=3; + switch ( input.LA(1) ) { + case 64: + { + alt85=1; + } + break; + case 61: + { + alt85=2; + } + break; + case 27: + { + alt85=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 85, 0, input); + + throw nvae; + } + + switch (alt85) { + case 1 : + // InternalExport.g:5223:3: kw= '!' + { + kw=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:5229:3: kw= '-' + { + kw=(Token)match(input,61,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + case 3 : + // InternalExport.g:5235:3: kw= '+' + { + kw=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpUnary" + + + // $ANTLR start "entryRuleXCastedExpression" + // InternalExport.g:5244:1: entryRuleXCastedExpression returns [EObject current=null] : iv_ruleXCastedExpression= ruleXCastedExpression EOF ; + public final EObject entryRuleXCastedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCastedExpression = null; + + + try { + // InternalExport.g:5244:58: (iv_ruleXCastedExpression= ruleXCastedExpression EOF ) + // InternalExport.g:5245:2: iv_ruleXCastedExpression= ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCastedExpression=ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCastedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCastedExpression" + + + // $ANTLR start "ruleXCastedExpression" + // InternalExport.g:5251:1: ruleXCastedExpression returns [EObject current=null] : (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ; + public final EObject ruleXCastedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject this_XPostfixOperation_0 = null; + + EObject lv_type_3_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:5257:2: ( (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ) + // InternalExport.g:5258:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) + { + // InternalExport.g:5258:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) + // InternalExport.g:5259:3: this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + + } + pushFollow(FOLLOW_13); + this_XPostfixOperation_0=ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XPostfixOperation_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:5267:3: ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* + loop86: + do { + int alt86=2; + int LA86_0 = input.LA(1); + + if ( (LA86_0==21) ) { + int LA86_2 = input.LA(2); + + if ( (synpred14_InternalExport()) ) { + alt86=1; + } + + + } + + + switch (alt86) { + case 1 : + // InternalExport.g:5268:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) + { + // InternalExport.g:5268:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) + // InternalExport.g:5269:5: ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) + { + // InternalExport.g:5275:5: ( () otherlv_2= 'as' ) + // InternalExport.g:5276:6: () otherlv_2= 'as' + { + // InternalExport.g:5276:6: () + // InternalExport.g:5277:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(), + current); + + } + + } + + otherlv_2=(Token)match(input,21,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + + } + + } + + + } + + // InternalExport.g:5289:4: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalExport.g:5290:5: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalExport.g:5290:5: (lv_type_3_0= ruleJvmTypeReference ) + // InternalExport.g:5291:6: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_13); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCastedExpressionRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop86; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCastedExpression" + + + // $ANTLR start "entryRuleXPostfixOperation" + // InternalExport.g:5313:1: entryRuleXPostfixOperation returns [EObject current=null] : iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ; + public final EObject entryRuleXPostfixOperation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXPostfixOperation = null; + + + try { + // InternalExport.g:5313:58: (iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ) + // InternalExport.g:5314:2: iv_ruleXPostfixOperation= ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXPostfixOperationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXPostfixOperation=ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXPostfixOperation; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXPostfixOperation" + + + // $ANTLR start "ruleXPostfixOperation" + // InternalExport.g:5320:1: ruleXPostfixOperation returns [EObject current=null] : (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ; + public final EObject ruleXPostfixOperation() throws RecognitionException { + EObject current = null; + + EObject this_XMemberFeatureCall_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:5326:2: ( (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ) + // InternalExport.g:5327:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) + { + // InternalExport.g:5327:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) + // InternalExport.g:5328:3: this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + + } + pushFollow(FOLLOW_77); + this_XMemberFeatureCall_0=ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XMemberFeatureCall_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:5336:3: ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==99) ) { + int LA87_1 = input.LA(2); + + if ( (synpred15_InternalExport()) ) { + alt87=1; + } + } + else if ( (LA87_0==100) ) { + int LA87_2 = input.LA(2); + + if ( (synpred15_InternalExport()) ) { + alt87=1; + } + } + switch (alt87) { + case 1 : + // InternalExport.g:5337:4: ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) + { + // InternalExport.g:5347:4: ( () ( ( ruleOpPostfix ) ) ) + // InternalExport.g:5348:5: () ( ( ruleOpPostfix ) ) + { + // InternalExport.g:5348:5: () + // InternalExport.g:5349:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(), + current); + + } + + } + + // InternalExport.g:5355:5: ( ( ruleOpPostfix ) ) + // InternalExport.g:5356:6: ( ruleOpPostfix ) + { + // InternalExport.g:5356:6: ( ruleOpPostfix ) + // InternalExport.g:5357:7: ruleOpPostfix + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXPostfixOperationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + + } + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXPostfixOperation" + + + // $ANTLR start "entryRuleOpPostfix" + // InternalExport.g:5377:1: entryRuleOpPostfix returns [String current=null] : iv_ruleOpPostfix= ruleOpPostfix EOF ; + public final String entryRuleOpPostfix() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpPostfix = null; + + + try { + // InternalExport.g:5377:49: (iv_ruleOpPostfix= ruleOpPostfix EOF ) + // InternalExport.g:5378:2: iv_ruleOpPostfix= ruleOpPostfix EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpPostfix=ruleOpPostfix(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpPostfix.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpPostfix" + + + // $ANTLR start "ruleOpPostfix" + // InternalExport.g:5384:1: ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '++' | kw= '--' ) ; + public final AntlrDatatypeRuleToken ruleOpPostfix() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:5390:2: ( (kw= '++' | kw= '--' ) ) + // InternalExport.g:5391:2: (kw= '++' | kw= '--' ) + { + // InternalExport.g:5391:2: (kw= '++' | kw= '--' ) + int alt88=2; + int LA88_0 = input.LA(1); + + if ( (LA88_0==99) ) { + alt88=1; + } + else if ( (LA88_0==100) ) { + alt88=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 88, 0, input); + + throw nvae; + } + switch (alt88) { + case 1 : + // InternalExport.g:5392:3: kw= '++' + { + kw=(Token)match(input,99,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExport.g:5398:3: kw= '--' + { + kw=(Token)match(input,100,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpPostfix" + + + // $ANTLR start "entryRuleXMemberFeatureCall" + // InternalExport.g:5407:1: entryRuleXMemberFeatureCall returns [EObject current=null] : iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ; + public final EObject entryRuleXMemberFeatureCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXMemberFeatureCall = null; + + + try { + // InternalExport.g:5407:59: (iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ) + // InternalExport.g:5408:2: iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXMemberFeatureCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXMemberFeatureCall" + + + // $ANTLR start "ruleXMemberFeatureCall" + // InternalExport.g:5414:1: ruleXMemberFeatureCall returns [EObject current=null] : (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ; + public final EObject ruleXMemberFeatureCall() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_explicitStatic_3_0=null; + Token otherlv_8=null; + Token lv_nullSafe_9_0=null; + Token lv_explicitStatic_10_0=null; + Token otherlv_11=null; + Token otherlv_13=null; + Token otherlv_15=null; + Token lv_explicitOperationCall_17_0=null; + Token otherlv_20=null; + Token otherlv_22=null; + EObject this_XPrimaryExpression_0 = null; + + EObject lv_value_6_0 = null; + + EObject lv_typeArguments_12_0 = null; + + EObject lv_typeArguments_14_0 = null; + + EObject lv_memberCallArguments_18_0 = null; + + EObject lv_memberCallArguments_19_0 = null; + + EObject lv_memberCallArguments_21_0 = null; + + EObject lv_memberCallArguments_23_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:5420:2: ( (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ) + // InternalExport.g:5421:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) + { + // InternalExport.g:5421:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) + // InternalExport.g:5422:3: this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_78); + this_XPrimaryExpression_0=ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XPrimaryExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:5430:3: ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* + loop97: + do { + int alt97=3; + switch ( input.LA(1) ) { + case 65: + { + int LA97_2 = input.LA(2); + + if ( (synpred16_InternalExport()) ) { + alt97=1; + } + else if ( (synpred17_InternalExport()) ) { + alt97=2; + } + + + } + break; + case 41: + { + int LA97_3 = input.LA(2); + + if ( (synpred16_InternalExport()) ) { + alt97=1; + } + else if ( (synpred17_InternalExport()) ) { + alt97=2; + } + + + } + break; + case 101: + { + int LA97_4 = input.LA(2); + + if ( (synpred17_InternalExport()) ) { + alt97=2; + } + + + } + break; + + } + + switch (alt97) { + case 1 : + // InternalExport.g:5431:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) + { + // InternalExport.g:5431:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) + // InternalExport.g:5432:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) + { + // InternalExport.g:5432:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) + // InternalExport.g:5433:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + { + // InternalExport.g:5453:6: ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + // InternalExport.g:5454:7: () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign + { + // InternalExport.g:5454:7: () + // InternalExport.g:5455:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(), + current); + + } + + } + + // InternalExport.g:5461:7: (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) + int alt89=2; + int LA89_0 = input.LA(1); + + if ( (LA89_0==65) ) { + alt89=1; + } + else if ( (LA89_0==41) ) { + alt89=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 89, 0, input); + + throw nvae; + } + switch (alt89) { + case 1 : + // InternalExport.g:5462:8: otherlv_2= '.' + { + otherlv_2=(Token)match(input,65,FOLLOW_79); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + + } + + } + break; + case 2 : + // InternalExport.g:5467:8: ( (lv_explicitStatic_3_0= '::' ) ) + { + // InternalExport.g:5467:8: ( (lv_explicitStatic_3_0= '::' ) ) + // InternalExport.g:5468:9: (lv_explicitStatic_3_0= '::' ) + { + // InternalExport.g:5468:9: (lv_explicitStatic_3_0= '::' ) + // InternalExport.g:5469:10: lv_explicitStatic_3_0= '::' + { + lv_explicitStatic_3_0=(Token)match(input,41,FOLLOW_79); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitStatic", lv_explicitStatic_3_0 != null, "::"); + + } + + } + + + } + + + } + break; + + } + + // InternalExport.g:5482:7: ( ( ruleFeatureCallID ) ) + // InternalExport.g:5483:8: ( ruleFeatureCallID ) + { + // InternalExport.g:5483:8: ( ruleFeatureCallID ) + // InternalExport.g:5484:9: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + + } + pushFollow(FOLLOW_31); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + + } + pushFollow(FOLLOW_64); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:5507:5: ( (lv_value_6_0= ruleXAssignment ) ) + // InternalExport.g:5508:6: (lv_value_6_0= ruleXAssignment ) + { + // InternalExport.g:5508:6: (lv_value_6_0= ruleXAssignment ) + // InternalExport.g:5509:7: lv_value_6_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + + } + pushFollow(FOLLOW_78); + lv_value_6_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + set( + current, + "value", + lv_value_6_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:5528:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) + { + // InternalExport.g:5528:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) + // InternalExport.g:5529:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? + { + // InternalExport.g:5529:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) + // InternalExport.g:5530:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) + { + // InternalExport.g:5550:6: ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) + // InternalExport.g:5551:7: () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) + { + // InternalExport.g:5551:7: () + // InternalExport.g:5552:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), + current); + + } + + } + + // InternalExport.g:5558:7: (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) + int alt90=3; + switch ( input.LA(1) ) { + case 65: + { + alt90=1; + } + break; + case 101: + { + alt90=2; + } + break; + case 41: + { + alt90=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 90, 0, input); + + throw nvae; + } + + switch (alt90) { + case 1 : + // InternalExport.g:5559:8: otherlv_8= '.' + { + otherlv_8=(Token)match(input,65,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + + } + + } + break; + case 2 : + // InternalExport.g:5564:8: ( (lv_nullSafe_9_0= '?.' ) ) + { + // InternalExport.g:5564:8: ( (lv_nullSafe_9_0= '?.' ) ) + // InternalExport.g:5565:9: (lv_nullSafe_9_0= '?.' ) + { + // InternalExport.g:5565:9: (lv_nullSafe_9_0= '?.' ) + // InternalExport.g:5566:10: lv_nullSafe_9_0= '?.' + { + lv_nullSafe_9_0=(Token)match(input,101,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "nullSafe", lv_nullSafe_9_0 != null, "?."); + + } + + } + + + } + + + } + break; + case 3 : + // InternalExport.g:5579:8: ( (lv_explicitStatic_10_0= '::' ) ) + { + // InternalExport.g:5579:8: ( (lv_explicitStatic_10_0= '::' ) ) + // InternalExport.g:5580:9: (lv_explicitStatic_10_0= '::' ) + { + // InternalExport.g:5580:9: (lv_explicitStatic_10_0= '::' ) + // InternalExport.g:5581:10: lv_explicitStatic_10_0= '::' + { + lv_explicitStatic_10_0=(Token)match(input,41,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitStatic", lv_explicitStatic_10_0 != null, "::"); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + // InternalExport.g:5596:5: (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? + int alt92=2; + int LA92_0 = input.LA(1); + + if ( (LA92_0==60) ) { + alt92=1; + } + switch (alt92) { + case 1 : + // InternalExport.g:5597:6: otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' + { + otherlv_11=(Token)match(input,60,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + + } + // InternalExport.g:5601:6: ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:5602:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:5602:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:5603:8: lv_typeArguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + + } + pushFollow(FOLLOW_82); + lv_typeArguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:5620:6: (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* + loop91: + do { + int alt91=2; + int LA91_0 = input.LA(1); + + if ( (LA91_0==25) ) { + alt91=1; + } + + + switch (alt91) { + case 1 : + // InternalExport.g:5621:7: otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_13=(Token)match(input,25,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + + } + // InternalExport.g:5625:7: ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:5626:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:5626:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:5627:9: lv_typeArguments_14_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + + } + pushFollow(FOLLOW_82); + lv_typeArguments_14_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_14_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop91; + } + } while (true); + + otherlv_15=(Token)match(input,59,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + + } + + } + break; + + } + + // InternalExport.g:5650:5: ( ( ruleIdOrSuper ) ) + // InternalExport.g:5651:6: ( ruleIdOrSuper ) + { + // InternalExport.g:5651:6: ( ruleIdOrSuper ) + // InternalExport.g:5652:7: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + + } + pushFollow(FOLLOW_83); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:5666:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? + int alt95=2; + alt95 = dfa95.predict(input); + switch (alt95) { + case 1 : + // InternalExport.g:5667:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' + { + // InternalExport.g:5667:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) + // InternalExport.g:5668:7: ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) + { + // InternalExport.g:5672:7: (lv_explicitOperationCall_17_0= '(' ) + // InternalExport.g:5673:8: lv_explicitOperationCall_17_0= '(' + { + lv_explicitOperationCall_17_0=(Token)match(input,30,FOLLOW_84); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitOperationCall", lv_explicitOperationCall_17_0 != null, "("); + + } + + } + + + } + + // InternalExport.g:5685:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? + int alt94=3; + alt94 = dfa94.predict(input); + switch (alt94) { + case 1 : + // InternalExport.g:5686:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) + { + // InternalExport.g:5686:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) + // InternalExport.g:5687:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) + { + // InternalExport.g:5712:8: (lv_memberCallArguments_18_0= ruleXShortClosure ) + // InternalExport.g:5713:9: lv_memberCallArguments_18_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + + } + pushFollow(FOLLOW_24); + lv_memberCallArguments_18_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_18_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:5731:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) + { + // InternalExport.g:5731:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) + // InternalExport.g:5732:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* + { + // InternalExport.g:5732:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) + // InternalExport.g:5733:9: (lv_memberCallArguments_19_0= ruleXExpression ) + { + // InternalExport.g:5733:9: (lv_memberCallArguments_19_0= ruleXExpression ) + // InternalExport.g:5734:10: lv_memberCallArguments_19_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + + } + pushFollow(FOLLOW_57); + lv_memberCallArguments_19_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_19_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:5751:8: (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* + loop93: + do { + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==25) ) { + alt93=1; + } + + + switch (alt93) { + case 1 : + // InternalExport.g:5752:9: otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) + { + otherlv_20=(Token)match(input,25,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + + } + // InternalExport.g:5756:9: ( (lv_memberCallArguments_21_0= ruleXExpression ) ) + // InternalExport.g:5757:10: (lv_memberCallArguments_21_0= ruleXExpression ) + { + // InternalExport.g:5757:10: (lv_memberCallArguments_21_0= ruleXExpression ) + // InternalExport.g:5758:11: lv_memberCallArguments_21_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + + } + pushFollow(FOLLOW_57); + lv_memberCallArguments_21_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_21_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop93; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_22=(Token)match(input,31,FOLLOW_85); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + + } + + } + break; + + } + + // InternalExport.g:5783:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? + int alt96=2; + alt96 = dfa96.predict(input); + switch (alt96) { + case 1 : + // InternalExport.g:5784:6: ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) + { + // InternalExport.g:5790:6: (lv_memberCallArguments_23_0= ruleXClosure ) + // InternalExport.g:5791:7: lv_memberCallArguments_23_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + + } + pushFollow(FOLLOW_78); + lv_memberCallArguments_23_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_23_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + break; + + default : + break loop97; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXMemberFeatureCall" + + + // $ANTLR start "entryRuleXPrimaryExpression" + // InternalExport.g:5814:1: entryRuleXPrimaryExpression returns [EObject current=null] : iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ; + public final EObject entryRuleXPrimaryExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXPrimaryExpression = null; + + + try { + // InternalExport.g:5814:59: (iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ) + // InternalExport.g:5815:2: iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXPrimaryExpression=ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXPrimaryExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXPrimaryExpression" + + + // $ANTLR start "ruleXPrimaryExpression" + // InternalExport.g:5821:1: ruleXPrimaryExpression returns [EObject current=null] : (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ; + public final EObject ruleXPrimaryExpression() throws RecognitionException { + EObject current = null; + + EObject this_XConstructorCall_0 = null; + + EObject this_XBlockExpression_1 = null; + + EObject this_XSwitchExpression_2 = null; + + EObject this_XSynchronizedExpression_3 = null; + + EObject this_XFeatureCall_4 = null; + + EObject this_XLiteral_5 = null; + + EObject this_XIfExpression_6 = null; + + EObject this_XForLoopExpression_7 = null; + + EObject this_XBasicForLoopExpression_8 = null; + + EObject this_XWhileExpression_9 = null; + + EObject this_XDoWhileExpression_10 = null; + + EObject this_XThrowExpression_11 = null; + + EObject this_XReturnExpression_12 = null; + + EObject this_XTryCatchFinallyExpression_13 = null; + + EObject this_XParenthesizedExpression_14 = null; + + + + enterRule(); + + try { + // InternalExport.g:5827:2: ( (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ) + // InternalExport.g:5828:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) + { + // InternalExport.g:5828:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) + int alt98=15; + alt98 = dfa98.predict(input); + switch (alt98) { + case 1 : + // InternalExport.g:5829:3: this_XConstructorCall_0= ruleXConstructorCall + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XConstructorCall_0=ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XConstructorCall_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:5838:3: this_XBlockExpression_1= ruleXBlockExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XBlockExpression_1=ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBlockExpression_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 3 : + // InternalExport.g:5847:3: this_XSwitchExpression_2= ruleXSwitchExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + + } + pushFollow(FOLLOW_2); + this_XSwitchExpression_2=ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSwitchExpression_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 4 : + // InternalExport.g:5856:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) + { + // InternalExport.g:5856:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) + // InternalExport.g:5857:4: ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + + } + pushFollow(FOLLOW_2); + this_XSynchronizedExpression_3=ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSynchronizedExpression_3; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 5 : + // InternalExport.g:5874:3: this_XFeatureCall_4= ruleXFeatureCall + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + + } + pushFollow(FOLLOW_2); + this_XFeatureCall_4=ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFeatureCall_4; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 6 : + // InternalExport.g:5883:3: this_XLiteral_5= ruleXLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + + } + pushFollow(FOLLOW_2); + this_XLiteral_5=ruleXLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XLiteral_5; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 7 : + // InternalExport.g:5892:3: this_XIfExpression_6= ruleXIfExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + + } + pushFollow(FOLLOW_2); + this_XIfExpression_6=ruleXIfExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XIfExpression_6; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 8 : + // InternalExport.g:5901:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) + { + // InternalExport.g:5901:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) + // InternalExport.g:5902:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + + } + pushFollow(FOLLOW_2); + this_XForLoopExpression_7=ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XForLoopExpression_7; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 9 : + // InternalExport.g:5925:3: this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + + } + pushFollow(FOLLOW_2); + this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBasicForLoopExpression_8; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 10 : + // InternalExport.g:5934:3: this_XWhileExpression_9= ruleXWhileExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + + } + pushFollow(FOLLOW_2); + this_XWhileExpression_9=ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XWhileExpression_9; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 11 : + // InternalExport.g:5943:3: this_XDoWhileExpression_10= ruleXDoWhileExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + + } + pushFollow(FOLLOW_2); + this_XDoWhileExpression_10=ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XDoWhileExpression_10; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 12 : + // InternalExport.g:5952:3: this_XThrowExpression_11= ruleXThrowExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + + } + pushFollow(FOLLOW_2); + this_XThrowExpression_11=ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XThrowExpression_11; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 13 : + // InternalExport.g:5961:3: this_XReturnExpression_12= ruleXReturnExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + + } + pushFollow(FOLLOW_2); + this_XReturnExpression_12=ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XReturnExpression_12; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 14 : + // InternalExport.g:5970:3: this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + + } + pushFollow(FOLLOW_2); + this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XTryCatchFinallyExpression_13; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 15 : + // InternalExport.g:5979:3: this_XParenthesizedExpression_14= ruleXParenthesizedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + + } + pushFollow(FOLLOW_2); + this_XParenthesizedExpression_14=ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XParenthesizedExpression_14; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXPrimaryExpression" + + + // $ANTLR start "entryRuleXLiteral" + // InternalExport.g:5991:1: entryRuleXLiteral returns [EObject current=null] : iv_ruleXLiteral= ruleXLiteral EOF ; + public final EObject entryRuleXLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXLiteral = null; + + + try { + // InternalExport.g:5991:49: (iv_ruleXLiteral= ruleXLiteral EOF ) + // InternalExport.g:5992:2: iv_ruleXLiteral= ruleXLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXLiteral=ruleXLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXLiteral" + + + // $ANTLR start "ruleXLiteral" + // InternalExport.g:5998:1: ruleXLiteral returns [EObject current=null] : (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ; + public final EObject ruleXLiteral() throws RecognitionException { + EObject current = null; + + EObject this_XCollectionLiteral_0 = null; + + EObject this_XClosure_1 = null; + + EObject this_XBooleanLiteral_2 = null; + + EObject this_XNumberLiteral_3 = null; + + EObject this_XNullLiteral_4 = null; + + EObject this_XStringLiteral_5 = null; + + EObject this_XTypeLiteral_6 = null; + + + + enterRule(); + + try { + // InternalExport.g:6004:2: ( (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ) + // InternalExport.g:6005:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) + { + // InternalExport.g:6005:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) + int alt99=7; + int LA99_0 = input.LA(1); + + if ( (LA99_0==102) ) { + alt99=1; + } + else if ( (LA99_0==22) && (synpred23_InternalExport())) { + alt99=2; + } + else if ( ((LA99_0>=76 && LA99_0<=77)) ) { + alt99=3; + } + else if ( (LA99_0==RULE_INT||(LA99_0>=RULE_HEX && LA99_0<=RULE_DECIMAL)) ) { + alt99=4; + } + else if ( (LA99_0==78) ) { + alt99=5; + } + else if ( (LA99_0==RULE_STRING) ) { + alt99=6; + } + else if ( (LA99_0==110) ) { + alt99=7; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 99, 0, input); + + throw nvae; + } + switch (alt99) { + case 1 : + // InternalExport.g:6006:3: this_XCollectionLiteral_0= ruleXCollectionLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XCollectionLiteral_0=ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XCollectionLiteral_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:6015:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) + { + // InternalExport.g:6015:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) + // InternalExport.g:6016:4: ( ( () '[' ) )=>this_XClosure_1= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XClosure_1=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XClosure_1; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 3 : + // InternalExport.g:6032:3: this_XBooleanLiteral_2= ruleXBooleanLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + + } + pushFollow(FOLLOW_2); + this_XBooleanLiteral_2=ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBooleanLiteral_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 4 : + // InternalExport.g:6041:3: this_XNumberLiteral_3= ruleXNumberLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + + } + pushFollow(FOLLOW_2); + this_XNumberLiteral_3=ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XNumberLiteral_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 5 : + // InternalExport.g:6050:3: this_XNullLiteral_4= ruleXNullLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + + } + pushFollow(FOLLOW_2); + this_XNullLiteral_4=ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XNullLiteral_4; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 6 : + // InternalExport.g:6059:3: this_XStringLiteral_5= ruleXStringLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + + } + pushFollow(FOLLOW_2); + this_XStringLiteral_5=ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XStringLiteral_5; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 7 : + // InternalExport.g:6068:3: this_XTypeLiteral_6= ruleXTypeLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + + } + pushFollow(FOLLOW_2); + this_XTypeLiteral_6=ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XTypeLiteral_6; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXLiteral" + + + // $ANTLR start "entryRuleXCollectionLiteral" + // InternalExport.g:6080:1: entryRuleXCollectionLiteral returns [EObject current=null] : iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ; + public final EObject entryRuleXCollectionLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCollectionLiteral = null; + + + try { + // InternalExport.g:6080:59: (iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ) + // InternalExport.g:6081:2: iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCollectionLiteral=ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCollectionLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCollectionLiteral" + + + // $ANTLR start "ruleXCollectionLiteral" + // InternalExport.g:6087:1: ruleXCollectionLiteral returns [EObject current=null] : (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ; + public final EObject ruleXCollectionLiteral() throws RecognitionException { + EObject current = null; + + EObject this_XSetLiteral_0 = null; + + EObject this_XListLiteral_1 = null; + + + + enterRule(); + + try { + // InternalExport.g:6093:2: ( (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ) + // InternalExport.g:6094:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) + { + // InternalExport.g:6094:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) + int alt100=2; + int LA100_0 = input.LA(1); + + if ( (LA100_0==102) ) { + int LA100_1 = input.LA(2); + + if ( (LA100_1==22) ) { + alt100=2; + } + else if ( (LA100_1==18) ) { + alt100=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 100, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 100, 0, input); + + throw nvae; + } + switch (alt100) { + case 1 : + // InternalExport.g:6095:3: this_XSetLiteral_0= ruleXSetLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XSetLiteral_0=ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSetLiteral_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:6104:3: this_XListLiteral_1= ruleXListLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XListLiteral_1=ruleXListLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XListLiteral_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCollectionLiteral" + + + // $ANTLR start "entryRuleXSetLiteral" + // InternalExport.g:6116:1: entryRuleXSetLiteral returns [EObject current=null] : iv_ruleXSetLiteral= ruleXSetLiteral EOF ; + public final EObject entryRuleXSetLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSetLiteral = null; + + + try { + // InternalExport.g:6116:52: (iv_ruleXSetLiteral= ruleXSetLiteral EOF ) + // InternalExport.g:6117:2: iv_ruleXSetLiteral= ruleXSetLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSetLiteral=ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSetLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSetLiteral" + + + // $ANTLR start "ruleXSetLiteral" + // InternalExport.g:6123:1: ruleXSetLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ; + public final EObject ruleXSetLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_elements_3_0 = null; + + EObject lv_elements_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6129:2: ( ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ) + // InternalExport.g:6130:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) + { + // InternalExport.g:6130:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) + // InternalExport.g:6131:3: () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' + { + // InternalExport.g:6131:3: () + // InternalExport.g:6132:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,102,FOLLOW_9); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + + } + otherlv_2=(Token)match(input,18,FOLLOW_86); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + + } + // InternalExport.g:6146:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? + int alt102=2; + int LA102_0 = input.LA(1); + + if ( ((LA102_0>=RULE_ID && LA102_0<=RULE_INT)||(LA102_0>=RULE_HEX && LA102_0<=RULE_DECIMAL)||(LA102_0>=15 && LA102_0<=16)||LA102_0==18||LA102_0==20||LA102_0==22||LA102_0==27||LA102_0==30||LA102_0==46||LA102_0==49||(LA102_0>=60 && LA102_0<=61)||LA102_0==64||(LA102_0>=76 && LA102_0<=78)||LA102_0==80||(LA102_0>=102 && LA102_0<=104)||(LA102_0>=107 && LA102_0<=113)||LA102_0==115) ) { + alt102=1; + } + switch (alt102) { + case 1 : + // InternalExport.g:6147:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + { + // InternalExport.g:6147:4: ( (lv_elements_3_0= ruleXExpression ) ) + // InternalExport.g:6148:5: (lv_elements_3_0= ruleXExpression ) + { + // InternalExport.g:6148:5: (lv_elements_3_0= ruleXExpression ) + // InternalExport.g:6149:6: lv_elements_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_62); + lv_elements_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:6166:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + loop101: + do { + int alt101=2; + int LA101_0 = input.LA(1); + + if ( (LA101_0==25) ) { + alt101=1; + } + + + switch (alt101) { + case 1 : + // InternalExport.g:6167:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,25,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + + } + // InternalExport.g:6171:5: ( (lv_elements_5_0= ruleXExpression ) ) + // InternalExport.g:6172:6: (lv_elements_5_0= ruleXExpression ) + { + // InternalExport.g:6172:6: (lv_elements_5_0= ruleXExpression ) + // InternalExport.g:6173:7: lv_elements_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_62); + lv_elements_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop101; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSetLiteral" + + + // $ANTLR start "entryRuleXListLiteral" + // InternalExport.g:6200:1: entryRuleXListLiteral returns [EObject current=null] : iv_ruleXListLiteral= ruleXListLiteral EOF ; + public final EObject entryRuleXListLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXListLiteral = null; + + + try { + // InternalExport.g:6200:53: (iv_ruleXListLiteral= ruleXListLiteral EOF ) + // InternalExport.g:6201:2: iv_ruleXListLiteral= ruleXListLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXListLiteral=ruleXListLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXListLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXListLiteral" + + + // $ANTLR start "ruleXListLiteral" + // InternalExport.g:6207:1: ruleXListLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ; + public final EObject ruleXListLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_elements_3_0 = null; + + EObject lv_elements_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6213:2: ( ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ) + // InternalExport.g:6214:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) + { + // InternalExport.g:6214:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) + // InternalExport.g:6215:3: () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' + { + // InternalExport.g:6215:3: () + // InternalExport.g:6216:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,102,FOLLOW_63); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + + } + otherlv_2=(Token)match(input,22,FOLLOW_87); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + + } + // InternalExport.g:6230:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? + int alt104=2; + int LA104_0 = input.LA(1); + + if ( ((LA104_0>=RULE_ID && LA104_0<=RULE_INT)||(LA104_0>=RULE_HEX && LA104_0<=RULE_DECIMAL)||(LA104_0>=15 && LA104_0<=16)||LA104_0==18||LA104_0==20||LA104_0==22||LA104_0==27||LA104_0==30||LA104_0==46||LA104_0==49||(LA104_0>=60 && LA104_0<=61)||LA104_0==64||(LA104_0>=76 && LA104_0<=78)||LA104_0==80||(LA104_0>=102 && LA104_0<=104)||(LA104_0>=107 && LA104_0<=113)||LA104_0==115) ) { + alt104=1; + } + switch (alt104) { + case 1 : + // InternalExport.g:6231:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + { + // InternalExport.g:6231:4: ( (lv_elements_3_0= ruleXExpression ) ) + // InternalExport.g:6232:5: (lv_elements_3_0= ruleXExpression ) + { + // InternalExport.g:6232:5: (lv_elements_3_0= ruleXExpression ) + // InternalExport.g:6233:6: lv_elements_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_88); + lv_elements_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:6250:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + loop103: + do { + int alt103=2; + int LA103_0 = input.LA(1); + + if ( (LA103_0==25) ) { + alt103=1; + } + + + switch (alt103) { + case 1 : + // InternalExport.g:6251:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,25,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + + } + // InternalExport.g:6255:5: ( (lv_elements_5_0= ruleXExpression ) ) + // InternalExport.g:6256:6: (lv_elements_5_0= ruleXExpression ) + { + // InternalExport.g:6256:6: (lv_elements_5_0= ruleXExpression ) + // InternalExport.g:6257:7: lv_elements_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_88); + lv_elements_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop103; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXListLiteral" + + + // $ANTLR start "entryRuleXClosure" + // InternalExport.g:6284:1: entryRuleXClosure returns [EObject current=null] : iv_ruleXClosure= ruleXClosure EOF ; + public final EObject entryRuleXClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXClosure = null; + + + try { + // InternalExport.g:6284:49: (iv_ruleXClosure= ruleXClosure EOF ) + // InternalExport.g:6285:2: iv_ruleXClosure= ruleXClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXClosure=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXClosure" + + + // $ANTLR start "ruleXClosure" + // InternalExport.g:6291:1: ruleXClosure returns [EObject current=null] : ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ; + public final EObject ruleXClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token lv_explicitSyntax_5_0=null; + Token otherlv_7=null; + EObject lv_declaredFormalParameters_2_0 = null; + + EObject lv_declaredFormalParameters_4_0 = null; + + EObject lv_expression_6_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6297:2: ( ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ) + // InternalExport.g:6298:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) + { + // InternalExport.g:6298:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) + // InternalExport.g:6299:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' + { + // InternalExport.g:6299:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) + // InternalExport.g:6300:4: ( ( () '[' ) )=> ( () otherlv_1= '[' ) + { + // InternalExport.g:6306:4: ( () otherlv_1= '[' ) + // InternalExport.g:6307:5: () otherlv_1= '[' + { + // InternalExport.g:6307:5: () + // InternalExport.g:6308:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,22,FOLLOW_89); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + + } + + } + + + } + + // InternalExport.g:6320:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? + int alt107=2; + alt107 = dfa107.predict(input); + switch (alt107) { + case 1 : + // InternalExport.g:6321:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) + { + // InternalExport.g:6344:4: ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) + // InternalExport.g:6345:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) + { + // InternalExport.g:6345:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==RULE_ID||LA106_0==30||LA106_0==94) ) { + alt106=1; + } + switch (alt106) { + case 1 : + // InternalExport.g:6346:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* + { + // InternalExport.g:6346:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) + // InternalExport.g:6347:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) + { + // InternalExport.g:6347:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) + // InternalExport.g:6348:8: lv_declaredFormalParameters_2_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + + } + pushFollow(FOLLOW_90); + lv_declaredFormalParameters_2_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_2_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:6365:6: (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* + loop105: + do { + int alt105=2; + int LA105_0 = input.LA(1); + + if ( (LA105_0==25) ) { + alt105=1; + } + + + switch (alt105) { + case 1 : + // InternalExport.g:6366:7: otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) + { + otherlv_3=(Token)match(input,25,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + + } + // InternalExport.g:6370:7: ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) + // InternalExport.g:6371:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) + { + // InternalExport.g:6371:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) + // InternalExport.g:6372:9: lv_declaredFormalParameters_4_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + + } + pushFollow(FOLLOW_90); + lv_declaredFormalParameters_4_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_4_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop105; + } + } while (true); + + + } + break; + + } + + // InternalExport.g:6391:5: ( (lv_explicitSyntax_5_0= '|' ) ) + // InternalExport.g:6392:6: (lv_explicitSyntax_5_0= '|' ) + { + // InternalExport.g:6392:6: (lv_explicitSyntax_5_0= '|' ) + // InternalExport.g:6393:7: lv_explicitSyntax_5_0= '|' + { + lv_explicitSyntax_5_0=(Token)match(input,75,FOLLOW_91); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXClosureRule()); + } + setWithLastConsumed(current, "explicitSyntax", lv_explicitSyntax_5_0 != null, "|"); + + } + + } + + + } + + + } + + + } + break; + + } + + // InternalExport.g:6407:3: ( (lv_expression_6_0= ruleXExpressionInClosure ) ) + // InternalExport.g:6408:4: (lv_expression_6_0= ruleXExpressionInClosure ) + { + // InternalExport.g:6408:4: (lv_expression_6_0= ruleXExpressionInClosure ) + // InternalExport.g:6409:5: lv_expression_6_0= ruleXExpressionInClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_16); + lv_expression_6_0=ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + set( + current, + "expression", + lv_expression_6_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_7=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXClosure" + + + // $ANTLR start "entryRuleXExpressionInClosure" + // InternalExport.g:6434:1: entryRuleXExpressionInClosure returns [EObject current=null] : iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ; + public final EObject entryRuleXExpressionInClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXExpressionInClosure = null; + + + try { + // InternalExport.g:6434:61: (iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ) + // InternalExport.g:6435:2: iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionInClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpressionInClosure=ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpressionInClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpressionInClosure" + + + // $ANTLR start "ruleXExpressionInClosure" + // InternalExport.g:6441:1: ruleXExpressionInClosure returns [EObject current=null] : ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ; + public final EObject ruleXExpressionInClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject lv_expressions_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6447:2: ( ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ) + // InternalExport.g:6448:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) + { + // InternalExport.g:6448:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) + // InternalExport.g:6449:3: () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* + { + // InternalExport.g:6449:3: () + // InternalExport.g:6450:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(), + current); + + } + + } + + // InternalExport.g:6456:3: ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* + loop109: + do { + int alt109=2; + int LA109_0 = input.LA(1); + + if ( ((LA109_0>=RULE_ID && LA109_0<=RULE_INT)||(LA109_0>=RULE_HEX && LA109_0<=RULE_DECIMAL)||(LA109_0>=15 && LA109_0<=16)||LA109_0==18||LA109_0==20||LA109_0==22||LA109_0==27||LA109_0==30||LA109_0==46||LA109_0==49||(LA109_0>=60 && LA109_0<=61)||LA109_0==64||(LA109_0>=76 && LA109_0<=78)||LA109_0==80||(LA109_0>=102 && LA109_0<=113)||LA109_0==115) ) { + alt109=1; + } + + + switch (alt109) { + case 1 : + // InternalExport.g:6457:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? + { + // InternalExport.g:6457:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:6458:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:6458:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) + // InternalExport.g:6459:6: lv_expressions_1_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + + } + pushFollow(FOLLOW_92); + lv_expressions_1_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule()); + } + add( + current, + "expressions", + lv_expressions_1_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:6476:4: (otherlv_2= ';' )? + int alt108=2; + int LA108_0 = input.LA(1); + + if ( (LA108_0==26) ) { + alt108=1; + } + switch (alt108) { + case 1 : + // InternalExport.g:6477:5: otherlv_2= ';' + { + otherlv_2=(Token)match(input,26,FOLLOW_93); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + + } + + } + break; + + } + + + } + break; + + default : + break loop109; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpressionInClosure" + + + // $ANTLR start "entryRuleXShortClosure" + // InternalExport.g:6487:1: entryRuleXShortClosure returns [EObject current=null] : iv_ruleXShortClosure= ruleXShortClosure EOF ; + public final EObject entryRuleXShortClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXShortClosure = null; + + + try { + // InternalExport.g:6487:54: (iv_ruleXShortClosure= ruleXShortClosure EOF ) + // InternalExport.g:6488:2: iv_ruleXShortClosure= ruleXShortClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXShortClosure=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXShortClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXShortClosure" + + + // $ANTLR start "ruleXShortClosure" + // InternalExport.g:6494:1: ruleXShortClosure returns [EObject current=null] : ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXShortClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_explicitSyntax_4_0=null; + EObject lv_declaredFormalParameters_1_0 = null; + + EObject lv_declaredFormalParameters_3_0 = null; + + EObject lv_expression_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6500:2: ( ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ) + // InternalExport.g:6501:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) + { + // InternalExport.g:6501:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) + // InternalExport.g:6502:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) + { + // InternalExport.g:6502:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) + // InternalExport.g:6503:4: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) + { + // InternalExport.g:6528:4: ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) + // InternalExport.g:6529:5: () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) + { + // InternalExport.g:6529:5: () + // InternalExport.g:6530:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(), + current); + + } + + } + + // InternalExport.g:6536:5: ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==RULE_ID||LA111_0==30||LA111_0==94) ) { + alt111=1; + } + switch (alt111) { + case 1 : + // InternalExport.g:6537:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* + { + // InternalExport.g:6537:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) + // InternalExport.g:6538:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) + { + // InternalExport.g:6538:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) + // InternalExport.g:6539:8: lv_declaredFormalParameters_1_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + + } + pushFollow(FOLLOW_90); + lv_declaredFormalParameters_1_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_1_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:6556:6: (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* + loop110: + do { + int alt110=2; + int LA110_0 = input.LA(1); + + if ( (LA110_0==25) ) { + alt110=1; + } + + + switch (alt110) { + case 1 : + // InternalExport.g:6557:7: otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) + { + otherlv_2=(Token)match(input,25,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + + } + // InternalExport.g:6561:7: ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) + // InternalExport.g:6562:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) + { + // InternalExport.g:6562:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) + // InternalExport.g:6563:9: lv_declaredFormalParameters_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + + } + pushFollow(FOLLOW_90); + lv_declaredFormalParameters_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop110; + } + } while (true); + + + } + break; + + } + + // InternalExport.g:6582:5: ( (lv_explicitSyntax_4_0= '|' ) ) + // InternalExport.g:6583:6: (lv_explicitSyntax_4_0= '|' ) + { + // InternalExport.g:6583:6: (lv_explicitSyntax_4_0= '|' ) + // InternalExport.g:6584:7: lv_explicitSyntax_4_0= '|' + { + lv_explicitSyntax_4_0=(Token)match(input,75,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXShortClosureRule()); + } + setWithLastConsumed(current, "explicitSyntax", lv_explicitSyntax_4_0 != null, "|"); + + } + + } + + + } + + + } + + + } + + // InternalExport.g:6598:3: ( (lv_expression_5_0= ruleXExpression ) ) + // InternalExport.g:6599:4: (lv_expression_5_0= ruleXExpression ) + { + // InternalExport.g:6599:4: (lv_expression_5_0= ruleXExpression ) + // InternalExport.g:6600:5: lv_expression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + set( + current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXShortClosure" + + + // $ANTLR start "entryRuleXParenthesizedExpression" + // InternalExport.g:6621:1: entryRuleXParenthesizedExpression returns [EObject current=null] : iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ; + public final EObject entryRuleXParenthesizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXParenthesizedExpression = null; + + + try { + // InternalExport.g:6621:65: (iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ) + // InternalExport.g:6622:2: iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXParenthesizedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXParenthesizedExpression" + + + // $ANTLR start "ruleXParenthesizedExpression" + // InternalExport.g:6628:1: ruleXParenthesizedExpression returns [EObject current=null] : (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ; + public final EObject ruleXParenthesizedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + EObject this_XExpression_1 = null; + + + + enterRule(); + + try { + // InternalExport.g:6634:2: ( (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ) + // InternalExport.g:6635:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) + { + // InternalExport.g:6635:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) + // InternalExport.g:6636:3: otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' + { + otherlv_0=(Token)match(input,30,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_24); + this_XExpression_1=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XExpression_1; + afterParserOrEnumRuleCall(); + + } + otherlv_2=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXParenthesizedExpression" + + + // $ANTLR start "entryRuleXIfExpression" + // InternalExport.g:6656:1: entryRuleXIfExpression returns [EObject current=null] : iv_ruleXIfExpression= ruleXIfExpression EOF ; + public final EObject entryRuleXIfExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXIfExpression = null; + + + try { + // InternalExport.g:6656:54: (iv_ruleXIfExpression= ruleXIfExpression EOF ) + // InternalExport.g:6657:2: iv_ruleXIfExpression= ruleXIfExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXIfExpression=ruleXIfExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXIfExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXIfExpression" + + + // $ANTLR start "ruleXIfExpression" + // InternalExport.g:6663:1: ruleXIfExpression returns [EObject current=null] : ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ; + public final EObject ruleXIfExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_if_3_0 = null; + + EObject lv_then_5_0 = null; + + EObject lv_else_7_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6669:2: ( ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ) + // InternalExport.g:6670:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) + { + // InternalExport.g:6670:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) + // InternalExport.g:6671:3: () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? + { + // InternalExport.g:6671:3: () + // InternalExport.g:6672:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,46,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + + } + otherlv_2=(Token)match(input,30,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExport.g:6686:3: ( (lv_if_3_0= ruleXExpression ) ) + // InternalExport.g:6687:4: (lv_if_3_0= ruleXExpression ) + { + // InternalExport.g:6687:4: (lv_if_3_0= ruleXExpression ) + // InternalExport.g:6688:5: lv_if_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_24); + lv_if_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "if", + lv_if_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,31,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + + } + // InternalExport.g:6709:3: ( (lv_then_5_0= ruleXExpression ) ) + // InternalExport.g:6710:4: (lv_then_5_0= ruleXExpression ) + { + // InternalExport.g:6710:4: (lv_then_5_0= ruleXExpression ) + // InternalExport.g:6711:5: lv_then_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_44); + lv_then_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:6728:3: ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? + int alt112=2; + int LA112_0 = input.LA(1); + + if ( (LA112_0==48) ) { + int LA112_1 = input.LA(2); + + if ( (synpred27_InternalExport()) ) { + alt112=1; + } + } + switch (alt112) { + case 1 : + // InternalExport.g:6729:4: ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) + { + // InternalExport.g:6729:4: ( ( 'else' )=>otherlv_6= 'else' ) + // InternalExport.g:6730:5: ( 'else' )=>otherlv_6= 'else' + { + otherlv_6=(Token)match(input,48,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + + } + + } + + // InternalExport.g:6736:4: ( (lv_else_7_0= ruleXExpression ) ) + // InternalExport.g:6737:5: (lv_else_7_0= ruleXExpression ) + { + // InternalExport.g:6737:5: (lv_else_7_0= ruleXExpression ) + // InternalExport.g:6738:6: lv_else_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + + } + pushFollow(FOLLOW_2); + lv_else_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "else", + lv_else_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXIfExpression" + + + // $ANTLR start "entryRuleXSwitchExpression" + // InternalExport.g:6760:1: entryRuleXSwitchExpression returns [EObject current=null] : iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ; + public final EObject entryRuleXSwitchExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSwitchExpression = null; + + + try { + // InternalExport.g:6760:58: (iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ) + // InternalExport.g:6761:2: iv_ruleXSwitchExpression= ruleXSwitchExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSwitchExpression=ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSwitchExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSwitchExpression" + + + // $ANTLR start "ruleXSwitchExpression" + // InternalExport.g:6767:1: ruleXSwitchExpression returns [EObject current=null] : ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ; + public final EObject ruleXSwitchExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + Token otherlv_12=null; + Token otherlv_13=null; + Token otherlv_15=null; + EObject lv_declaredParam_3_0 = null; + + EObject lv_switch_5_0 = null; + + EObject lv_declaredParam_7_0 = null; + + EObject lv_switch_9_0 = null; + + EObject lv_cases_11_0 = null; + + EObject lv_default_14_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6773:2: ( ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ) + // InternalExport.g:6774:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) + { + // InternalExport.g:6774:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) + // InternalExport.g:6775:3: () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' + { + // InternalExport.g:6775:3: () + // InternalExport.g:6776:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,49,FOLLOW_94); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + + } + // InternalExport.g:6786:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) + int alt114=2; + alt114 = dfa114.predict(input); + switch (alt114) { + case 1 : + // InternalExport.g:6787:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) + { + // InternalExport.g:6787:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) + // InternalExport.g:6788:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' + { + // InternalExport.g:6788:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) + // InternalExport.g:6789:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + { + // InternalExport.g:6799:6: (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + // InternalExport.g:6800:7: otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' + { + otherlv_2=(Token)match(input,30,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + + } + // InternalExport.g:6804:7: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) + // InternalExport.g:6805:8: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + { + // InternalExport.g:6805:8: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + // InternalExport.g:6806:9: lv_declaredParam_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + + } + pushFollow(FOLLOW_39); + lv_declaredParam_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,43,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + + } + + } + + + } + + // InternalExport.g:6829:5: ( (lv_switch_5_0= ruleXExpression ) ) + // InternalExport.g:6830:6: (lv_switch_5_0= ruleXExpression ) + { + // InternalExport.g:6830:6: (lv_switch_5_0= ruleXExpression ) + // InternalExport.g:6831:7: lv_switch_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_24); + lv_switch_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "switch", + lv_switch_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,31,FOLLOW_9); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + + } + + } + + + } + break; + case 2 : + // InternalExport.g:6854:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) + { + // InternalExport.g:6854:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) + // InternalExport.g:6855:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) + { + // InternalExport.g:6855:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? + int alt113=2; + alt113 = dfa113.predict(input); + switch (alt113) { + case 1 : + // InternalExport.g:6856:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) + { + // InternalExport.g:6865:6: ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) + // InternalExport.g:6866:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' + { + // InternalExport.g:6866:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) + // InternalExport.g:6867:8: (lv_declaredParam_7_0= ruleJvmFormalParameter ) + { + // InternalExport.g:6867:8: (lv_declaredParam_7_0= ruleJvmFormalParameter ) + // InternalExport.g:6868:9: lv_declaredParam_7_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + + } + pushFollow(FOLLOW_39); + lv_declaredParam_7_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_7_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_8=(Token)match(input,43,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + + } + + } + + + } + break; + + } + + // InternalExport.g:6891:5: ( (lv_switch_9_0= ruleXExpression ) ) + // InternalExport.g:6892:6: (lv_switch_9_0= ruleXExpression ) + { + // InternalExport.g:6892:6: (lv_switch_9_0= ruleXExpression ) + // InternalExport.g:6893:7: lv_switch_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_9); + lv_switch_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "switch", + lv_switch_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + otherlv_10=(Token)match(input,18,FOLLOW_95); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + + } + // InternalExport.g:6916:3: ( (lv_cases_11_0= ruleXCasePart ) )* + loop115: + do { + int alt115=2; + int LA115_0 = input.LA(1); + + if ( (LA115_0==RULE_ID||LA115_0==25||LA115_0==30||LA115_0==43||LA115_0==51||LA115_0==94) ) { + alt115=1; + } + + + switch (alt115) { + case 1 : + // InternalExport.g:6917:4: (lv_cases_11_0= ruleXCasePart ) + { + // InternalExport.g:6917:4: (lv_cases_11_0= ruleXCasePart ) + // InternalExport.g:6918:5: lv_cases_11_0= ruleXCasePart + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_95); + lv_cases_11_0=ruleXCasePart(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + add( + current, + "cases", + lv_cases_11_0, + "org.eclipse.xtext.xbase.Xbase.XCasePart"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop115; + } + } while (true); + + // InternalExport.g:6935:3: (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? + int alt116=2; + int LA116_0 = input.LA(1); + + if ( (LA116_0==50) ) { + alt116=1; + } + switch (alt116) { + case 1 : + // InternalExport.g:6936:4: otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) + { + otherlv_12=(Token)match(input,50,FOLLOW_39); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + + } + otherlv_13=(Token)match(input,43,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + + } + // InternalExport.g:6944:4: ( (lv_default_14_0= ruleXExpression ) ) + // InternalExport.g:6945:5: (lv_default_14_0= ruleXExpression ) + { + // InternalExport.g:6945:5: (lv_default_14_0= ruleXExpression ) + // InternalExport.g:6946:6: lv_default_14_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + + } + pushFollow(FOLLOW_48); + lv_default_14_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "default", + lv_default_14_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + otherlv_15=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSwitchExpression" + + + // $ANTLR start "entryRuleXCasePart" + // InternalExport.g:6972:1: entryRuleXCasePart returns [EObject current=null] : iv_ruleXCasePart= ruleXCasePart EOF ; + public final EObject entryRuleXCasePart() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCasePart = null; + + + try { + // InternalExport.g:6972:50: (iv_ruleXCasePart= ruleXCasePart EOF ) + // InternalExport.g:6973:2: iv_ruleXCasePart= ruleXCasePart EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCasePart=ruleXCasePart(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCasePart; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCasePart" + + + // $ANTLR start "ruleXCasePart" + // InternalExport.g:6979:1: ruleXCasePart returns [EObject current=null] : ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ; + public final EObject ruleXCasePart() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token otherlv_4=null; + Token lv_fallThrough_6_0=null; + EObject lv_typeGuard_1_0 = null; + + EObject lv_case_3_0 = null; + + EObject lv_then_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:6985:2: ( ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ) + // InternalExport.g:6986:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) + { + // InternalExport.g:6986:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) + // InternalExport.g:6987:3: () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) + { + // InternalExport.g:6987:3: () + // InternalExport.g:6988:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXCasePartAccess().getXCasePartAction_0(), + current); + + } + + } + + // InternalExport.g:6994:3: ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==RULE_ID||LA117_0==30||LA117_0==94) ) { + alt117=1; + } + switch (alt117) { + case 1 : + // InternalExport.g:6995:4: (lv_typeGuard_1_0= ruleJvmTypeReference ) + { + // InternalExport.g:6995:4: (lv_typeGuard_1_0= ruleJvmTypeReference ) + // InternalExport.g:6996:5: lv_typeGuard_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_96); + lv_typeGuard_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "typeGuard", + lv_typeGuard_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + // InternalExport.g:7013:3: (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? + int alt118=2; + int LA118_0 = input.LA(1); + + if ( (LA118_0==51) ) { + alt118=1; + } + switch (alt118) { + case 1 : + // InternalExport.g:7014:4: otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) + { + otherlv_2=(Token)match(input,51,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + + } + // InternalExport.g:7018:4: ( (lv_case_3_0= ruleXExpression ) ) + // InternalExport.g:7019:5: (lv_case_3_0= ruleXExpression ) + { + // InternalExport.g:7019:5: (lv_case_3_0= ruleXExpression ) + // InternalExport.g:7020:6: lv_case_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_97); + lv_case_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "case", + lv_case_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalExport.g:7038:3: ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) + int alt119=2; + int LA119_0 = input.LA(1); + + if ( (LA119_0==43) ) { + alt119=1; + } + else if ( (LA119_0==25) ) { + alt119=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 119, 0, input); + + throw nvae; + } + switch (alt119) { + case 1 : + // InternalExport.g:7039:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) + { + // InternalExport.g:7039:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) + // InternalExport.g:7040:5: otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,43,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + + } + // InternalExport.g:7044:5: ( (lv_then_5_0= ruleXExpression ) ) + // InternalExport.g:7045:6: (lv_then_5_0= ruleXExpression ) + { + // InternalExport.g:7045:6: (lv_then_5_0= ruleXExpression ) + // InternalExport.g:7046:7: lv_then_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + + } + pushFollow(FOLLOW_2); + lv_then_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:7065:4: ( (lv_fallThrough_6_0= ',' ) ) + { + // InternalExport.g:7065:4: ( (lv_fallThrough_6_0= ',' ) ) + // InternalExport.g:7066:5: (lv_fallThrough_6_0= ',' ) + { + // InternalExport.g:7066:5: (lv_fallThrough_6_0= ',' ) + // InternalExport.g:7067:6: lv_fallThrough_6_0= ',' + { + lv_fallThrough_6_0=(Token)match(input,25,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXCasePartRule()); + } + setWithLastConsumed(current, "fallThrough", lv_fallThrough_6_0 != null, ","); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCasePart" + + + // $ANTLR start "entryRuleXForLoopExpression" + // InternalExport.g:7084:1: entryRuleXForLoopExpression returns [EObject current=null] : iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ; + public final EObject entryRuleXForLoopExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXForLoopExpression = null; + + + try { + // InternalExport.g:7084:59: (iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ) + // InternalExport.g:7085:2: iv_ruleXForLoopExpression= ruleXForLoopExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXForLoopExpression=ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXForLoopExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXForLoopExpression" + + + // $ANTLR start "ruleXForLoopExpression" + // InternalExport.g:7091:1: ruleXForLoopExpression returns [EObject current=null] : ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ; + public final EObject ruleXForLoopExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_declaredParam_3_0 = null; + + EObject lv_forExpression_5_0 = null; + + EObject lv_eachExpression_7_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7097:2: ( ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ) + // InternalExport.g:7098:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) + { + // InternalExport.g:7098:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) + // InternalExport.g:7099:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) + { + // InternalExport.g:7099:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) + // InternalExport.g:7100:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + { + // InternalExport.g:7113:4: ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + // InternalExport.g:7114:5: () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' + { + // InternalExport.g:7114:5: () + // InternalExport.g:7115:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,16,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + + } + otherlv_2=(Token)match(input,30,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + + } + // InternalExport.g:7129:5: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) + // InternalExport.g:7130:6: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + { + // InternalExport.g:7130:6: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + // InternalExport.g:7131:7: lv_declaredParam_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + + } + pushFollow(FOLLOW_39); + lv_declaredParam_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,43,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + + } + + } + + + } + + // InternalExport.g:7154:3: ( (lv_forExpression_5_0= ruleXExpression ) ) + // InternalExport.g:7155:4: (lv_forExpression_5_0= ruleXExpression ) + { + // InternalExport.g:7155:4: (lv_forExpression_5_0= ruleXExpression ) + // InternalExport.g:7156:5: lv_forExpression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_24); + lv_forExpression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "forExpression", + lv_forExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,31,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + + } + // InternalExport.g:7177:3: ( (lv_eachExpression_7_0= ruleXExpression ) ) + // InternalExport.g:7178:4: (lv_eachExpression_7_0= ruleXExpression ) + { + // InternalExport.g:7178:4: (lv_eachExpression_7_0= ruleXExpression ) + // InternalExport.g:7179:5: lv_eachExpression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_eachExpression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "eachExpression", + lv_eachExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXForLoopExpression" + + + // $ANTLR start "entryRuleXBasicForLoopExpression" + // InternalExport.g:7200:1: entryRuleXBasicForLoopExpression returns [EObject current=null] : iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ; + public final EObject entryRuleXBasicForLoopExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBasicForLoopExpression = null; + + + try { + // InternalExport.g:7200:64: (iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ) + // InternalExport.g:7201:2: iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBasicForLoopExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBasicForLoopExpression" + + + // $ANTLR start "ruleXBasicForLoopExpression" + // InternalExport.g:7207:1: ruleXBasicForLoopExpression returns [EObject current=null] : ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ; + public final EObject ruleXBasicForLoopExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + Token otherlv_12=null; + EObject lv_initExpressions_3_0 = null; + + EObject lv_initExpressions_5_0 = null; + + EObject lv_expression_7_0 = null; + + EObject lv_updateExpressions_9_0 = null; + + EObject lv_updateExpressions_11_0 = null; + + EObject lv_eachExpression_13_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7213:2: ( ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ) + // InternalExport.g:7214:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) + { + // InternalExport.g:7214:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) + // InternalExport.g:7215:3: () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) + { + // InternalExport.g:7215:3: () + // InternalExport.g:7216:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,16,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + + } + otherlv_2=(Token)match(input,30,FOLLOW_98); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExport.g:7230:3: ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? + int alt121=2; + int LA121_0 = input.LA(1); + + if ( ((LA121_0>=RULE_ID && LA121_0<=RULE_INT)||(LA121_0>=RULE_HEX && LA121_0<=RULE_DECIMAL)||(LA121_0>=15 && LA121_0<=16)||LA121_0==18||LA121_0==20||LA121_0==22||LA121_0==27||LA121_0==30||LA121_0==46||LA121_0==49||(LA121_0>=60 && LA121_0<=61)||LA121_0==64||(LA121_0>=76 && LA121_0<=78)||LA121_0==80||(LA121_0>=102 && LA121_0<=113)||LA121_0==115) ) { + alt121=1; + } + switch (alt121) { + case 1 : + // InternalExport.g:7231:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* + { + // InternalExport.g:7231:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:7232:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:7232:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) + // InternalExport.g:7233:6: lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_37); + lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "initExpressions", + lv_initExpressions_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7250:4: (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* + loop120: + do { + int alt120=2; + int LA120_0 = input.LA(1); + + if ( (LA120_0==25) ) { + alt120=1; + } + + + switch (alt120) { + case 1 : + // InternalExport.g:7251:5: otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) + { + otherlv_4=(Token)match(input,25,FOLLOW_99); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + + } + // InternalExport.g:7255:5: ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:7256:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:7256:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) + // InternalExport.g:7257:7: lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_37); + lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "initExpressions", + lv_initExpressions_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop120; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,26,FOLLOW_100); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + + } + // InternalExport.g:7280:3: ( (lv_expression_7_0= ruleXExpression ) )? + int alt122=2; + int LA122_0 = input.LA(1); + + if ( ((LA122_0>=RULE_ID && LA122_0<=RULE_INT)||(LA122_0>=RULE_HEX && LA122_0<=RULE_DECIMAL)||(LA122_0>=15 && LA122_0<=16)||LA122_0==18||LA122_0==20||LA122_0==22||LA122_0==27||LA122_0==30||LA122_0==46||LA122_0==49||(LA122_0>=60 && LA122_0<=61)||LA122_0==64||(LA122_0>=76 && LA122_0<=78)||LA122_0==80||(LA122_0>=102 && LA122_0<=104)||(LA122_0>=107 && LA122_0<=113)||LA122_0==115) ) { + alt122=1; + } + switch (alt122) { + case 1 : + // InternalExport.g:7281:4: (lv_expression_7_0= ruleXExpression ) + { + // InternalExport.g:7281:4: (lv_expression_7_0= ruleXExpression ) + // InternalExport.g:7282:5: lv_expression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_34); + lv_expression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + current, + "expression", + lv_expression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + otherlv_8=(Token)match(input,26,FOLLOW_101); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + + } + // InternalExport.g:7303:3: ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? + int alt124=2; + int LA124_0 = input.LA(1); + + if ( ((LA124_0>=RULE_ID && LA124_0<=RULE_INT)||(LA124_0>=RULE_HEX && LA124_0<=RULE_DECIMAL)||(LA124_0>=15 && LA124_0<=16)||LA124_0==18||LA124_0==20||LA124_0==22||LA124_0==27||LA124_0==30||LA124_0==46||LA124_0==49||(LA124_0>=60 && LA124_0<=61)||LA124_0==64||(LA124_0>=76 && LA124_0<=78)||LA124_0==80||(LA124_0>=102 && LA124_0<=104)||(LA124_0>=107 && LA124_0<=113)||LA124_0==115) ) { + alt124=1; + } + switch (alt124) { + case 1 : + // InternalExport.g:7304:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* + { + // InternalExport.g:7304:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) + // InternalExport.g:7305:5: (lv_updateExpressions_9_0= ruleXExpression ) + { + // InternalExport.g:7305:5: (lv_updateExpressions_9_0= ruleXExpression ) + // InternalExport.g:7306:6: lv_updateExpressions_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + + } + pushFollow(FOLLOW_57); + lv_updateExpressions_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "updateExpressions", + lv_updateExpressions_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7323:4: (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* + loop123: + do { + int alt123=2; + int LA123_0 = input.LA(1); + + if ( (LA123_0==25) ) { + alt123=1; + } + + + switch (alt123) { + case 1 : + // InternalExport.g:7324:5: otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) + { + otherlv_10=(Token)match(input,25,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + + } + // InternalExport.g:7328:5: ( (lv_updateExpressions_11_0= ruleXExpression ) ) + // InternalExport.g:7329:6: (lv_updateExpressions_11_0= ruleXExpression ) + { + // InternalExport.g:7329:6: (lv_updateExpressions_11_0= ruleXExpression ) + // InternalExport.g:7330:7: lv_updateExpressions_11_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + + } + pushFollow(FOLLOW_57); + lv_updateExpressions_11_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "updateExpressions", + lv_updateExpressions_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop123; + } + } while (true); + + + } + break; + + } + + otherlv_12=(Token)match(input,31,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + + } + // InternalExport.g:7353:3: ( (lv_eachExpression_13_0= ruleXExpression ) ) + // InternalExport.g:7354:4: (lv_eachExpression_13_0= ruleXExpression ) + { + // InternalExport.g:7354:4: (lv_eachExpression_13_0= ruleXExpression ) + // InternalExport.g:7355:5: lv_eachExpression_13_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + + } + pushFollow(FOLLOW_2); + lv_eachExpression_13_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + current, + "eachExpression", + lv_eachExpression_13_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBasicForLoopExpression" + + + // $ANTLR start "entryRuleXWhileExpression" + // InternalExport.g:7376:1: entryRuleXWhileExpression returns [EObject current=null] : iv_ruleXWhileExpression= ruleXWhileExpression EOF ; + public final EObject entryRuleXWhileExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXWhileExpression = null; + + + try { + // InternalExport.g:7376:57: (iv_ruleXWhileExpression= ruleXWhileExpression EOF ) + // InternalExport.g:7377:2: iv_ruleXWhileExpression= ruleXWhileExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXWhileExpression=ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXWhileExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXWhileExpression" + + + // $ANTLR start "ruleXWhileExpression" + // InternalExport.g:7383:1: ruleXWhileExpression returns [EObject current=null] : ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXWhileExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_predicate_3_0 = null; + + EObject lv_body_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7389:2: ( ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ) + // InternalExport.g:7390:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) + { + // InternalExport.g:7390:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) + // InternalExport.g:7391:3: () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) + { + // InternalExport.g:7391:3: () + // InternalExport.g:7392:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,103,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + + } + otherlv_2=(Token)match(input,30,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExport.g:7406:3: ( (lv_predicate_3_0= ruleXExpression ) ) + // InternalExport.g:7407:4: (lv_predicate_3_0= ruleXExpression ) + { + // InternalExport.g:7407:4: (lv_predicate_3_0= ruleXExpression ) + // InternalExport.g:7408:5: lv_predicate_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_24); + lv_predicate_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + current, + "predicate", + lv_predicate_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,31,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + + } + // InternalExport.g:7429:3: ( (lv_body_5_0= ruleXExpression ) ) + // InternalExport.g:7430:4: (lv_body_5_0= ruleXExpression ) + { + // InternalExport.g:7430:4: (lv_body_5_0= ruleXExpression ) + // InternalExport.g:7431:5: lv_body_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_2); + lv_body_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + current, + "body", + lv_body_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXWhileExpression" + + + // $ANTLR start "entryRuleXDoWhileExpression" + // InternalExport.g:7452:1: entryRuleXDoWhileExpression returns [EObject current=null] : iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ; + public final EObject entryRuleXDoWhileExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXDoWhileExpression = null; + + + try { + // InternalExport.g:7452:59: (iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ) + // InternalExport.g:7453:2: iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXDoWhileExpression=ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXDoWhileExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXDoWhileExpression" + + + // $ANTLR start "ruleXDoWhileExpression" + // InternalExport.g:7459:1: ruleXDoWhileExpression returns [EObject current=null] : ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ; + public final EObject ruleXDoWhileExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_body_2_0 = null; + + EObject lv_predicate_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7465:2: ( ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ) + // InternalExport.g:7466:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) + { + // InternalExport.g:7466:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) + // InternalExport.g:7467:3: () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' + { + // InternalExport.g:7467:3: () + // InternalExport.g:7468:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,104,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + + } + // InternalExport.g:7478:3: ( (lv_body_2_0= ruleXExpression ) ) + // InternalExport.g:7479:4: (lv_body_2_0= ruleXExpression ) + { + // InternalExport.g:7479:4: (lv_body_2_0= ruleXExpression ) + // InternalExport.g:7480:5: lv_body_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_102); + lv_body_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + current, + "body", + lv_body_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_3=(Token)match(input,103,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + + } + otherlv_4=(Token)match(input,30,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + + } + // InternalExport.g:7505:3: ( (lv_predicate_5_0= ruleXExpression ) ) + // InternalExport.g:7506:4: (lv_predicate_5_0= ruleXExpression ) + { + // InternalExport.g:7506:4: (lv_predicate_5_0= ruleXExpression ) + // InternalExport.g:7507:5: lv_predicate_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_24); + lv_predicate_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + current, + "predicate", + lv_predicate_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXDoWhileExpression" + + + // $ANTLR start "entryRuleXBlockExpression" + // InternalExport.g:7532:1: entryRuleXBlockExpression returns [EObject current=null] : iv_ruleXBlockExpression= ruleXBlockExpression EOF ; + public final EObject entryRuleXBlockExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBlockExpression = null; + + + try { + // InternalExport.g:7532:57: (iv_ruleXBlockExpression= ruleXBlockExpression EOF ) + // InternalExport.g:7533:2: iv_ruleXBlockExpression= ruleXBlockExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBlockExpression=ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBlockExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBlockExpression" + + + // $ANTLR start "ruleXBlockExpression" + // InternalExport.g:7539:1: ruleXBlockExpression returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ; + public final EObject ruleXBlockExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + EObject lv_expressions_2_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7545:2: ( ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ) + // InternalExport.g:7546:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) + { + // InternalExport.g:7546:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) + // InternalExport.g:7547:3: () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' + { + // InternalExport.g:7547:3: () + // InternalExport.g:7548:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,18,FOLLOW_103); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + + } + // InternalExport.g:7558:3: ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* + loop126: + do { + int alt126=2; + int LA126_0 = input.LA(1); + + if ( ((LA126_0>=RULE_ID && LA126_0<=RULE_INT)||(LA126_0>=RULE_HEX && LA126_0<=RULE_DECIMAL)||(LA126_0>=15 && LA126_0<=16)||LA126_0==18||LA126_0==20||LA126_0==22||LA126_0==27||LA126_0==30||LA126_0==46||LA126_0==49||(LA126_0>=60 && LA126_0<=61)||LA126_0==64||(LA126_0>=76 && LA126_0<=78)||LA126_0==80||(LA126_0>=102 && LA126_0<=113)||LA126_0==115) ) { + alt126=1; + } + + + switch (alt126) { + case 1 : + // InternalExport.g:7559:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? + { + // InternalExport.g:7559:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExport.g:7560:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExport.g:7560:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) + // InternalExport.g:7561:6: lv_expressions_2_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + + } + pushFollow(FOLLOW_104); + lv_expressions_2_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBlockExpressionRule()); + } + add( + current, + "expressions", + lv_expressions_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7578:4: (otherlv_3= ';' )? + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==26) ) { + alt125=1; + } + switch (alt125) { + case 1 : + // InternalExport.g:7579:5: otherlv_3= ';' + { + otherlv_3=(Token)match(input,26,FOLLOW_103); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + + } + + } + break; + + } + + + } + break; + + default : + break loop126; + } + } while (true); + + otherlv_4=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBlockExpression" + + + // $ANTLR start "entryRuleXExpressionOrVarDeclaration" + // InternalExport.g:7593:1: entryRuleXExpressionOrVarDeclaration returns [EObject current=null] : iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ; + public final EObject entryRuleXExpressionOrVarDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXExpressionOrVarDeclaration = null; + + + try { + // InternalExport.g:7593:68: (iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ) + // InternalExport.g:7594:2: iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpressionOrVarDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" + + + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // InternalExport.g:7600:1: ruleXExpressionOrVarDeclaration returns [EObject current=null] : (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ; + public final EObject ruleXExpressionOrVarDeclaration() throws RecognitionException { + EObject current = null; + + EObject this_XVariableDeclaration_0 = null; + + EObject this_XExpression_1 = null; + + + + enterRule(); + + try { + // InternalExport.g:7606:2: ( (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ) + // InternalExport.g:7607:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) + { + // InternalExport.g:7607:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) + int alt127=2; + int LA127_0 = input.LA(1); + + if ( ((LA127_0>=105 && LA127_0<=106)) ) { + alt127=1; + } + else if ( ((LA127_0>=RULE_ID && LA127_0<=RULE_INT)||(LA127_0>=RULE_HEX && LA127_0<=RULE_DECIMAL)||(LA127_0>=15 && LA127_0<=16)||LA127_0==18||LA127_0==20||LA127_0==22||LA127_0==27||LA127_0==30||LA127_0==46||LA127_0==49||(LA127_0>=60 && LA127_0<=61)||LA127_0==64||(LA127_0>=76 && LA127_0<=78)||LA127_0==80||(LA127_0>=102 && LA127_0<=104)||(LA127_0>=107 && LA127_0<=113)||LA127_0==115) ) { + alt127=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 127, 0, input); + + throw nvae; + } + switch (alt127) { + case 1 : + // InternalExport.g:7608:3: this_XVariableDeclaration_0= ruleXVariableDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XVariableDeclaration_0=ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XVariableDeclaration_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:7617:3: this_XExpression_1= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XExpression_1=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XExpression_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpressionOrVarDeclaration" + + + // $ANTLR start "entryRuleXVariableDeclaration" + // InternalExport.g:7629:1: entryRuleXVariableDeclaration returns [EObject current=null] : iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ; + public final EObject entryRuleXVariableDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXVariableDeclaration = null; + + + try { + // InternalExport.g:7629:61: (iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ) + // InternalExport.g:7630:2: iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXVariableDeclaration=ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXVariableDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXVariableDeclaration" + + + // $ANTLR start "ruleXVariableDeclaration" + // InternalExport.g:7636:1: ruleXVariableDeclaration returns [EObject current=null] : ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ; + public final EObject ruleXVariableDeclaration() throws RecognitionException { + EObject current = null; + + Token lv_writeable_1_0=null; + Token otherlv_2=null; + Token otherlv_6=null; + EObject lv_type_3_0 = null; + + AntlrDatatypeRuleToken lv_name_4_0 = null; + + AntlrDatatypeRuleToken lv_name_5_0 = null; + + EObject lv_right_7_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7642:2: ( ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ) + // InternalExport.g:7643:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) + { + // InternalExport.g:7643:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) + // InternalExport.g:7644:3: () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? + { + // InternalExport.g:7644:3: () + // InternalExport.g:7645:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(), + current); + + } + + } + + // InternalExport.g:7651:3: ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) + int alt128=2; + int LA128_0 = input.LA(1); + + if ( (LA128_0==105) ) { + alt128=1; + } + else if ( (LA128_0==106) ) { + alt128=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 128, 0, input); + + throw nvae; + } + switch (alt128) { + case 1 : + // InternalExport.g:7652:4: ( (lv_writeable_1_0= 'var' ) ) + { + // InternalExport.g:7652:4: ( (lv_writeable_1_0= 'var' ) ) + // InternalExport.g:7653:5: (lv_writeable_1_0= 'var' ) + { + // InternalExport.g:7653:5: (lv_writeable_1_0= 'var' ) + // InternalExport.g:7654:6: lv_writeable_1_0= 'var' + { + lv_writeable_1_0=(Token)match(input,105,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXVariableDeclarationRule()); + } + setWithLastConsumed(current, "writeable", lv_writeable_1_0 != null, "var"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:7667:4: otherlv_2= 'val' + { + otherlv_2=(Token)match(input,106,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + + } + + } + break; + + } + + // InternalExport.g:7672:3: ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) + int alt129=2; + int LA129_0 = input.LA(1); + + if ( (LA129_0==RULE_ID) ) { + int LA129_1 = input.LA(2); + + if ( (synpred31_InternalExport()) ) { + alt129=1; + } + else if ( (true) ) { + alt129=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 129, 1, input); + + throw nvae; + } + } + else if ( (LA129_0==30) && (synpred31_InternalExport())) { + alt129=1; + } + else if ( (LA129_0==94) && (synpred31_InternalExport())) { + alt129=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 129, 0, input); + + throw nvae; + } + switch (alt129) { + case 1 : + // InternalExport.g:7673:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) + { + // InternalExport.g:7673:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) + // InternalExport.g:7674:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) + { + // InternalExport.g:7687:5: ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) + // InternalExport.g:7688:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) + { + // InternalExport.g:7688:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalExport.g:7689:7: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalExport.g:7689:7: (lv_type_3_0= ruleJvmTypeReference ) + // InternalExport.g:7690:8: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + + } + pushFollow(FOLLOW_4); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7707:6: ( (lv_name_4_0= ruleValidID ) ) + // InternalExport.g:7708:7: (lv_name_4_0= ruleValidID ) + { + // InternalExport.g:7708:7: (lv_name_4_0= ruleValidID ) + // InternalExport.g:7709:8: lv_name_4_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + + } + pushFollow(FOLLOW_105); + lv_name_4_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "name", + lv_name_4_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:7729:4: ( (lv_name_5_0= ruleValidID ) ) + { + // InternalExport.g:7729:4: ( (lv_name_5_0= ruleValidID ) ) + // InternalExport.g:7730:5: (lv_name_5_0= ruleValidID ) + { + // InternalExport.g:7730:5: (lv_name_5_0= ruleValidID ) + // InternalExport.g:7731:6: lv_name_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_105); + lv_name_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "name", + lv_name_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalExport.g:7749:3: (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? + int alt130=2; + int LA130_0 = input.LA(1); + + if ( (LA130_0==24) ) { + alt130=1; + } + switch (alt130) { + case 1 : + // InternalExport.g:7750:4: otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) + { + otherlv_6=(Token)match(input,24,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + + } + // InternalExport.g:7754:4: ( (lv_right_7_0= ruleXExpression ) ) + // InternalExport.g:7755:5: (lv_right_7_0= ruleXExpression ) + { + // InternalExport.g:7755:5: (lv_right_7_0= ruleXExpression ) + // InternalExport.g:7756:6: lv_right_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_2); + lv_right_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "right", + lv_right_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXVariableDeclaration" + + + // $ANTLR start "entryRuleJvmFormalParameter" + // InternalExport.g:7778:1: entryRuleJvmFormalParameter returns [EObject current=null] : iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ; + public final EObject entryRuleJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmFormalParameter = null; + + + try { + // InternalExport.g:7778:59: (iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ) + // InternalExport.g:7779:2: iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmFormalParameter=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmFormalParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmFormalParameter" + + + // $ANTLR start "ruleJvmFormalParameter" + // InternalExport.g:7785:1: ruleJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ; + public final EObject ruleJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject lv_parameterType_0_0 = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7791:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ) + // InternalExport.g:7792:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) + { + // InternalExport.g:7792:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) + // InternalExport.g:7793:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) + { + // InternalExport.g:7793:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? + int alt131=2; + int LA131_0 = input.LA(1); + + if ( (LA131_0==RULE_ID) ) { + int LA131_1 = input.LA(2); + + if ( (LA131_1==RULE_ID||LA131_1==22||LA131_1==60||LA131_1==65) ) { + alt131=1; + } + } + else if ( (LA131_0==30||LA131_0==94) ) { + alt131=1; + } + switch (alt131) { + case 1 : + // InternalExport.g:7794:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + { + // InternalExport.g:7794:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + // InternalExport.g:7795:5: lv_parameterType_0_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_4); + lv_parameterType_0_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + // InternalExport.g:7812:3: ( (lv_name_1_0= ruleValidID ) ) + // InternalExport.g:7813:4: (lv_name_1_0= ruleValidID ) + { + // InternalExport.g:7813:4: (lv_name_1_0= ruleValidID ) + // InternalExport.g:7814:5: lv_name_1_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_name_1_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmFormalParameter" + + + // $ANTLR start "entryRuleFullJvmFormalParameter" + // InternalExport.g:7835:1: entryRuleFullJvmFormalParameter returns [EObject current=null] : iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ; + public final EObject entryRuleFullJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleFullJvmFormalParameter = null; + + + try { + // InternalExport.g:7835:63: (iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ) + // InternalExport.g:7836:2: iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleFullJvmFormalParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFullJvmFormalParameter" + + + // $ANTLR start "ruleFullJvmFormalParameter" + // InternalExport.g:7842:1: ruleFullJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ; + public final EObject ruleFullJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject lv_parameterType_0_0 = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7848:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ) + // InternalExport.g:7849:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) + { + // InternalExport.g:7849:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) + // InternalExport.g:7850:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) + { + // InternalExport.g:7850:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) + // InternalExport.g:7851:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + { + // InternalExport.g:7851:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + // InternalExport.g:7852:5: lv_parameterType_0_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_4); + lv_parameterType_0_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7869:3: ( (lv_name_1_0= ruleValidID ) ) + // InternalExport.g:7870:4: (lv_name_1_0= ruleValidID ) + { + // InternalExport.g:7870:4: (lv_name_1_0= ruleValidID ) + // InternalExport.g:7871:5: lv_name_1_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_name_1_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFullJvmFormalParameter" + + + // $ANTLR start "entryRuleXFeatureCall" + // InternalExport.g:7892:1: entryRuleXFeatureCall returns [EObject current=null] : iv_ruleXFeatureCall= ruleXFeatureCall EOF ; + public final EObject entryRuleXFeatureCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFeatureCall = null; + + + try { + // InternalExport.g:7892:53: (iv_ruleXFeatureCall= ruleXFeatureCall EOF ) + // InternalExport.g:7893:2: iv_ruleXFeatureCall= ruleXFeatureCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFeatureCall=ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFeatureCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFeatureCall" + + + // $ANTLR start "ruleXFeatureCall" + // InternalExport.g:7899:1: ruleXFeatureCall returns [EObject current=null] : ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ; + public final EObject ruleXFeatureCall() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token lv_explicitOperationCall_7_0=null; + Token otherlv_10=null; + Token otherlv_12=null; + EObject lv_typeArguments_2_0 = null; + + EObject lv_typeArguments_4_0 = null; + + EObject lv_featureCallArguments_8_0 = null; + + EObject lv_featureCallArguments_9_0 = null; + + EObject lv_featureCallArguments_11_0 = null; + + EObject lv_featureCallArguments_13_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:7905:2: ( ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ) + // InternalExport.g:7906:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) + { + // InternalExport.g:7906:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) + // InternalExport.g:7907:3: () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? + { + // InternalExport.g:7907:3: () + // InternalExport.g:7908:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(), + current); + + } + + } + + // InternalExport.g:7914:3: (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? + int alt133=2; + int LA133_0 = input.LA(1); + + if ( (LA133_0==60) ) { + alt133=1; + } + switch (alt133) { + case 1 : + // InternalExport.g:7915:4: otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' + { + otherlv_1=(Token)match(input,60,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + + } + // InternalExport.g:7919:4: ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:7920:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:7920:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:7921:6: lv_typeArguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_82); + lv_typeArguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7938:4: (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop132: + do { + int alt132=2; + int LA132_0 = input.LA(1); + + if ( (LA132_0==25) ) { + alt132=1; + } + + + switch (alt132) { + case 1 : + // InternalExport.g:7939:5: otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,25,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + + } + // InternalExport.g:7943:5: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:7944:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:7944:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:7945:7: lv_typeArguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_82); + lv_typeArguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop132; + } + } while (true); + + otherlv_5=(Token)match(input,59,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + + } + + } + break; + + } + + // InternalExport.g:7968:3: ( ( ruleIdOrSuper ) ) + // InternalExport.g:7969:4: ( ruleIdOrSuper ) + { + // InternalExport.g:7969:4: ( ruleIdOrSuper ) + // InternalExport.g:7970:5: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + + } + pushFollow(FOLLOW_106); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:7984:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? + int alt136=2; + alt136 = dfa136.predict(input); + switch (alt136) { + case 1 : + // InternalExport.g:7985:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' + { + // InternalExport.g:7985:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) + // InternalExport.g:7986:5: ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) + { + // InternalExport.g:7990:5: (lv_explicitOperationCall_7_0= '(' ) + // InternalExport.g:7991:6: lv_explicitOperationCall_7_0= '(' + { + lv_explicitOperationCall_7_0=(Token)match(input,30,FOLLOW_84); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + setWithLastConsumed(current, "explicitOperationCall", lv_explicitOperationCall_7_0 != null, "("); + + } + + } + + + } + + // InternalExport.g:8003:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? + int alt135=3; + alt135 = dfa135.predict(input); + switch (alt135) { + case 1 : + // InternalExport.g:8004:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) + { + // InternalExport.g:8004:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) + // InternalExport.g:8005:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) + { + // InternalExport.g:8030:6: (lv_featureCallArguments_8_0= ruleXShortClosure ) + // InternalExport.g:8031:7: lv_featureCallArguments_8_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + + } + pushFollow(FOLLOW_24); + lv_featureCallArguments_8_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_8_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:8049:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) + { + // InternalExport.g:8049:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) + // InternalExport.g:8050:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* + { + // InternalExport.g:8050:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) + // InternalExport.g:8051:7: (lv_featureCallArguments_9_0= ruleXExpression ) + { + // InternalExport.g:8051:7: (lv_featureCallArguments_9_0= ruleXExpression ) + // InternalExport.g:8052:8: lv_featureCallArguments_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + + } + pushFollow(FOLLOW_57); + lv_featureCallArguments_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:8069:6: (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* + loop134: + do { + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==25) ) { + alt134=1; + } + + + switch (alt134) { + case 1 : + // InternalExport.g:8070:7: otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) + { + otherlv_10=(Token)match(input,25,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + + } + // InternalExport.g:8074:7: ( (lv_featureCallArguments_11_0= ruleXExpression ) ) + // InternalExport.g:8075:8: (lv_featureCallArguments_11_0= ruleXExpression ) + { + // InternalExport.g:8075:8: (lv_featureCallArguments_11_0= ruleXExpression ) + // InternalExport.g:8076:9: lv_featureCallArguments_11_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + + } + pushFollow(FOLLOW_57); + lv_featureCallArguments_11_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop134; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_12=(Token)match(input,31,FOLLOW_107); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + + } + + } + break; + + } + + // InternalExport.g:8101:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? + int alt137=2; + alt137 = dfa137.predict(input); + switch (alt137) { + case 1 : + // InternalExport.g:8102:4: ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) + { + // InternalExport.g:8108:4: (lv_featureCallArguments_13_0= ruleXClosure ) + // InternalExport.g:8109:5: lv_featureCallArguments_13_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_2); + lv_featureCallArguments_13_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_13_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFeatureCall" + + + // $ANTLR start "entryRuleFeatureCallID" + // InternalExport.g:8130:1: entryRuleFeatureCallID returns [String current=null] : iv_ruleFeatureCallID= ruleFeatureCallID EOF ; + public final String entryRuleFeatureCallID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleFeatureCallID = null; + + + try { + // InternalExport.g:8130:53: (iv_ruleFeatureCallID= ruleFeatureCallID EOF ) + // InternalExport.g:8131:2: iv_ruleFeatureCallID= ruleFeatureCallID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleFeatureCallID=ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleFeatureCallID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFeatureCallID" + + + // $ANTLR start "ruleFeatureCallID" + // InternalExport.g:8137:1: ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ; + public final AntlrDatatypeRuleToken ruleFeatureCallID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8143:2: ( (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ) + // InternalExport.g:8144:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) + { + // InternalExport.g:8144:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) + int alt138=5; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt138=1; + } + break; + case 107: + { + alt138=2; + } + break; + case 108: + { + alt138=3; + } + break; + case 20: + { + alt138=4; + } + break; + case 15: + { + alt138=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 138, 0, input); + + throw nvae; + } + + switch (alt138) { + case 1 : + // InternalExport.g:8145:3: this_ValidID_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:8156:3: kw= 'extends' + { + kw=(Token)match(input,107,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + + } + + } + break; + case 3 : + // InternalExport.g:8162:3: kw= 'static' + { + kw=(Token)match(input,108,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + + } + + } + break; + case 4 : + // InternalExport.g:8168:3: kw= 'import' + { + kw=(Token)match(input,20,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + + } + + } + break; + case 5 : + // InternalExport.g:8174:3: kw= 'extension' + { + kw=(Token)match(input,15,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFeatureCallID" + + + // $ANTLR start "entryRuleIdOrSuper" + // InternalExport.g:8183:1: entryRuleIdOrSuper returns [String current=null] : iv_ruleIdOrSuper= ruleIdOrSuper EOF ; + public final String entryRuleIdOrSuper() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleIdOrSuper = null; + + + try { + // InternalExport.g:8183:49: (iv_ruleIdOrSuper= ruleIdOrSuper EOF ) + // InternalExport.g:8184:2: iv_ruleIdOrSuper= ruleIdOrSuper EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_1); + iv_ruleIdOrSuper=ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleIdOrSuper.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleIdOrSuper" + + + // $ANTLR start "ruleIdOrSuper" + // InternalExport.g:8190:1: ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ; + public final AntlrDatatypeRuleToken ruleIdOrSuper() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_FeatureCallID_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8196:2: ( (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ) + // InternalExport.g:8197:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) + { + // InternalExport.g:8197:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==RULE_ID||LA139_0==15||LA139_0==20||(LA139_0>=107 && LA139_0<=108)) ) { + alt139=1; + } + else if ( (LA139_0==109) ) { + alt139=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 139, 0, input); + + throw nvae; + } + switch (alt139) { + case 1 : + // InternalExport.g:8198:3: this_FeatureCallID_0= ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_FeatureCallID_0=ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_FeatureCallID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:8209:3: kw= 'super' + { + kw=(Token)match(input,109,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleIdOrSuper" + + + // $ANTLR start "entryRuleXConstructorCall" + // InternalExport.g:8218:1: entryRuleXConstructorCall returns [EObject current=null] : iv_ruleXConstructorCall= ruleXConstructorCall EOF ; + public final EObject entryRuleXConstructorCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXConstructorCall = null; + + + try { + // InternalExport.g:8218:57: (iv_ruleXConstructorCall= ruleXConstructorCall EOF ) + // InternalExport.g:8219:2: iv_ruleXConstructorCall= ruleXConstructorCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXConstructorCall=ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXConstructorCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXConstructorCall" + + + // $ANTLR start "ruleXConstructorCall" + // InternalExport.g:8225:1: ruleXConstructorCall returns [EObject current=null] : ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ; + public final EObject ruleXConstructorCall() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token lv_explicitConstructorCall_8_0=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_typeArguments_4_0 = null; + + EObject lv_typeArguments_6_0 = null; + + EObject lv_arguments_9_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + EObject lv_arguments_14_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8231:2: ( ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ) + // InternalExport.g:8232:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) + { + // InternalExport.g:8232:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) + // InternalExport.g:8233:3: () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? + { + // InternalExport.g:8233:3: () + // InternalExport.g:8234:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,80,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + + } + // InternalExport.g:8244:3: ( ( ruleQualifiedName ) ) + // InternalExport.g:8245:4: ( ruleQualifiedName ) + { + // InternalExport.g:8245:4: ( ruleQualifiedName ) + // InternalExport.g:8246:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + + } + pushFollow(FOLLOW_108); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:8260:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? + int alt141=2; + alt141 = dfa141.predict(input); + switch (alt141) { + case 1 : + // InternalExport.g:8261:4: ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' + { + // InternalExport.g:8261:4: ( ( '<' )=>otherlv_3= '<' ) + // InternalExport.g:8262:5: ( '<' )=>otherlv_3= '<' + { + otherlv_3=(Token)match(input,60,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + + } + + } + + // InternalExport.g:8268:4: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:8269:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:8269:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:8270:6: lv_typeArguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_82); + lv_typeArguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:8287:4: (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* + loop140: + do { + int alt140=2; + int LA140_0 = input.LA(1); + + if ( (LA140_0==25) ) { + alt140=1; + } + + + switch (alt140) { + case 1 : + // InternalExport.g:8288:5: otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_5=(Token)match(input,25,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + + } + // InternalExport.g:8292:5: ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:8293:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:8293:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:8294:7: lv_typeArguments_6_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + + } + pushFollow(FOLLOW_82); + lv_typeArguments_6_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop140; + } + } while (true); + + otherlv_7=(Token)match(input,59,FOLLOW_106); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + + } + + } + break; + + } + + // InternalExport.g:8317:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? + int alt144=2; + alt144 = dfa144.predict(input); + switch (alt144) { + case 1 : + // InternalExport.g:8318:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' + { + // InternalExport.g:8318:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) + // InternalExport.g:8319:5: ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) + { + // InternalExport.g:8323:5: (lv_explicitConstructorCall_8_0= '(' ) + // InternalExport.g:8324:6: lv_explicitConstructorCall_8_0= '(' + { + lv_explicitConstructorCall_8_0=(Token)match(input,30,FOLLOW_84); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + setWithLastConsumed(current, "explicitConstructorCall", lv_explicitConstructorCall_8_0 != null, "("); + + } + + } + + + } + + // InternalExport.g:8336:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? + int alt143=3; + alt143 = dfa143.predict(input); + switch (alt143) { + case 1 : + // InternalExport.g:8337:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) + { + // InternalExport.g:8337:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) + // InternalExport.g:8338:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) + { + // InternalExport.g:8363:6: (lv_arguments_9_0= ruleXShortClosure ) + // InternalExport.g:8364:7: lv_arguments_9_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + + } + pushFollow(FOLLOW_24); + lv_arguments_9_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:8382:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) + { + // InternalExport.g:8382:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) + // InternalExport.g:8383:6: ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* + { + // InternalExport.g:8383:6: ( (lv_arguments_10_0= ruleXExpression ) ) + // InternalExport.g:8384:7: (lv_arguments_10_0= ruleXExpression ) + { + // InternalExport.g:8384:7: (lv_arguments_10_0= ruleXExpression ) + // InternalExport.g:8385:8: lv_arguments_10_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + + } + pushFollow(FOLLOW_57); + lv_arguments_10_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:8402:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* + loop142: + do { + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==25) ) { + alt142=1; + } + + + switch (alt142) { + case 1 : + // InternalExport.g:8403:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) + { + otherlv_11=(Token)match(input,25,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + + } + // InternalExport.g:8407:7: ( (lv_arguments_12_0= ruleXExpression ) ) + // InternalExport.g:8408:8: (lv_arguments_12_0= ruleXExpression ) + { + // InternalExport.g:8408:8: (lv_arguments_12_0= ruleXExpression ) + // InternalExport.g:8409:9: lv_arguments_12_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + + } + pushFollow(FOLLOW_57); + lv_arguments_12_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop142; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_13=(Token)match(input,31,FOLLOW_107); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + + } + + } + break; + + } + + // InternalExport.g:8434:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? + int alt145=2; + alt145 = dfa145.predict(input); + switch (alt145) { + case 1 : + // InternalExport.g:8435:4: ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) + { + // InternalExport.g:8441:4: (lv_arguments_14_0= ruleXClosure ) + // InternalExport.g:8442:5: lv_arguments_14_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_2); + lv_arguments_14_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_14_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXConstructorCall" + + + // $ANTLR start "entryRuleXBooleanLiteral" + // InternalExport.g:8463:1: entryRuleXBooleanLiteral returns [EObject current=null] : iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ; + public final EObject entryRuleXBooleanLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBooleanLiteral = null; + + + try { + // InternalExport.g:8463:56: (iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ) + // InternalExport.g:8464:2: iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBooleanLiteral=ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBooleanLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBooleanLiteral" + + + // $ANTLR start "ruleXBooleanLiteral" + // InternalExport.g:8470:1: ruleXBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ; + public final EObject ruleXBooleanLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_isTrue_2_0=null; + + + enterRule(); + + try { + // InternalExport.g:8476:2: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ) + // InternalExport.g:8477:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) + { + // InternalExport.g:8477:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) + // InternalExport.g:8478:3: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) + { + // InternalExport.g:8478:3: () + // InternalExport.g:8479:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(), + current); + + } + + } + + // InternalExport.g:8485:3: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==77) ) { + alt146=1; + } + else if ( (LA146_0==76) ) { + alt146=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 146, 0, input); + + throw nvae; + } + switch (alt146) { + case 1 : + // InternalExport.g:8486:4: otherlv_1= 'false' + { + otherlv_1=(Token)match(input,77,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + + } + + } + break; + case 2 : + // InternalExport.g:8491:4: ( (lv_isTrue_2_0= 'true' ) ) + { + // InternalExport.g:8491:4: ( (lv_isTrue_2_0= 'true' ) ) + // InternalExport.g:8492:5: (lv_isTrue_2_0= 'true' ) + { + // InternalExport.g:8492:5: (lv_isTrue_2_0= 'true' ) + // InternalExport.g:8493:6: lv_isTrue_2_0= 'true' + { + lv_isTrue_2_0=(Token)match(input,76,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXBooleanLiteralRule()); + } + setWithLastConsumed(current, "isTrue", lv_isTrue_2_0 != null, "true"); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBooleanLiteral" + + + // $ANTLR start "entryRuleXNullLiteral" + // InternalExport.g:8510:1: entryRuleXNullLiteral returns [EObject current=null] : iv_ruleXNullLiteral= ruleXNullLiteral EOF ; + public final EObject entryRuleXNullLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXNullLiteral = null; + + + try { + // InternalExport.g:8510:53: (iv_ruleXNullLiteral= ruleXNullLiteral EOF ) + // InternalExport.g:8511:2: iv_ruleXNullLiteral= ruleXNullLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXNullLiteral=ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXNullLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXNullLiteral" + + + // $ANTLR start "ruleXNullLiteral" + // InternalExport.g:8517:1: ruleXNullLiteral returns [EObject current=null] : ( () otherlv_1= 'null' ) ; + public final EObject ruleXNullLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalExport.g:8523:2: ( ( () otherlv_1= 'null' ) ) + // InternalExport.g:8524:2: ( () otherlv_1= 'null' ) + { + // InternalExport.g:8524:2: ( () otherlv_1= 'null' ) + // InternalExport.g:8525:3: () otherlv_1= 'null' + { + // InternalExport.g:8525:3: () + // InternalExport.g:8526:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,78,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXNullLiteral" + + + // $ANTLR start "entryRuleXNumberLiteral" + // InternalExport.g:8540:1: entryRuleXNumberLiteral returns [EObject current=null] : iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ; + public final EObject entryRuleXNumberLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXNumberLiteral = null; + + + try { + // InternalExport.g:8540:55: (iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ) + // InternalExport.g:8541:2: iv_ruleXNumberLiteral= ruleXNumberLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXNumberLiteral=ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXNumberLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXNumberLiteral" + + + // $ANTLR start "ruleXNumberLiteral" + // InternalExport.g:8547:1: ruleXNumberLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleNumber ) ) ) ; + public final EObject ruleXNumberLiteral() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8553:2: ( ( () ( (lv_value_1_0= ruleNumber ) ) ) ) + // InternalExport.g:8554:2: ( () ( (lv_value_1_0= ruleNumber ) ) ) + { + // InternalExport.g:8554:2: ( () ( (lv_value_1_0= ruleNumber ) ) ) + // InternalExport.g:8555:3: () ( (lv_value_1_0= ruleNumber ) ) + { + // InternalExport.g:8555:3: () + // InternalExport.g:8556:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(), + current); + + } + + } + + // InternalExport.g:8562:3: ( (lv_value_1_0= ruleNumber ) ) + // InternalExport.g:8563:4: (lv_value_1_0= ruleNumber ) + { + // InternalExport.g:8563:4: (lv_value_1_0= ruleNumber ) + // InternalExport.g:8564:5: lv_value_1_0= ruleNumber + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_value_1_0=ruleNumber(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXNumberLiteralRule()); + } + set( + current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xbase.Number"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXNumberLiteral" + + + // $ANTLR start "entryRuleXStringLiteral" + // InternalExport.g:8585:1: entryRuleXStringLiteral returns [EObject current=null] : iv_ruleXStringLiteral= ruleXStringLiteral EOF ; + public final EObject entryRuleXStringLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXStringLiteral = null; + + + try { + // InternalExport.g:8585:55: (iv_ruleXStringLiteral= ruleXStringLiteral EOF ) + // InternalExport.g:8586:2: iv_ruleXStringLiteral= ruleXStringLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXStringLiteral=ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXStringLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXStringLiteral" + + + // $ANTLR start "ruleXStringLiteral" + // InternalExport.g:8592:1: ruleXStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ; + public final EObject ruleXStringLiteral() throws RecognitionException { + EObject current = null; + + Token lv_value_1_0=null; + + + enterRule(); + + try { + // InternalExport.g:8598:2: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) ) + // InternalExport.g:8599:2: ( () ( (lv_value_1_0= RULE_STRING ) ) ) + { + // InternalExport.g:8599:2: ( () ( (lv_value_1_0= RULE_STRING ) ) ) + // InternalExport.g:8600:3: () ( (lv_value_1_0= RULE_STRING ) ) + { + // InternalExport.g:8600:3: () + // InternalExport.g:8601:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(), + current); + + } + + } + + // InternalExport.g:8607:3: ( (lv_value_1_0= RULE_STRING ) ) + // InternalExport.g:8608:4: (lv_value_1_0= RULE_STRING ) + { + // InternalExport.g:8608:4: (lv_value_1_0= RULE_STRING ) + // InternalExport.g:8609:5: lv_value_1_0= RULE_STRING + { + lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXStringLiteralRule()); + } + setWithLastConsumed( + current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXStringLiteral" + + + // $ANTLR start "entryRuleXTypeLiteral" + // InternalExport.g:8629:1: entryRuleXTypeLiteral returns [EObject current=null] : iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ; + public final EObject entryRuleXTypeLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXTypeLiteral = null; + + + try { + // InternalExport.g:8629:53: (iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ) + // InternalExport.g:8630:2: iv_ruleXTypeLiteral= ruleXTypeLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXTypeLiteral=ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXTypeLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXTypeLiteral" + + + // $ANTLR start "ruleXTypeLiteral" + // InternalExport.g:8636:1: ruleXTypeLiteral returns [EObject current=null] : ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ; + public final EObject ruleXTypeLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_5=null; + AntlrDatatypeRuleToken lv_arrayDimensions_4_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8642:2: ( ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ) + // InternalExport.g:8643:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) + { + // InternalExport.g:8643:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) + // InternalExport.g:8644:3: () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' + { + // InternalExport.g:8644:3: () + // InternalExport.g:8645:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,110,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + + } + otherlv_2=(Token)match(input,30,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExport.g:8659:3: ( ( ruleQualifiedName ) ) + // InternalExport.g:8660:4: ( ruleQualifiedName ) + { + // InternalExport.g:8660:4: ( ruleQualifiedName ) + // InternalExport.g:8661:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXTypeLiteralRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + + } + pushFollow(FOLLOW_109); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:8675:3: ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* + loop147: + do { + int alt147=2; + int LA147_0 = input.LA(1); + + if ( (LA147_0==22) ) { + alt147=1; + } + + + switch (alt147) { + case 1 : + // InternalExport.g:8676:4: (lv_arrayDimensions_4_0= ruleArrayBrackets ) + { + // InternalExport.g:8676:4: (lv_arrayDimensions_4_0= ruleArrayBrackets ) + // InternalExport.g:8677:5: lv_arrayDimensions_4_0= ruleArrayBrackets + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_109); + lv_arrayDimensions_4_0=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTypeLiteralRule()); + } + add( + current, + "arrayDimensions", + lv_arrayDimensions_4_0, + "org.eclipse.xtext.xbase.Xtype.ArrayBrackets"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop147; + } + } while (true); + + otherlv_5=(Token)match(input,31,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXTypeLiteral" + + + // $ANTLR start "entryRuleXThrowExpression" + // InternalExport.g:8702:1: entryRuleXThrowExpression returns [EObject current=null] : iv_ruleXThrowExpression= ruleXThrowExpression EOF ; + public final EObject entryRuleXThrowExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXThrowExpression = null; + + + try { + // InternalExport.g:8702:57: (iv_ruleXThrowExpression= ruleXThrowExpression EOF ) + // InternalExport.g:8703:2: iv_ruleXThrowExpression= ruleXThrowExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXThrowExpression=ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXThrowExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXThrowExpression" + + + // $ANTLR start "ruleXThrowExpression" + // InternalExport.g:8709:1: ruleXThrowExpression returns [EObject current=null] : ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ; + public final EObject ruleXThrowExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_expression_2_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8715:2: ( ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ) + // InternalExport.g:8716:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) + { + // InternalExport.g:8716:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) + // InternalExport.g:8717:3: () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) + { + // InternalExport.g:8717:3: () + // InternalExport.g:8718:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,111,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + + } + // InternalExport.g:8728:3: ( (lv_expression_2_0= ruleXExpression ) ) + // InternalExport.g:8729:4: (lv_expression_2_0= ruleXExpression ) + { + // InternalExport.g:8729:4: (lv_expression_2_0= ruleXExpression ) + // InternalExport.g:8730:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXThrowExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXThrowExpression" + + + // $ANTLR start "entryRuleXReturnExpression" + // InternalExport.g:8751:1: entryRuleXReturnExpression returns [EObject current=null] : iv_ruleXReturnExpression= ruleXReturnExpression EOF ; + public final EObject entryRuleXReturnExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXReturnExpression = null; + + + try { + // InternalExport.g:8751:58: (iv_ruleXReturnExpression= ruleXReturnExpression EOF ) + // InternalExport.g:8752:2: iv_ruleXReturnExpression= ruleXReturnExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXReturnExpression=ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXReturnExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXReturnExpression" + + + // $ANTLR start "ruleXReturnExpression" + // InternalExport.g:8758:1: ruleXReturnExpression returns [EObject current=null] : ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ; + public final EObject ruleXReturnExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_expression_2_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8764:2: ( ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ) + // InternalExport.g:8765:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) + { + // InternalExport.g:8765:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) + // InternalExport.g:8766:3: () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? + { + // InternalExport.g:8766:3: () + // InternalExport.g:8767:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,112,FOLLOW_110); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + + } + // InternalExport.g:8777:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? + int alt148=2; + alt148 = dfa148.predict(input); + switch (alt148) { + case 1 : + // InternalExport.g:8778:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) + { + // InternalExport.g:8779:4: (lv_expression_2_0= ruleXExpression ) + // InternalExport.g:8780:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXReturnExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXReturnExpression" + + + // $ANTLR start "entryRuleXTryCatchFinallyExpression" + // InternalExport.g:8801:1: entryRuleXTryCatchFinallyExpression returns [EObject current=null] : iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ; + public final EObject entryRuleXTryCatchFinallyExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXTryCatchFinallyExpression = null; + + + try { + // InternalExport.g:8801:67: (iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ) + // InternalExport.g:8802:2: iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXTryCatchFinallyExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXTryCatchFinallyExpression" + + + // $ANTLR start "ruleXTryCatchFinallyExpression" + // InternalExport.g:8808:1: ruleXTryCatchFinallyExpression returns [EObject current=null] : ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ; + public final EObject ruleXTryCatchFinallyExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_expression_2_0 = null; + + EObject lv_catchClauses_3_0 = null; + + EObject lv_finallyExpression_5_0 = null; + + EObject lv_finallyExpression_7_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8814:2: ( ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ) + // InternalExport.g:8815:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) + { + // InternalExport.g:8815:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) + // InternalExport.g:8816:3: () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) + { + // InternalExport.g:8816:3: () + // InternalExport.g:8817:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,113,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + + } + // InternalExport.g:8827:3: ( (lv_expression_2_0= ruleXExpression ) ) + // InternalExport.g:8828:4: (lv_expression_2_0= ruleXExpression ) + { + // InternalExport.g:8828:4: (lv_expression_2_0= ruleXExpression ) + // InternalExport.g:8829:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_111); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:8846:3: ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) + int alt151=2; + int LA151_0 = input.LA(1); + + if ( (LA151_0==116) ) { + alt151=1; + } + else if ( (LA151_0==114) ) { + alt151=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 151, 0, input); + + throw nvae; + } + switch (alt151) { + case 1 : + // InternalExport.g:8847:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) + { + // InternalExport.g:8847:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) + // InternalExport.g:8848:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? + { + // InternalExport.g:8848:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ + int cnt149=0; + loop149: + do { + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==116) ) { + int LA149_2 = input.LA(2); + + if ( (synpred40_InternalExport()) ) { + alt149=1; + } + + + } + + + switch (alt149) { + case 1 : + // InternalExport.g:8849:6: ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) + { + // InternalExport.g:8850:6: (lv_catchClauses_3_0= ruleXCatchClause ) + // InternalExport.g:8851:7: lv_catchClauses_3_0= ruleXCatchClause + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + + } + pushFollow(FOLLOW_112); + lv_catchClauses_3_0=ruleXCatchClause(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + add( + current, + "catchClauses", + lv_catchClauses_3_0, + "org.eclipse.xtext.xbase.Xbase.XCatchClause"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + if ( cnt149 >= 1 ) break loop149; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(149, input); + throw eee; + } + cnt149++; + } while (true); + + // InternalExport.g:8868:5: ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? + int alt150=2; + int LA150_0 = input.LA(1); + + if ( (LA150_0==114) ) { + int LA150_1 = input.LA(2); + + if ( (synpred41_InternalExport()) ) { + alt150=1; + } + } + switch (alt150) { + case 1 : + // InternalExport.g:8869:6: ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) + { + // InternalExport.g:8869:6: ( ( 'finally' )=>otherlv_4= 'finally' ) + // InternalExport.g:8870:7: ( 'finally' )=>otherlv_4= 'finally' + { + otherlv_4=(Token)match(input,114,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + + } + + } + + // InternalExport.g:8876:6: ( (lv_finallyExpression_5_0= ruleXExpression ) ) + // InternalExport.g:8877:7: (lv_finallyExpression_5_0= ruleXExpression ) + { + // InternalExport.g:8877:7: (lv_finallyExpression_5_0= ruleXExpression ) + // InternalExport.g:8878:8: lv_finallyExpression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_finallyExpression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "finallyExpression", + lv_finallyExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:8898:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) + { + // InternalExport.g:8898:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) + // InternalExport.g:8899:5: otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) + { + otherlv_6=(Token)match(input,114,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + + } + // InternalExport.g:8903:5: ( (lv_finallyExpression_7_0= ruleXExpression ) ) + // InternalExport.g:8904:6: (lv_finallyExpression_7_0= ruleXExpression ) + { + // InternalExport.g:8904:6: (lv_finallyExpression_7_0= ruleXExpression ) + // InternalExport.g:8905:7: lv_finallyExpression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_finallyExpression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "finallyExpression", + lv_finallyExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXTryCatchFinallyExpression" + + + // $ANTLR start "entryRuleXSynchronizedExpression" + // InternalExport.g:8928:1: entryRuleXSynchronizedExpression returns [EObject current=null] : iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ; + public final EObject entryRuleXSynchronizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSynchronizedExpression = null; + + + try { + // InternalExport.g:8928:64: (iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ) + // InternalExport.g:8929:2: iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSynchronizedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSynchronizedExpression" + + + // $ANTLR start "ruleXSynchronizedExpression" + // InternalExport.g:8935:1: ruleXSynchronizedExpression returns [EObject current=null] : ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXSynchronizedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_param_3_0 = null; + + EObject lv_expression_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:8941:2: ( ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ) + // InternalExport.g:8942:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) + { + // InternalExport.g:8942:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) + // InternalExport.g:8943:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) + { + // InternalExport.g:8943:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) + // InternalExport.g:8944:4: ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) + { + // InternalExport.g:8951:4: ( () otherlv_1= 'synchronized' otherlv_2= '(' ) + // InternalExport.g:8952:5: () otherlv_1= 'synchronized' otherlv_2= '(' + { + // InternalExport.g:8952:5: () + // InternalExport.g:8953:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,115,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + + } + otherlv_2=(Token)match(input,30,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + + } + + } + + + } + + // InternalExport.g:8969:3: ( (lv_param_3_0= ruleXExpression ) ) + // InternalExport.g:8970:4: (lv_param_3_0= ruleXExpression ) + { + // InternalExport.g:8970:4: (lv_param_3_0= ruleXExpression ) + // InternalExport.g:8971:5: lv_param_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_24); + lv_param_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + current, + "param", + lv_param_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,31,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + + } + // InternalExport.g:8992:3: ( (lv_expression_5_0= ruleXExpression ) ) + // InternalExport.g:8993:4: (lv_expression_5_0= ruleXExpression ) + { + // InternalExport.g:8993:4: (lv_expression_5_0= ruleXExpression ) + // InternalExport.g:8994:5: lv_expression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSynchronizedExpression" + + + // $ANTLR start "entryRuleXCatchClause" + // InternalExport.g:9015:1: entryRuleXCatchClause returns [EObject current=null] : iv_ruleXCatchClause= ruleXCatchClause EOF ; + public final EObject entryRuleXCatchClause() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCatchClause = null; + + + try { + // InternalExport.g:9015:53: (iv_ruleXCatchClause= ruleXCatchClause EOF ) + // InternalExport.g:9016:2: iv_ruleXCatchClause= ruleXCatchClause EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCatchClause=ruleXCatchClause(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCatchClause; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCatchClause" + + + // $ANTLR start "ruleXCatchClause" + // InternalExport.g:9022:1: ruleXCatchClause returns [EObject current=null] : ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ; + public final EObject ruleXCatchClause() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + EObject lv_declaredParam_2_0 = null; + + EObject lv_expression_4_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9028:2: ( ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ) + // InternalExport.g:9029:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) + { + // InternalExport.g:9029:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) + // InternalExport.g:9030:3: ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) + { + // InternalExport.g:9030:3: ( ( 'catch' )=>otherlv_0= 'catch' ) + // InternalExport.g:9031:4: ( 'catch' )=>otherlv_0= 'catch' + { + otherlv_0=(Token)match(input,116,FOLLOW_23); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + + } + + } + + otherlv_1=(Token)match(input,30,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + + } + // InternalExport.g:9041:3: ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) + // InternalExport.g:9042:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) + { + // InternalExport.g:9042:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) + // InternalExport.g:9043:5: lv_declaredParam_2_0= ruleFullJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_24); + lv_declaredParam_2_0=ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_2_0, + "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_3=(Token)match(input,31,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + + } + // InternalExport.g:9064:3: ( (lv_expression_4_0= ruleXExpression ) ) + // InternalExport.g:9065:4: (lv_expression_4_0= ruleXExpression ) + { + // InternalExport.g:9065:4: (lv_expression_4_0= ruleXExpression ) + // InternalExport.g:9066:5: lv_expression_4_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_4_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + current, + "expression", + lv_expression_4_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCatchClause" + + + // $ANTLR start "entryRuleQualifiedName" + // InternalExport.g:9087:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + public final String entryRuleQualifiedName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedName = null; + + + try { + // InternalExport.g:9087:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalExport.g:9088:2: iv_ruleQualifiedName= ruleQualifiedName EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedName=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedName.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // InternalExport.g:9094:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ; + public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + AntlrDatatypeRuleToken this_ValidID_2 = null; + + + + enterRule(); + + try { + // InternalExport.g:9100:2: ( (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ) + // InternalExport.g:9101:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) + { + // InternalExport.g:9101:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) + // InternalExport.g:9102:3: this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_55); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:9112:3: ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* + loop152: + do { + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==65) ) { + int LA152_2 = input.LA(2); + + if ( (LA152_2==RULE_ID) ) { + int LA152_3 = input.LA(3); + + if ( (synpred44_InternalExport()) ) { + alt152=1; + } + + + } + + + } + + + switch (alt152) { + case 1 : + // InternalExport.g:9113:4: ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID + { + // InternalExport.g:9113:4: ( ( '.' )=>kw= '.' ) + // InternalExport.g:9114:5: ( '.' )=>kw= '.' + { + kw=(Token)match(input,65,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + + } + pushFollow(FOLLOW_55); + this_ValidID_2=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_2); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + + default : + break loop152; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedName" + + + // $ANTLR start "entryRuleNumber" + // InternalExport.g:9136:1: entryRuleNumber returns [String current=null] : iv_ruleNumber= ruleNumber EOF ; + public final String entryRuleNumber() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleNumber = null; + + + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // InternalExport.g:9138:2: (iv_ruleNumber= ruleNumber EOF ) + // InternalExport.g:9139:2: iv_ruleNumber= ruleNumber EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_1); + iv_ruleNumber=ruleNumber(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleNumber.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + + myHiddenTokenState.restore(); + + } + return current; + } + // $ANTLR end "entryRuleNumber" + + + // $ANTLR start "ruleNumber" + // InternalExport.g:9148:1: ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ; + public final AntlrDatatypeRuleToken ruleNumber() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_HEX_0=null; + Token this_INT_1=null; + Token this_DECIMAL_2=null; + Token kw=null; + Token this_INT_4=null; + Token this_DECIMAL_5=null; + + + enterRule(); + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // InternalExport.g:9155:2: ( (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ) + // InternalExport.g:9156:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) + { + // InternalExport.g:9156:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) + int alt156=2; + int LA156_0 = input.LA(1); + + if ( (LA156_0==RULE_HEX) ) { + alt156=1; + } + else if ( (LA156_0==RULE_INT||LA156_0==RULE_DECIMAL) ) { + alt156=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 156, 0, input); + + throw nvae; + } + switch (alt156) { + case 1 : + // InternalExport.g:9157:3: this_HEX_0= RULE_HEX + { + this_HEX_0=(Token)match(input,RULE_HEX,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_HEX_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + + } + + } + break; + case 2 : + // InternalExport.g:9165:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) + { + // InternalExport.g:9165:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) + // InternalExport.g:9166:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? + { + // InternalExport.g:9166:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) + int alt153=2; + int LA153_0 = input.LA(1); + + if ( (LA153_0==RULE_INT) ) { + alt153=1; + } + else if ( (LA153_0==RULE_DECIMAL) ) { + alt153=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 153, 0, input); + + throw nvae; + } + switch (alt153) { + case 1 : + // InternalExport.g:9167:5: this_INT_1= RULE_INT + { + this_INT_1=(Token)match(input,RULE_INT,FOLLOW_55); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_INT_1); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + + } + + } + break; + case 2 : + // InternalExport.g:9175:5: this_DECIMAL_2= RULE_DECIMAL + { + this_DECIMAL_2=(Token)match(input,RULE_DECIMAL,FOLLOW_55); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_DECIMAL_2); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + + } + + } + break; + + } + + // InternalExport.g:9183:4: (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? + int alt155=2; + int LA155_0 = input.LA(1); + + if ( (LA155_0==65) ) { + int LA155_1 = input.LA(2); + + if ( (LA155_1==RULE_INT||LA155_1==RULE_DECIMAL) ) { + alt155=1; + } + } + switch (alt155) { + case 1 : + // InternalExport.g:9184:5: kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) + { + kw=(Token)match(input,65,FOLLOW_113); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + + } + // InternalExport.g:9189:5: (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) + int alt154=2; + int LA154_0 = input.LA(1); + + if ( (LA154_0==RULE_INT) ) { + alt154=1; + } + else if ( (LA154_0==RULE_DECIMAL) ) { + alt154=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 154, 0, input); + + throw nvae; + } + switch (alt154) { + case 1 : + // InternalExport.g:9190:6: this_INT_4= RULE_INT + { + this_INT_4=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_INT_4); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + + } + + } + break; + case 2 : + // InternalExport.g:9198:6: this_DECIMAL_5= RULE_DECIMAL + { + this_DECIMAL_5=(Token)match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_DECIMAL_5); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + + } + + } + break; + + } + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + + myHiddenTokenState.restore(); + + } + return current; + } + // $ANTLR end "ruleNumber" + + + // $ANTLR start "entryRuleJvmTypeReference" + // InternalExport.g:9215:1: entryRuleJvmTypeReference returns [EObject current=null] : iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ; + public final EObject entryRuleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmTypeReference = null; + + + try { + // InternalExport.g:9215:57: (iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ) + // InternalExport.g:9216:2: iv_ruleJvmTypeReference= ruleJvmTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmTypeReference=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmTypeReference" + + + // $ANTLR start "ruleJvmTypeReference" + // InternalExport.g:9222:1: ruleJvmTypeReference returns [EObject current=null] : ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ; + public final EObject ruleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmParameterizedTypeReference_0 = null; + + EObject this_XFunctionTypeRef_3 = null; + + + + enterRule(); + + try { + // InternalExport.g:9228:2: ( ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ) + // InternalExport.g:9229:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + { + // InternalExport.g:9229:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + int alt158=2; + int LA158_0 = input.LA(1); + + if ( (LA158_0==RULE_ID) ) { + alt158=1; + } + else if ( (LA158_0==30||LA158_0==94) ) { + alt158=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 158, 0, input); + + throw nvae; + } + switch (alt158) { + case 1 : + // InternalExport.g:9230:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + { + // InternalExport.g:9230:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + // InternalExport.g:9231:4: this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_107); + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmParameterizedTypeReference_0; + afterParserOrEnumRuleCall(); + + } + // InternalExport.g:9239:4: ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + loop157: + do { + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==22) ) { + int LA157_2 = input.LA(2); + + if ( (LA157_2==23) ) { + int LA157_3 = input.LA(3); + + if ( (synpred45_InternalExport()) ) { + alt157=1; + } + + + } + + + } + + + switch (alt157) { + case 1 : + // InternalExport.g:9240:5: ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) + { + // InternalExport.g:9246:5: ( () ruleArrayBrackets ) + // InternalExport.g:9247:6: () ruleArrayBrackets + { + // InternalExport.g:9247:6: () + // InternalExport.g:9248:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + current); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + + } + pushFollow(FOLLOW_107); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop157; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalExport.g:9265:3: this_XFunctionTypeRef_3= ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XFunctionTypeRef_3=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFunctionTypeRef_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmTypeReference" + + + // $ANTLR start "entryRuleArrayBrackets" + // InternalExport.g:9277:1: entryRuleArrayBrackets returns [String current=null] : iv_ruleArrayBrackets= ruleArrayBrackets EOF ; + public final String entryRuleArrayBrackets() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleArrayBrackets = null; + + + try { + // InternalExport.g:9277:53: (iv_ruleArrayBrackets= ruleArrayBrackets EOF ) + // InternalExport.g:9278:2: iv_ruleArrayBrackets= ruleArrayBrackets EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + iv_ruleArrayBrackets=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleArrayBrackets.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArrayBrackets" + + + // $ANTLR start "ruleArrayBrackets" + // InternalExport.g:9284:1: ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' kw= ']' ) ; + public final AntlrDatatypeRuleToken ruleArrayBrackets() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExport.g:9290:2: ( (kw= '[' kw= ']' ) ) + // InternalExport.g:9291:2: (kw= '[' kw= ']' ) + { + // InternalExport.g:9291:2: (kw= '[' kw= ']' ) + // InternalExport.g:9292:3: kw= '[' kw= ']' + { + kw=(Token)match(input,22,FOLLOW_16); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + + } + kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArrayBrackets" + + + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalExport.g:9306:1: entryRuleXFunctionTypeRef returns [EObject current=null] : iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ; + public final EObject entryRuleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFunctionTypeRef = null; + + + try { + // InternalExport.g:9306:57: (iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ) + // InternalExport.g:9307:2: iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFunctionTypeRef; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFunctionTypeRef" + + + // $ANTLR start "ruleXFunctionTypeRef" + // InternalExport.g:9313:1: ruleXFunctionTypeRef returns [EObject current=null] : ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_5=null; + EObject lv_paramTypes_1_0 = null; + + EObject lv_paramTypes_3_0 = null; + + EObject lv_returnType_6_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9319:2: ( ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ) + // InternalExport.g:9320:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + { + // InternalExport.g:9320:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + // InternalExport.g:9321:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + { + // InternalExport.g:9321:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? + int alt161=2; + int LA161_0 = input.LA(1); + + if ( (LA161_0==30) ) { + alt161=1; + } + switch (alt161) { + case 1 : + // InternalExport.g:9322:4: otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' + { + otherlv_0=(Token)match(input,30,FOLLOW_114); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + + } + // InternalExport.g:9326:4: ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? + int alt160=2; + int LA160_0 = input.LA(1); + + if ( (LA160_0==RULE_ID||LA160_0==30||LA160_0==94) ) { + alt160=1; + } + switch (alt160) { + case 1 : + // InternalExport.g:9327:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + { + // InternalExport.g:9327:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) + // InternalExport.g:9328:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + { + // InternalExport.g:9328:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + // InternalExport.g:9329:7: lv_paramTypes_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + + } + pushFollow(FOLLOW_57); + lv_paramTypes_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9346:5: (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + loop159: + do { + int alt159=2; + int LA159_0 = input.LA(1); + + if ( (LA159_0==25) ) { + alt159=1; + } + + + switch (alt159) { + case 1 : + // InternalExport.g:9347:6: otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + { + otherlv_2=(Token)match(input,25,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + + } + // InternalExport.g:9351:6: ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + // InternalExport.g:9352:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + { + // InternalExport.g:9352:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + // InternalExport.g:9353:8: lv_paramTypes_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + + } + pushFollow(FOLLOW_57); + lv_paramTypes_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop159; + } + } while (true); + + + } + break; + + } + + otherlv_4=(Token)match(input,31,FOLLOW_115); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + + } + + } + break; + + } + + otherlv_5=(Token)match(input,94,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + + } + // InternalExport.g:9381:3: ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + // InternalExport.g:9382:4: (lv_returnType_6_0= ruleJvmTypeReference ) + { + // InternalExport.g:9382:4: (lv_returnType_6_0= ruleJvmTypeReference ) + // InternalExport.g:9383:5: lv_returnType_6_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_returnType_6_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFunctionTypeRef" + + + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalExport.g:9404:1: entryRuleJvmParameterizedTypeReference returns [EObject current=null] : iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ; + public final EObject entryRuleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmParameterizedTypeReference = null; + + + try { + // InternalExport.g:9404:70: (iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ) + // InternalExport.g:9405:2: iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmParameterizedTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmParameterizedTypeReference" + + + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalExport.g:9411:1: ruleJvmParameterizedTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ; + public final EObject ruleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token otherlv_9=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_arguments_2_0 = null; + + EObject lv_arguments_4_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9417:2: ( ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ) + // InternalExport.g:9418:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + { + // InternalExport.g:9418:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + // InternalExport.g:9419:3: ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + { + // InternalExport.g:9419:3: ( ( ruleQualifiedName ) ) + // InternalExport.g:9420:4: ( ruleQualifiedName ) + { + // InternalExport.g:9420:4: ( ruleQualifiedName ) + // InternalExport.g:9421:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + + } + pushFollow(FOLLOW_116); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9435:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + int alt166=2; + alt166 = dfa166.predict(input); + switch (alt166) { + case 1 : + // InternalExport.g:9436:4: ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + { + // InternalExport.g:9436:4: ( ( '<' )=>otherlv_1= '<' ) + // InternalExport.g:9437:5: ( '<' )=>otherlv_1= '<' + { + otherlv_1=(Token)match(input,60,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + + } + + } + + // InternalExport.g:9443:4: ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:9444:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:9444:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:9445:6: lv_arguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_82); + lv_arguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9462:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop162: + do { + int alt162=2; + int LA162_0 = input.LA(1); + + if ( (LA162_0==25) ) { + alt162=1; + } + + + switch (alt162) { + case 1 : + // InternalExport.g:9463:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,25,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + + } + // InternalExport.g:9467:5: ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:9468:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:9468:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:9469:7: lv_arguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_82); + lv_arguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop162; + } + } while (true); + + otherlv_5=(Token)match(input,59,FOLLOW_55); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + + } + // InternalExport.g:9491:4: ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + loop165: + do { + int alt165=2; + int LA165_0 = input.LA(1); + + if ( (LA165_0==65) ) { + int LA165_2 = input.LA(2); + + if ( (LA165_2==RULE_ID) ) { + int LA165_3 = input.LA(3); + + if ( (synpred47_InternalExport()) ) { + alt165=1; + } + + + } + + + } + + + switch (alt165) { + case 1 : + // InternalExport.g:9492:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + { + // InternalExport.g:9492:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) + // InternalExport.g:9493:6: ( ( () '.' ) )=> ( () otherlv_7= '.' ) + { + // InternalExport.g:9499:6: ( () otherlv_7= '.' ) + // InternalExport.g:9500:7: () otherlv_7= '.' + { + // InternalExport.g:9500:7: () + // InternalExport.g:9501:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + current); + + } + + } + + otherlv_7=(Token)match(input,65,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + + } + + } + + + } + + // InternalExport.g:9513:5: ( ( ruleValidID ) ) + // InternalExport.g:9514:6: ( ruleValidID ) + { + // InternalExport.g:9514:6: ( ruleValidID ) + // InternalExport.g:9515:7: ruleValidID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + + } + pushFollow(FOLLOW_117); + ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9529:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + int alt164=2; + alt164 = dfa164.predict(input); + switch (alt164) { + case 1 : + // InternalExport.g:9530:6: ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' + { + // InternalExport.g:9530:6: ( ( '<' )=>otherlv_9= '<' ) + // InternalExport.g:9531:7: ( '<' )=>otherlv_9= '<' + { + otherlv_9=(Token)match(input,60,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + + } + + } + + // InternalExport.g:9537:6: ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:9538:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:9538:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:9539:8: lv_arguments_10_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + + } + pushFollow(FOLLOW_82); + lv_arguments_10_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9556:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* + loop163: + do { + int alt163=2; + int LA163_0 = input.LA(1); + + if ( (LA163_0==25) ) { + alt163=1; + } + + + switch (alt163) { + case 1 : + // InternalExport.g:9557:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_11=(Token)match(input,25,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + + } + // InternalExport.g:9561:7: ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalExport.g:9562:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalExport.g:9562:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + // InternalExport.g:9563:9: lv_arguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + + } + pushFollow(FOLLOW_82); + lv_arguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop163; + } + } while (true); + + otherlv_13=(Token)match(input,59,FOLLOW_55); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + + } + + } + break; + + } + + + } + break; + + default : + break loop165; + } + } while (true); + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmParameterizedTypeReference" + + + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalExport.g:9592:1: entryRuleJvmArgumentTypeReference returns [EObject current=null] : iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ; + public final EObject entryRuleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmArgumentTypeReference = null; + + + try { + // InternalExport.g:9592:65: (iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ) + // InternalExport.g:9593:2: iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmArgumentTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmArgumentTypeReference" + + + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalExport.g:9599:1: ruleJvmArgumentTypeReference returns [EObject current=null] : (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ; + public final EObject ruleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmTypeReference_0 = null; + + EObject this_JvmWildcardTypeReference_1 = null; + + + + enterRule(); + + try { + // InternalExport.g:9605:2: ( (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ) + // InternalExport.g:9606:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + { + // InternalExport.g:9606:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + int alt167=2; + int LA167_0 = input.LA(1); + + if ( (LA167_0==RULE_ID||LA167_0==30||LA167_0==94) ) { + alt167=1; + } + else if ( (LA167_0==45) ) { + alt167=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 167, 0, input); + + throw nvae; + } + switch (alt167) { + case 1 : + // InternalExport.g:9607:3: this_JvmTypeReference_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_JvmTypeReference_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmTypeReference_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExport.g:9616:3: this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmWildcardTypeReference_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmArgumentTypeReference" + + + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalExport.g:9628:1: entryRuleJvmWildcardTypeReference returns [EObject current=null] : iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ; + public final EObject entryRuleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmWildcardTypeReference = null; + + + try { + // InternalExport.g:9628:65: (iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ) + // InternalExport.g:9629:2: iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmWildcardTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmWildcardTypeReference" + + + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalExport.g:9635:1: ruleJvmWildcardTypeReference returns [EObject current=null] : ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ; + public final EObject ruleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_constraints_2_0 = null; + + EObject lv_constraints_3_0 = null; + + EObject lv_constraints_4_0 = null; + + EObject lv_constraints_5_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9641:2: ( ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ) + // InternalExport.g:9642:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + { + // InternalExport.g:9642:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + // InternalExport.g:9643:3: () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + { + // InternalExport.g:9643:3: () + // InternalExport.g:9644:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,45,FOLLOW_118); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + + } + // InternalExport.g:9654:3: ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + int alt170=3; + int LA170_0 = input.LA(1); + + if ( (LA170_0==107) ) { + alt170=1; + } + else if ( (LA170_0==109) ) { + alt170=2; + } + switch (alt170) { + case 1 : + // InternalExport.g:9655:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + { + // InternalExport.g:9655:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + // InternalExport.g:9656:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + { + // InternalExport.g:9656:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) + // InternalExport.g:9657:6: (lv_constraints_2_0= ruleJvmUpperBound ) + { + // InternalExport.g:9657:6: (lv_constraints_2_0= ruleJvmUpperBound ) + // InternalExport.g:9658:7: lv_constraints_2_0= ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + + } + pushFollow(FOLLOW_119); + lv_constraints_2_0=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9675:5: ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + loop168: + do { + int alt168=2; + int LA168_0 = input.LA(1); + + if ( (LA168_0==117) ) { + alt168=1; + } + + + switch (alt168) { + case 1 : + // InternalExport.g:9676:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + { + // InternalExport.g:9676:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + // InternalExport.g:9677:7: lv_constraints_3_0= ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_119); + lv_constraints_3_0=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop168; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalExport.g:9696:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + { + // InternalExport.g:9696:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + // InternalExport.g:9697:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + { + // InternalExport.g:9697:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) + // InternalExport.g:9698:6: (lv_constraints_4_0= ruleJvmLowerBound ) + { + // InternalExport.g:9698:6: (lv_constraints_4_0= ruleJvmLowerBound ) + // InternalExport.g:9699:7: lv_constraints_4_0= ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + + } + pushFollow(FOLLOW_119); + lv_constraints_4_0=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:9716:5: ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + loop169: + do { + int alt169=2; + int LA169_0 = input.LA(1); + + if ( (LA169_0==117) ) { + alt169=1; + } + + + switch (alt169) { + case 1 : + // InternalExport.g:9717:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + { + // InternalExport.g:9717:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + // InternalExport.g:9718:7: lv_constraints_5_0= ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_119); + lv_constraints_5_0=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop169; + } + } while (true); + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmWildcardTypeReference" + + + // $ANTLR start "entryRuleJvmUpperBound" + // InternalExport.g:9741:1: entryRuleJvmUpperBound returns [EObject current=null] : iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ; + public final EObject entryRuleJvmUpperBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBound = null; + + + try { + // InternalExport.g:9741:54: (iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ) + // InternalExport.g:9742:2: iv_ruleJvmUpperBound= ruleJvmUpperBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBound=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBound" + + + // $ANTLR start "ruleJvmUpperBound" + // InternalExport.g:9748:1: ruleJvmUpperBound returns [EObject current=null] : (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9754:2: ( (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExport.g:9755:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExport.g:9755:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExport.g:9756:3: otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,107,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + + } + // InternalExport.g:9760:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExport.g:9761:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExport.g:9761:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExport.g:9762:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBound" + + + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalExport.g:9783:1: entryRuleJvmUpperBoundAnded returns [EObject current=null] : iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ; + public final EObject entryRuleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBoundAnded = null; + + + try { + // InternalExport.g:9783:59: (iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ) + // InternalExport.g:9784:2: iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBoundAnded" + + + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalExport.g:9790:1: ruleJvmUpperBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9796:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExport.g:9797:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExport.g:9797:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExport.g:9798:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,117,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalExport.g:9802:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExport.g:9803:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExport.g:9803:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExport.g:9804:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBoundAnded" + + + // $ANTLR start "entryRuleJvmLowerBound" + // InternalExport.g:9825:1: entryRuleJvmLowerBound returns [EObject current=null] : iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ; + public final EObject entryRuleJvmLowerBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBound = null; + + + try { + // InternalExport.g:9825:54: (iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ) + // InternalExport.g:9826:2: iv_ruleJvmLowerBound= ruleJvmLowerBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBound=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBound" + + + // $ANTLR start "ruleJvmLowerBound" + // InternalExport.g:9832:1: ruleJvmLowerBound returns [EObject current=null] : (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9838:2: ( (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExport.g:9839:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExport.g:9839:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExport.g:9840:3: otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,109,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + + } + // InternalExport.g:9844:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExport.g:9845:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExport.g:9845:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExport.g:9846:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBound" + + + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalExport.g:9867:1: entryRuleJvmLowerBoundAnded returns [EObject current=null] : iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ; + public final EObject entryRuleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBoundAnded = null; + + + try { + // InternalExport.g:9867:59: (iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ) + // InternalExport.g:9868:2: iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBoundAnded" + + + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalExport.g:9874:1: ruleJvmLowerBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9880:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExport.g:9881:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExport.g:9881:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExport.g:9882:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,117,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalExport.g:9886:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExport.g:9887:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExport.g:9887:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExport.g:9888:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBoundAnded" + + + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalExport.g:9909:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ; + public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null; + + + try { + // InternalExport.g:9909:65: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ) + // InternalExport.g:9910:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameWithWildcard.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameWithWildcard" + + + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalExport.g:9916:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ; + public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_QualifiedName_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9922:2: ( (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ) + // InternalExport.g:9923:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + { + // InternalExport.g:9923:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + // InternalExport.g:9924:3: this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + + } + pushFollow(FOLLOW_120); + this_QualifiedName_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_QualifiedName_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,65,FOLLOW_121); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + + } + kw=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameWithWildcard" + + + // $ANTLR start "entryRuleValidID" + // InternalExport.g:9948:1: entryRuleValidID returns [String current=null] : iv_ruleValidID= ruleValidID EOF ; + public final String entryRuleValidID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleValidID = null; + + + try { + // InternalExport.g:9948:47: (iv_ruleValidID= ruleValidID EOF ) + // InternalExport.g:9949:2: iv_ruleValidID= ruleValidID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleValidID=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleValidID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleValidID" + + + // $ANTLR start "ruleValidID" + // InternalExport.g:9955:1: ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ; + public final AntlrDatatypeRuleToken ruleValidID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_ID_0=null; + + + enterRule(); + + try { + // InternalExport.g:9961:2: (this_ID_0= RULE_ID ) + // InternalExport.g:9962:2: this_ID_0= RULE_ID + { + this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ID_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleValidID" + + + // $ANTLR start "entryRuleXImportDeclaration" + // InternalExport.g:9972:1: entryRuleXImportDeclaration returns [EObject current=null] : iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ; + public final EObject entryRuleXImportDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXImportDeclaration = null; + + + try { + // InternalExport.g:9972:59: (iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ) + // InternalExport.g:9973:2: iv_ruleXImportDeclaration= ruleXImportDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXImportDeclaration=ruleXImportDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXImportDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXImportDeclaration" + + + // $ANTLR start "ruleXImportDeclaration" + // InternalExport.g:9979:1: ruleXImportDeclaration returns [EObject current=null] : (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ; + public final EObject ruleXImportDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_static_1_0=null; + Token lv_extension_2_0=null; + Token lv_wildcard_4_0=null; + Token otherlv_8=null; + AntlrDatatypeRuleToken lv_memberName_5_0 = null; + + AntlrDatatypeRuleToken lv_importedNamespace_7_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:9985:2: ( (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ) + // InternalExport.g:9986:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + { + // InternalExport.g:9986:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + // InternalExport.g:9987:3: otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? + { + otherlv_0=(Token)match(input,20,FOLLOW_122); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + + } + // InternalExport.g:9991:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) + int alt173=3; + alt173 = dfa173.predict(input); + switch (alt173) { + case 1 : + // InternalExport.g:9992:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + { + // InternalExport.g:9992:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + // InternalExport.g:9993:5: ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + { + // InternalExport.g:9993:5: ( (lv_static_1_0= 'static' ) ) + // InternalExport.g:9994:6: (lv_static_1_0= 'static' ) + { + // InternalExport.g:9994:6: (lv_static_1_0= 'static' ) + // InternalExport.g:9995:7: lv_static_1_0= 'static' + { + lv_static_1_0=(Token)match(input,108,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "static", lv_static_1_0 != null, "static"); + + } + + } + + + } + + // InternalExport.g:10007:5: ( (lv_extension_2_0= 'extension' ) )? + int alt171=2; + int LA171_0 = input.LA(1); + + if ( (LA171_0==15) ) { + alt171=1; + } + switch (alt171) { + case 1 : + // InternalExport.g:10008:6: (lv_extension_2_0= 'extension' ) + { + // InternalExport.g:10008:6: (lv_extension_2_0= 'extension' ) + // InternalExport.g:10009:7: lv_extension_2_0= 'extension' + { + lv_extension_2_0=(Token)match(input,15,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "extension", lv_extension_2_0 != null, "extension"); + + } + + } + + + } + break; + + } + + // InternalExport.g:10021:5: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalExport.g:10022:6: ( ruleQualifiedNameInStaticImport ) + { + // InternalExport.g:10022:6: ( ruleQualifiedNameInStaticImport ) + // InternalExport.g:10023:7: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + + } + pushFollow(FOLLOW_123); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExport.g:10037:5: ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + int alt172=2; + int LA172_0 = input.LA(1); + + if ( (LA172_0==62) ) { + alt172=1; + } + else if ( (LA172_0==RULE_ID) ) { + alt172=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 172, 0, input); + + throw nvae; + } + switch (alt172) { + case 1 : + // InternalExport.g:10038:6: ( (lv_wildcard_4_0= '*' ) ) + { + // InternalExport.g:10038:6: ( (lv_wildcard_4_0= '*' ) ) + // InternalExport.g:10039:7: (lv_wildcard_4_0= '*' ) + { + // InternalExport.g:10039:7: (lv_wildcard_4_0= '*' ) + // InternalExport.g:10040:8: lv_wildcard_4_0= '*' + { + lv_wildcard_4_0=(Token)match(input,62,FOLLOW_124); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "wildcard", lv_wildcard_4_0 != null, "*"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:10053:6: ( (lv_memberName_5_0= ruleValidID ) ) + { + // InternalExport.g:10053:6: ( (lv_memberName_5_0= ruleValidID ) ) + // InternalExport.g:10054:7: (lv_memberName_5_0= ruleValidID ) + { + // InternalExport.g:10054:7: (lv_memberName_5_0= ruleValidID ) + // InternalExport.g:10055:8: lv_memberName_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + + } + pushFollow(FOLLOW_124); + lv_memberName_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalExport.g:10075:4: ( ( ruleQualifiedName ) ) + { + // InternalExport.g:10075:4: ( ( ruleQualifiedName ) ) + // InternalExport.g:10076:5: ( ruleQualifiedName ) + { + // InternalExport.g:10076:5: ( ruleQualifiedName ) + // InternalExport.g:10077:6: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + + } + pushFollow(FOLLOW_124); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 3 : + // InternalExport.g:10092:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + { + // InternalExport.g:10092:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + // InternalExport.g:10093:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + { + // InternalExport.g:10093:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + // InternalExport.g:10094:6: lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + + } + pushFollow(FOLLOW_124); + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalExport.g:10112:3: (otherlv_8= ';' )? + int alt174=2; + int LA174_0 = input.LA(1); + + if ( (LA174_0==26) ) { + alt174=1; + } + switch (alt174) { + case 1 : + // InternalExport.g:10113:4: otherlv_8= ';' + { + otherlv_8=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + + } + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXImportDeclaration" + + + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalExport.g:10122:1: entryRuleQualifiedNameInStaticImport returns [String current=null] : iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ; + public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null; + + + try { + // InternalExport.g:10122:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ) + // InternalExport.g:10123:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameInStaticImport.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameInStaticImport" + + + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalExport.g:10129:1: ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID kw= '.' )+ ; + public final AntlrDatatypeRuleToken ruleQualifiedNameInStaticImport() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalExport.g:10135:2: ( (this_ValidID_0= ruleValidID kw= '.' )+ ) + // InternalExport.g:10136:2: (this_ValidID_0= ruleValidID kw= '.' )+ + { + // InternalExport.g:10136:2: (this_ValidID_0= ruleValidID kw= '.' )+ + int cnt175=0; + loop175: + do { + int alt175=2; + int LA175_0 = input.LA(1); + + if ( (LA175_0==RULE_ID) ) { + int LA175_2 = input.LA(2); + + if ( (LA175_2==65) ) { + alt175=1; + } + + + } + + + switch (alt175) { + case 1 : + // InternalExport.g:10137:3: this_ValidID_0= ruleValidID kw= '.' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_120); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,65,FOLLOW_125); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + + } + + } + break; + + default : + if ( cnt175 >= 1 ) break loop175; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(175, input); + throw eee; + } + cnt175++; + } while (true); + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameInStaticImport" + + // $ANTLR start synpred1_InternalExport + public final void synpred1_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:1186:4: ( ruleCastedExpression ) + // InternalExport.g:1186:5: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred1_InternalExport + + // $ANTLR start synpred2_InternalExport + public final void synpred2_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:1610:4: ( 'else' ) + // InternalExport.g:1610:5: 'else' + { + match(input,48,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred2_InternalExport + + // $ANTLR start synpred3_InternalExport + public final void synpred3_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:3977:6: ( ( () ( ( ruleOpMultiAssign ) ) ) ) + // InternalExport.g:3977:7: ( () ( ( ruleOpMultiAssign ) ) ) + { + // InternalExport.g:3977:7: ( () ( ( ruleOpMultiAssign ) ) ) + // InternalExport.g:3978:7: () ( ( ruleOpMultiAssign ) ) + { + // InternalExport.g:3978:7: () + // InternalExport.g:3979:7: + { + } + + // InternalExport.g:3980:7: ( ( ruleOpMultiAssign ) ) + // InternalExport.g:3981:8: ( ruleOpMultiAssign ) + { + // InternalExport.g:3981:8: ( ruleOpMultiAssign ) + // InternalExport.g:3982:9: ruleOpMultiAssign + { + pushFollow(FOLLOW_2); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred3_InternalExport + + // $ANTLR start synpred4_InternalExport + public final void synpred4_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4171:5: ( ( () ( ( ruleOpOr ) ) ) ) + // InternalExport.g:4171:6: ( () ( ( ruleOpOr ) ) ) + { + // InternalExport.g:4171:6: ( () ( ( ruleOpOr ) ) ) + // InternalExport.g:4172:6: () ( ( ruleOpOr ) ) + { + // InternalExport.g:4172:6: () + // InternalExport.g:4173:6: + { + } + + // InternalExport.g:4174:6: ( ( ruleOpOr ) ) + // InternalExport.g:4175:7: ( ruleOpOr ) + { + // InternalExport.g:4175:7: ( ruleOpOr ) + // InternalExport.g:4176:8: ruleOpOr + { + pushFollow(FOLLOW_2); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred4_InternalExport + + // $ANTLR start synpred5_InternalExport + public final void synpred5_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4278:5: ( ( () ( ( ruleOpAnd ) ) ) ) + // InternalExport.g:4278:6: ( () ( ( ruleOpAnd ) ) ) + { + // InternalExport.g:4278:6: ( () ( ( ruleOpAnd ) ) ) + // InternalExport.g:4279:6: () ( ( ruleOpAnd ) ) + { + // InternalExport.g:4279:6: () + // InternalExport.g:4280:6: + { + } + + // InternalExport.g:4281:6: ( ( ruleOpAnd ) ) + // InternalExport.g:4282:7: ( ruleOpAnd ) + { + // InternalExport.g:4282:7: ( ruleOpAnd ) + // InternalExport.g:4283:8: ruleOpAnd + { + pushFollow(FOLLOW_2); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred5_InternalExport + + // $ANTLR start synpred6_InternalExport + public final void synpred6_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4385:5: ( ( () ( ( ruleOpEquality ) ) ) ) + // InternalExport.g:4385:6: ( () ( ( ruleOpEquality ) ) ) + { + // InternalExport.g:4385:6: ( () ( ( ruleOpEquality ) ) ) + // InternalExport.g:4386:6: () ( ( ruleOpEquality ) ) + { + // InternalExport.g:4386:6: () + // InternalExport.g:4387:6: + { + } + + // InternalExport.g:4388:6: ( ( ruleOpEquality ) ) + // InternalExport.g:4389:7: ( ruleOpEquality ) + { + // InternalExport.g:4389:7: ( ruleOpEquality ) + // InternalExport.g:4390:8: ruleOpEquality + { + pushFollow(FOLLOW_2); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred6_InternalExport + + // $ANTLR start synpred7_InternalExport + public final void synpred7_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4513:6: ( ( () 'instanceof' ) ) + // InternalExport.g:4513:7: ( () 'instanceof' ) + { + // InternalExport.g:4513:7: ( () 'instanceof' ) + // InternalExport.g:4514:7: () 'instanceof' + { + // InternalExport.g:4514:7: () + // InternalExport.g:4515:7: + { + } + + match(input,91,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred7_InternalExport + + // $ANTLR start synpred8_InternalExport + public final void synpred8_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4556:6: ( ( () ( ( ruleOpCompare ) ) ) ) + // InternalExport.g:4556:7: ( () ( ( ruleOpCompare ) ) ) + { + // InternalExport.g:4556:7: ( () ( ( ruleOpCompare ) ) ) + // InternalExport.g:4557:7: () ( ( ruleOpCompare ) ) + { + // InternalExport.g:4557:7: () + // InternalExport.g:4558:7: + { + } + + // InternalExport.g:4559:7: ( ( ruleOpCompare ) ) + // InternalExport.g:4560:8: ( ruleOpCompare ) + { + // InternalExport.g:4560:8: ( ruleOpCompare ) + // InternalExport.g:4561:9: ruleOpCompare + { + pushFollow(FOLLOW_2); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred8_InternalExport + + // $ANTLR start synpred9_InternalExport + public final void synpred9_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4691:5: ( ( () ( ( ruleOpOther ) ) ) ) + // InternalExport.g:4691:6: ( () ( ( ruleOpOther ) ) ) + { + // InternalExport.g:4691:6: ( () ( ( ruleOpOther ) ) ) + // InternalExport.g:4692:6: () ( ( ruleOpOther ) ) + { + // InternalExport.g:4692:6: () + // InternalExport.g:4693:6: + { + } + + // InternalExport.g:4694:6: ( ( ruleOpOther ) ) + // InternalExport.g:4695:7: ( ruleOpOther ) + { + // InternalExport.g:4695:7: ( ruleOpOther ) + // InternalExport.g:4696:8: ruleOpOther + { + pushFollow(FOLLOW_2); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred9_InternalExport + + // $ANTLR start synpred10_InternalExport + public final void synpred10_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4811:6: ( ( '>' '>' ) ) + // InternalExport.g:4811:7: ( '>' '>' ) + { + // InternalExport.g:4811:7: ( '>' '>' ) + // InternalExport.g:4812:7: '>' '>' + { + match(input,59,FOLLOW_74); if (state.failed) return ; + match(input,59,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred10_InternalExport + + // $ANTLR start synpred11_InternalExport + public final void synpred11_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4846:6: ( ( '<' '<' ) ) + // InternalExport.g:4846:7: ( '<' '<' ) + { + // InternalExport.g:4846:7: ( '<' '<' ) + // InternalExport.g:4847:7: '<' '<' + { + match(input,60,FOLLOW_66); if (state.failed) return ; + match(input,60,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred11_InternalExport + + // $ANTLR start synpred12_InternalExport + public final void synpred12_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:4919:5: ( ( () ( ( ruleOpAdd ) ) ) ) + // InternalExport.g:4919:6: ( () ( ( ruleOpAdd ) ) ) + { + // InternalExport.g:4919:6: ( () ( ( ruleOpAdd ) ) ) + // InternalExport.g:4920:6: () ( ( ruleOpAdd ) ) + { + // InternalExport.g:4920:6: () + // InternalExport.g:4921:6: + { + } + + // InternalExport.g:4922:6: ( ( ruleOpAdd ) ) + // InternalExport.g:4923:7: ( ruleOpAdd ) + { + // InternalExport.g:4923:7: ( ruleOpAdd ) + // InternalExport.g:4924:8: ruleOpAdd + { + pushFollow(FOLLOW_2); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred12_InternalExport + + // $ANTLR start synpred13_InternalExport + public final void synpred13_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5034:5: ( ( () ( ( ruleOpMulti ) ) ) ) + // InternalExport.g:5034:6: ( () ( ( ruleOpMulti ) ) ) + { + // InternalExport.g:5034:6: ( () ( ( ruleOpMulti ) ) ) + // InternalExport.g:5035:6: () ( ( ruleOpMulti ) ) + { + // InternalExport.g:5035:6: () + // InternalExport.g:5036:6: + { + } + + // InternalExport.g:5037:6: ( ( ruleOpMulti ) ) + // InternalExport.g:5038:7: ( ruleOpMulti ) + { + // InternalExport.g:5038:7: ( ruleOpMulti ) + // InternalExport.g:5039:8: ruleOpMulti + { + pushFollow(FOLLOW_2); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred13_InternalExport + + // $ANTLR start synpred14_InternalExport + public final void synpred14_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5269:5: ( ( () 'as' ) ) + // InternalExport.g:5269:6: ( () 'as' ) + { + // InternalExport.g:5269:6: ( () 'as' ) + // InternalExport.g:5270:6: () 'as' + { + // InternalExport.g:5270:6: () + // InternalExport.g:5271:6: + { + } + + match(input,21,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred14_InternalExport + + // $ANTLR start synpred15_InternalExport + public final void synpred15_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5337:4: ( ( () ( ( ruleOpPostfix ) ) ) ) + // InternalExport.g:5337:5: ( () ( ( ruleOpPostfix ) ) ) + { + // InternalExport.g:5337:5: ( () ( ( ruleOpPostfix ) ) ) + // InternalExport.g:5338:5: () ( ( ruleOpPostfix ) ) + { + // InternalExport.g:5338:5: () + // InternalExport.g:5339:5: + { + } + + // InternalExport.g:5340:5: ( ( ruleOpPostfix ) ) + // InternalExport.g:5341:6: ( ruleOpPostfix ) + { + // InternalExport.g:5341:6: ( ruleOpPostfix ) + // InternalExport.g:5342:7: ruleOpPostfix + { + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred15_InternalExport + + // $ANTLR start synpred16_InternalExport + public final void synpred16_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5433:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) + // InternalExport.g:5433:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + { + // InternalExport.g:5433:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + // InternalExport.g:5434:7: () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign + { + // InternalExport.g:5434:7: () + // InternalExport.g:5435:7: + { + } + + // InternalExport.g:5436:7: ( '.' | ( ( '::' ) ) ) + int alt176=2; + int LA176_0 = input.LA(1); + + if ( (LA176_0==65) ) { + alt176=1; + } + else if ( (LA176_0==41) ) { + alt176=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 176, 0, input); + + throw nvae; + } + switch (alt176) { + case 1 : + // InternalExport.g:5437:8: '.' + { + match(input,65,FOLLOW_79); if (state.failed) return ; + + } + break; + case 2 : + // InternalExport.g:5439:8: ( ( '::' ) ) + { + // InternalExport.g:5439:8: ( ( '::' ) ) + // InternalExport.g:5440:9: ( '::' ) + { + // InternalExport.g:5440:9: ( '::' ) + // InternalExport.g:5441:10: '::' + { + match(input,41,FOLLOW_79); if (state.failed) return ; + + } + + + } + + + } + break; + + } + + // InternalExport.g:5445:7: ( ( ruleFeatureCallID ) ) + // InternalExport.g:5446:8: ( ruleFeatureCallID ) + { + // InternalExport.g:5446:8: ( ruleFeatureCallID ) + // InternalExport.g:5447:9: ruleFeatureCallID + { + pushFollow(FOLLOW_31); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred16_InternalExport + + // $ANTLR start synpred17_InternalExport + public final void synpred17_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5530:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) ) + // InternalExport.g:5530:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) + { + // InternalExport.g:5530:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) + // InternalExport.g:5531:7: () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) + { + // InternalExport.g:5531:7: () + // InternalExport.g:5532:7: + { + } + + // InternalExport.g:5533:7: ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) + int alt177=3; + switch ( input.LA(1) ) { + case 65: + { + alt177=1; + } + break; + case 101: + { + alt177=2; + } + break; + case 41: + { + alt177=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 177, 0, input); + + throw nvae; + } + + switch (alt177) { + case 1 : + // InternalExport.g:5534:8: '.' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + break; + case 2 : + // InternalExport.g:5536:8: ( ( '?.' ) ) + { + // InternalExport.g:5536:8: ( ( '?.' ) ) + // InternalExport.g:5537:9: ( '?.' ) + { + // InternalExport.g:5537:9: ( '?.' ) + // InternalExport.g:5538:10: '?.' + { + match(input,101,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + break; + case 3 : + // InternalExport.g:5542:8: ( ( '::' ) ) + { + // InternalExport.g:5542:8: ( ( '::' ) ) + // InternalExport.g:5543:9: ( '::' ) + { + // InternalExport.g:5543:9: ( '::' ) + // InternalExport.g:5544:10: '::' + { + match(input,41,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + break; + + } + + + } + + + } + } + // $ANTLR end synpred17_InternalExport + + // $ANTLR start synpred18_InternalExport + public final void synpred18_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5668:7: ( ( '(' ) ) + // InternalExport.g:5668:8: ( '(' ) + { + // InternalExport.g:5668:8: ( '(' ) + // InternalExport.g:5669:8: '(' + { + match(input,30,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred18_InternalExport + + // $ANTLR start synpred19_InternalExport + public final void synpred19_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5687:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExport.g:5687:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExport.g:5687:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExport.g:5688:9: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExport.g:5688:9: () + // InternalExport.g:5689:9: + { + } + + // InternalExport.g:5690:9: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt179=2; + int LA179_0 = input.LA(1); + + if ( (LA179_0==RULE_ID||LA179_0==30||LA179_0==94) ) { + alt179=1; + } + switch (alt179) { + case 1 : + // InternalExport.g:5691:10: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExport.g:5691:10: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:5692:11: ( ruleJvmFormalParameter ) + { + // InternalExport.g:5692:11: ( ruleJvmFormalParameter ) + // InternalExport.g:5693:12: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExport.g:5696:10: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop178: + do { + int alt178=2; + int LA178_0 = input.LA(1); + + if ( (LA178_0==25) ) { + alt178=1; + } + + + switch (alt178) { + case 1 : + // InternalExport.g:5697:11: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,25,FOLLOW_71); if (state.failed) return ; + // InternalExport.g:5698:11: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:5699:12: ( ruleJvmFormalParameter ) + { + // InternalExport.g:5699:12: ( ruleJvmFormalParameter ) + // InternalExport.g:5700:13: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop178; + } + } while (true); + + + } + break; + + } + + // InternalExport.g:5705:9: ( ( '|' ) ) + // InternalExport.g:5706:10: ( '|' ) + { + // InternalExport.g:5706:10: ( '|' ) + // InternalExport.g:5707:11: '|' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred19_InternalExport + + // $ANTLR start synpred20_InternalExport + public final void synpred20_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5784:6: ( ( () '[' ) ) + // InternalExport.g:5784:7: ( () '[' ) + { + // InternalExport.g:5784:7: ( () '[' ) + // InternalExport.g:5785:7: () '[' + { + // InternalExport.g:5785:7: () + // InternalExport.g:5786:7: + { + } + + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred20_InternalExport + + // $ANTLR start synpred21_InternalExport + public final void synpred21_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5857:4: ( ( () 'synchronized' '(' ) ) + // InternalExport.g:5857:5: ( () 'synchronized' '(' ) + { + // InternalExport.g:5857:5: ( () 'synchronized' '(' ) + // InternalExport.g:5858:5: () 'synchronized' '(' + { + // InternalExport.g:5858:5: () + // InternalExport.g:5859:5: + { + } + + match(input,115,FOLLOW_23); if (state.failed) return ; + match(input,30,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred21_InternalExport + + // $ANTLR start synpred22_InternalExport + public final void synpred22_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:5902:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalExport.g:5902:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalExport.g:5902:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalExport.g:5903:5: () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' + { + // InternalExport.g:5903:5: () + // InternalExport.g:5904:5: + { + } + + match(input,16,FOLLOW_23); if (state.failed) return ; + match(input,30,FOLLOW_71); if (state.failed) return ; + // InternalExport.g:5907:5: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:5908:6: ( ruleJvmFormalParameter ) + { + // InternalExport.g:5908:6: ( ruleJvmFormalParameter ) + // InternalExport.g:5909:7: ruleJvmFormalParameter + { + pushFollow(FOLLOW_39); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,43,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred22_InternalExport + + // $ANTLR start synpred23_InternalExport + public final void synpred23_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:6016:4: ( ( () '[' ) ) + // InternalExport.g:6016:5: ( () '[' ) + { + // InternalExport.g:6016:5: ( () '[' ) + // InternalExport.g:6017:5: () '[' + { + // InternalExport.g:6017:5: () + // InternalExport.g:6018:5: + { + } + + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred23_InternalExport + + // $ANTLR start synpred25_InternalExport + public final void synpred25_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:6321:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExport.g:6321:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExport.g:6321:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExport.g:6322:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExport.g:6322:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt181=2; + int LA181_0 = input.LA(1); + + if ( (LA181_0==RULE_ID||LA181_0==30||LA181_0==94) ) { + alt181=1; + } + switch (alt181) { + case 1 : + // InternalExport.g:6323:6: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExport.g:6323:6: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:6324:7: ( ruleJvmFormalParameter ) + { + // InternalExport.g:6324:7: ( ruleJvmFormalParameter ) + // InternalExport.g:6325:8: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExport.g:6328:6: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop180: + do { + int alt180=2; + int LA180_0 = input.LA(1); + + if ( (LA180_0==25) ) { + alt180=1; + } + + + switch (alt180) { + case 1 : + // InternalExport.g:6329:7: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,25,FOLLOW_71); if (state.failed) return ; + // InternalExport.g:6330:7: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:6331:8: ( ruleJvmFormalParameter ) + { + // InternalExport.g:6331:8: ( ruleJvmFormalParameter ) + // InternalExport.g:6332:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop180; + } + } while (true); + + + } + break; + + } + + // InternalExport.g:6337:5: ( ( '|' ) ) + // InternalExport.g:6338:6: ( '|' ) + { + // InternalExport.g:6338:6: ( '|' ) + // InternalExport.g:6339:7: '|' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred25_InternalExport + + // $ANTLR start synpred27_InternalExport + public final void synpred27_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:6730:5: ( 'else' ) + // InternalExport.g:6730:6: 'else' + { + match(input,48,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred27_InternalExport + + // $ANTLR start synpred28_InternalExport + public final void synpred28_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:6789:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalExport.g:6789:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalExport.g:6789:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalExport.g:6790:7: '(' ( ( ruleJvmFormalParameter ) ) ':' + { + match(input,30,FOLLOW_71); if (state.failed) return ; + // InternalExport.g:6791:7: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:6792:8: ( ruleJvmFormalParameter ) + { + // InternalExport.g:6792:8: ( ruleJvmFormalParameter ) + // InternalExport.g:6793:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_39); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,43,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred28_InternalExport + + // $ANTLR start synpred29_InternalExport + public final void synpred29_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:6856:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalExport.g:6856:7: ( ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalExport.g:6856:7: ( ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalExport.g:6857:7: ( ( ruleJvmFormalParameter ) ) ':' + { + // InternalExport.g:6857:7: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:6858:8: ( ruleJvmFormalParameter ) + { + // InternalExport.g:6858:8: ( ruleJvmFormalParameter ) + // InternalExport.g:6859:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_39); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,43,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred29_InternalExport + + // $ANTLR start synpred31_InternalExport + public final void synpred31_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:7674:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) ) + // InternalExport.g:7674:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) + { + // InternalExport.g:7674:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) + // InternalExport.g:7675:6: ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) + { + // InternalExport.g:7675:6: ( ( ruleJvmTypeReference ) ) + // InternalExport.g:7676:7: ( ruleJvmTypeReference ) + { + // InternalExport.g:7676:7: ( ruleJvmTypeReference ) + // InternalExport.g:7677:8: ruleJvmTypeReference + { + pushFollow(FOLLOW_4); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExport.g:7680:6: ( ( ruleValidID ) ) + // InternalExport.g:7681:7: ( ruleValidID ) + { + // InternalExport.g:7681:7: ( ruleValidID ) + // InternalExport.g:7682:8: ruleValidID + { + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred31_InternalExport + + // $ANTLR start synpred32_InternalExport + public final void synpred32_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:7986:5: ( ( '(' ) ) + // InternalExport.g:7986:6: ( '(' ) + { + // InternalExport.g:7986:6: ( '(' ) + // InternalExport.g:7987:6: '(' + { + match(input,30,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred32_InternalExport + + // $ANTLR start synpred33_InternalExport + public final void synpred33_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8005:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExport.g:8005:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExport.g:8005:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExport.g:8006:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExport.g:8006:7: () + // InternalExport.g:8007:7: + { + } + + // InternalExport.g:8008:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt185=2; + int LA185_0 = input.LA(1); + + if ( (LA185_0==RULE_ID||LA185_0==30||LA185_0==94) ) { + alt185=1; + } + switch (alt185) { + case 1 : + // InternalExport.g:8009:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExport.g:8009:8: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:8010:9: ( ruleJvmFormalParameter ) + { + // InternalExport.g:8010:9: ( ruleJvmFormalParameter ) + // InternalExport.g:8011:10: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExport.g:8014:8: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop184: + do { + int alt184=2; + int LA184_0 = input.LA(1); + + if ( (LA184_0==25) ) { + alt184=1; + } + + + switch (alt184) { + case 1 : + // InternalExport.g:8015:9: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,25,FOLLOW_71); if (state.failed) return ; + // InternalExport.g:8016:9: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:8017:10: ( ruleJvmFormalParameter ) + { + // InternalExport.g:8017:10: ( ruleJvmFormalParameter ) + // InternalExport.g:8018:11: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop184; + } + } while (true); + + + } + break; + + } + + // InternalExport.g:8023:7: ( ( '|' ) ) + // InternalExport.g:8024:8: ( '|' ) + { + // InternalExport.g:8024:8: ( '|' ) + // InternalExport.g:8025:9: '|' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred33_InternalExport + + // $ANTLR start synpred34_InternalExport + public final void synpred34_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8102:4: ( ( () '[' ) ) + // InternalExport.g:8102:5: ( () '[' ) + { + // InternalExport.g:8102:5: ( () '[' ) + // InternalExport.g:8103:5: () '[' + { + // InternalExport.g:8103:5: () + // InternalExport.g:8104:5: + { + } + + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred34_InternalExport + + // $ANTLR start synpred35_InternalExport + public final void synpred35_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8262:5: ( '<' ) + // InternalExport.g:8262:6: '<' + { + match(input,60,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred35_InternalExport + + // $ANTLR start synpred36_InternalExport + public final void synpred36_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8319:5: ( ( '(' ) ) + // InternalExport.g:8319:6: ( '(' ) + { + // InternalExport.g:8319:6: ( '(' ) + // InternalExport.g:8320:6: '(' + { + match(input,30,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred36_InternalExport + + // $ANTLR start synpred37_InternalExport + public final void synpred37_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8338:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExport.g:8338:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExport.g:8338:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExport.g:8339:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExport.g:8339:7: () + // InternalExport.g:8340:7: + { + } + + // InternalExport.g:8341:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt187=2; + int LA187_0 = input.LA(1); + + if ( (LA187_0==RULE_ID||LA187_0==30||LA187_0==94) ) { + alt187=1; + } + switch (alt187) { + case 1 : + // InternalExport.g:8342:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExport.g:8342:8: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:8343:9: ( ruleJvmFormalParameter ) + { + // InternalExport.g:8343:9: ( ruleJvmFormalParameter ) + // InternalExport.g:8344:10: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExport.g:8347:8: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop186: + do { + int alt186=2; + int LA186_0 = input.LA(1); + + if ( (LA186_0==25) ) { + alt186=1; + } + + + switch (alt186) { + case 1 : + // InternalExport.g:8348:9: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,25,FOLLOW_71); if (state.failed) return ; + // InternalExport.g:8349:9: ( ( ruleJvmFormalParameter ) ) + // InternalExport.g:8350:10: ( ruleJvmFormalParameter ) + { + // InternalExport.g:8350:10: ( ruleJvmFormalParameter ) + // InternalExport.g:8351:11: ruleJvmFormalParameter + { + pushFollow(FOLLOW_90); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop186; + } + } while (true); + + + } + break; + + } + + // InternalExport.g:8356:7: ( ( '|' ) ) + // InternalExport.g:8357:8: ( '|' ) + { + // InternalExport.g:8357:8: ( '|' ) + // InternalExport.g:8358:9: '|' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred37_InternalExport + + // $ANTLR start synpred38_InternalExport + public final void synpred38_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8435:4: ( ( () '[' ) ) + // InternalExport.g:8435:5: ( () '[' ) + { + // InternalExport.g:8435:5: ( () '[' ) + // InternalExport.g:8436:5: () '[' + { + // InternalExport.g:8436:5: () + // InternalExport.g:8437:5: + { + } + + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred38_InternalExport + + // $ANTLR start synpred39_InternalExport + public final void synpred39_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8778:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING ) + // InternalExport.g: + { + if ( (input.LA(1)>=RULE_ID && input.LA(1)<=RULE_INT)||(input.LA(1)>=RULE_HEX && input.LA(1)<=RULE_DECIMAL)||(input.LA(1)>=15 && input.LA(1)<=16)||input.LA(1)==18||input.LA(1)==20||input.LA(1)==22||input.LA(1)==27||input.LA(1)==30||input.LA(1)==46||input.LA(1)==49||(input.LA(1)>=60 && input.LA(1)<=61)||input.LA(1)==64||(input.LA(1)>=76 && input.LA(1)<=78)||input.LA(1)==80||(input.LA(1)>=102 && input.LA(1)<=104)||(input.LA(1)>=107 && input.LA(1)<=113)||input.LA(1)==115 ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + } + // $ANTLR end synpred39_InternalExport + + // $ANTLR start synpred40_InternalExport + public final void synpred40_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8849:6: ( 'catch' ) + // InternalExport.g:8849:7: 'catch' + { + match(input,116,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred40_InternalExport + + // $ANTLR start synpred41_InternalExport + public final void synpred41_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:8870:7: ( 'finally' ) + // InternalExport.g:8870:8: 'finally' + { + match(input,114,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred41_InternalExport + + // $ANTLR start synpred44_InternalExport + public final void synpred44_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:9114:5: ( '.' ) + // InternalExport.g:9114:6: '.' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred44_InternalExport + + // $ANTLR start synpred45_InternalExport + public final void synpred45_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:9240:5: ( ( () ruleArrayBrackets ) ) + // InternalExport.g:9240:6: ( () ruleArrayBrackets ) + { + // InternalExport.g:9240:6: ( () ruleArrayBrackets ) + // InternalExport.g:9241:6: () ruleArrayBrackets + { + // InternalExport.g:9241:6: () + // InternalExport.g:9242:6: + { + } + + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred45_InternalExport + + // $ANTLR start synpred46_InternalExport + public final void synpred46_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:9437:5: ( '<' ) + // InternalExport.g:9437:6: '<' + { + match(input,60,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred46_InternalExport + + // $ANTLR start synpred47_InternalExport + public final void synpred47_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:9493:6: ( ( () '.' ) ) + // InternalExport.g:9493:7: ( () '.' ) + { + // InternalExport.g:9493:7: ( () '.' ) + // InternalExport.g:9494:7: () '.' + { + // InternalExport.g:9494:7: () + // InternalExport.g:9495:7: + { + } + + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred47_InternalExport + + // $ANTLR start synpred48_InternalExport + public final void synpred48_InternalExport_fragment() throws RecognitionException { + // InternalExport.g:9531:7: ( '<' ) + // InternalExport.g:9531:8: '<' + { + match(input,60,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred48_InternalExport + + // Delegated rules + + public final boolean synpred35_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred35_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred8_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred8_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred22_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred22_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred18_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred18_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred19_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred19_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred48_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred48_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred13_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred13_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred3_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred39_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred39_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred7_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred7_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred17_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred17_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred34_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred34_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred47_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred47_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred38_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred38_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred21_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred21_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred6_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred6_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred12_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred12_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred2_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred2_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred25_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred25_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred16_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred16_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred29_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred29_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred46_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred46_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred33_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred33_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred32_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred32_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred20_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred20_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred45_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred45_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred5_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred5_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred37_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred37_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred41_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred41_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred1_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred1_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred11_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred11_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred23_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred23_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred28_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred28_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred15_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred15_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred36_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred36_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred31_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred31_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred9_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred9_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred4_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred4_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred14_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred14_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred44_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred44_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred27_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred27_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred40_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred40_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred10_InternalExport() { + state.backtracking++; + int start = input.mark(); + try { + synpred10_InternalExport_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA30 dfa30 = new DFA30(this); + protected DFA66 dfa66 = new DFA66(this); + protected DFA76 dfa76 = new DFA76(this); + protected DFA79 dfa79 = new DFA79(this); + protected DFA95 dfa95 = new DFA95(this); + protected DFA94 dfa94 = new DFA94(this); + protected DFA96 dfa96 = new DFA96(this); + protected DFA98 dfa98 = new DFA98(this); + protected DFA107 dfa107 = new DFA107(this); + protected DFA114 dfa114 = new DFA114(this); + protected DFA113 dfa113 = new DFA113(this); + protected DFA136 dfa136 = new DFA136(this); + protected DFA135 dfa135 = new DFA135(this); + protected DFA137 dfa137 = new DFA137(this); + protected DFA141 dfa141 = new DFA141(this); + protected DFA144 dfa144 = new DFA144(this); + protected DFA143 dfa143 = new DFA143(this); + protected DFA145 dfa145 = new DFA145(this); + protected DFA148 dfa148 = new DFA148(this); + protected DFA166 dfa166 = new DFA166(this); + protected DFA164 dfa164 = new DFA164(this); + protected DFA173 dfa173 = new DFA173(this); + static final String dfa_1s = "\36\uffff"; + static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; + static final String dfa_3s = "\1\123\1\uffff\1\0\33\uffff"; + static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; + static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; + static final String[] dfa_6s = { + "\4\3\12\uffff\1\3\13\uffff\1\2\13\uffff\1\1\3\uffff\1\3\2\uffff\1\3\13\uffff\1\3\2\uffff\1\3\1\uffff\11\3\1\uffff\10\3", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA30 extends DFA { + + public DFA30(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 30; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "1175:2: (this_LetExpression_0= ruleLetExpression | ( ( ruleCastedExpression )=>this_CastedExpression_1= ruleCastedExpression ) | this_ChainExpression_2= ruleChainExpression )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA30_2 = input.LA(1); + + + int index30_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred1_InternalExport()) ) {s = 29;} + + else if ( (true) ) {s = 3;} + + + input.seek(index30_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 30, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_7s = "\12\uffff"; + static final String dfa_8s = "\1\10\11\uffff"; + static final String dfa_9s = "\1\4\7\0\2\uffff"; + static final String dfa_10s = "\1\164\7\0\2\uffff"; + static final String dfa_11s = "\10\uffff\1\2\1\1"; + static final String dfa_12s = "\1\uffff\1\2\1\3\1\4\1\5\1\6\1\0\1\1\2\uffff}>"; + static final String[] dfa_13s = { + "\3\10\1\uffff\2\10\5\uffff\2\10\1\uffff\6\10\1\uffff\3\10\2\uffff\2\10\11\uffff\1\10\1\uffff\2\10\1\uffff\1\10\1\uffff\6\10\1\uffff\3\10\1\uffff\1\7\1\6\5\10\12\uffff\3\10\1\uffff\1\10\3\uffff\1\1\1\2\1\3\1\4\1\5\34\10", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); + static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); + static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); + static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); + static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); + static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); + static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); + + class DFA66 extends DFA { + + public DFA66(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 66; + this.eot = dfa_7; + this.eof = dfa_8; + this.min = dfa_9; + this.max = dfa_10; + this.accept = dfa_11; + this.special = dfa_12; + this.transition = dfa_13; + } + public String getDescription() { + return "3975:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA66_6 = input.LA(1); + + + int index66_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_6); + if ( s>=0 ) return s; + break; + case 1 : + int LA66_7 = input.LA(1); + + + int index66_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_7); + if ( s>=0 ) return s; + break; + case 2 : + int LA66_1 = input.LA(1); + + + int index66_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_1); + if ( s>=0 ) return s; + break; + case 3 : + int LA66_2 = input.LA(1); + + + int index66_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_2); + if ( s>=0 ) return s; + break; + case 4 : + int LA66_3 = input.LA(1); + + + int index66_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_3); + if ( s>=0 ) return s; + break; + case 5 : + int LA66_4 = input.LA(1); + + + int index66_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_4); + if ( s>=0 ) return s; + break; + case 6 : + int LA66_5 = input.LA(1); + + + int index66_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExport()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index66_5); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 66, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_14s = "\13\uffff"; + static final String dfa_15s = "\1\1\12\uffff"; + static final String dfa_16s = "\1\4\1\uffff\10\0\1\uffff"; + static final String dfa_17s = "\1\164\1\uffff\10\0\1\uffff"; + static final String dfa_18s = "\1\uffff\1\2\10\uffff\1\1"; + static final String dfa_19s = "\2\uffff\1\5\1\3\1\1\1\2\1\4\1\0\1\6\1\7\1\uffff}>"; + static final String[] dfa_20s = { + "\3\1\1\uffff\2\1\5\uffff\2\1\1\uffff\6\1\1\uffff\3\1\2\uffff\2\1\11\uffff\1\1\1\uffff\1\1\1\4\1\uffff\1\1\1\uffff\6\1\1\uffff\3\1\1\uffff\1\3\1\2\5\1\12\uffff\3\1\1\uffff\1\1\3\uffff\10\1\1\5\1\6\1\7\1\10\1\11\24\1", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "" + }; + + static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); + static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s); + static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); + static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s); + static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); + static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); + static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s); + + class DFA76 extends DFA { + + public DFA76(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 76; + this.eot = dfa_14; + this.eof = dfa_15; + this.min = dfa_16; + this.max = dfa_17; + this.accept = dfa_18; + this.special = dfa_19; + this.transition = dfa_20; + } + public String getDescription() { + return "()* loopback of 4689:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA76_7 = input.LA(1); + + + int index76_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_7); + if ( s>=0 ) return s; + break; + case 1 : + int LA76_4 = input.LA(1); + + + int index76_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_4); + if ( s>=0 ) return s; + break; + case 2 : + int LA76_5 = input.LA(1); + + + int index76_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_5); + if ( s>=0 ) return s; + break; + case 3 : + int LA76_3 = input.LA(1); + + + int index76_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA76_6 = input.LA(1); + + + int index76_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_6); + if ( s>=0 ) return s; + break; + case 5 : + int LA76_2 = input.LA(1); + + + int index76_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_2); + if ( s>=0 ) return s; + break; + case 6 : + int LA76_8 = input.LA(1); + + + int index76_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_8); + if ( s>=0 ) return s; + break; + case 7 : + int LA76_9 = input.LA(1); + + + int index76_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExport()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index76_9); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 76, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_21s = "\1\54\2\uffff\1\73\7\uffff"; + static final String dfa_22s = "\1\140\2\uffff\1\135\7\uffff"; + static final String dfa_23s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\3\1\6"; + static final String dfa_24s = "\13\uffff}>"; + static final String[] dfa_25s = { + "\1\1\16\uffff\1\3\1\6\37\uffff\1\2\1\4\1\5\1\7\1\10", + "", + "", + "\1\12\41\uffff\1\11", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); + static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); + static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); + static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); + static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); + + class DFA79 extends DFA { + + public DFA79(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 79; + this.eot = dfa_14; + this.eof = dfa_14; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4765:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )"; + } + } + static final String dfa_26s = "\116\uffff"; + static final String dfa_27s = "\1\2\115\uffff"; + static final String dfa_28s = "\1\4\1\0\114\uffff"; + static final String dfa_29s = "\1\164\1\0\114\uffff"; + static final String dfa_30s = "\2\uffff\1\2\112\uffff\1\1"; + static final String dfa_31s = "\1\uffff\1\0\114\uffff}>"; + static final String[] dfa_32s = { + "\3\2\1\uffff\2\2\5\uffff\2\2\1\uffff\6\2\1\uffff\3\2\2\uffff\1\1\1\2\11\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\6\2\1\uffff\3\2\1\uffff\7\2\12\uffff\3\2\1\uffff\1\2\3\uffff\41\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s); + static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s); + static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s); + static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s); + static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s); + static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s); + static final short[][] dfa_32 = unpackEncodedStringArray(dfa_32s); + + class DFA95 extends DFA { + + public DFA95(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 95; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "5666:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA95_1 = input.LA(1); + + + int index95_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred18_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index95_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 95, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_33s = "\44\uffff"; + static final String dfa_34s = "\1\4\2\0\41\uffff"; + static final String dfa_35s = "\1\163\2\0\41\uffff"; + static final String dfa_36s = "\3\uffff\2\1\1\2\35\uffff\1\3"; + static final String dfa_37s = "\1\0\1\1\1\2\41\uffff}>"; + static final String[] dfa_38s = { + "\1\1\2\5\1\uffff\2\5\5\uffff\2\5\1\uffff\1\5\1\uffff\1\5\1\uffff\1\5\4\uffff\1\5\2\uffff\1\2\1\43\16\uffff\1\5\2\uffff\1\5\12\uffff\2\5\2\uffff\1\5\12\uffff\1\4\3\5\1\uffff\1\5\15\uffff\1\3\7\uffff\3\5\2\uffff\7\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_33 = DFA.unpackEncodedString(dfa_33s); + static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s); + static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s); + static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s); + static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s); + static final short[][] dfa_38 = unpackEncodedStringArray(dfa_38s); + + class DFA94 extends DFA { + + public DFA94(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 94; + this.eot = dfa_33; + this.eof = dfa_33; + this.min = dfa_34; + this.max = dfa_35; + this.accept = dfa_36; + this.special = dfa_37; + this.transition = dfa_38; + } + public String getDescription() { + return "5685:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA94_0 = input.LA(1); + + + int index94_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA94_0==RULE_ID) ) {s = 1;} + + else if ( (LA94_0==30) ) {s = 2;} + + else if ( (LA94_0==94) && (synpred19_InternalExport())) {s = 3;} + + else if ( (LA94_0==75) && (synpred19_InternalExport())) {s = 4;} + + else if ( ((LA94_0>=RULE_STRING && LA94_0<=RULE_INT)||(LA94_0>=RULE_HEX && LA94_0<=RULE_DECIMAL)||(LA94_0>=15 && LA94_0<=16)||LA94_0==18||LA94_0==20||LA94_0==22||LA94_0==27||LA94_0==46||LA94_0==49||(LA94_0>=60 && LA94_0<=61)||LA94_0==64||(LA94_0>=76 && LA94_0<=78)||LA94_0==80||(LA94_0>=102 && LA94_0<=104)||(LA94_0>=107 && LA94_0<=113)||LA94_0==115) ) {s = 5;} + + else if ( (LA94_0==31) ) {s = 35;} + + + input.seek(index94_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA94_1 = input.LA(1); + + + int index94_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred19_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index94_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA94_2 = input.LA(1); + + + int index94_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred19_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index94_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 94, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_39s = { + "\3\2\1\uffff\2\2\5\uffff\2\2\1\uffff\4\2\1\1\1\2\1\uffff\3\2\2\uffff\2\2\11\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\6\2\1\uffff\3\2\1\uffff\7\2\12\uffff\3\2\1\uffff\1\2\3\uffff\41\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_39 = unpackEncodedStringArray(dfa_39s); + + class DFA96 extends DFA { + + public DFA96(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 96; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_39; + } + public String getDescription() { + return "5783:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA96_1 = input.LA(1); + + + int index96_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred20_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index96_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 96, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_40s = "\40\uffff"; + static final String dfa_41s = "\1\4\26\uffff\1\0\10\uffff"; + static final String dfa_42s = "\1\163\26\uffff\1\0\10\uffff"; + static final String dfa_43s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11"; + static final String dfa_44s = "\1\0\26\uffff\1\1\10\uffff}>"; + static final String[] dfa_45s = { + "\1\5\2\14\1\uffff\2\14\5\uffff\1\5\1\27\1\uffff\1\2\1\uffff\1\5\1\uffff\1\14\7\uffff\1\35\17\uffff\1\26\2\uffff\1\3\12\uffff\1\5\17\uffff\3\14\1\uffff\1\1\25\uffff\1\14\1\30\1\31\2\uffff\3\5\1\14\1\32\1\33\1\34\1\uffff\1\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s); + static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s); + static final char[] dfa_42 = DFA.unpackEncodedStringToUnsignedChars(dfa_42s); + static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s); + static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s); + static final short[][] dfa_45 = unpackEncodedStringArray(dfa_45s); + + class DFA98 extends DFA { + + public DFA98(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 98; + this.eot = dfa_40; + this.eof = dfa_40; + this.min = dfa_41; + this.max = dfa_42; + this.accept = dfa_43; + this.special = dfa_44; + this.transition = dfa_45; + } + public String getDescription() { + return "5828:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA98_0 = input.LA(1); + + + int index98_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA98_0==80) ) {s = 1;} + + else if ( (LA98_0==18) ) {s = 2;} + + else if ( (LA98_0==49) ) {s = 3;} + + else if ( (LA98_0==115) && (synpred21_InternalExport())) {s = 4;} + + else if ( (LA98_0==RULE_ID||LA98_0==15||LA98_0==20||LA98_0==60||(LA98_0>=107 && LA98_0<=109)) ) {s = 5;} + + else if ( ((LA98_0>=RULE_STRING && LA98_0<=RULE_INT)||(LA98_0>=RULE_HEX && LA98_0<=RULE_DECIMAL)||LA98_0==22||(LA98_0>=76 && LA98_0<=78)||LA98_0==102||LA98_0==110) ) {s = 12;} + + else if ( (LA98_0==46) ) {s = 22;} + + else if ( (LA98_0==16) ) {s = 23;} + + else if ( (LA98_0==103) ) {s = 24;} + + else if ( (LA98_0==104) ) {s = 25;} + + else if ( (LA98_0==111) ) {s = 26;} + + else if ( (LA98_0==112) ) {s = 27;} + + else if ( (LA98_0==113) ) {s = 28;} + + else if ( (LA98_0==30) ) {s = 29;} + + + input.seek(index98_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA98_23 = input.LA(1); + + + int index98_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred22_InternalExport()) ) {s = 30;} + + else if ( (true) ) {s = 31;} + + + input.seek(index98_23); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 98, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_46s = "\46\uffff"; + static final String dfa_47s = "\1\4\2\0\43\uffff"; + static final String dfa_48s = "\1\163\2\0\43\uffff"; + static final String dfa_49s = "\3\uffff\2\1\1\2\40\uffff"; + static final String dfa_50s = "\1\0\1\1\1\2\43\uffff}>"; + static final String[] dfa_51s = { + "\1\1\2\5\1\uffff\2\5\5\uffff\2\5\1\uffff\1\5\1\uffff\1\5\1\uffff\2\5\3\uffff\1\5\2\uffff\1\2\17\uffff\1\5\2\uffff\1\5\12\uffff\2\5\2\uffff\1\5\12\uffff\1\4\3\5\1\uffff\1\5\15\uffff\1\3\7\uffff\14\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_46 = DFA.unpackEncodedString(dfa_46s); + static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s); + static final char[] dfa_48 = DFA.unpackEncodedStringToUnsignedChars(dfa_48s); + static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s); + static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s); + static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s); + + class DFA107 extends DFA { + + public DFA107(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 107; + this.eot = dfa_46; + this.eof = dfa_46; + this.min = dfa_47; + this.max = dfa_48; + this.accept = dfa_49; + this.special = dfa_50; + this.transition = dfa_51; + } + public String getDescription() { + return "6320:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA107_0 = input.LA(1); + + + int index107_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA107_0==RULE_ID) ) {s = 1;} + + else if ( (LA107_0==30) ) {s = 2;} + + else if ( (LA107_0==94) && (synpred25_InternalExport())) {s = 3;} + + else if ( (LA107_0==75) && (synpred25_InternalExport())) {s = 4;} + + else if ( ((LA107_0>=RULE_STRING && LA107_0<=RULE_INT)||(LA107_0>=RULE_HEX && LA107_0<=RULE_DECIMAL)||(LA107_0>=15 && LA107_0<=16)||LA107_0==18||LA107_0==20||(LA107_0>=22 && LA107_0<=23)||LA107_0==27||LA107_0==46||LA107_0==49||(LA107_0>=60 && LA107_0<=61)||LA107_0==64||(LA107_0>=76 && LA107_0<=78)||LA107_0==80||(LA107_0>=102 && LA107_0<=113)||LA107_0==115) ) {s = 5;} + + + input.seek(index107_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA107_1 = input.LA(1); + + + int index107_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred25_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index107_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA107_2 = input.LA(1); + + + int index107_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred25_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index107_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 107, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_52s = "\43\uffff"; + static final String dfa_53s = "\1\4\1\0\41\uffff"; + static final String dfa_54s = "\1\163\1\0\41\uffff"; + static final String dfa_55s = "\2\uffff\1\2\37\uffff\1\1"; + static final String dfa_56s = "\1\uffff\1\0\41\uffff}>"; + static final String[] dfa_57s = { + "\3\2\1\uffff\2\2\5\uffff\2\2\1\uffff\1\2\1\uffff\1\2\1\uffff\1\2\4\uffff\1\2\2\uffff\1\1\17\uffff\1\2\2\uffff\1\2\12\uffff\2\2\2\uffff\1\2\13\uffff\3\2\1\uffff\1\2\15\uffff\1\2\7\uffff\3\2\2\uffff\7\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s); + static final char[] dfa_53 = DFA.unpackEncodedStringToUnsignedChars(dfa_53s); + static final char[] dfa_54 = DFA.unpackEncodedStringToUnsignedChars(dfa_54s); + static final short[] dfa_55 = DFA.unpackEncodedString(dfa_55s); + static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s); + static final short[][] dfa_57 = unpackEncodedStringArray(dfa_57s); + + class DFA114 extends DFA { + + public DFA114(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 114; + this.eot = dfa_52; + this.eof = dfa_52; + this.min = dfa_53; + this.max = dfa_54; + this.accept = dfa_55; + this.special = dfa_56; + this.transition = dfa_57; + } + public String getDescription() { + return "6786:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA114_1 = input.LA(1); + + + int index114_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred28_InternalExport()) ) {s = 34;} + + else if ( (true) ) {s = 2;} + + + input.seek(index114_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 114, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_58s = "\42\uffff"; + static final String dfa_59s = "\1\4\2\0\37\uffff"; + static final String dfa_60s = "\1\163\2\0\37\uffff"; + static final String dfa_61s = "\3\uffff\1\1\1\2\35\uffff"; + static final String dfa_62s = "\1\0\1\1\1\2\37\uffff}>"; + static final String[] dfa_63s = { + "\1\1\2\4\1\uffff\2\4\5\uffff\2\4\1\uffff\1\4\1\uffff\1\4\1\uffff\1\4\4\uffff\1\4\2\uffff\1\2\17\uffff\1\4\2\uffff\1\4\12\uffff\2\4\2\uffff\1\4\13\uffff\3\4\1\uffff\1\4\15\uffff\1\3\7\uffff\3\4\2\uffff\7\4\1\uffff\1\4", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_58 = DFA.unpackEncodedString(dfa_58s); + static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s); + static final char[] dfa_60 = DFA.unpackEncodedStringToUnsignedChars(dfa_60s); + static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); + static final short[] dfa_62 = DFA.unpackEncodedString(dfa_62s); + static final short[][] dfa_63 = unpackEncodedStringArray(dfa_63s); + + class DFA113 extends DFA { + + public DFA113(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 113; + this.eot = dfa_58; + this.eof = dfa_58; + this.min = dfa_59; + this.max = dfa_60; + this.accept = dfa_61; + this.special = dfa_62; + this.transition = dfa_63; + } + public String getDescription() { + return "6855:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA113_0 = input.LA(1); + + + int index113_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA113_0==RULE_ID) ) {s = 1;} + + else if ( (LA113_0==30) ) {s = 2;} + + else if ( (LA113_0==94) && (synpred29_InternalExport())) {s = 3;} + + else if ( ((LA113_0>=RULE_STRING && LA113_0<=RULE_INT)||(LA113_0>=RULE_HEX && LA113_0<=RULE_DECIMAL)||(LA113_0>=15 && LA113_0<=16)||LA113_0==18||LA113_0==20||LA113_0==22||LA113_0==27||LA113_0==46||LA113_0==49||(LA113_0>=60 && LA113_0<=61)||LA113_0==64||(LA113_0>=76 && LA113_0<=78)||LA113_0==80||(LA113_0>=102 && LA113_0<=104)||(LA113_0>=107 && LA113_0<=113)||LA113_0==115) ) {s = 4;} + + + input.seek(index113_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA113_1 = input.LA(1); + + + int index113_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred29_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index113_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA113_2 = input.LA(1); + + + int index113_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred29_InternalExport()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index113_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 113, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA136 extends DFA { + + public DFA136(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 136; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "7984:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA136_1 = input.LA(1); + + + int index136_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred32_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index136_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 136, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA135 extends DFA { + + public DFA135(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 135; + this.eot = dfa_33; + this.eof = dfa_33; + this.min = dfa_34; + this.max = dfa_35; + this.accept = dfa_36; + this.special = dfa_37; + this.transition = dfa_38; + } + public String getDescription() { + return "8003:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA135_0 = input.LA(1); + + + int index135_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA135_0==RULE_ID) ) {s = 1;} + + else if ( (LA135_0==30) ) {s = 2;} + + else if ( (LA135_0==94) && (synpred33_InternalExport())) {s = 3;} + + else if ( (LA135_0==75) && (synpred33_InternalExport())) {s = 4;} + + else if ( ((LA135_0>=RULE_STRING && LA135_0<=RULE_INT)||(LA135_0>=RULE_HEX && LA135_0<=RULE_DECIMAL)||(LA135_0>=15 && LA135_0<=16)||LA135_0==18||LA135_0==20||LA135_0==22||LA135_0==27||LA135_0==46||LA135_0==49||(LA135_0>=60 && LA135_0<=61)||LA135_0==64||(LA135_0>=76 && LA135_0<=78)||LA135_0==80||(LA135_0>=102 && LA135_0<=104)||(LA135_0>=107 && LA135_0<=113)||LA135_0==115) ) {s = 5;} + + else if ( (LA135_0==31) ) {s = 35;} + + + input.seek(index135_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA135_1 = input.LA(1); + + + int index135_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred33_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index135_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA135_2 = input.LA(1); + + + int index135_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred33_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index135_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 135, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA137 extends DFA { + + public DFA137(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 137; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_39; + } + public String getDescription() { + return "8101:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA137_1 = input.LA(1); + + + int index137_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred34_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index137_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 137, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_64s = { + "\3\2\1\uffff\2\2\5\uffff\2\2\1\uffff\6\2\1\uffff\3\2\2\uffff\2\2\11\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\6\2\1\uffff\3\2\1\uffff\1\2\1\1\5\2\12\uffff\3\2\1\uffff\1\2\3\uffff\41\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_64 = unpackEncodedStringArray(dfa_64s); + + class DFA141 extends DFA { + + public DFA141(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 141; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_64; + } + public String getDescription() { + return "8260:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA141_1 = input.LA(1); + + + int index141_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred35_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index141_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 141, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA144 extends DFA { + + public DFA144(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 144; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "8317:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA144_1 = input.LA(1); + + + int index144_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred36_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index144_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 144, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA143 extends DFA { + + public DFA143(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 143; + this.eot = dfa_33; + this.eof = dfa_33; + this.min = dfa_34; + this.max = dfa_35; + this.accept = dfa_36; + this.special = dfa_37; + this.transition = dfa_38; + } + public String getDescription() { + return "8336:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA143_0 = input.LA(1); + + + int index143_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA143_0==RULE_ID) ) {s = 1;} + + else if ( (LA143_0==30) ) {s = 2;} + + else if ( (LA143_0==94) && (synpred37_InternalExport())) {s = 3;} + + else if ( (LA143_0==75) && (synpred37_InternalExport())) {s = 4;} + + else if ( ((LA143_0>=RULE_STRING && LA143_0<=RULE_INT)||(LA143_0>=RULE_HEX && LA143_0<=RULE_DECIMAL)||(LA143_0>=15 && LA143_0<=16)||LA143_0==18||LA143_0==20||LA143_0==22||LA143_0==27||LA143_0==46||LA143_0==49||(LA143_0>=60 && LA143_0<=61)||LA143_0==64||(LA143_0>=76 && LA143_0<=78)||LA143_0==80||(LA143_0>=102 && LA143_0<=104)||(LA143_0>=107 && LA143_0<=113)||LA143_0==115) ) {s = 5;} + + else if ( (LA143_0==31) ) {s = 35;} + + + input.seek(index143_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA143_1 = input.LA(1); + + + int index143_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred37_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index143_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA143_2 = input.LA(1); + + + int index143_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred37_InternalExport()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index143_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 143, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA145 extends DFA { + + public DFA145(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 145; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_39; + } + public String getDescription() { + return "8434:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA145_1 = input.LA(1); + + + int index145_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred38_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index145_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 145, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_65s = "\1\41\115\uffff"; + static final String dfa_66s = "\1\4\40\0\55\uffff"; + static final String dfa_67s = "\1\164\40\0\55\uffff"; + static final String dfa_68s = "\41\uffff\1\2\53\uffff\1\1"; + static final String dfa_69s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>"; + static final String[] dfa_70s = { + "\1\1\1\27\1\24\1\uffff\1\23\1\25\5\uffff\1\5\1\32\1\uffff\1\12\1\41\1\4\1\41\1\20\1\41\1\uffff\2\41\1\10\2\uffff\1\40\1\41\11\uffff\1\41\1\uffff\2\41\1\uffff\1\31\1\uffff\1\41\1\13\4\41\1\uffff\3\41\1\uffff\1\41\1\15\1\7\2\41\1\6\1\41\12\uffff\1\22\1\21\1\26\1\uffff\1\11\3\uffff\22\41\1\17\1\33\1\34\2\41\1\2\1\3\1\16\1\30\1\35\1\36\1\37\1\41\1\14\1\41", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[] dfa_65 = DFA.unpackEncodedString(dfa_65s); + static final char[] dfa_66 = DFA.unpackEncodedStringToUnsignedChars(dfa_66s); + static final char[] dfa_67 = DFA.unpackEncodedStringToUnsignedChars(dfa_67s); + static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s); + static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s); + static final short[][] dfa_70 = unpackEncodedStringArray(dfa_70s); + + class DFA148 extends DFA { + + public DFA148(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 148; + this.eot = dfa_26; + this.eof = dfa_65; + this.min = dfa_66; + this.max = dfa_67; + this.accept = dfa_68; + this.special = dfa_69; + this.transition = dfa_70; + } + public String getDescription() { + return "8777:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA148_1 = input.LA(1); + + + int index148_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA148_2 = input.LA(1); + + + int index148_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA148_3 = input.LA(1); + + + int index148_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA148_4 = input.LA(1); + + + int index148_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA148_5 = input.LA(1); + + + int index148_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA148_6 = input.LA(1); + + + int index148_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA148_7 = input.LA(1); + + + int index148_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA148_8 = input.LA(1); + + + int index148_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA148_9 = input.LA(1); + + + int index148_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA148_10 = input.LA(1); + + + int index148_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA148_11 = input.LA(1); + + + int index148_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA148_12 = input.LA(1); + + + int index148_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA148_13 = input.LA(1); + + + int index148_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA148_14 = input.LA(1); + + + int index148_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA148_15 = input.LA(1); + + + int index148_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA148_16 = input.LA(1); + + + int index148_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA148_17 = input.LA(1); + + + int index148_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA148_18 = input.LA(1); + + + int index148_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA148_19 = input.LA(1); + + + int index148_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_19); + if ( s>=0 ) return s; + break; + case 19 : + int LA148_20 = input.LA(1); + + + int index148_20 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_20); + if ( s>=0 ) return s; + break; + case 20 : + int LA148_21 = input.LA(1); + + + int index148_21 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_21); + if ( s>=0 ) return s; + break; + case 21 : + int LA148_22 = input.LA(1); + + + int index148_22 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_22); + if ( s>=0 ) return s; + break; + case 22 : + int LA148_23 = input.LA(1); + + + int index148_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_23); + if ( s>=0 ) return s; + break; + case 23 : + int LA148_24 = input.LA(1); + + + int index148_24 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_24); + if ( s>=0 ) return s; + break; + case 24 : + int LA148_25 = input.LA(1); + + + int index148_25 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_25); + if ( s>=0 ) return s; + break; + case 25 : + int LA148_26 = input.LA(1); + + + int index148_26 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_26); + if ( s>=0 ) return s; + break; + case 26 : + int LA148_27 = input.LA(1); + + + int index148_27 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_27); + if ( s>=0 ) return s; + break; + case 27 : + int LA148_28 = input.LA(1); + + + int index148_28 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_28); + if ( s>=0 ) return s; + break; + case 28 : + int LA148_29 = input.LA(1); + + + int index148_29 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_29); + if ( s>=0 ) return s; + break; + case 29 : + int LA148_30 = input.LA(1); + + + int index148_30 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_30); + if ( s>=0 ) return s; + break; + case 30 : + int LA148_31 = input.LA(1); + + + int index148_31 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_31); + if ( s>=0 ) return s; + break; + case 31 : + int LA148_32 = input.LA(1); + + + int index148_32 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExport()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index148_32); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 148, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_71s = "\117\uffff"; + static final String dfa_72s = "\1\2\116\uffff"; + static final String dfa_73s = "\1\4\1\0\115\uffff"; + static final String dfa_74s = "\1\165\1\0\115\uffff"; + static final String dfa_75s = "\2\uffff\1\2\113\uffff\1\1"; + static final String dfa_76s = "\1\uffff\1\0\115\uffff}>"; + static final String[] dfa_77s = { + "\3\2\1\uffff\2\2\5\uffff\2\2\1\uffff\6\2\1\uffff\3\2\2\uffff\2\2\11\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\6\2\1\uffff\3\2\1\uffff\1\2\1\1\5\2\12\uffff\3\2\1\uffff\1\2\3\uffff\42\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", "", "", "", @@ -11283,120 +33335,268 @@ public final boolean synpred2_InternalExport() { "" }; - static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); - static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); - static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); - static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); - static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); - static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + static final short[] dfa_71 = DFA.unpackEncodedString(dfa_71s); + static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s); + static final char[] dfa_73 = DFA.unpackEncodedStringToUnsignedChars(dfa_73s); + static final char[] dfa_74 = DFA.unpackEncodedStringToUnsignedChars(dfa_74s); + static final short[] dfa_75 = DFA.unpackEncodedString(dfa_75s); + static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s); + static final short[][] dfa_77 = unpackEncodedStringArray(dfa_77s); - class DFA30 extends DFA { + class DFA166 extends DFA { - public DFA30(BaseRecognizer recognizer) { + public DFA166(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 30; - this.eot = dfa_1; - this.eof = dfa_1; - this.min = dfa_2; - this.max = dfa_3; - this.accept = dfa_4; - this.special = dfa_5; - this.transition = dfa_6; + this.decisionNumber = 166; + this.eot = dfa_71; + this.eof = dfa_72; + this.min = dfa_73; + this.max = dfa_74; + this.accept = dfa_75; + this.special = dfa_76; + this.transition = dfa_77; } public String getDescription() { - return "1175:2: (this_LetExpression_0= ruleLetExpression | ( ( ruleCastedExpression )=>this_CastedExpression_1= ruleCastedExpression ) | this_ChainExpression_2= ruleChainExpression )"; + return "9435:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA30_2 = input.LA(1); + int LA166_1 = input.LA(1); - int index30_2 = input.index(); + int index166_1 = input.index(); input.rewind(); s = -1; - if ( (synpred1_InternalExport()) ) {s = 29;} + if ( (synpred46_InternalExport()) ) {s = 78;} - else if ( (true) ) {s = 3;} + else if ( (true) ) {s = 2;} - input.seek(index30_2); + input.seek(index166_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 30, _s, input); + new NoViableAltException(getDescription(), 166, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA164 extends DFA { + + public DFA164(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 164; + this.eot = dfa_71; + this.eof = dfa_72; + this.min = dfa_73; + this.max = dfa_74; + this.accept = dfa_75; + this.special = dfa_76; + this.transition = dfa_77; + } + public String getDescription() { + return "9529:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA164_1 = input.LA(1); + + + int index164_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred48_InternalExport()) ) {s = 78;} + + else if ( (true) ) {s = 2;} + + + input.seek(index164_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 164, _s, input); error(nvae); throw nvae; } } + static final String dfa_78s = "\7\uffff"; + static final String dfa_79s = "\2\uffff\1\4\3\uffff\1\4"; + static final String dfa_80s = "\1\4\1\uffff\1\32\1\4\2\uffff\1\32"; + static final String dfa_81s = "\1\154\1\uffff\1\101\1\76\2\uffff\1\101"; + static final String dfa_82s = "\1\uffff\1\1\2\uffff\1\2\1\3\1\uffff"; + static final String dfa_83s = "\7\uffff}>"; + static final String[] dfa_84s = { + "\1\2\147\uffff\1\1", + "", + "\1\4\46\uffff\1\3", + "\1\6\71\uffff\1\5", + "", + "", + "\1\4\46\uffff\1\3" + }; + + static final short[] dfa_78 = DFA.unpackEncodedString(dfa_78s); + static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s); + static final char[] dfa_80 = DFA.unpackEncodedStringToUnsignedChars(dfa_80s); + static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s); + static final short[] dfa_82 = DFA.unpackEncodedString(dfa_82s); + static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s); + static final short[][] dfa_84 = unpackEncodedStringArray(dfa_84s); + + class DFA173 extends DFA { + + public DFA173(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 173; + this.eot = dfa_78; + this.eof = dfa_79; + this.min = dfa_80; + this.max = dfa_81; + this.accept = dfa_82; + this.special = dfa_83; + this.transition = dfa_84; + } + public String getDescription() { + return "9991:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) )"; + } + } public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000002010L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000008010L}); public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000004000L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000040000L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x000000000004B000L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x000000000000B000L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000010000L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000020010L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x000000000000B002L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000100000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x000000000012C000L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x000000000002C000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000040000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000080010L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x000000000002C002L}); public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000020L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000080002L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000001500000L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x48009100100100F0L,0x000000000003FDFFL}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000001400000L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x000000000E000010L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000001C00000L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000002000010L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000016000000L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000012000000L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000020000000L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000040000010L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000100010L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000190000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x48009100900100F0L,0x000000000003FDFFL}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000110000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000007900020000L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000600000000L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000400000000L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000001000000L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000007800020000L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000006000020000L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000001800000L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000008000000002L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000020000000000L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000010L,0x0000000000038000L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000040000000002L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000080000000002L}); - public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000400000000002L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000010010000L}); - public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x48000000100100F0L,0x000000000003FDFFL}); - public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0003000000000000L}); - public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000020000L}); - public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0004000000000002L}); - public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0008000000000002L}); - public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0010000000000002L}); - public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x07E0000000000002L}); - public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0800000002000002L}); - public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x3000000000000002L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x8000000000000002L}); - public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x48009100300100F0L,0x000000000003FDFFL}); - public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000020800000L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x00000000000001FEL}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x48009100100300F0L,0x000000000003FDFFL}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000820000L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000100000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000200002L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000005400000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x20024400400400F0L,0x00000000000FF7FDL}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000800000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000005000000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000038000010L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000007000000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000008000010L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000058000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000048000000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000040000000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000100000010L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000400010L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000640000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x20024402400400F0L,0x00000000000FF7FDL}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000440000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x000001E400080000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000001000000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000001800000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000001000000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000004000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x000001E000080000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000018000080000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000006000000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000020000000002L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000080000000000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000010L,0x00000000000E0000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000100000000002L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000200000000002L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000800000000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0001000000000002L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000040040000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x20000000400400F0L,0x00000000000FF7FDL}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x000C000000000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000080000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0010000000000002L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0020000000000002L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0040000000000002L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x1F80000000000002L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x2000000008000002L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0xC000000000000002L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x20024400C00400F0L,0x00000000000FF7FDL}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000082000000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x00000000000007F8L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x20024400400C00F0L,0x00000000000FF7FDL}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000002080000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x3002400048558370L,0x000BF9C000017001L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x1800000000000002L,0x0000000001F00000L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x1000000000000000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0A00000000000000L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0200000000000000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0180000000000002L,0x0000000006000000L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x1A00000000000002L,0x0000000008000000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000040000010L,0x0000000040000000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x1800100000000002L,0x00000001F0000000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0800000000000000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x1000000000000000L,0x0000000040000000L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xC000000000000002L,0x0000000600000000L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000002L,0x0000001800000000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000020000000002L,0x0000002000000002L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000108010L,0x0000180000000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x1000000000108010L,0x0000380000000000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000200040000010L,0x0000000040000000L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0800000002000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000020040400002L,0x0000002000000002L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x30024000C8558370L,0x000BF9C040017801L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000020000400002L,0x0000002000000002L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x30024000485D8370L,0x000BF9C000017001L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x3002400048D58370L,0x000BF9C000017001L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000002800000L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x3002400048D58370L,0x000BFFC040017801L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000002000000L,0x0000000000000800L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x3002400048D58370L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x300240004C558372L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x3002400048558372L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x3002400048558370L,0x000BF9C040017001L}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x000C080042080010L,0x0000000040000000L}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0008080002000000L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000080002000000L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x300240004C558370L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x3002400048558370L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x300240004C558370L,0x000BF9C000017001L}); + public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x30024000C8558370L,0x000BF9C000017001L}); + public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); + public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x30024000485D8370L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x300240004C5D8370L,0x000BFFC000017001L}); + public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000001000002L}); + public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0000000040400002L}); + public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0000000000400002L}); + public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x1000000040400002L}); + public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000000080400000L}); + public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x3002400048558372L,0x000BF9C000017001L}); + public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000000000000000L,0x0014000000000000L}); + public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0000000000000002L,0x0014000000000000L}); + public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0000000000000240L}); + public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x00000000C0000010L,0x0000000040000000L}); + public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L}); + public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x1000000000000002L}); + public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x1000000000000002L,0x0000000000000002L}); + public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000000000002L,0x0000280000000000L}); + public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000000002L,0x0020000000000000L}); + public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000000000010L,0x0000100000000000L}); + public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x4000000000000010L}); + public static final BitSet FOLLOW_124 = new BitSet(new long[]{0x0000000004000002L}); + public static final BitSet FOLLOW_125 = new BitSet(new long[]{0x0000000000000012L}); } \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSemanticSequencer.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSemanticSequencer.java index a8ddabe7c4..8e18b3824e 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSemanticSequencer.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSemanticSequencer.java @@ -44,9 +44,54 @@ import org.eclipse.xtext.Action; import org.eclipse.xtext.Parameter; import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.common.types.JvmFormalParameter; +import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference; +import org.eclipse.xtext.common.types.JvmInnerTypeReference; +import org.eclipse.xtext.common.types.JvmLowerBound; +import org.eclipse.xtext.common.types.JvmParameterizedTypeReference; +import org.eclipse.xtext.common.types.JvmTypeParameter; +import org.eclipse.xtext.common.types.JvmUpperBound; +import org.eclipse.xtext.common.types.JvmWildcardTypeReference; +import org.eclipse.xtext.common.types.TypesPackage; import org.eclipse.xtext.serializer.ISerializationContext; import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; +import org.eclipse.xtext.xbase.XAssignment; +import org.eclipse.xtext.xbase.XBasicForLoopExpression; +import org.eclipse.xtext.xbase.XBinaryOperation; +import org.eclipse.xtext.xbase.XBlockExpression; +import org.eclipse.xtext.xbase.XBooleanLiteral; +import org.eclipse.xtext.xbase.XCasePart; +import org.eclipse.xtext.xbase.XCastedExpression; +import org.eclipse.xtext.xbase.XCatchClause; +import org.eclipse.xtext.xbase.XClosure; +import org.eclipse.xtext.xbase.XConstructorCall; +import org.eclipse.xtext.xbase.XDoWhileExpression; +import org.eclipse.xtext.xbase.XFeatureCall; +import org.eclipse.xtext.xbase.XForLoopExpression; +import org.eclipse.xtext.xbase.XIfExpression; +import org.eclipse.xtext.xbase.XInstanceOfExpression; +import org.eclipse.xtext.xbase.XListLiteral; +import org.eclipse.xtext.xbase.XMemberFeatureCall; +import org.eclipse.xtext.xbase.XNullLiteral; +import org.eclipse.xtext.xbase.XNumberLiteral; +import org.eclipse.xtext.xbase.XPostfixOperation; +import org.eclipse.xtext.xbase.XReturnExpression; +import org.eclipse.xtext.xbase.XSetLiteral; +import org.eclipse.xtext.xbase.XStringLiteral; +import org.eclipse.xtext.xbase.XSwitchExpression; +import org.eclipse.xtext.xbase.XSynchronizedExpression; +import org.eclipse.xtext.xbase.XThrowExpression; +import org.eclipse.xtext.xbase.XTryCatchFinallyExpression; +import org.eclipse.xtext.xbase.XTypeLiteral; +import org.eclipse.xtext.xbase.XUnaryOperation; +import org.eclipse.xtext.xbase.XVariableDeclaration; +import org.eclipse.xtext.xbase.XWhileExpression; +import org.eclipse.xtext.xbase.XbasePackage; +import org.eclipse.xtext.xtype.XFunctionTypeRef; +import org.eclipse.xtext.xtype.XImportDeclaration; +import org.eclipse.xtext.xtype.XImportSection; +import org.eclipse.xtext.xtype.XtypePackage; @SuppressWarnings("all") public abstract class AbstractExportSemanticSequencer extends ExpressionSemanticSequencer { @@ -340,6 +385,245 @@ else if (rule == grammarAccess.getFeatureCallRule() } else break; } + else if (epackage == TypesPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case TypesPackage.JVM_FORMAL_PARAMETER: + if (rule == grammarAccess.getFullJvmFormalParameterRule()) { + sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmFormalParameterRule()) { + sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject); + return; + } + else break; + case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE: + sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); + return; + case TypesPackage.JVM_INNER_TYPE_REFERENCE: + sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); + return; + case TypesPackage.JVM_LOWER_BOUND: + if (rule == grammarAccess.getJvmLowerBoundAndedRule()) { + sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmLowerBoundRule()) { + sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE: + if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) { + sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmTypeReferenceRule() + || action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0() + || rule == grammarAccess.getJvmParameterizedTypeReferenceRule() + || rule == grammarAccess.getJvmArgumentTypeReferenceRule()) { + sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else break; + case TypesPackage.JVM_TYPE_PARAMETER: + sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); + return; + case TypesPackage.JVM_UPPER_BOUND: + if (rule == grammarAccess.getJvmUpperBoundAndedRule()) { + sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmUpperBoundRule()) { + sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE: + sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); + return; + } + else if (epackage == XbasePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XbasePackage.XASSIGNMENT: + sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject); + return; + case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION: + sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject); + return; + case XbasePackage.XBINARY_OPERATION: + sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject); + return; + case XbasePackage.XBLOCK_EXPRESSION: + if (rule == grammarAccess.getXExpressionRule() + || rule == grammarAccess.getXAssignmentRule() + || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOrExpressionRule() + || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAndExpressionRule() + || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXEqualityExpressionRule() + || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXRelationalExpressionRule() + || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0() + || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOtherOperatorExpressionRule() + || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAdditiveExpressionRule() + || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXMultiplicativeExpressionRule() + || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXUnaryOperationRule() + || rule == grammarAccess.getXCastedExpressionRule() + || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0() + || rule == grammarAccess.getXPostfixOperationRule() + || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0() + || rule == grammarAccess.getXMemberFeatureCallRule() + || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0() + || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0() + || rule == grammarAccess.getXPrimaryExpressionRule() + || rule == grammarAccess.getXParenthesizedExpressionRule() + || rule == grammarAccess.getXBlockExpressionRule() + || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) { + sequence_XBlockExpression(context, (XBlockExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getXExpressionInClosureRule()) { + sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject); + return; + } + else break; + case XbasePackage.XBOOLEAN_LITERAL: + sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject); + return; + case XbasePackage.XCASE_PART: + sequence_XCasePart(context, (XCasePart) semanticObject); + return; + case XbasePackage.XCASTED_EXPRESSION: + sequence_XCastedExpression(context, (XCastedExpression) semanticObject); + return; + case XbasePackage.XCATCH_CLAUSE: + sequence_XCatchClause(context, (XCatchClause) semanticObject); + return; + case XbasePackage.XCLOSURE: + if (rule == grammarAccess.getXExpressionRule() + || rule == grammarAccess.getXAssignmentRule() + || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOrExpressionRule() + || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAndExpressionRule() + || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXEqualityExpressionRule() + || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXRelationalExpressionRule() + || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0() + || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOtherOperatorExpressionRule() + || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAdditiveExpressionRule() + || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXMultiplicativeExpressionRule() + || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXUnaryOperationRule() + || rule == grammarAccess.getXCastedExpressionRule() + || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0() + || rule == grammarAccess.getXPostfixOperationRule() + || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0() + || rule == grammarAccess.getXMemberFeatureCallRule() + || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0() + || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0() + || rule == grammarAccess.getXPrimaryExpressionRule() + || rule == grammarAccess.getXLiteralRule() + || rule == grammarAccess.getXClosureRule() + || rule == grammarAccess.getXParenthesizedExpressionRule() + || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) { + sequence_XClosure(context, (XClosure) semanticObject); + return; + } + else if (rule == grammarAccess.getXShortClosureRule()) { + sequence_XShortClosure(context, (XClosure) semanticObject); + return; + } + else break; + case XbasePackage.XCONSTRUCTOR_CALL: + sequence_XConstructorCall(context, (XConstructorCall) semanticObject); + return; + case XbasePackage.XDO_WHILE_EXPRESSION: + sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject); + return; + case XbasePackage.XFEATURE_CALL: + sequence_XFeatureCall(context, (XFeatureCall) semanticObject); + return; + case XbasePackage.XFOR_LOOP_EXPRESSION: + sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject); + return; + case XbasePackage.XIF_EXPRESSION: + sequence_XIfExpression(context, (XIfExpression) semanticObject); + return; + case XbasePackage.XINSTANCE_OF_EXPRESSION: + sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject); + return; + case XbasePackage.XLIST_LITERAL: + sequence_XListLiteral(context, (XListLiteral) semanticObject); + return; + case XbasePackage.XMEMBER_FEATURE_CALL: + sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject); + return; + case XbasePackage.XNULL_LITERAL: + sequence_XNullLiteral(context, (XNullLiteral) semanticObject); + return; + case XbasePackage.XNUMBER_LITERAL: + sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject); + return; + case XbasePackage.XPOSTFIX_OPERATION: + sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject); + return; + case XbasePackage.XRETURN_EXPRESSION: + sequence_XReturnExpression(context, (XReturnExpression) semanticObject); + return; + case XbasePackage.XSET_LITERAL: + sequence_XSetLiteral(context, (XSetLiteral) semanticObject); + return; + case XbasePackage.XSTRING_LITERAL: + sequence_XStringLiteral(context, (XStringLiteral) semanticObject); + return; + case XbasePackage.XSWITCH_EXPRESSION: + sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject); + return; + case XbasePackage.XSYNCHRONIZED_EXPRESSION: + sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject); + return; + case XbasePackage.XTHROW_EXPRESSION: + sequence_XThrowExpression(context, (XThrowExpression) semanticObject); + return; + case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION: + sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject); + return; + case XbasePackage.XTYPE_LITERAL: + sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject); + return; + case XbasePackage.XUNARY_OPERATION: + sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject); + return; + case XbasePackage.XVARIABLE_DECLARATION: + sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject); + return; + case XbasePackage.XWHILE_EXPRESSION: + sequence_XWhileExpression(context, (XWhileExpression) semanticObject); + return; + } + else if (epackage == XtypePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XtypePackage.XFUNCTION_TYPE_REF: + sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); + return; + case XtypePackage.XIMPORT_DECLARATION: + sequence_XImportDeclaration(context, (XImportDeclaration) semanticObject); + return; + case XtypePackage.XIMPORT_SECTION: + sequence_XImportSection(context, (XImportSection) semanticObject); + return; + } if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); } diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSyntacticSequencer.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSyntacticSequencer.java index cac9ca8ccd..ed92bba2fd 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSyntacticSequencer.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/serializer/AbstractExportSyntacticSequencer.java @@ -11,6 +11,7 @@ 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.GroupAlias; import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; @@ -22,19 +23,56 @@ public abstract class AbstractExportSyntacticSequencer extends AbstractSyntactic protected ExportGrammarAccess grammarAccess; protected AbstractElementAlias match_ParanthesizedExpression_LeftParenthesisKeyword_0_a; protected AbstractElementAlias match_ParanthesizedExpression_LeftParenthesisKeyword_0_p; + protected AbstractElementAlias match_XBlockExpression_SemicolonKeyword_2_1_q; + protected AbstractElementAlias match_XExpressionInClosure_SemicolonKeyword_1_1_q; + protected AbstractElementAlias match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q; + protected AbstractElementAlias match_XImportDeclaration_SemicolonKeyword_2_q; + protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_a; + protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_p; @Inject protected void init(IGrammarAccess access) { grammarAccess = (ExportGrammarAccess) access; match_ParanthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); match_ParanthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + match_XBlockExpression_SemicolonKeyword_2_1_q = new TokenAlias(false, true, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + match_XExpressionInClosure_SemicolonKeyword_1_1_q = new TokenAlias(false, true, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()), new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2())); + match_XImportDeclaration_SemicolonKeyword_2_q = new TokenAlias(false, true, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + match_XParenthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + match_XParenthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } @Override protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (ruleCall.getRule() == grammarAccess.getArrayBracketsRule()) + return getArrayBracketsToken(semanticObject, ruleCall, node); + else if (ruleCall.getRule() == grammarAccess.getOpSingleAssignRule()) + return getOpSingleAssignToken(semanticObject, ruleCall, node); return ""; } + /** + * ArrayBrackets : + * '[' ']' + * ; + */ + protected String getArrayBracketsToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "[ ]"; + } + + /** + * OpSingleAssign: + * '=' + * ; + */ + protected String getOpSingleAssignToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "="; + } @Override protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { @@ -46,6 +84,18 @@ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition trans emit_ParanthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes); else if (match_ParanthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax)) emit_ParanthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XBlockExpression_SemicolonKeyword_2_1_q.equals(syntax)) + emit_XBlockExpression_SemicolonKeyword_2_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XExpressionInClosure_SemicolonKeyword_1_1_q.equals(syntax)) + emit_XExpressionInClosure_SemicolonKeyword_1_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q.equals(syntax)) + emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XImportDeclaration_SemicolonKeyword_2_q.equals(syntax)) + emit_XImportDeclaration_SemicolonKeyword_2_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_a.equals(syntax)) + emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax)) + emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes); else acceptNodes(getLastNavigableState(), syntaxNodes); } } @@ -150,4 +200,176 @@ protected void emit_ParanthesizedExpression_LeftParenthesisKeyword_0_p(EObject s acceptNodes(transition, nodes); } + /** + * 

+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' ')' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 
+	 *
+ */ + protected void emit_XBlockExpression_SemicolonKeyword_2_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 
+	 *
+ */ + protected void emit_XExpressionInClosure_SemicolonKeyword_1_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ('(' ')')?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '=>' returnType=JvmTypeReference
+	 
+	 *
+ */ + protected void emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     importedNamespace=QualifiedNameWithWildcard (ambiguity) (rule end)
+	 *     importedType=[JvmDeclaredType|QualifiedName] (ambiguity) (rule end)
+	 *     memberName=ValidID (ambiguity) (rule end)
+	 *     wildcard?='*' (ambiguity) (rule end)
+	 
+	 *
+ */ + protected void emit_XImportDeclaration_SemicolonKeyword_2_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     '('*
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' (rule start)
+	 *     (rule start) (ambiguity) 'return' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 
+	 *
+ */ + protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     '('+
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' ')' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 
+	 *
+ */ + protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + } diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/services/ExportGrammarAccess.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/services/ExportGrammarAccess.java index 65ff1aedd0..52a0916b14 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/services/ExportGrammarAccess.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/services/ExportGrammarAccess.java @@ -17,9 +17,10 @@ import org.eclipse.xtext.ParserRule; import org.eclipse.xtext.RuleCall; import org.eclipse.xtext.TerminalRule; -import org.eclipse.xtext.common.services.TerminalsGrammarAccess; import org.eclipse.xtext.service.AbstractElementFinder; import org.eclipse.xtext.service.GrammarProvider; +import org.eclipse.xtext.xbase.services.XbaseGrammarAccess; +import org.eclipse.xtext.xbase.services.XtypeGrammarAccess; @Singleton public class ExportGrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { @@ -837,15 +838,19 @@ public class QualifiedIDElements extends AbstractParserRuleElementFinder { private final ExpressionGrammarAccess gaExpression; - private final TerminalsGrammarAccess gaTerminals; + private final XbaseGrammarAccess gaXbase; + + private final XtypeGrammarAccess gaXtype; @Inject public ExportGrammarAccess(GrammarProvider grammarProvider, ExpressionGrammarAccess gaExpression, - TerminalsGrammarAccess gaTerminals) { + XbaseGrammarAccess gaXbase, + XtypeGrammarAccess gaXtype) { this.grammar = internalFindGrammar(grammarProvider); this.gaExpression = gaExpression; - this.gaTerminals = gaTerminals; + this.gaXbase = gaXbase; + this.gaXtype = gaXtype; this.pExportModel = new ExportModelElements(); this.pImport = new ImportElements(); this.pExtension = new ExtensionElements(); @@ -887,8 +892,12 @@ public ExpressionGrammarAccess getExpressionGrammarAccess() { return gaExpression; } - public TerminalsGrammarAccess getTerminalsGrammarAccess() { - return gaTerminals; + public XbaseGrammarAccess getXbaseGrammarAccess() { + return gaXbase; + } + + public XtypeGrammarAccess getXtypeGrammarAccess() { + return gaXtype; } @@ -1543,41 +1552,976 @@ public ParserRule getIdentifierRule() { return getIdentifierAccess().getRule(); } - //terminal ID: '^'?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; - public TerminalRule getIDRule() { - return gaTerminals.getIDRule(); + //XExpression returns XExpression : + // XAssignment; + public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() { + return gaXbase.getXExpressionAccess(); + } + + public ParserRule getXExpressionRule() { + return getXExpressionAccess().getRule(); + } + + //XAssignment returns XExpression : + // {XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | + // XOrExpression ( + // =>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign]) rightOperand=XAssignment + // )?; + public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() { + return gaXbase.getXAssignmentAccess(); + } + + public ParserRule getXAssignmentRule() { + return getXAssignmentAccess().getRule(); + } + + //OpSingleAssign: + // '=' + //; + public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() { + return gaXbase.getOpSingleAssignAccess(); + } + + public ParserRule getOpSingleAssignRule() { + return getOpSingleAssignAccess().getRule(); + } + + //OpMultiAssign: + // '+=' | '-=' | '*=' | '/=' | '%=' | + // '<' '<' '=' | + // '>' '>'? '>='; + public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() { + return gaXbase.getOpMultiAssignAccess(); + } + + public ParserRule getOpMultiAssignRule() { + return getOpMultiAssignAccess().getRule(); + } + + //XOrExpression returns XExpression: + // XAndExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr]) rightOperand=XAndExpression)*; + public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() { + return gaXbase.getXOrExpressionAccess(); + } + + public ParserRule getXOrExpressionRule() { + return getXOrExpressionAccess().getRule(); + } + + //OpOr: + // '||'; + public XbaseGrammarAccess.OpOrElements getOpOrAccess() { + return gaXbase.getOpOrAccess(); + } + + public ParserRule getOpOrRule() { + return getOpOrAccess().getRule(); + } + + //XAndExpression returns XExpression: + // XEqualityExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd]) rightOperand=XEqualityExpression)*; + public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() { + return gaXbase.getXAndExpressionAccess(); + } + + public ParserRule getXAndExpressionRule() { + return getXAndExpressionAccess().getRule(); + } + + //OpAnd: + // '&&'; + public XbaseGrammarAccess.OpAndElements getOpAndAccess() { + return gaXbase.getOpAndAccess(); + } + + public ParserRule getOpAndRule() { + return getOpAndAccess().getRule(); + } + + //XEqualityExpression returns XExpression: + // XRelationalExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality]) + // rightOperand=XRelationalExpression)*; + public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() { + return gaXbase.getXEqualityExpressionAccess(); + } + + public ParserRule getXEqualityExpressionRule() { + return getXEqualityExpressionAccess().getRule(); + } + + //OpEquality: + // '==' | '!=' | '===' | '!=='; + public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() { + return gaXbase.getOpEqualityAccess(); + } + + public ParserRule getOpEqualityRule() { + return getOpEqualityAccess().getRule(); + } + + //XRelationalExpression returns XExpression: + // XOtherOperatorExpression + // (=>({XInstanceOfExpression.expression=current} 'instanceof') type=JvmTypeReference | + // =>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare]) rightOperand=XOtherOperatorExpression)*; + public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() { + return gaXbase.getXRelationalExpressionAccess(); + } + + public ParserRule getXRelationalExpressionRule() { + return getXRelationalExpressionAccess().getRule(); + } + + //OpCompare: + // '>=' | '<' '=' | '>' | '<' ; + public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() { + return gaXbase.getOpCompareAccess(); + } + + public ParserRule getOpCompareRule() { + return getOpCompareAccess().getRule(); + } + + //XOtherOperatorExpression returns XExpression: + // XAdditiveExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther]) + // rightOperand=XAdditiveExpression)*; + public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() { + return gaXbase.getXOtherOperatorExpressionAccess(); + } + + public ParserRule getXOtherOperatorExpressionRule() { + return getXOtherOperatorExpressionAccess().getRule(); + } + + //OpOther: + // '->' + // | '..<' + // | '>' '..' + // | '..' + // | '=>' + // | '>' (=>('>' '>') | '>') + // | '<' (=>('<' '<') | '<' | '=>') + // | '<>' + // | '?:'; + public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() { + return gaXbase.getOpOtherAccess(); + } + + public ParserRule getOpOtherRule() { + return getOpOtherAccess().getRule(); + } + + //XAdditiveExpression returns XExpression: + // XMultiplicativeExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd]) + // rightOperand=XMultiplicativeExpression)*; + public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() { + return gaXbase.getXAdditiveExpressionAccess(); + } + + public ParserRule getXAdditiveExpressionRule() { + return getXAdditiveExpressionAccess().getRule(); + } + + //OpAdd: + // '+' | '-'; + public XbaseGrammarAccess.OpAddElements getOpAddAccess() { + return gaXbase.getOpAddAccess(); + } + + public ParserRule getOpAddRule() { + return getOpAddAccess().getRule(); + } + + //XMultiplicativeExpression returns XExpression: + // XUnaryOperation (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti]) rightOperand=XUnaryOperation)*; + public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() { + return gaXbase.getXMultiplicativeExpressionAccess(); + } + + public ParserRule getXMultiplicativeExpressionRule() { + return getXMultiplicativeExpressionAccess().getRule(); + } + + //OpMulti: + // '*' | '**' | '/' | '%'; + public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() { + return gaXbase.getOpMultiAccess(); + } + + public ParserRule getOpMultiRule() { + return getOpMultiAccess().getRule(); + } + + //XUnaryOperation returns XExpression: + // {XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation + // | XCastedExpression; + public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() { + return gaXbase.getXUnaryOperationAccess(); + } + + public ParserRule getXUnaryOperationRule() { + return getXUnaryOperationAccess().getRule(); + } + + //OpUnary: + // "!" | "-" | "+"; + public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() { + return gaXbase.getOpUnaryAccess(); + } + + public ParserRule getOpUnaryRule() { + return getOpUnaryAccess().getRule(); + } + + //XCastedExpression returns XExpression: + // XPostfixOperation (=>({XCastedExpression.target=current} 'as') type=JvmTypeReference)* + //; + public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() { + return gaXbase.getXCastedExpressionAccess(); + } + + public ParserRule getXCastedExpressionRule() { + return getXCastedExpressionAccess().getRule(); + } + + //XPostfixOperation returns XExpression: + // XMemberFeatureCall =>({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])? + //; + public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() { + return gaXbase.getXPostfixOperationAccess(); + } + + public ParserRule getXPostfixOperationRule() { + return getXPostfixOperationAccess().getRule(); + } + + //OpPostfix: + // "++" | "--" + //; + public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() { + return gaXbase.getOpPostfixAccess(); + } + + public ParserRule getOpPostfixRule() { + return getOpPostfixAccess().getRule(); + } + + //XMemberFeatureCall returns XExpression: + // XPrimaryExpression + // (=>({XAssignment.assignable=current} ('.'|explicitStatic?="::") feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment + // |=>({XMemberFeatureCall.memberCallTarget=current} ("."|nullSafe?="?."|explicitStatic?="::")) + // ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // feature=[types::JvmIdentifiableElement|IdOrSuper] ( + // =>explicitOperationCall?='(' + // ( + // memberCallArguments+=XShortClosure + // | memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)* + // )? + // ')')? + // memberCallArguments+=XClosure? + // )*; + public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() { + return gaXbase.getXMemberFeatureCallAccess(); + } + + public ParserRule getXMemberFeatureCallRule() { + return getXMemberFeatureCallAccess().getRule(); + } + + //XPrimaryExpression returns XExpression: + // XConstructorCall | + // XBlockExpression | + // XSwitchExpression | + // XSynchronizedExpression | + // XFeatureCall | + // XLiteral | + // XIfExpression | + // XForLoopExpression | + // XBasicForLoopExpression | + // XWhileExpression | + // XDoWhileExpression | + // XThrowExpression | + // XReturnExpression | + // XTryCatchFinallyExpression | + // XParenthesizedExpression; + public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() { + return gaXbase.getXPrimaryExpressionAccess(); + } + + public ParserRule getXPrimaryExpressionRule() { + return getXPrimaryExpressionAccess().getRule(); + } + + //XLiteral returns XExpression: + // XCollectionLiteral | + // XClosure | + // XBooleanLiteral | + // XNumberLiteral | + // XNullLiteral | + // XStringLiteral | + // XTypeLiteral + //; + public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() { + return gaXbase.getXLiteralAccess(); + } + + public ParserRule getXLiteralRule() { + return getXLiteralAccess().getRule(); + } + + //XCollectionLiteral: + // XSetLiteral | XListLiteral + //; + public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() { + return gaXbase.getXCollectionLiteralAccess(); + } + + public ParserRule getXCollectionLiteralRule() { + return getXCollectionLiteralAccess().getRule(); + } + + //XSetLiteral: + // {XSetLiteral} '#' '{' (elements+=XExpression (',' elements+=XExpression )*)? '}' + //; + public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() { + return gaXbase.getXSetLiteralAccess(); + } + + public ParserRule getXSetLiteralRule() { + return getXSetLiteralAccess().getRule(); + } + + //XListLiteral: + // {XListLiteral} '#' '[' (elements+=XExpression (',' elements+=XExpression )*)? ']' + //; + public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() { + return gaXbase.getXListLiteralAccess(); + } + + public ParserRule getXListLiteralRule() { + return getXListLiteralAccess().getRule(); + } + + //XClosure returns XExpression: + // =>({XClosure} + // '[') + // =>((declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?='|')? + // expression=XExpressionInClosure + // ']'; + public XbaseGrammarAccess.XClosureElements getXClosureAccess() { + return gaXbase.getXClosureAccess(); + } + + public ParserRule getXClosureRule() { + return getXClosureAccess().getRule(); + } + + //XExpressionInClosure returns XExpression: + // {XBlockExpression} + // (expressions+=XExpressionOrVarDeclaration ';'?)* + //; + public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() { + return gaXbase.getXExpressionInClosureAccess(); + } + + public ParserRule getXExpressionInClosureRule() { + return getXExpressionInClosureAccess().getRule(); + } + + //XShortClosure returns XExpression: + // =>({XClosure} (declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?='|') expression=XExpression; + public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() { + return gaXbase.getXShortClosureAccess(); + } + + public ParserRule getXShortClosureRule() { + return getXShortClosureAccess().getRule(); + } + + //XParenthesizedExpression returns XExpression: + // '(' XExpression ')'; + public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() { + return gaXbase.getXParenthesizedExpressionAccess(); + } + + public ParserRule getXParenthesizedExpressionRule() { + return getXParenthesizedExpressionAccess().getRule(); + } + + //XIfExpression returns XExpression: + // {XIfExpression} + // 'if' '(' if=XExpression ')' + // then=XExpression + // (=>'else' else=XExpression)?; + public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() { + return gaXbase.getXIfExpressionAccess(); + } + + public ParserRule getXIfExpressionRule() { + return getXIfExpressionAccess().getRule(); + } + + //XSwitchExpression returns XExpression: + // {XSwitchExpression} + // 'switch' (=>('(' declaredParam=JvmFormalParameter ':') switch=XExpression ')' + // | =>(declaredParam=JvmFormalParameter ':')? switch=XExpression) '{' + // (cases+=XCasePart)* + // ('default' ':' default=XExpression )? + // '}'; + public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() { + return gaXbase.getXSwitchExpressionAccess(); + } + + public ParserRule getXSwitchExpressionRule() { + return getXSwitchExpressionAccess().getRule(); + } + + //XCasePart: + // {XCasePart} + // typeGuard=JvmTypeReference? ('case' case=XExpression)? + // (':' then=XExpression | fallThrough?=',') ; + public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() { + return gaXbase.getXCasePartAccess(); + } + + public ParserRule getXCasePartRule() { + return getXCasePartAccess().getRule(); + } + + //XForLoopExpression returns XExpression: + // =>({XForLoopExpression} + // 'for' '(' declaredParam=JvmFormalParameter ':') forExpression=XExpression ')' + // eachExpression=XExpression; + public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() { + return gaXbase.getXForLoopExpressionAccess(); + } + + public ParserRule getXForLoopExpressionRule() { + return getXForLoopExpressionAccess().getRule(); + } + + //XBasicForLoopExpression returns XExpression: + // {XBasicForLoopExpression} + // 'for' '('(initExpressions+=XExpressionOrVarDeclaration (',' initExpressions+=XExpressionOrVarDeclaration)*)? ';' + // expression=XExpression? ';' + // (updateExpressions+=XExpression (',' updateExpressions+=XExpression)*)? ')' + // eachExpression=XExpression; + public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() { + return gaXbase.getXBasicForLoopExpressionAccess(); + } + + public ParserRule getXBasicForLoopExpressionRule() { + return getXBasicForLoopExpressionAccess().getRule(); + } + + //XWhileExpression returns XExpression: + // {XWhileExpression} + // 'while' '(' predicate=XExpression ')' + // body=XExpression; + public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() { + return gaXbase.getXWhileExpressionAccess(); + } + + public ParserRule getXWhileExpressionRule() { + return getXWhileExpressionAccess().getRule(); + } + + //XDoWhileExpression returns XExpression: + // {XDoWhileExpression} + // 'do' + // body=XExpression + // 'while' '(' predicate=XExpression ')'; + public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() { + return gaXbase.getXDoWhileExpressionAccess(); + } + + public ParserRule getXDoWhileExpressionRule() { + return getXDoWhileExpressionAccess().getRule(); + } + + //XBlockExpression returns XExpression: + // {XBlockExpression} + // '{' + // (expressions+=XExpressionOrVarDeclaration ';'?)* + // '}'; + public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() { + return gaXbase.getXBlockExpressionAccess(); + } + + public ParserRule getXBlockExpressionRule() { + return getXBlockExpressionAccess().getRule(); + } + + //XExpressionOrVarDeclaration returns XExpression: + // XVariableDeclaration | XExpression; + public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() { + return gaXbase.getXExpressionOrVarDeclarationAccess(); + } + + public ParserRule getXExpressionOrVarDeclarationRule() { + return getXExpressionOrVarDeclarationAccess().getRule(); + } + + //XVariableDeclaration returns XExpression: + // {XVariableDeclaration} + // (writeable?='var'|'val') (=>(type=JvmTypeReference name=ValidID) | name=ValidID) ('=' right=XExpression)?; + public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() { + return gaXbase.getXVariableDeclarationAccess(); + } + + public ParserRule getXVariableDeclarationRule() { + return getXVariableDeclarationAccess().getRule(); + } + + //JvmFormalParameter returns types::JvmFormalParameter: + // (parameterType=JvmTypeReference)? name=ValidID; + public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() { + return gaXbase.getJvmFormalParameterAccess(); + } + + public ParserRule getJvmFormalParameterRule() { + return getJvmFormalParameterAccess().getRule(); + } + + //FullJvmFormalParameter returns types::JvmFormalParameter: + // parameterType=JvmTypeReference name=ValidID; + public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() { + return gaXbase.getFullJvmFormalParameterAccess(); + } + + public ParserRule getFullJvmFormalParameterRule() { + return getFullJvmFormalParameterAccess().getRule(); + } + + //XFeatureCall returns XExpression: + // {XFeatureCall} + // ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // feature=[types::JvmIdentifiableElement|IdOrSuper] + // (=>explicitOperationCall?='(' + // ( + // featureCallArguments+=XShortClosure + // | featureCallArguments+=XExpression (',' featureCallArguments+=XExpression)* + // )? + // ')')? + // featureCallArguments+=XClosure?; + public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() { + return gaXbase.getXFeatureCallAccess(); + } + + public ParserRule getXFeatureCallRule() { + return getXFeatureCallAccess().getRule(); + } + + //FeatureCallID: + // ValidID | 'extends' | 'static' | 'import' | 'extension' + //; + public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() { + return gaXbase.getFeatureCallIDAccess(); + } + + public ParserRule getFeatureCallIDRule() { + return getFeatureCallIDAccess().getRule(); + } + + //IdOrSuper : + // FeatureCallID | 'super' + //; + public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() { + return gaXbase.getIdOrSuperAccess(); + } + + public ParserRule getIdOrSuperRule() { + return getIdOrSuperAccess().getRule(); + } + + //XConstructorCall returns XExpression: + // {XConstructorCall} + // 'new' constructor=[types::JvmConstructor|QualifiedName] + // (=>'<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // (=>explicitConstructorCall?='(' + // ( + // arguments+=XShortClosure + // | arguments+=XExpression (',' arguments+=XExpression)* + // )? + // ')')? + // arguments+=XClosure?; + public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() { + return gaXbase.getXConstructorCallAccess(); + } + + public ParserRule getXConstructorCallRule() { + return getXConstructorCallAccess().getRule(); + } + + //XBooleanLiteral returns XExpression : + // {XBooleanLiteral} ('false' | isTrue?='true'); + public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() { + return gaXbase.getXBooleanLiteralAccess(); + } + + public ParserRule getXBooleanLiteralRule() { + return getXBooleanLiteralAccess().getRule(); + } + + //XNullLiteral returns XExpression : + // {XNullLiteral} 'null'; + public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() { + return gaXbase.getXNullLiteralAccess(); + } + + public ParserRule getXNullLiteralRule() { + return getXNullLiteralAccess().getRule(); + } + + //XNumberLiteral returns XExpression : + // {XNumberLiteral} value=Number; + public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() { + return gaXbase.getXNumberLiteralAccess(); + } + + public ParserRule getXNumberLiteralRule() { + return getXNumberLiteralAccess().getRule(); + } + + //XStringLiteral returns XExpression: + // {XStringLiteral} value=STRING; + public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() { + return gaXbase.getXStringLiteralAccess(); + } + + public ParserRule getXStringLiteralRule() { + return getXStringLiteralAccess().getRule(); + } + + //XTypeLiteral returns XExpression : + // {XTypeLiteral} 'typeof' '(' type=[types::JvmType|QualifiedName] (arrayDimensions+=ArrayBrackets)* ')' + //; + public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() { + return gaXbase.getXTypeLiteralAccess(); + } + + public ParserRule getXTypeLiteralRule() { + return getXTypeLiteralAccess().getRule(); + } + + //XThrowExpression returns XExpression : + // {XThrowExpression} 'throw' expression=XExpression; + public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() { + return gaXbase.getXThrowExpressionAccess(); + } + + public ParserRule getXThrowExpressionRule() { + return getXThrowExpressionAccess().getRule(); + } + + //XReturnExpression returns XExpression : + // {XReturnExpression} 'return' (->expression=XExpression)?; + public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() { + return gaXbase.getXReturnExpressionAccess(); + } + + public ParserRule getXReturnExpressionRule() { + return getXReturnExpressionAccess().getRule(); + } + + //XTryCatchFinallyExpression returns XExpression: + // {XTryCatchFinallyExpression} + // 'try' + // expression=XExpression + // ( + // catchClauses+=XCatchClause+ + // (=>'finally' finallyExpression=XExpression)? + // | 'finally' finallyExpression=XExpression + // ); + public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() { + return gaXbase.getXTryCatchFinallyExpressionAccess(); + } + + public ParserRule getXTryCatchFinallyExpressionRule() { + return getXTryCatchFinallyExpressionAccess().getRule(); + } + + //XSynchronizedExpression returns XExpression: + // =>({XSynchronizedExpression} + // 'synchronized' '(') param=XExpression ')' expression=XExpression; + public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() { + return gaXbase.getXSynchronizedExpressionAccess(); + } + + public ParserRule getXSynchronizedExpressionRule() { + return getXSynchronizedExpressionAccess().getRule(); + } + + //XCatchClause : + // =>'catch' '(' declaredParam=FullJvmFormalParameter ')' expression=XExpression; + public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() { + return gaXbase.getXCatchClauseAccess(); + } + + public ParserRule getXCatchClauseRule() { + return getXCatchClauseAccess().getRule(); + } + + //@Override + //QualifiedName: + // ValidID (=>'.' ValidID)*; + public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() { + return gaXbase.getQualifiedNameAccess(); + } + + public ParserRule getQualifiedNameRule() { + return getQualifiedNameAccess().getRule(); + } + + //Number hidden(): + // HEX | (INT | DECIMAL) ('.' (INT | DECIMAL))?; + public XbaseGrammarAccess.NumberElements getNumberAccess() { + return gaXbase.getNumberAccess(); } - //terminal INT returns ecore::EInt: ('0'..'9')+; + public ParserRule getNumberRule() { + return getNumberAccess().getRule(); + } + + ///** + // * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes, + // * which makes downstream grammars break on classloading, when a rule is removed. + // */ + //StaticQualifier: + // (ValidID '::')+ + //; + public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() { + return gaXbase.getStaticQualifierAccess(); + } + + public ParserRule getStaticQualifierRule() { + return getStaticQualifierAccess().getRule(); + } + + //terminal HEX: + // ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ + // ('#' (('b'|'B')('i'|'I') | ('l'|'L')))?; + public TerminalRule getHEXRule() { + return gaXbase.getHEXRule(); + } + + //terminal INT returns ecore::EInt: + // '0'..'9' ('0'..'9'|'_')*; public TerminalRule getINTRule() { - return gaTerminals.getINTRule(); + return gaXbase.getINTRule(); + } + + //terminal DECIMAL: + // INT + // (('e'|'E') ('+'|'-')? INT)? + // (('b'|'B')('i'|'I'|'d'|'D') | ('l'|'L'|'d'|'D'|'f'|'F'))?; + public TerminalRule getDECIMALRule() { + return gaXbase.getDECIMALRule(); + } + + //JvmTypeReference: + // JvmParameterizedTypeReference =>({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)* + // | XFunctionTypeRef; + public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() { + return gaXtype.getJvmTypeReferenceAccess(); + } + + public ParserRule getJvmTypeReferenceRule() { + return getJvmTypeReferenceAccess().getRule(); + } + + //ArrayBrackets : + // '[' ']' + //; + public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() { + return gaXtype.getArrayBracketsAccess(); + } + + public ParserRule getArrayBracketsRule() { + return getArrayBracketsAccess().getRule(); + } + + //XFunctionTypeRef: + // ('(' (paramTypes+=JvmTypeReference (',' paramTypes+=JvmTypeReference)*)? ')')? '=>' returnType=JvmTypeReference; + public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() { + return gaXtype.getXFunctionTypeRefAccess(); + } + + public ParserRule getXFunctionTypeRefRule() { + return getXFunctionTypeRefAccess().getRule(); + } + + //JvmParameterizedTypeReference: + // type=[JvmType|QualifiedName] ( + // =>'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>' + // (=>({JvmInnerTypeReference.outer=current} '.') type=[JvmType|ValidID] (=>'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>')?)* + // )?; + public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() { + return gaXtype.getJvmParameterizedTypeReferenceAccess(); + } + + public ParserRule getJvmParameterizedTypeReferenceRule() { + return getJvmParameterizedTypeReferenceAccess().getRule(); + } + + //JvmArgumentTypeReference returns JvmTypeReference: + // JvmTypeReference | JvmWildcardTypeReference; + public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() { + return gaXtype.getJvmArgumentTypeReferenceAccess(); + } + + public ParserRule getJvmArgumentTypeReferenceRule() { + return getJvmArgumentTypeReferenceAccess().getRule(); + } + + //JvmWildcardTypeReference: + // {JvmWildcardTypeReference} '?' ( + // constraints+=JvmUpperBound (constraints+=JvmUpperBoundAnded)* + // | constraints+=JvmLowerBound (constraints+=JvmLowerBoundAnded)* + // )?; + public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() { + return gaXtype.getJvmWildcardTypeReferenceAccess(); + } + + public ParserRule getJvmWildcardTypeReferenceRule() { + return getJvmWildcardTypeReferenceAccess().getRule(); + } + + //JvmUpperBound : + // 'extends' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() { + return gaXtype.getJvmUpperBoundAccess(); + } + + public ParserRule getJvmUpperBoundRule() { + return getJvmUpperBoundAccess().getRule(); + } + + //JvmUpperBoundAnded returns JvmUpperBound: + // '&' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() { + return gaXtype.getJvmUpperBoundAndedAccess(); + } + + public ParserRule getJvmUpperBoundAndedRule() { + return getJvmUpperBoundAndedAccess().getRule(); + } + + //JvmLowerBound : + // 'super' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() { + return gaXtype.getJvmLowerBoundAccess(); + } + + public ParserRule getJvmLowerBoundRule() { + return getJvmLowerBoundAccess().getRule(); + } + + //JvmLowerBoundAnded returns JvmLowerBound: + // '&' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() { + return gaXtype.getJvmLowerBoundAndedAccess(); + } + + public ParserRule getJvmLowerBoundAndedRule() { + return getJvmLowerBoundAndedAccess().getRule(); + } + + //JvmTypeParameter : + // name=ValidID + // (constraints+=JvmUpperBound (constraints+=JvmUpperBoundAnded)*)?; + public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() { + return gaXtype.getJvmTypeParameterAccess(); + } + + public ParserRule getJvmTypeParameterRule() { + return getJvmTypeParameterAccess().getRule(); + } + + //QualifiedNameWithWildcard : + // QualifiedName '.' '*'; + public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() { + return gaXtype.getQualifiedNameWithWildcardAccess(); + } + + public ParserRule getQualifiedNameWithWildcardRule() { + return getQualifiedNameWithWildcardAccess().getRule(); + } + + //ValidID: + // ID; + public XtypeGrammarAccess.ValidIDElements getValidIDAccess() { + return gaXtype.getValidIDAccess(); + } + + public ParserRule getValidIDRule() { + return getValidIDAccess().getRule(); + } + + //XImportSection: + // importDeclarations+=XImportDeclaration+; + public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() { + return gaXtype.getXImportSectionAccess(); + } + + public ParserRule getXImportSectionRule() { + return getXImportSectionAccess().getRule(); + } + + //XImportDeclaration: + // 'import' ( + // (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID)) + // | importedType=[JvmDeclaredType|QualifiedName] + // | importedNamespace=QualifiedNameWithWildcard) ';'? + //; + public XtypeGrammarAccess.XImportDeclarationElements getXImportDeclarationAccess() { + return gaXtype.getXImportDeclarationAccess(); + } + + public ParserRule getXImportDeclarationRule() { + return getXImportDeclarationAccess().getRule(); + } + + //QualifiedNameInStaticImport: + // (ValidID '.')+ + //; + public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() { + return gaXtype.getQualifiedNameInStaticImportAccess(); + } + + public ParserRule getQualifiedNameInStaticImportRule() { + return getQualifiedNameInStaticImportAccess().getRule(); + } + + //terminal ID: + // '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; + public TerminalRule getIDRule() { + return gaXtype.getIDRule(); } //terminal STRING: - // '"' ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|'"') )* '"' | - // "'" ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|"'") )* "'" - // ; + // '"' ( '\\' . /* ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') */ | !('\\'|'"') )* '"'? | + // "'" ( '\\' . /* ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') */ | !('\\'|"'") )* "'"?; public TerminalRule getSTRINGRule() { - return gaTerminals.getSTRINGRule(); + return gaXtype.getSTRINGRule(); } - //terminal ML_COMMENT : '/*' -> '*/'; + //terminal ML_COMMENT: '/*' -> '*/'; public TerminalRule getML_COMMENTRule() { - return gaTerminals.getML_COMMENTRule(); + return gaXtype.getML_COMMENTRule(); } - //terminal SL_COMMENT : '//' !('\n'|'\r')* ('\r'? '\n')?; + //terminal SL_COMMENT: '//' !('\n'|'\r')* ('\r'? '\n')?; public TerminalRule getSL_COMMENTRule() { - return gaTerminals.getSL_COMMENTRule(); + return gaXtype.getSL_COMMENTRule(); } - //terminal WS : (' '|'\t'|'\r'|'\n')+; + //terminal WS: (' '|'\t'|'\r'|'\n')+; public TerminalRule getWSRule() { - return gaTerminals.getWSRule(); + return gaXtype.getWSRule(); } //terminal ANY_OTHER: .; public TerminalRule getANY_OTHERRule() { - return gaTerminals.getANY_OTHERRule(); + return gaXtype.getANY_OTHERRule(); } } diff --git a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/validation/AbstractExportValidator.java b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/validation/AbstractExportValidator.java index 12c71caa67..5bf6ac5622 100644 --- a/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/validation/AbstractExportValidator.java +++ b/com.avaloq.tools.ddk.xtext.export/src-gen/com/avaloq/tools/ddk/xtext/export/validation/AbstractExportValidator.java @@ -15,6 +15,9 @@ protected List getEPackages() { List result = new ArrayList(super.getEPackages()); result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.avaloq.com/tools/ddk/xtext/export/Export")); result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.avaloq.com/tools/ddk/xtext/expression/Expression")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xbase")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/common/JavaVMTypes")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xtype")); return result; } } diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/ExportRuntimeModule.java b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/ExportRuntimeModule.java index 34463c042f..8fb590b095 100644 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/ExportRuntimeModule.java +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/ExportRuntimeModule.java @@ -23,9 +23,6 @@ */ public class ExportRuntimeModule extends com.avaloq.tools.ddk.xtext.export.AbstractExportRuntimeModule { - /** - * {@inheritDoc} - */ @Override public Class bindIValueConverterService() { return ExportValueConverterService.class; @@ -36,6 +33,7 @@ public Class bind * * @return implementation */ + @Override public Class bindIQualifiedNameConverter() { return ExportQualifiedNameConverter.class; } diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportFeatureExtensionGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportFeatureExtensionGenerator.xtend deleted file mode 100644 index 0319533d2b..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportFeatureExtensionGenerator.xtend +++ /dev/null @@ -1,77 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject - -class ExportFeatureExtensionGenerator { - - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel it, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - ''' - package «exportFeatureExtension.toJavaPackage»; - - import org.eclipse.xtext.naming.IQualifiedNameProvider; - import com.avaloq.tools.ddk.xtext.resource.AbstractExportFeatureExtension; - import com.avaloq.tools.ddk.xtext.resource.AbstractResourceDescriptionStrategy; - import com.avaloq.tools.ddk.xtext.resource.AbstractSelectorFragmentProvider; - import com.avaloq.tools.ddk.xtext.resource.IFingerprintComputer; - import com.google.inject.Inject; - - import «exportedNamesProvider»; - - - public class «exportFeatureExtension.toSimpleName» extends AbstractExportFeatureExtension { - - @Inject - private «exportedNamesProvider.toSimpleName» namesProvider; - - @Inject - private «fingerprintComputer.toSimpleName» fingerprintComputer; - - @Inject - private «fragmentProvider.toSimpleName» fragmentProvider; - - @Inject - private «resourceDescriptionStrategy.toSimpleName» resourceDescriptionStrategy; - - @Override - protected IQualifiedNameProvider getNamesProvider() { - return namesProvider; - } - - @Override - protected IFingerprintComputer getFingerprintComputer() { - return fingerprintComputer; - } - - @Override - protected AbstractSelectorFragmentProvider getFragmentProvider() { - return fragmentProvider; - } - - @Override - protected AbstractResourceDescriptionStrategy getResourceDescriptionStrategy() { - return resourceDescriptionStrategy; - } - - } - ''' - } - -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGenerator.xtend deleted file mode 100644 index 675aba6710..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGenerator.xtend +++ /dev/null @@ -1,136 +0,0 @@ -/* - * generated by Xtext - */ -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject -import org.eclipse.core.resources.IProject -import org.eclipse.core.resources.ResourcesPlugin -import org.eclipse.emf.ecore.resource.Resource -import org.eclipse.xtext.generator.IFileSystemAccess -import org.eclipse.xtext.generator.IGenerator2 -import org.eclipse.xtext.generator.IGeneratorContext -import org.eclipse.xtext.generator.IFileSystemAccess2 - -/** - * Generates code from your model files on save. - * - * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation - */ -class ExportGenerator implements IGenerator2 { - - @Inject - extension ExportGeneratorSupport generatorSupport - @Inject - extension Naming - @Inject - extension ExportGeneratorX - - @Inject - GenModelUtilX genModelUtil - - @Inject - ExportedNamesProviderGenerator exportedNamesProviderGenerator - @Inject - ResourceDescriptionManagerGenerator resourceDescriptionManagerGenerator - @Inject - ResourceDescriptionStrategyGenerator resourceDescriptionStrategyGenerator - @Inject - ResourceDescriptionConstantsGenerator resourceDescriptionConstantsGenerator - @Inject - FingerprintComputerGenerator fingerprintComputerGenerator - @Inject - FragmentProviderGenerator fragmentProviderGenerator - @Inject - ExportFeatureExtensionGenerator exportFeatureExtensionGenerator - - CompilationContext compilationContext - - override void doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { - if (input === null || input.contents.empty || !(input.contents.head instanceof ExportModel)) { - return - } - val model = input.contents.head as ExportModel - genModelUtil.resource = model.eResource - var IProject project = null - if (input.URI.isPlatformResource) { - val res = ResourcesPlugin.workspace.root.findMember(input.URI.toPlatformString(true)) - if (res !== null) { - project = res.project - } - } - - generatorSupport.executeWithProjectResourceLoader(project, [ - compilationContext = generatorSupport.getCompilationContext(model, genModelUtil) - - generateExportedNamesProvider(model, fsa) - generateResourceDescriptionManager(model, fsa) - generateResourceDescriptionStrategy(model, fsa) - generateResourceDescriptionConstants(model, fsa) - generateFingerprintComputer(model, fsa) - generateFragmentProvider(model, fsa) - generateFeatureExtension(model, fsa) - ]) - } - - def generateExportedNamesProvider(ExportModel model, IFileSystemAccess fsa) { - val fileName = model.exportedNamesProvider.toFileName - fsa.generateFile(fileName, exportedNamesProviderGenerator.generate(model, compilationContext, genModelUtil)) - } - - def generateResourceDescriptionManager(ExportModel model, IFileSystemAccess fsa) { - if(!model.extension){ - val fileName = model.resourceDescriptionManager.toFileName - fsa.generateFile(fileName, ExportOutputConfigurationProvider.STUB_OUTPUT, resourceDescriptionManagerGenerator.generate(model, compilationContext, genModelUtil)) - } - } - - def generateResourceDescriptionStrategy(ExportModel model, IFileSystemAccess fsa) { - val fileName = model.resourceDescriptionStrategy.toFileName - fsa.generateFile(fileName, resourceDescriptionStrategyGenerator.generate(model, compilationContext, genModelUtil)) - } - - def generateResourceDescriptionConstants(ExportModel model, IFileSystemAccess fsa) { - val fileName = model.resourceDescriptionConstants.toFileName - fsa.generateFile(fileName, resourceDescriptionConstantsGenerator.generate(model, compilationContext, genModelUtil)) - } - - def generateFingerprintComputer(ExportModel model, IFileSystemAccess fsa) { - val fileName = model.fingerprintComputer.toFileName - fsa.generateFile(fileName, fingerprintComputerGenerator.generate(model, compilationContext, genModelUtil)) - } - - def generateFragmentProvider(ExportModel model, IFileSystemAccess fsa) { - val fileName = model.fragmentProvider.toFileName - if (model.exports.exists(e|e.fingerprint && e.fragmentAttribute !== null) || model.isExtension) { - fsa.generateFile(fileName, fragmentProviderGenerator.generate(model, compilationContext, genModelUtil)) - } else if (!model.exports.empty){ - fsa.generateFile(fileName, ''' - package «model.fragmentProvider.toJavaPackage»; - - import com.avaloq.tools.ddk.xtext.linking.ShortFragmentProvider; - - - public class «model.fragmentProvider.toSimpleName» extends ShortFragmentProvider { - - } - ''') - } - } - - def generateFeatureExtension(ExportModel model, IFileSystemAccess fsa) { - if (model.extension) { - val fileName = model.exportFeatureExtension.toFileName - fsa.generateFile(fileName, exportFeatureExtensionGenerator.generate(model, compilationContext, genModelUtil)) - } - } - - override afterGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) {} - - override beforeGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) {} - -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGeneratorSupport.java b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGeneratorSupport.java deleted file mode 100644 index 580ce0f630..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportGeneratorSupport.java +++ /dev/null @@ -1,175 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ -package com.avaloq.tools.ddk.xtext.export.generator; - -import java.util.HashMap; -import java.util.List; - -import org.eclipse.emf.ecore.EPackage; -import org.eclipse.emf.ecore.util.EcoreUtil; -import org.eclipse.internal.xtend.expression.parser.SyntaxConstants; -import org.eclipse.xtend.expression.ExecutionContextImpl; -import org.eclipse.xtend.expression.ResourceManagerDefaultImpl; -import org.eclipse.xtend.expression.TypeSystemImpl; -import org.eclipse.xtend.expression.Variable; -import org.eclipse.xtend.typesystem.Type; -import org.eclipse.xtend.typesystem.emf.EmfRegistryMetaModel; -import org.eclipse.xtext.resource.IEObjectDescription; - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel; -import com.avaloq.tools.ddk.xtext.export.export.ExportPackage; -import com.avaloq.tools.ddk.xtext.export.export.Extension; -import com.avaloq.tools.ddk.xtext.export.export.Import; -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext; -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX; -import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorSupport; -import com.avaloq.tools.ddk.xtext.util.EObjectUtil; -import com.google.common.base.Function; -import com.google.common.base.Predicates; -import com.google.common.collect.Iterables; -import com.google.common.collect.Lists; - - -/** - * Various utility functions for the export language. - */ -public final class ExportGeneratorSupport extends GeneratorSupport { - - /** - * Return a compilation context for Xtend executions during the generator run. - * - * @param model - * the BuildDescription for which we generate - * @param genModelUtil - * GenModel util, must not be {@code null} - * @return the {@link CompilationContext} - */ - public CompilationContext getCompilationContext(final ExportModel model, final GenModelUtilX genModelUtil) { - return new CompilationContext(new ExportExecutionContext(model), genModelUtil); - } - - /** - * Helper class defining the execution context for an Xtend compilation during build generation. - * Sets up the metamodels as needed. - */ - private static class ExportExecutionContext extends ExecutionContextImpl { - - ExportExecutionContext(final ExportModel model) { - super(new ResourceManagerDefaultImpl(), new ExportResource(model), new TypeSystemImpl(), new HashMap(), null, null, null, null, null, null, null, null, null); - registerMetaModels(model); - } - - /** - * Register the metamodels for this execution context. - * - * @param model - * The model - */ - private void registerMetaModels(final ExportModel model) { - // First, create one meta model that has all the packages that are visible. Use the scope provider to get that list, - // then convert to a list of EPackages. - final EPackage[] ePackages = Lists.newArrayList(Iterables.transform(EObjectUtil.getScopeProviderByEObject(model).getScope(model, ExportPackage.Literals.IMPORT__PACKAGE).getAllElements(), new Function() { - @Override - public EPackage apply(final IEObjectDescription from) { - return (EPackage) EcoreUtil.resolve(from.getEObjectOrProxy(), model); - } - })).toArray(new EPackage[0]); - registerMetaModel(new EmfRegistryMetaModel() { - @Override - public EPackage[] allPackages() { - return ePackages; - } - - @Override - public Type getTypeForName(final String name) { - final String[] frags = name.split(SyntaxConstants.NS_DELIM); - if (frags.length == 2) { - // convert references which use import alias - for (Import imp : model.getImports()) { - if (frags[0].equals(imp.getName()) && imp.getPackage() != null) { - return super.getTypeForName(imp.getPackage().getName() + SyntaxConstants.NS_DELIM + frags[1]); - } - } - } - return super.getTypeForName(name); - } - }); - // Finally, add the default meta models - // registerMetaModel(new EmfRegistryMetaModel()); - // registerMetaModel(new JavaBeansMetaModel()); - } - } - - /** - * "Fake" resource for Xtend compilation that gives correct extensions and package imports depending on whether - * we're running Xtend inside the export section or the scoping section. - */ - private static class ExportResource implements org.eclipse.xtend.expression.Resource { - - private final ExportModel model; - private String qualifiedName; - private List importedExtensions; - private Iterable importedNamespaces; - - ExportResource(final ExportModel model) { - this.model = model; - } - - @Override - public String getFullyQualifiedName() { - if (qualifiedName == null) { - this.setFullyQualifiedName(model.eResource().getURI().path()); - } - return qualifiedName; - } - - @Override - public String[] getImportedExtensions() { - if (importedExtensions == null) { - importedExtensions = Lists.transform(model.getExtensions(), new Function() { - @Override - public String apply(final Extension from) { - return from.getExtension(); - } - }); - } - // Hmmm... do we have to care about re-exported extensions? Or does Xtend do that by itself? - return importedExtensions.toArray(new String[importedExtensions.size()]); - } - - @Override - public String[] getImportedNamespaces() { - if (importedNamespaces == null) { - importedNamespaces = Iterables.filter(Iterables.transform(model.getImports(), new Function() { - @Override - public String apply(final Import from) { - if (from.getPackage() == null) { - return null; - } - final String name = from.getPackage().getName(); - if (name == null || name.length() == 0) { - return null; - } - return name; - } - }), Predicates. notNull()); - } - return Lists.newArrayList(importedNamespaces).toArray(new String[0]); - } - - @Override - public void setFullyQualifiedName(final String fqn) { - qualifiedName = fqn; - } - - } - -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportModelTypeResolver.java b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportModelTypeResolver.java new file mode 100644 index 0000000000..9218cf5b35 --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportModelTypeResolver.java @@ -0,0 +1,117 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.export.generator; + +import java.util.List; + +import org.eclipse.emf.ecore.EClassifier; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.util.EcoreUtil; + +import com.avaloq.tools.ddk.xtext.export.export.ExportModel; +import com.avaloq.tools.ddk.xtext.export.export.ExportPackage; +import com.avaloq.tools.ddk.xtext.export.export.Import; +import com.avaloq.tools.ddk.xtext.util.EObjectUtil; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; + + +/** + * Resolves the model type names that appear in export expressions (casts, {@code typeSelect} and {@code isInstance}) + * to their EMF {@link EClassifier} using the EPackages imported by the export model. + *

+ * This reproduces, without the classic Xtend type system, the resolution that the legacy + * {@code EmfRegistryMetaModel} performed: an unqualified name such as {@code Entity} is looked up across all + * imported packages, while an aliased or package qualified name such as {@code alias::Entity} resolves the alias to + * the imported package first. The list of visible EPackages is obtained exactly as the legacy generator did, namely + * through the scope of the {@code IMPORT__PACKAGE} reference. + */ +public final class ExportModelTypeResolver { + + private final ExportModel model; + private final List packages; + + /** + * Creates a resolver for the given export model. + * + * @param model + * the export model whose imported packages provide the visible model types, must not be {@code null} + */ + public ExportModelTypeResolver(final ExportModel model) { + this.model = model; + this.packages = Lists.newArrayList(Iterables.transform( + EObjectUtil.getScopeProviderByEObject(model).getScope(model, ExportPackage.Literals.IMPORT__PACKAGE).getAllElements(), + d -> (EPackage) EcoreUtil.resolve(d.getEObjectOrProxy(), model))); + } + + /** + * Resolves the given DSL type name segments to the matching model classifier. + * + * @param segments + * the {@code ::}-separated name segments of the type, must not be {@code null} or empty + * @return the resolved classifier, or {@code null} if no imported package declares it + */ + public EClassifier resolve(final List segments) { + if (segments == null || segments.isEmpty()) { + return null; + } + if (segments.size() == 1) { + return findClassifier(segments.get(0)); + } + final String alias = segments.get(0); + final String typeName = segments.get(segments.size() - 1); + for (final Import imp : model.getImports()) { + if (alias.equals(imp.getName()) && imp.getPackage() != null) { + return imp.getPackage().getEClassifier(typeName); + } + } + for (final EPackage ePackage : packages) { + if (alias.equals(ePackage.getName())) { + final EClassifier classifier = ePackage.getEClassifier(typeName); + if (classifier != null) { + return classifier; + } + } + } + return findClassifier(typeName); + } + + /** + * Finds the first classifier with the given (unqualified) name across all imported packages. + * + * @param name + * the unqualified classifier name, must not be {@code null} + * @return the matching classifier, or {@code null} if none is found + */ + private EClassifier findClassifier(final String name) { + for (final EPackage ePackage : packages) { + final EClassifier classifier = ePackage.getEClassifier(name); + if (classifier != null) { + return classifier; + } + } + return null; + } + + /** + * Convenience factory that returns {@code null} when the given element is not an export model. + * + * @param element + * the model element an export expression originates from, may be {@code null} + * @return a resolver for the containing export model, or {@code null} if none can be determined + */ + public static ExportModelTypeResolver forElement(final EObject element) { + final ExportModel exportModel = org.eclipse.xtext.EcoreUtil2.getContainerOfType(element, ExportModel.class); + return exportModel == null ? null : new ExportModelTypeResolver(exportModel); + } + +} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportedNamesProviderGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportedNamesProviderGenerator.xtend deleted file mode 100644 index 450e35dc13..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ExportedNamesProviderGenerator.xtend +++ /dev/null @@ -1,96 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject -import org.eclipse.emf.ecore.EClass - -class ExportedNamesProviderGenerator { - - @Inject extension CodeGenerationX - @Inject extension GeneratorUtilX - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel it, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - val grammar = grammar - ''' - package «exportedNamesProvider.toJavaPackage()»; - - import org.eclipse.emf.ecore.EClass; - import org.eclipse.emf.ecore.EObject; - import org.eclipse.emf.ecore.EPackage; - import org.eclipse.xtext.naming.QualifiedName; - - import com.avaloq.tools.ddk.xtext.naming.AbstractExportedNameProvider; - - - /** - * Qualified name provider for grammar «grammar?.name?:exportedNamesProvider.toSimpleName» providing the qualified names for exported objects. - */ - public class «exportedNamesProvider.toSimpleName» extends AbstractExportedNameProvider { - - «IF !exports.isEmpty» - «val types = exports» - @Override - public QualifiedName qualifiedName(final EObject object) { - EClass eClass = object.eClass(); - EPackage ePackage = eClass.getEPackage(); - «val exportedEClasses = types.map[type].toSet()» - «val exportsMap = types.sortedExportsByEPackage()» - «FOR p : exportsMap.keySet().sortBy[nsURI]» - if (ePackage == «p.qualifiedPackageInterfaceName()».eINSTANCE) { - int classifierID = eClass.getClassifierID(); - switch (classifierID) { - «FOR c : p.EClassifiers.filter(EClass).filter(c|exportedEClasses.exists(e|e.isSuperTypeOf(c)))» - case «c.classifierIdLiteral()»: { - return qualifiedName((«c.instanceClassName()») object); - } - «ENDFOR» - default: - return null; - } - } - «ENDFOR» - return null; - } - - «FOR c : types» - /** - * Return the qualified name under which a «c.type.name» object is exported, or null if the object should not be exported. - * - * @param obj - * The object to be exported - * @return The object's qualified name, or null if the object is not to be exported - */ - protected QualifiedName qualifiedName(final «c.type.instanceClassName()» obj) { - «javaContributorComment(c.location())» - «IF c.naming !== null» - final Object name = «c.naming.javaExpression(ctx.clone('obj', c.type))»; - return name != null ? «IF c.qualifiedName»getConverter().toQualifiedName(String.valueOf(name))«ELSE»qualifyWithContainerName(obj, String.valueOf(name))«ENDIF» : null; - «ELSE» - return «IF c.qualifiedName»getConverter().toQualifiedName(getResolver().apply(obj))«ELSE»qualifyWithContainerName(obj, getResolver().apply(obj))«ENDIF»; // "name" attribute by default - «ENDIF» - } - - «ENDFOR» - «ENDIF» - } - ''' - } -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FingerprintComputerGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FingerprintComputerGenerator.xtend deleted file mode 100644 index 988a0689f3..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FingerprintComputerGenerator.xtend +++ /dev/null @@ -1,134 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.export.export.InterfaceExpression -import com.avaloq.tools.ddk.xtext.export.export.InterfaceField -import com.avaloq.tools.ddk.xtext.export.export.InterfaceItem -import com.avaloq.tools.ddk.xtext.export.export.InterfaceNavigation -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject -import org.eclipse.emf.ecore.EClass - -class FingerprintComputerGenerator { - - @Inject extension CodeGenerationX - @Inject extension GeneratorUtilX - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel it, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - ''' - package «fingerprintComputer.toJavaPackage»; - - import org.eclipse.emf.ecore.EObject; - «IF !interfaces.isEmpty» - import org.eclipse.emf.ecore.EPackage; - import org.eclipse.emf.ecore.util.Switch; - «ENDIF» - - import com.avaloq.tools.ddk.xtext.resource.AbstractStreamingFingerprintComputer; - - import com.google.common.hash.Hasher; - - - public class «fingerprintComputer.toSimpleName» extends AbstractStreamingFingerprintComputer { - - «IF interfaces.isEmpty» - // no fingerprint defined - @Override - public String computeFingerprint(final org.eclipse.emf.ecore.resource.Resource resource) { - return null; - } - - «ENDIF» - private ThreadLocal hasherAccess = new ThreadLocal(); - - «FOR p : interfaces.map[type.EPackage].toSet.sortBy[nsURI]» - private final Switch «p.name»Switch = new «p.qualifiedSwitchClassName()»() { - «FOR f : interfaces.filter[type.EPackage == p]» - - «javaContributorComment(f.location())» - @Override - public Hasher case«f.type.name»(final «f.type.instanceClassName()» obj) { - final Hasher hasher = hasherAccess.get(); - «IF f.guard !== null» - if (!(«f.guard.javaExpression(ctx.clone('obj', f.type))»)) { - return hasher; - } - «ENDIF» - hasher.putUnencodedChars(obj.eClass().getName()).putChar(ITEM_SEP); - «val superFPs = f.getSuperInterfaces(f.type)» - «FOR superFingerprint : superFPs» - «FOR superItem : superFingerprint.items» - «doProfile(superItem, ctx, genModelUtil, superFingerprint.type)» - «ENDFOR» - «ENDFOR» - «FOR item : f.items» - «doProfile(item, ctx, genModelUtil, f.type)» - «ENDFOR» - return hasher; - } - «ENDFOR» - }; - - «ENDFOR» - @Override - protected void fingerprint(final EObject object, Hasher hasher) { - hasherAccess.set(hasher); - «IF !interfaces.isEmpty» - final EPackage ePackage = object.eClass().getEPackage(); - «FOR p : interfaces.map[type.EPackage].toSet().sortBy[nsURI]» - if (ePackage == «p.qualifiedPackageInterfaceName()».eINSTANCE) { - «p.name»Switch.doSwitch(object); - } - «ENDFOR» - «ENDIF» - hasherAccess.set(null); - } - } - ''' - } - - def dispatch doProfile(InterfaceItem it, CompilationContext ctx, extension GenModelUtilX genModelUtil, EClass type) { - 'ERROR' + it.toString + ' ' + javaContributorComment(it.location()) - } - - def dispatch doProfile(InterfaceField it, CompilationContext ctx, extension GenModelUtilX genModelUtil, EClass type) ''' - «IF field.many && (unordered == true) » - fingerprintFeature(obj, «field.literalIdentifier()», FingerprintOrder.UNORDERED, hasher); - «ELSE» - fingerprintFeature(obj, «field.literalIdentifier()», hasher); - «ENDIF» - hasher.putChar(ITEM_SEP); - ''' - - def dispatch doProfile(InterfaceNavigation it, CompilationContext ctx, extension GenModelUtilX genModelUtil, EClass type) ''' - «IF ref.many && (unordered == true) » - fingerprintRef(obj, «ref.literalIdentifier()», FingerprintOrder.UNORDERED, hasher); - «ELSE» - fingerprintRef(obj, «ref.literalIdentifier()», hasher); - «ENDIF» - hasher.putChar(ITEM_SEP); - ''' - - def dispatch doProfile(InterfaceExpression it, CompilationContext ctx, extension GenModelUtilX genModelUtil, EClass type) ''' - fingerprintExpr(«expr.javaExpression(ctx.clone('obj', type))», obj, FingerprintOrder.«if (unordered) "UNORDERED" else "ORDERED"», FingerprintIndirection.«if (ref) "INDIRECT" else "DIRECT"», hasher); - hasher.putChar(ITEM_SEP); - ''' - -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FragmentProviderGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FragmentProviderGenerator.xtend deleted file mode 100644 index b66003cb67..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/FragmentProviderGenerator.xtend +++ /dev/null @@ -1,94 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject -import org.eclipse.emf.ecore.EClass - -class FragmentProviderGenerator { - - @Inject extension GeneratorUtilX - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel it, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - val grammar = grammar - val fingerprintedExports = exports.filter[fingerprint && fragmentAttribute !== null].toList - ''' - package «fragmentProvider.toJavaPackage»; - - «IF !fingerprintedExports.isEmpty» - import org.eclipse.emf.ecore.EClass; - «ENDIF» - «IF !fingerprintedExports.isEmpty || it.extension» - import org.eclipse.emf.ecore.EObject; - «ENDIF» - «IF !fingerprintedExports.isEmpty» - import org.eclipse.emf.ecore.EPackage; - «ENDIF» - - import com.avaloq.tools.ddk.xtext.resource.AbstractSelectorFragmentProvider; - - - public class «getFragmentProvider().toSimpleName()» extends AbstractSelectorFragmentProvider { - - «IF !fingerprintedExports.isEmpty» - @Override - public boolean appendFragmentSegment(final EObject object, StringBuilder builder) { - EClass eClass = object.eClass(); - EPackage ePackage = eClass.getEPackage(); - «val typeMap = fingerprintedExports.typeMap(grammar)» - «val sortedExportsMap = fingerprintedExports.sortedExportsByEPackage()» - «FOR p : sortedExportsMap.keySet()» - if (ePackage == «p.qualifiedPackageInterfaceName()».eINSTANCE) { - int classifierID = eClass.getClassifierID(); - switch (classifierID) { - «FOR c : p.EClassifiers.filter(EClass).filter(c|fingerprintedExports.map[type].exists(e|e.isSuperTypeOf(c)))» - «val e = typeMap.get(c)» - «javaContributorComment(e.location())» - case «c.classifierIdLiteral()»: { - return appendFragmentSegment((«c.instanceClassName()») object, builder); - } - «ENDFOR» - default: - return super.appendFragmentSegment(object, builder); - } - } - «ENDFOR» - return super.appendFragmentSegment(object, builder); - } - «ENDIF» - - «IF it.extension» - @Override - protected boolean appendFragmentSegmentFallback(final EObject object, StringBuilder builder) { - // For export extension we must return false, so the logic will try other extensions - return false; - } - - «ENDIF» - «FOR e : fingerprintedExports» - protected boolean appendFragmentSegment(final «e.type.instanceClassName()» obj, StringBuilder builder) { - return computeSelectorFragmentSegment(obj, «e.fragmentAttribute.literalIdentifier()», «e.fragmentUnique», builder); - } - - «ENDFOR» - } - ''' - } - -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionConstantsGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionConstantsGenerator.xtend deleted file mode 100644 index d642edcb61..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionConstantsGenerator.xtend +++ /dev/null @@ -1,55 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject - -class ResourceDescriptionConstantsGenerator { - - @Inject extension CodeGenerationX - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel it, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - ''' - package «getResourceDescriptionConstants().toJavaPackage()»; - - public interface «getResourceDescriptionConstants().toSimpleName()» { - «val types = it.exports» - «FOR c : types.filter[!it.type.abstract]» - «val a = c.allEAttributes» - «val d = c.allUserData()» - «IF !a.isEmpty || !d.isEmpty» - // Export «c.type.name» - «IF !a.isEmpty» - «FOR attr : a» - public static final String «attr.constantName(c.type)» = "«attr.name.javaEncode()»"; //$NON-NLS-1$ - «ENDFOR» - «ENDIF» - «IF !d.isEmpty» - «FOR data : d» - public static final String «data.constantName(c.type)» = "«data.name.javaEncode()»"; //$NON-NLS-1$ - «ENDFOR» - «ENDIF» - - «ENDIF» - «ENDFOR» - } - ''' - } - -} \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionManagerGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionManagerGenerator.xtend deleted file mode 100644 index 5e0c4a5c3a..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionManagerGenerator.xtend +++ /dev/null @@ -1,60 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject - -class ResourceDescriptionManagerGenerator { - - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel model, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - val grammar = model.grammar - val usedGrammars = if (grammar !== null) grammar.usedGrammars else newArrayList - val extendedGrammar = if (usedGrammars.isEmpty || usedGrammars.head.name.endsWith('.Terminals')) null else usedGrammars.head - ''' - package «model.resourceDescriptionManager.toJavaPackage»; - - import java.util.Set; - - import com.avaloq.tools.ddk.xtext.resource.AbstractCachingResourceDescriptionManager; - «IF extendedGrammar !== null» - import «extendedGrammar.resourceDescriptionManager»; - import com.google.common.collect.ImmutableSet; - import com.google.common.collect.Sets; - «ENDIF» - import com.google.inject.Singleton; - - - /** - * Resource description manager for «model.name» resources. - */ - @Singleton - public class «model.resourceDescriptionManager.toSimpleName» extends AbstractCachingResourceDescriptionManager { - - public static final Set INTERESTING_EXTS = «IF extendedGrammar !== null»ImmutableSet.copyOf(Sets.union(«extendedGrammar.resourceDescriptionManager.toSimpleName».INTERESTING_EXTS, of(/*add extensions here*/)));«ELSE»all();«ENDIF» - - @Override - protected Set getInterestingExtensions() { - return INTERESTING_EXTS; - } - - } - ''' - } - -} \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionStrategyGenerator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionStrategyGenerator.xtend deleted file mode 100644 index a21a06d5a2..0000000000 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/generator/ResourceDescriptionStrategyGenerator.xtend +++ /dev/null @@ -1,190 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.export.generator - -import com.avaloq.tools.ddk.xtext.export.export.Export -import com.avaloq.tools.ddk.xtext.export.export.ExportModel -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.google.inject.Inject - -class ResourceDescriptionStrategyGenerator { - - @Inject extension CodeGenerationX - @Inject extension GeneratorUtilX - @Inject extension Naming - @Inject extension ExportGeneratorX - - def generate(ExportModel it, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - ''' - package «resourceDescriptionStrategy.toJavaPackage»; - - import java.util.Map; - import java.util.Set; - - import org.eclipse.emf.ecore.EClass; - import org.eclipse.emf.ecore.EObject; - import org.eclipse.emf.ecore.EPackage; - import org.eclipse.emf.ecore.resource.Resource; - import org.eclipse.emf.ecore.util.Switch; - import org.eclipse.xtext.resource.IEObjectDescription; - import org.eclipse.xtext.util.IAcceptor; - - import com.avaloq.tools.ddk.xtext.resource.AbstractResourceDescriptionStrategy; - «IF exports.exists[e|e.fingerprint||e.resourceFingerprint]» - import com.avaloq.tools.ddk.xtext.resource.IFingerprintComputer; - «ENDIF» - «IF exports.exists(e|e.lookup)» - import com.avaloq.tools.ddk.xtext.resource.DetachableEObjectDescription; - «ENDIF» - import com.avaloq.tools.ddk.xtext.resource.extensions.AbstractForwardingResourceDescriptionStrategyMap; - import com.google.common.collect.ImmutableMap; - import com.google.common.collect.ImmutableSet; - «val types = exports» - - - public class «resourceDescriptionStrategy.toSimpleName» extends AbstractResourceDescriptionStrategy { - - private static final Set EXPORTED_ECLASSES = ImmutableSet.copyOf(new EClass[] { - «val e = types.typeMap(grammar)» - «FOR c : e.keySet.sortBy[literalIdentifier] SEPARATOR ',\n'»«c.literalIdentifier»«ENDFOR» - }); - - @Override - public Set getExportedEClasses(final Resource resource) { - return EXPORTED_ECLASSES; - } - - «IF !types.isEmpty» - private final ThreadLocal> acceptor = new ThreadLocal>(); - - «FOR p : types.filter[!type.abstract].map[type.EPackage].toSet.sortBy[nsURI]» - private final Switch «p.name»ExportSwitch = new «p.qualifiedSwitchClassName»() { - - @Override - public Boolean defaultCase(final EObject obj) { - return true; - } - «FOR c : types.filter[!type.abstract && type.EPackage == p]» - - «javaContributorComment(c.location)» - @Override - public Boolean case«c.type.name»(final «c.type.instanceClassName()» obj) { - «val guard = c.guard.javaExpression(ctx.clone('obj', c.type))» - «IF c.guard === null» - «generateCaseBody(c, ctx, genModelUtil)» - «ELSEIF !guard.equalsIgnoreCase("false")» - «javaContributorComment(c.guard.location)» - if («guard») { - «generateCaseBody(c, ctx, genModelUtil)» - } - «ENDIF» - - // can «c.type.name» contain any nested «types.map[type].filter[!abstract].map[name].toSet» objects ? - return «c.type.canContain(types.map[type].filter[!abstract].toSet, grammar)»; - } - «ENDFOR» - }; - - «ENDFOR» - @Override - protected boolean doCreateEObjectDescriptions(final EObject object, final IAcceptor acceptor) { - try { - this.acceptor.set(acceptor); - final EPackage ePackage = object.eClass().getEPackage(); - «FOR p : types.filter[!type.abstract].map[type.EPackage].toSet.sortBy[nsURI]» - if (ePackage == «p.qualifiedPackageInterfaceName».eINSTANCE) { - return «p.name»ExportSwitch.doSwitch(object); - } - «ENDFOR» - «IF it.extension» - // Extension does not have to cover all EPackages of the language - return false; - «ELSE» - // TODO: generate code for other possible epackages (as defined by grammar) - return true; - «ENDIF» - } finally { - this.acceptor.set(null); - } - } - - «ENDIF» - } - ''' - } - - def generateCaseBody(ExportModel it, Export c, CompilationContext ctx, extension GenModelUtilX genModelUtil) { - val a = c.allEAttributes - val d = c.allUserData - ''' - «IF !a.isEmpty || !d.isEmpty || c.fingerprint || c.resourceFingerprint || c.lookup » - // Use a forwarding map to delay calculation as much as possible; otherwise we may get recursive EObject resolution attempts - Map data = new AbstractForwardingResourceDescriptionStrategyMap() { - - @Override - protected void fill(final ImmutableMap.Builder builder) { - Object value = null; - «IF c.fingerprint» - // Fingerprint - value = getFingerprint(obj); - if (value != null) { - builder.put(IFingerprintComputer.OBJECT_FINGERPRINT, value.toString()); - } - «ELSEIF c.resourceFingerprint» - // Resource fingerprint - value = getFingerprint(obj); - if (value != null) { - builder.put(IFingerprintComputer.RESOURCE_FINGERPRINT, value.toString()); - } - «ENDIF» - «IF c.lookup» - // Allow lookups - «IF c.lookupPredicate !== null» - «javaContributorComment(c.lookupPredicate.location)» - if («c.lookupPredicate.javaExpression(ctx.clone('obj', c.type))») { - builder.put(DetachableEObjectDescription.ALLOW_LOOKUP, Boolean.TRUE.toString()); - } - «ELSE» - builder.put(DetachableEObjectDescription.ALLOW_LOOKUP, Boolean.TRUE.toString()); - «ENDIF» - «ENDIF» - «IF !a.isEmpty » - // Exported attributes - «FOR attr : a» - value = obj.eGet(«attr.literalIdentifier», false); - if (value != null) { - builder.put(«resourceDescriptionConstants.toSimpleName».«attr.constantName(c.type)», value.toString()); - } - «ENDFOR» - «ENDIF» - «IF !d.isEmpty » - // User data - «FOR data : d» - value = «data.expr.javaExpression(ctx.clone('obj', c.type))»; - if (value != null) { - builder.put(«resourceDescriptionConstants.toSimpleName».«data.constantName(c.type)», value.toString()); - } - «ENDFOR» - «ENDIF» - } - }; - acceptEObjectDescription(obj, data, acceptor.get()); - «ELSE» - acceptEObjectDescription(obj, acceptor.get()); - «ENDIF» - ''' - } -} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionCompiler.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionCompiler.xtend new file mode 100644 index 0000000000..a575716bdc --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionCompiler.xtend @@ -0,0 +1,481 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.export.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanOperation +import com.avaloq.tools.ddk.xtext.expression.expression.CastedExpression +import com.avaloq.tools.ddk.xtext.expression.expression.CollectionExpression +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.expression.expression.IfExpression +import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.Literal +import com.avaloq.tools.ddk.xtext.expression.expression.NullLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall +import com.avaloq.tools.ddk.xtext.expression.expression.RealLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.TypeSelectExpression +import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensions +import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX +import com.google.inject.Inject +import java.util.List +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.common.types.JvmDeclaredType +import org.eclipse.xtext.common.types.JvmOperation +import org.eclipse.xtext.common.types.JvmType +import org.eclipse.xtext.util.Strings + +/** + * Compiles the custom {@link Expression} AST of the export expression DSL into equivalent Java source text. + *

+ * This is the self-contained, {@code org.eclipse.xtend}-free replacement of the legacy + * {@code CodeGenerationX}/{@code CompilationContext} expression compiler. It produces exactly the same Java + * fragments as the legacy compiler did, but resolves types, variables and the implicit ({@code this}) receiver + * through the shared {@link ExportTranslationContext} that the + * {@link ExportExpressionTranslator} already uses, rather than through the classic Xtend type system. + *

+ * The export generators splice the produced Java fragments into the body of the inferred provider methods. The + * {@code .ext}/{@code JAVA} extension branches of the legacy compiler are intentionally dropped: export sources no + * longer reference Xtend extension files. + */ +class ExportExpressionCompiler { + + /** Maps EMF model types to their generated Java instance class names. */ + @Inject GenModelUtilX genModelUtil + + /** Reuses the translator's type/variable/getter resolution so both stay consistent. */ + @Inject ExportExpressionTranslator translator + + ////////////////////////////////////////////////// + // ENTRY POINTS + ////////////////////////////////////////////////// + /** + * Tests whether the given expression can be compiled to Java by this compiler. + * + * @param expression + * the source expression, may be {@code null} + * @param context + * the compilation context, must not be {@code null} + * @return {@code true} if a non-{@code null} fragment without the {@code NOT COMPILABLE} marker can be produced + */ + def boolean isCompilable(Expression expression, ExportTranslationContext context) { + val expr = expression.javaExpression(context) + expr !== null && !expr.contains('/* NOT COMPILABLE: ') + } + + /** + * Compiles the given expression into the equivalent Java source text. + * + * @param expression + * the source expression, may be {@code null} + * @param context + * the compilation context, must not be {@code null} + * @return the Java source text, never {@code null} + */ + def dispatch String javaExpression(Void it, ExportTranslationContext ctx) { + '' + } + + def dispatch String javaExpression(Expression it, ExportTranslationContext ctx) { + notCompilable + } + + def private String notCompilable(Expression it) { + '/* NOT COMPILABLE: Complex expressions like "' + serialize() + '" cannot be translated to Java. Consider rewriting the expression or using a JAVA extension. */' + } + + ////////////////////////////////////////////////// + // LITERALS + ////////////////////////////////////////////////// + def dispatch String javaExpression(StringLiteral it, ExportTranslationContext ctx) { + '"' + javaEncode(getVal()) + '"' + } + + def dispatch String javaExpression(BooleanLiteral it, ExportTranslationContext ctx) { + getVal() + } + + def dispatch String javaExpression(IntegerLiteral it, ExportTranslationContext ctx) { + getVal().toString() + } + + def dispatch String javaExpression(NullLiteral it, ExportTranslationContext ctx) { + "null" + } + + def dispatch String javaExpression(RealLiteral it, ExportTranslationContext ctx) { + getVal().toString() + } + + def dispatch String javaExpression(ListLiteral it, ExportTranslationContext ctx) { + if (elements.empty) { + "java.util.Collections. emptyList()" + } else if (elements.size == 1) { + "java.util.Collections.singletonList(" + elements.head.javaExpression(ctx) + ")" + } else { + "com.google.common.collect.Lists.newArrayList(" + ', '.join(elements.map[javaExpression(ctx)]) + ")" + } + } + + ////////////////////////////////////////////////// + // TYPES AND VARIABLES + ////////////////////////////////////////////////// + def dispatch String javaExpression(Identifier it, ExportTranslationContext ctx) { + if (isThis()) ctx.implicitVariableName else '::'.join(id) + } + + def private boolean isTypeRef(FeatureCall it, ExportTranslationContext ctx) { + name === null && type !== null && (ctx.modelTypeResolver?.resolve(type.id) !== null || ctx.resolveDslType(type) !== null) + } + + def private boolean isVariableRef(Expression it, ExportTranslationContext ctx) { + false + } + + def private boolean isVariableRef(FeatureCall it, ExportTranslationContext ctx) { + target === null && name === null && type !== null && type.id.size == 1 && ctx.getVariable(type.id.head) !== null + } + + def private String featureCallTarget(FeatureCall it, ExportTranslationContext ctx) { + if (target === null || target.isThisCall()) + ctx.implicitVariableName + else + target.javaExpression(ctx) + } + + ////////////////////////////////////////////////// + // BOOLEAN OPERATIONS + ////////////////////////////////////////////////// + def dispatch String javaExpression(BooleanOperation it, ExportTranslationContext ctx) { + autoBracket(left.javaExpression(ctx) + ' ' + operator + ' ' + right.javaExpression(ctx), ctx) + } + + ////////////////////////////////////////////////// + // COLLECTION OPERATIONS + ////////////////////////////////////////////////// + def dispatch String javaExpression(CollectionExpression it, ExportTranslationContext ctx) { + if ('select' == name) { + 'com.google.common.collect.Iterables.filter(' + target.javaExpression(ctx) + + ', new com.google.common.base.Predicate() { public boolean apply(Object ' + + (if (getVar() !== null) getVar() else 'e') + ') {return ' + + exp.javaExpression(ctx) + ';} })' + } else { + notCompilable() + } + } + + def dispatch String javaExpression(TypeSelectExpression it, ExportTranslationContext ctx) { + if (isSimpleNavigation(ctx)) + 'com.google.common.collect.Iterables.filter(' + target.javaExpression(ctx) + ', ' + ctx.javaType(type) + '.class)' + else notCompilable() + } + + ////////////////////////////////////////////////// + // TYPE CAST + ////////////////////////////////////////////////// + def dispatch String javaExpression(CastedExpression it, ExportTranslationContext ctx) { + '((' + ctx.javaType(type) + ') ' + target.javaExpression(ctx) + ')' + } + + ////////////////////////////////////////////////// + // IF EXPRESSIONS + ////////////////////////////////////////////////// + def dispatch String javaExpression(IfExpression it, ExportTranslationContext ctx) { + autoBracket(condition.javaExpression(ctx) + ' ? ' + thenPart.javaExpression(ctx) + ' : ' + elsePart.javaExpression(ctx), ctx) + } + + ////////////////////////////////////////////////// + // FEATURE CALLS + ////////////////////////////////////////////////// + def dispatch String javaExpression(FeatureCall it, ExportTranslationContext ctx) { + if (isThisCall()) { + ctx.implicitVariableName + } else if (isVariableRef(ctx)) { + type.javaExpression(ctx) + } else if (isTypeRef(ctx)) { + ctx.javaType(type) + } else if (isSimpleFeatureCall(ctx)) { + featureCallTarget(ctx) + '.' + (if (calledFeature() == 'eContainer') 'eContainer' else (if (calledFeature() == 'isEmpty') 'isEmpty' else calledFeature().toFirstUpper().featureCallName())) + '()' + } else if (isSimpleNavigation(ctx)) { + notCompilable() + } else { + featureCallTarget(ctx) + '.' + (if (calledFeature() == 'eContainer') 'eContainer' else (if (calledFeature() == 'isEmpty') 'isEmpty' else calledFeature().toFirstUpper().featureCallName())) + '()' + } + } + + def private String featureCallName(String it) { + if (it.startsWith('^')) + it.substring(1, it.length).toFirstUpper().featureCallName() + else + (if (it.startsWith('Is')) 'is' else 'get') + it + } + + /** + * Tests whether the given feature call is a simple feature access on the implicit receiver or an in-scope + * variable, i.e. one that compiles to a single {@code getX()}/{@code isX()} accessor. Replaces the legacy + * {@code CodeGenerationX.isSimpleFeatureCall}. + * + * @param it + * the expression, must not be {@code null} + * @param ctx + * the compilation context, must not be {@code null} + * @return {@code true} if the call is a simple feature access + */ + def dispatch boolean isSimpleFeatureCall(Expression it, ExportTranslationContext ctx) { + false + } + + def dispatch boolean isSimpleFeatureCall(FeatureCall it, ExportTranslationContext ctx) { + eClass.name.contains('FeatureCall') && name === null && type.isFeature() && (target === null || target.isVariableRef(ctx) || target.isThisCall()) + } + + def dispatch boolean isSimpleNavigation(Expression it, ExportTranslationContext ctx) { + false + } + + def dispatch boolean isSimpleNavigation(TypeSelectExpression it, ExportTranslationContext ctx) { + true + } + + def dispatch boolean isSimpleNavigation(FeatureCall it, ExportTranslationContext ctx) { + name === null && type.isFeature() && (target === null || target.isVariableRef(ctx) || target.isThisCall() || target.isSimpleNavigation(ctx)) + } + + ////////////////////////////////////////////////// + // OPERATION CALLS + ////////////////////////////////////////////////// + def dispatch String javaExpression(OperationCall it, ExportTranslationContext ctx) { + if ((target === null || target.isThisCall()) && targetHasOperation(ctx)) { + (if (target !== null) target.javaExpression(ctx) + '.' else '') + name + '(' + ', '.join(params.map[javaExpression(ctx)]) + ')' + } else if (isArithmeticOperatorCall(ctx)) { + autoBracket((' ' + name + ' ').join(params.map(e|e.javaExpression(ctx))), ctx) + } else if (isSimpleConcatCall()) { + (' + ').join(params.map(e|e.javaExpression(ctx))) + } else if (isPrefixExpression()) { + autoBracket(name + params.head.javaExpression(ctx), ctx) + } else if ('first' == name && params.isEmpty && target !== null) { + target.javaExpression(ctx) + '.get(0)' + } else if ('isInstance' == name && params.size == 1 && target instanceof FeatureCall && (target as FeatureCall).isTypeRef(ctx)) { + autoBracket(params.head.javaExpression(ctx) + ' instanceof ' + target.javaExpression(ctx), ctx) + } else if ('eContainer' == name && params.isEmpty) { + target.javaExpression(ctx) + '.eContainer()' + } else { + (if (target !== null) target.javaExpression(ctx) + '.' else '') + name + '(' + (if (params.isEmpty) '' else ', '.join(params.map[javaExpression(ctx)])) + ')' + } + } + + /** + * Heuristically tests whether an unqualified or {@code this} qualified operation call refers to an operation + * declared on the implicit receiver's type. Replaces the legacy {@code CompilationContext.targetHasOperation}. + * + * @param it + * the operation call, must not be {@code null} + * @param ctx + * the compilation context, must not be {@code null} + * @return {@code true} if the implicit receiver type declares a matching operation + */ + def private boolean targetHasOperation(OperationCall it, ExportTranslationContext ctx) { + val receiverType = translator.resolveType(target, ctx) + if (!(receiverType instanceof JvmDeclaredType)) { + return false + } + val operationName = name + val parameterCount = params.size + val declaredType = receiverType as JvmDeclaredType + declaredType.allFeatures.filter(JvmOperation).exists [ + simpleName == operationName && parameters.size == parameterCount + ] + } + + ////////////////////////////////////////////////// + // EXPRESSION BRACKETING + ////////////////////////////////////////////////// + def private String autoBracket(Expression it, String javaCode, ExportTranslationContext ctx) { + if (requiresBracketing(ctx)) '(' + javaCode + ')' else javaCode + } + + def private dispatch boolean requiresBracketing(Expression it, ExportTranslationContext ctx) { + (isPrefixExpression() || isInfixExpression(ctx)) && eContainer() !== null && requiresBracketing(it, eContainer(), ctx) + } + + def private dispatch boolean requiresBracketing(Literal it, ExportTranslationContext ctx) { + false + } + + def private dispatch boolean requiresBracketing(Expression it, Object parent, ExportTranslationContext ctx) { + false + } + + def private dispatch boolean requiresBracketing(Expression it, Expression parent, ExportTranslationContext ctx) { + isPrefixExpression() && parent.isPrefixExpression() || + (isInfixExpression(ctx) && (parent.isPrefixExpression() || parent.isInfixExpression(ctx))) + } + + def private dispatch boolean requiresBracketing(OperationCall it, OperationCall parent, ExportTranslationContext ctx) { + isPrefixExpression() && parent.isPrefixExpression() || + (isInfixExpression(ctx) && (parent.isPrefixExpression() || (parent.isInfixExpression(ctx) && name != parent.name))) + } + + def private dispatch boolean requiresBracketing(BooleanOperation it, BooleanOperation parent, ExportTranslationContext ctx) { + operator != parent.operator + } + + ////////////////////////////////////////////////// + // OPERATOR CLASSIFICATION + ////////////////////////////////////////////////// + def private boolean isSimpleConcatCall(OperationCall it) { + name == '+' && type === null && target === null && !params.isEmpty + } + + def private boolean isNumber(Expression it, ExportTranslationContext ctx) { + val type = translator.resolveType(it, ctx) + type !== null && type.isNumeric + } + + def private boolean isNumeric(JvmType it) { + val name = qualifiedName + switch name { + case 'int', + case 'long', + case 'short', + case 'byte', + case 'double', + case 'float', + case 'java.lang.Integer', + case 'java.lang.Long', + case 'java.lang.Short', + case 'java.lang.Byte', + case 'java.lang.Double', + case 'java.lang.Float', + case 'java.lang.Number', + case 'java.math.BigInteger', + case 'java.math.BigDecimal': + true + default: + false + } + } + + def private dispatch boolean isArithmeticOperatorCall(OperationCall it, ExportTranslationContext ctx) { + type === null && target === null && params.size > 1 && (name == '+' || name == '-' || name == '*' || name == '/') && params.forall[isNumber(ctx)] + } + + def private dispatch boolean isArithmeticOperatorCall(Expression it, ExportTranslationContext ctx) { + false + } + + def private dispatch boolean isPrefixExpression(Expression it) { + false + } + + def private dispatch boolean isPrefixExpression(OperationCall it) { + type === null && target === null && params.size == 1 && (name == '-' || name == '!') + } + + def private dispatch boolean isInfixExpression(Void it, ExportTranslationContext ctx) { + false + } + + def private dispatch boolean isInfixExpression(Expression it, ExportTranslationContext ctx) { + false + } + + def private dispatch boolean isInfixExpression(OperationCall it, ExportTranslationContext ctx) { + isArithmeticOperatorCall(ctx) || 'isInstance' == name + } + + def private dispatch boolean isInfixExpression(IfExpression it, ExportTranslationContext ctx) { + true + } + + def private dispatch boolean isInfixExpression(BooleanOperation it, ExportTranslationContext ctx) { + true + } + + ////////////////////////////////////////////////// + // TYPE RESOLUTION + ////////////////////////////////////////////////// + /** + * Resolves the Java class name of the given source DSL type identifier. Model types resolve through the imported + * EPackages to their generated instance class name (exactly as the legacy {@code CompilationContext.javaType} + * did through {@code genModelUtil.instanceClassName}); plain Java types resolve against the classpath. Replaces + * the legacy {@code CompilationContext.javaType}. + * + * @param ctx + * the compilation context, must not be {@code null} + * @param type + * the source type identifier, must not be {@code null} + * @return the qualified Java class name (or the joined identifier when the type cannot be resolved) + */ + def private String javaType(ExportTranslationContext ctx, Identifier type) { + val classifier = ctx.modelTypeResolver?.resolve(type.id) + if (classifier !== null) { + return genModelUtil.instanceClassName(classifier) + } + val resolved = ctx.resolveDslType(type) + if (resolved === null) { + return '::'.join(type.id) + } + val name = resolved.qualifiedName + if (name.startsWith('java.lang.') && !name.substring('java.lang.'.length).contains('.')) { + name.substring('java.lang.'.length) + } else { + name + } + } + + ////////////////////////////////////////////////// + // HELPER FUNCTIONS + ////////////////////////////////////////////////// + def private dispatch boolean isThisCall(Expression it) { + false + } + + def private dispatch boolean isThisCall(FeatureCall it) { + name === null && type.isThis() + } + + def private boolean isFeature(Identifier it) { + id !== null && id.size == 1 + } + + def private dispatch boolean isThis(Expression it) { + false + } + + def private dispatch boolean isThis(Identifier it) { + id !== null && id.size == 1 && id.head == "this" + } + + def private String calledFeature(FeatureCall it) { + type.id.head + } + + def private String serialize(EObject it) { + ExpressionExtensions.serialize(it) + } + + def private dispatch String javaEncode(Expression it) { + javaEncode(serialize()) + } + + def private dispatch String javaEncode(String it) { + Strings.convertToJavaString(it) + } + + def private String join(String it, List strings) { + if (strings.isEmpty) '' else Strings.concat(it, strings) + } + +} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionTranslator.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionTranslator.xtend new file mode 100644 index 0000000000..5f7bc4333f --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportExpressionTranslator.xtend @@ -0,0 +1,870 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.export.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanOperation +import com.avaloq.tools.ddk.xtext.expression.expression.CastedExpression +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.expression.expression.IfExpression +import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.NullLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall +import com.avaloq.tools.ddk.xtext.expression.expression.RealLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.TypeSelectExpression +import com.avaloq.tools.ddk.xtext.export.generator.ExportModelTypeResolver +import com.google.common.collect.Iterables +import com.google.inject.Inject +import java.util.List +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.common.types.JvmDeclaredType +import org.eclipse.xtext.common.types.JvmFormalParameter +import org.eclipse.xtext.common.types.JvmOperation +import org.eclipse.xtext.common.types.JvmType +import org.eclipse.xtext.common.types.TypesFactory +import org.eclipse.xtext.common.types.util.TypeReferences +import org.eclipse.xtext.xbase.XExpression +import org.eclipse.xtext.xbase.XbaseFactory +import org.eclipse.xtext.xbase.lib.BooleanExtensions +import org.eclipse.xtext.xbase.lib.ObjectExtensions + +/** + * Translates the custom {@link Expression} AST of the export expression DSL into equivalent Xbase + * {@link XExpression} trees that can be compiled by the {@code XbaseCompiler} through the JVM model inferrer. + *

+ * Translation happens against an {@link ExportTranslationContext} that provides the variables in scope and the + * implicit ({@code this}) variable. Nodes that require resolving forms that are not yet supported return + * {@code null}; the {@link ExportExpressionCompiler} is used as the string fallback that the export generators + * splice into the inferred provider method bodies. + */ +class ExportExpressionTranslator { + + /** Provides access to the {@code org.eclipse.xtext.xbase.lib} operator methods that back binary operations. */ + @Inject extension TypeReferences + + /** + * Translates the given expression into an equivalent {@link XExpression}. + * + * @param expression + * the source expression, may be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the translated {@link XExpression}, or {@code null} if the expression cannot (yet) be translated + */ + def XExpression translate(Expression expression, ExportTranslationContext context) { + if (expression === null) { + return null + } + return expression.doTranslate(context) + } + + /** + * Resolves a factory expression of the form {@code Type.method(args)} to the fully qualified static Java method + * {@code .} by linking the type reference against the classpath. This replaces the + * legacy {@code .ext} based resolution: the declaring type is named directly in the export source rather than + * indirected through an Xtend extension file. + * + * @param expression + * the factory expression, must not be {@code null} + * @param sourceElement + * a model element used to resolve the type against the classpath, must not be {@code null} + * @return the fully qualified static method ({@code type.method}), or {@code null} if the expression is not a + * type-qualified operation call or the type cannot be resolved + */ + def String resolveFactoryMethod(Expression expression, EObject sourceElement) { + if (!(expression instanceof OperationCall)) { + return null + } + val call = expression as OperationCall + if (!(call.target instanceof FeatureCall)) { + return null + } + val typeReference = call.target as FeatureCall + if (typeReference.name !== null || typeReference.type === null) { + return null + } + val jvmType = findDeclaredType(typeReference.type.id.join('.'), sourceElement) + if (jvmType instanceof JvmDeclaredType) { + return jvmType.qualifiedName + '.' + call.name + } + null + } + + /** + * Tests whether the given expression can be extracted into a typed helper method, i.e. whether it can be both + * translated into an {@link XExpression} and have its result type resolved. The check is performed against a + * fresh trial context holding a single {@code ctx} variable of the given context type, so it can be used at code + * generation time before the actual JVM operation (and its formal parameter) exist. + * + * @param expression + * the source expression to test, must not be {@code null} + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return {@code true} if the expression can be extracted into a typed helper method + */ + def boolean canExtractAsValue(Expression expression, EClass contextType, EObject sourceElement) { + val context = newTrialContext(contextType, sourceElement) + translate(expression, context) !== null && resolveType(expression, context) !== null + } + + /** + * Tests whether the given expression can be extracted into a helper method whose result is a {@link String}, i.e. + * whether it can be translated and its result type resolves to {@code java.lang.String}. Used for splice sites that + * are overloaded on the argument type (such as a container query name) where extracting a non-{@code String} value + * would select the wrong overload. + * + * @param expression + * the source expression to test, must not be {@code null} + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return {@code true} if the expression can be extracted as a {@code String} valued helper method + */ + def boolean canExtractAsString(Expression expression, EClass contextType, EObject sourceElement) { + val context = newTrialContext(contextType, sourceElement) + if (translate(expression, context) === null) { + return false + } + val resolved = resolveType(expression, context) + resolved !== null && resolved.qualifiedName == String.name + } + + /** + * Tests whether the given expression can be extracted into a typed helper method that, in addition to the primary + * {@code ctx} variable, has the given extra variables in scope (for example a data match lambda's element + * description). The check uses a fresh trial context so it can be used at code generation time. + * + * @param expression + * the source expression to test, must not be {@code null} + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param extraVariables + * the extra variables as source-name to fully-qualified-type-name pairs, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return {@code true} if the expression can be extracted into a typed helper method + */ + def boolean canExtractAsValue(Expression expression, EClass contextType, List> extraVariables, + EObject sourceElement) { + val context = newTrialContext(contextType, sourceElement) + for (extra : extraVariables) { + context.putVariable(extra.key, newTrialParameter(extra.key, extra.value, sourceElement)) + } + translate(expression, context) !== null && resolveType(expression, context) !== null + } + + /** + * Creates a trial translation context holding a single {@code ctx} variable of the given context type. The + * context's type resolver resolves DSL type identifiers by their fully qualified name against the classpath. + * + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return the trial context, never {@code null} + */ + def private ExportTranslationContext newTrialContext(EClass contextType, EObject sourceElement) { + val parameter = newTrialParameter('ctx', contextType.instanceClassName, sourceElement) + val context = new ExportTranslationContext + context.sourceElement = sourceElement + context.putVariable('ctx', parameter) + context.implicitVariable = parameter + context.typeResolver = [Identifier identifier|findDeclaredType(identifier.id.join('.'), sourceElement)] + context + } + + /** + * Creates a trial formal parameter with the given name and type, used to populate a trial translation context. + * + * @param name + * the parameter name, must not be {@code null} + * @param typeName + * the fully qualified type name of the parameter, must not be {@code null} + * @param sourceElement + * a model element used to resolve the type against the classpath, must not be {@code null} + * @return the trial parameter, never {@code null} + */ + def private JvmFormalParameter newTrialParameter(String name, String typeName, EObject sourceElement) { + val parameter = TypesFactory.eINSTANCE.createJvmFormalParameter + parameter.name = name + val jvmType = findDeclaredType(typeName, sourceElement) + if (jvmType !== null) { + parameter.parameterType = createTypeRef(jvmType) + } + parameter + } + + /** + * Creates a translation context for rendering an expression to Java source text with the + * {@link ExportExpressionCompiler}. The context binds the implicit ({@code this}) receiver to the given Java + * variable name and EMF type, registers the implicit and any extra variables, and resolves DSL type identifiers + * against the classpath. This replaces the legacy {@code CompilationContext.clone(...)} factories. + * + * @param implicitVariableName + * the Java variable name an unqualified {@code this} reference compiles to, must not be {@code null} + * @param implicitType + * the EMF type of the implicit receiver, may be {@code null} + * @param extraVariables + * extra in-scope variables as source-name to fully-qualified-type-name pairs, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return the compilation context, never {@code null} + */ + def ExportTranslationContext newCompilationContext(String implicitVariableName, EClass implicitType, + List> extraVariables, EObject sourceElement) { + val context = new ExportTranslationContext + context.sourceElement = sourceElement + context.implicitVariableName = implicitVariableName + context.modelTypeResolver = ExportModelTypeResolver.forElement(sourceElement) + if (implicitType !== null) { + val parameter = newTrialParameter(implicitVariableName, implicitType.instanceClassName, sourceElement) + context.implicitVariable = parameter + context.putVariable(implicitVariableName, parameter) + } + for (extra : extraVariables) { + context.putVariable(extra.key, newTrialParameter(extra.key, extra.value, sourceElement)) + } + context.typeResolver = [Identifier identifier|findDeclaredType(identifier.id.join('.'), sourceElement)] + context + } + + /** + * Fallback for expression types that are not (yet) supported by the translator. + * + * @param it + * the source expression, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return {@code null}, indicating the expression cannot be translated yet + */ + def dispatch protected XExpression doTranslate(Expression it, ExportTranslationContext context) { + null + } + + /** + * Translates a string literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XStringLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(StringLiteral it, ExportTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXStringLiteral + literal.value = getVal() + literal + } + + /** + * Translates a boolean literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XBooleanLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(BooleanLiteral it, ExportTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXBooleanLiteral + literal.isTrue = 'true' == getVal() + literal + } + + /** + * Translates an integer literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XNumberLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(IntegerLiteral it, ExportTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXNumberLiteral + literal.value = Integer.toString(getVal()) + literal + } + + /** + * Translates a real (floating point) literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XNumberLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(RealLiteral it, ExportTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXNumberLiteral + literal.value = getVal() + literal + } + + /** + * Translates a {@code null} literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XNullLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(NullLiteral it, ExportTranslationContext context) { + XbaseFactory.eINSTANCE.createXNullLiteral + } + + /** + * Translates a list literal. Each element is translated recursively; if any element cannot be translated + * the whole list literal is considered untranslatable. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XListLiteral}, or {@code null} if an element cannot be translated + */ + def dispatch protected XExpression doTranslate(ListLiteral it, ExportTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXListLiteral + for (element : elements) { + val translated = element.translate(context) + if (translated === null) { + return null + } + literal.elements += translated + } + literal + } + + /** + * Translates a conditional expression (ternary {@code ? :} or {@code if}/{@code then}/{@code else}). When the + * source has no else branch a {@link org.eclipse.xtext.xbase.XNullLiteral} is used as the else value. + * + * @param it + * the source conditional, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XIfExpression}, or {@code null} if a branch cannot be translated + */ + def dispatch protected XExpression doTranslate(IfExpression it, ExportTranslationContext context) { + val xIf = XbaseFactory.eINSTANCE.createXIfExpression + val xCondition = condition.translate(context) + val xThen = thenPart.translate(context) + if (xCondition === null || xThen === null) { + return null + } + xIf.^if = xCondition + xIf.then = xThen + if (elsePart !== null) { + val xElse = elsePart.translate(context) + if (xElse === null) { + return null + } + xIf.^else = xElse + } else { + xIf.^else = XbaseFactory.eINSTANCE.createXNullLiteral + } + xIf + } + + /** + * Translates a boolean, equality or relational operation into an {@link org.eclipse.xtext.xbase.XBinaryOperation}. + * The operator is linked to the corresponding {@code org.eclipse.xtext.xbase.lib} operator method so that the + * {@code XbaseCompiler} can emit the equivalent Java code. Operators without a backing library method (currently + * {@code implies} and the relational comparisons) are left untranslated for now. + * + * @param it + * the source operation, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XBinaryOperation}, or {@code null} if it cannot (yet) be translated + */ + def dispatch protected XExpression doTranslate(BooleanOperation it, ExportTranslationContext context) { + val xLeft = left.translate(context) + val xRight = right.translate(context) + if (xLeft === null || xRight === null) { + return null + } + val sourceElement = context.sourceElement + switch operator { + case '||': toBinaryOperation(xLeft, xRight, BooleanExtensions, 'operator_or', sourceElement) + case '&&': toBinaryOperation(xLeft, xRight, BooleanExtensions, 'operator_and', sourceElement) + case '==': toBinaryOperation(xLeft, xRight, ObjectExtensions, 'operator_equals', sourceElement) + case '!=': toBinaryOperation(xLeft, xRight, ObjectExtensions, 'operator_notEquals', sourceElement) + default: null + } + } + + /** + * Translates an operation call. In order, an {@code isInstance} check is mapped to an + * {@link org.eclipse.xtext.xbase.XInstanceOfExpression}, a receiver or implicit method call (which also covers + * {@code eContainer}/{@code eClass} style operations) to an {@link org.eclipse.xtext.xbase.XMemberFeatureCall} + * linked to the resolved method, and finally an extension call to a {@code static} extension method. + * Arithmetic, concatenation and prefix operator calls are added in later increments. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the resolved expression, or {@code null} if it cannot (yet) be translated + */ + def dispatch protected XExpression doTranslate(OperationCall it, ExportTranslationContext context) { + it.translateInstanceOf(context) ?: it.translateMethodCall(context) ?: it.translateExtensionCall(context) + } + + /** + * Translates a type cast ({@code (Type) target}) into an {@link org.eclipse.xtext.xbase.XCastedExpression}. + * + * @param it + * the source cast, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the casted expression, or {@code null} if the type or target cannot be translated + */ + def dispatch protected XExpression doTranslate(CastedExpression it, ExportTranslationContext context) { + val jvmType = context.resolveDslType(type) + if (jvmType === null) { + return null + } + val xTarget = target.translate(context) + if (xTarget === null) { + return null + } + val cast = XbaseFactory.eINSTANCE.createXCastedExpression + cast.type = createTypeRef(jvmType) + cast.target = xTarget + cast + } + + /** + * Translates a {@code typeSelect(Type)} navigation into a {@code com.google.common.collect.Iterables.filter} + * call that keeps the elements assignable to the given type, mirroring the legacy code generation. + * + * @param it + * the source type select, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the filter feature call, or {@code null} if the type, target or filter method cannot be resolved + */ + def dispatch protected XExpression doTranslate(TypeSelectExpression it, ExportTranslationContext context) { + val jvmType = context.resolveDslType(type) + if (jvmType === null) { + return null + } + val xTarget = target.translate(context) + if (xTarget === null) { + return null + } + val filter = findIterablesFilterByClass(context.sourceElement) + if (filter === null) { + return null + } + val call = XbaseFactory.eINSTANCE.createXFeatureCall + call.feature = filter + call.featureCallArguments += xTarget + val typeLiteral = XbaseFactory.eINSTANCE.createXTypeLiteral + typeLiteral.type = jvmType + call.featureCallArguments += typeLiteral + call + } + + /** + * Translates a feature call. The supported cases are an unqualified {@code this} reference (mapped to the + * implicit variable), a single-segment identifier that matches a variable in scope, and a getter navigation + * ({@code receiver.feature}) which is resolved to the matching {@code getX()}/{@code isX()} operation on the + * receiver's JVM type. Type references and operation calls are added in later increments. + * + * @param it + * the source feature call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the resolved feature call, or {@code null} if it cannot (yet) be translated + */ + def dispatch protected XExpression doTranslate(FeatureCall it, ExportTranslationContext context) { + if (it.isThisReference) { + return context.implicitVariable.toFeatureCall + } + if (target === null && name === null && type !== null && type.id.size == 1) { + val parameter = context.getVariable(type.id.head) + if (parameter !== null) { + return parameter.toFeatureCall + } + } + if (name === null && type !== null && type.id.size == 1) { + return it.translateGetter(context) + } + null + } + + /** + * Tests whether the given feature call is an unqualified {@code this} reference. + * + * @param call + * the feature call, must not be {@code null} + * @return {@code true} if the call refers to {@code this} + */ + def private boolean isThisReference(FeatureCall call) { + call.name === null && call.target === null && call.type !== null && call.type.id.size == 1 && + 'this' == call.type.id.head + } + + /** + * Creates an {@link org.eclipse.xtext.xbase.XFeatureCall} that references the given formal parameter. + * + * @param parameter + * the formal parameter to reference, may be {@code null} + * @return the feature call, or {@code null} if the parameter is {@code null} + */ + def private XExpression toFeatureCall(JvmFormalParameter parameter) { + if (parameter === null) { + return null + } + val featureCall = XbaseFactory.eINSTANCE.createXFeatureCall + featureCall.feature = parameter + featureCall + } + + /** + * Translates a getter navigation ({@code receiver.feature}) into an {@link org.eclipse.xtext.xbase.XMemberFeatureCall} + * linked to the resolved {@code getX()}/{@code isX()} operation. The receiver is the translated target, or the + * implicit variable when there is no explicit target. + * + * @param it + * the source feature call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the member feature call, or {@code null} if the receiver type or getter cannot be resolved + */ + def private XExpression translateGetter(FeatureCall it, ExportTranslationContext context) { + val receiverType = resolveType(target, context) + if (receiverType === null) { + return null + } + val getter = findGetter(receiverType, type.id.head) + if (getter === null) { + return null + } + val receiver = if (target === null) context.implicitVariable.toFeatureCall else target.translate(context) + if (receiver === null) { + return null + } + val memberCall = XbaseFactory.eINSTANCE.createXMemberFeatureCall + memberCall.memberCallTarget = receiver + memberCall.feature = getter + memberCall + } + + /** + * Resolves the static JVM type of the given expression as far as needed to link getter navigations. Supported + * expressions are the implicit variable (when {@code expression} is {@code null} or a {@code this} reference), a + * variable in scope, and a getter navigation chain. + * + * @param expression + * the source expression whose type to resolve, may be {@code null} to denote the implicit variable + * @param context + * the translation context, must not be {@code null} + * @return the resolved JVM type, or {@code null} if it cannot be determined + */ + def JvmType resolveType(Expression expression, ExportTranslationContext context) { + if (expression === null) { + return context.implicitVariable?.parameterType?.type + } + switch expression { + CastedExpression: + context.resolveDslType(expression.type) + StringLiteral: + findDeclaredType(String, expression) + TypeSelectExpression: + findDeclaredType(Iterable, context.sourceElement) + ListLiteral: + findDeclaredType(List, context.sourceElement) + OperationCall: { + val receiverType = resolveType(expression.target, context) + findMethod(receiverType, expression.name, expression.params.size)?.returnType?.type + } + FeatureCall: { + if (expression.isThisReference) { + context.implicitVariable?.parameterType?.type + } else if (expression.target === null && expression.name === null && expression.type !== null && + expression.type.id.size == 1 && context.getVariable(expression.type.id.head) !== null) { + context.getVariable(expression.type.id.head).parameterType?.type + } else if (expression.name === null && expression.type !== null && expression.type.id.size == 1) { + val receiverType = resolveType(expression.target, context) + if (receiverType !== null) findGetter(receiverType, expression.type.id.head)?.returnType?.type else null + } else { + null + } + } + default: + null + } + } + + /** + * Finds the no-argument getter operation for the given feature name on the given JVM type. The candidate method + * names are the feature name itself (covering operations such as {@code eContainer} or {@code isEmpty}) as well as + * the {@code getX} and {@code isX} accessor variants. + * + * @param type + * the receiver type, must not be {@code null} + * @param feature + * the source feature name, must not be {@code null} + * @return the matching getter operation, or {@code null} if none is found + */ + def private JvmOperation findGetter(JvmType type, String feature) { + if (type instanceof JvmDeclaredType) { + val candidates = feature.getterCandidates + return type.allFeatures.filter(JvmOperation).findFirst [ + parameters.empty && candidates.contains(simpleName) + ] + } + null + } + + /** + * Computes the candidate getter method names for the given source feature name. + * + * @param feature + * the source feature name, must not be {@code null} + * @return the list of candidate method names, never {@code null} + */ + def private getterCandidates(String feature) { + val name = if (feature.startsWith('^')) feature.substring(1) else feature + val upper = name.toFirstUpper + #[name, 'get' + upper, 'is' + upper] + } + + /** + * Translates an {@code isInstance} operation call ({@code Type.isInstance(value)}) into an + * {@link org.eclipse.xtext.xbase.XInstanceOfExpression}. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the instance-of expression, or {@code null} if the call is not an {@code isInstance} type check or the + * type or value cannot be resolved + */ + def private XExpression translateInstanceOf(OperationCall it, ExportTranslationContext context) { + if (name != 'isInstance' || params.size != 1 || !(target instanceof FeatureCall)) { + return null + } + val typeReference = target as FeatureCall + if (typeReference.name !== null || typeReference.type === null) { + return null + } + val jvmType = context.resolveDslType(typeReference.type) + if (jvmType === null) { + return null + } + val xValue = params.head.translate(context) + if (xValue === null) { + return null + } + val instanceOf = XbaseFactory.eINSTANCE.createXInstanceOfExpression + instanceOf.expression = xValue + instanceOf.type = createTypeRef(jvmType) + instanceOf + } + + /** + * Translates a receiver or implicit method call ({@code receiver.method(args)} or {@code method(args)}) into an + * {@link org.eclipse.xtext.xbase.XMemberFeatureCall} linked to the resolved method. The receiver is the translated + * target, or the implicit variable when there is no explicit target. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the member feature call, or {@code null} if the receiver type, method or an argument cannot be resolved + */ + def private XExpression translateMethodCall(OperationCall it, ExportTranslationContext context) { + val receiverType = resolveType(target, context) + if (receiverType === null) { + return null + } + val operation = findMethod(receiverType, name, params.size) + if (operation === null) { + return null + } + val receiver = if (target === null) context.implicitVariable.toFeatureCall else target.translate(context) + if (receiver === null) { + return null + } + val memberCall = XbaseFactory.eINSTANCE.createXMemberFeatureCall + memberCall.memberCallTarget = receiver + memberCall.feature = operation + memberCall.explicitOperationCall = true + for (param : params) { + val xParam = param.translate(context) + if (xParam === null) { + return null + } + memberCall.memberCallArguments += xParam + } + memberCall + } + + /** + * Finds the method of the given name and parameter count on the given JVM type. + * + * @param type + * the receiver type, may be {@code null} + * @param methodName + * the source method name, must not be {@code null} + * @param parameterCount + * the number of arguments the call passes + * @return the matching method, or {@code null} if none is found + */ + def private JvmOperation findMethod(JvmType type, String methodName, int parameterCount) { + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + simpleName == methodName && parameters.size == parameterCount + ] + } + null + } + + /** + * Finds the {@code com.google.common.collect.Iterables.filter(Iterable, Class)} operation used to back a + * {@code typeSelect} navigation. + * + * @param context + * the source element used to resolve the type against the classpath, may be {@code null} + * @return the {@code filter} operation, or {@code null} if it cannot be resolved + */ + def private JvmOperation findIterablesFilterByClass(EObject context) { + if (context === null) { + return null + } + val type = findDeclaredType(Iterables, context) + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + isStatic && simpleName == 'filter' && parameters.size == 2 && + parameters.get(1).parameterType?.type?.simpleName == 'Class' + ] + } + null + } + + /** + * Translates an extension operation call into an {@link org.eclipse.xtext.xbase.XFeatureCall} that invokes the + * matching {@code static} extension method. The call's target (when present) is prepended to the declared + * parameters to form the argument list. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the feature call, or {@code null} if no matching extension method exists or an argument cannot be translated + */ + def private XExpression translateExtensionCall(OperationCall it, ExportTranslationContext context) { + val argumentCount = (if (target !== null) 1 else 0) + params.size + val operation = context.extensionClassNames.map [ className | + findExtensionOperation(className, name, argumentCount, context.sourceElement) + ].filterNull.head + if (operation === null) { + return null + } + val featureCall = XbaseFactory.eINSTANCE.createXFeatureCall + featureCall.feature = operation + if (target !== null) { + val xTarget = target.translate(context) + if (xTarget === null) { + return null + } + featureCall.featureCallArguments += xTarget + } + for (param : params) { + val xParam = param.translate(context) + if (xParam === null) { + return null + } + featureCall.featureCallArguments += xParam + } + featureCall + } + + /** + * Finds the {@code static} extension method of the given name and argument count on the given extension class. + * + * @param className + * the fully qualified name of the extension class, must not be {@code null} + * @param operationName + * the source operation name, must not be {@code null} + * @param argumentCount + * the number of arguments the call passes + * @param context + * the source element used to resolve the type against the classpath, may be {@code null} + * @return the matching {@code static} operation, or {@code null} if none is found + */ + def private JvmOperation findExtensionOperation(String className, String operationName, int argumentCount, + EObject context) { + if (context === null) { + return null + } + val type = findDeclaredType(className, context) + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + isStatic && simpleName == operationName && parameters.size == argumentCount + ] + } + null + } + + /** + * Builds an {@link org.eclipse.xtext.xbase.XBinaryOperation} linked to the given {@code org.eclipse.xtext.xbase.lib} + * operator method. + * + * @param left + * the already translated left operand, must not be {@code null} + * @param right + * the already translated right operand, must not be {@code null} + * @param operatorClass + * the {@code org.eclipse.xtext.xbase.lib} class declaring the operator method, must not be {@code null} + * @param operatorName + * the simple name of the operator method, must not be {@code null} + * @param context + * the source element used to resolve the operator type, may be {@code null} + * @return the binary operation, or {@code null} if the operator method cannot be resolved + */ + def private XExpression toBinaryOperation(XExpression left, XExpression right, Class operatorClass, + String operatorName, EObject context) { + val operation = findOperator(operatorClass, operatorName, context) + if (operation === null) { + return null + } + val binaryOperation = XbaseFactory.eINSTANCE.createXBinaryOperation + binaryOperation.leftOperand = left + binaryOperation.rightOperand = right + binaryOperation.feature = operation + binaryOperation + } + + /** + * Resolves the two-argument operator method of the given name on the given {@code org.eclipse.xtext.xbase.lib} class. + * + * @param operatorClass + * the class declaring the operator method, must not be {@code null} + * @param operatorName + * the simple name of the operator method, must not be {@code null} + * @param context + * the source element used to resolve the type against the classpath, may be {@code null} + * @return the operator {@link JvmOperation}, or {@code null} if it cannot be resolved + */ + def private JvmOperation findOperator(Class operatorClass, String operatorName, EObject context) { + if (context === null) { + return null + } + val type = findDeclaredType(operatorClass, context) + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + simpleName == operatorName && parameters.size == 2 + ] + } + null + } + +} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportJvmModelInferrer.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportJvmModelInferrer.xtend new file mode 100644 index 0000000000..31ef549b6a --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportJvmModelInferrer.xtend @@ -0,0 +1,733 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.export.jvmmodel + +import com.avaloq.tools.ddk.xtext.export.export.Export +import com.avaloq.tools.ddk.xtext.export.export.ExportModel +import com.avaloq.tools.ddk.xtext.export.export.InterfaceExpression +import com.avaloq.tools.ddk.xtext.export.export.InterfaceField +import com.avaloq.tools.ddk.xtext.export.export.InterfaceItem +import com.avaloq.tools.ddk.xtext.export.export.InterfaceNavigation +import com.avaloq.tools.ddk.xtext.export.generator.ExportGeneratorX +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX +import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorSupport +import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX +import com.avaloq.tools.ddk.xtext.linking.ShortFragmentProvider +import com.avaloq.tools.ddk.xtext.naming.AbstractExportedNameProvider +import com.avaloq.tools.ddk.xtext.resource.AbstractCachingResourceDescriptionManager +import com.avaloq.tools.ddk.xtext.resource.AbstractExportFeatureExtension +import com.avaloq.tools.ddk.xtext.resource.AbstractResourceDescriptionStrategy +import com.avaloq.tools.ddk.xtext.resource.AbstractSelectorFragmentProvider +import com.avaloq.tools.ddk.xtext.resource.AbstractStreamingFingerprintComputer +import com.avaloq.tools.ddk.xtext.resource.IFingerprintComputer +import com.google.common.hash.Hasher +import com.google.inject.Inject +import com.google.inject.Singleton +import java.util.Collection +import java.util.Map +import java.util.Set +import org.eclipse.core.resources.IProject +import org.eclipse.core.resources.ResourcesPlugin +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EPackage +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.util.Switch +import org.eclipse.xtext.common.types.JvmAnnotationReference +import org.eclipse.xtext.common.types.JvmAnnotationType +import org.eclipse.xtext.common.types.JvmGenericType +import org.eclipse.xtext.common.types.JvmVisibility +import org.eclipse.xtext.common.types.TypesFactory +import org.eclipse.xtext.naming.IQualifiedNameProvider +import org.eclipse.xtext.naming.QualifiedName +import org.eclipse.xtext.resource.IEObjectDescription +import org.eclipse.xtext.util.IAcceptor +import org.eclipse.xtext.util.Strings +import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer +import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor +import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder +import org.eclipse.xtext.xbase.lib.Pair + +/** + * Infers a JVM model from an export model. + *

+ * Replaces the former {@code IGenerator2} based {@code ExportGenerator}: the exported names provider, resource + * description manager, resource description strategy, resource description constants, fingerprint computer, fragment + * provider and (for extension models) the export feature extension are now contributed as inferred JVM types whose + * Java source is emitted by the Xbase {@code JvmModelGenerator}. The method bodies are produced as strings and + * attached verbatim; framework types referenced by those strings are emitted fully qualified so that the generated + * compilation units need no import section of their own. + */ +class ExportJvmModelInferrer extends AbstractModelInferrer { + + @Inject extension JvmTypesBuilder + @Inject extension ExportGeneratorX + @Inject extension GeneratorUtilX + + @Inject GenModelUtilX genModelUtil + @Inject TypesFactory typesFactory + @Inject GeneratorSupport generatorSupport + @Inject ExportExpressionCompiler compiler + @Inject ExportExpressionTranslator translator + + /** + * Infers the export provider JVM types for the given export model. + * + * @param model + * the export model, must not be {@code null} + * @param acceptor + * the type acceptor, must not be {@code null} + * @param isPreIndexingPhase + * whether the method is called in the pre-indexing phase + */ + def dispatch void infer(ExportModel model, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) { + if (isPreIndexingPhase) { + return + } + genModelUtil.resource = model.eResource + + // The expression based method body strings are produced eagerly here (inside the project resource loader + // required by the expression compiler) rather than from within the deferred body closures, which run later + // during emission. + val Map bodies = newHashMap + generatorSupport.executeWithProjectResourceLoader(model.projectOf, [ + if (!model.exports.isEmpty) { + bodies.put('qnDispatch', model.qualifiedNameDispatchBody.toString) + for (var i = 0; i < model.exports.size; i++) { + bodies.put('qn' + i, model.qualifiedNameBody(model.exports.get(i)).toString) + } + for (p : model.strategyPackages) { + bodies.put('strategySwitch:' + p.nsURI, model.strategySwitchInitializer(p).toString) + } + } + for (p : model.fingerprintPackages) { + bodies.put('fpSwitch:' + p.nsURI, model.fingerprintSwitchInitializer(p).toString) + } + ]) + + inferExportedNamesProvider(model, acceptor, bodies) + if (!model.extension) { + inferResourceDescriptionManager(model, acceptor) + } + inferResourceDescriptionStrategy(model, acceptor, bodies) + inferResourceDescriptionConstants(model, acceptor) + inferFingerprintComputer(model, acceptor, bodies) + inferFragmentProvider(model, acceptor) + if (model.extension) { + inferExportFeatureExtension(model, acceptor) + } + } + + /** + * Infers the {@code ExportedNamesProvider}. + */ + def private void inferExportedNamesProvider(ExportModel model, IJvmDeclaredTypeAcceptor acceptor, Map bodies) { + val providerName = model.exportedNamesProvider + acceptor.accept(model.toClass(providerName)) [ + superTypes += typeRef(AbstractExportedNameProvider) + addSuppressWarningsAll + documentation = '''Qualified name provider providing the qualified names for exported objects.''' + if (!model.exports.isEmpty) { + members += model.toMethod('qualifiedName', typeRef(QualifiedName)) [ + visibility = JvmVisibility.PUBLIC + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('object', typeRef(EObject)) + val text = bodies.get('qnDispatch') + body = [append(text)] + ] + for (var i = 0; i < model.exports.size; i++) { + val c = model.exports.get(i) + val text = bodies.get('qn' + i) + members += model.toMethod('qualifiedName', typeRef(QualifiedName)) [ + visibility = JvmVisibility.PROTECTED + parameters += model.toParameter('obj', typeRef(genModelUtil.instanceClassName(c.type))) + body = [append(text)] + ] + } + } + ] + } + + /** + * Infers the {@code ResourceDescriptionManager}. + */ + def private void inferResourceDescriptionManager(ExportModel model, IJvmDeclaredTypeAcceptor acceptor) { + val grammar = model.grammar + val usedGrammars = if (grammar !== null) grammar.usedGrammars else newArrayList + val extendedGrammar = if (usedGrammars.isEmpty || usedGrammars.head.name.endsWith('.Terminals')) null else usedGrammars.head + val initializer = if (extendedGrammar !== null) { + '''com.google.common.collect.ImmutableSet.copyOf(com.google.common.collect.Sets.union(«extendedGrammar.resourceDescriptionManager».INTERESTING_EXTS, of(/*add extensions here*/)))''' + } else { + '''all()''' + } + acceptor.accept(model.toClass(model.resourceDescriptionManager)) [ + superTypes += typeRef(AbstractCachingResourceDescriptionManager) + annotations += typeOnlyAnnotation(Singleton) + addSuppressWarningsAll + documentation = '''Resource description manager for «model.name» resources.''' + members += model.toField('INTERESTING_EXTS', typeRef(Set, typeRef(String))) [ + visibility = JvmVisibility.PUBLIC + static = true + final = true + initializer = [append(initializer.toString)] + ] + members += model.toMethod('getInterestingExtensions', typeRef(Set, typeRef(String))) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + body = [append('return INTERESTING_EXTS;')] + ] + ] + } + + /** + * Infers the {@code ResourceDescriptionStrategy}. + */ + def private void inferResourceDescriptionStrategy(ExportModel model, IJvmDeclaredTypeAcceptor acceptor, Map bodies) { + acceptor.accept(model.toClass(model.resourceDescriptionStrategy)) [ + superTypes += typeRef(AbstractResourceDescriptionStrategy) + addSuppressWarningsAll + members += model.toField('EXPORTED_ECLASSES', typeRef(Set, typeRef(EClass))) [ + visibility = JvmVisibility.PRIVATE + static = true + final = true + initializer = [append(model.exportedEClassesInitializer.toString)] + ] + members += model.toMethod('getExportedEClasses', typeRef(Set, typeRef(EClass))) [ + visibility = JvmVisibility.PUBLIC + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('resource', typeRef(Resource)) + body = [append('return EXPORTED_ECLASSES;')] + ] + if (!model.exports.isEmpty) { + members += model.toField('acceptor', typeRef(ThreadLocal, typeRef(IAcceptor, typeRef(IEObjectDescription)))) [ + visibility = JvmVisibility.PRIVATE + final = true + initializer = [append('new ThreadLocal>()')] + ] + for (p : model.strategyPackages) { + val text = bodies.get('strategySwitch:' + p.nsURI) + members += model.toField(p.name + 'ExportSwitch', typeRef(Switch, typeRef(Boolean))) [ + visibility = JvmVisibility.PRIVATE + final = true + initializer = [append(text)] + ] + } + members += model.toMethod('doCreateEObjectDescriptions', typeRef(Boolean.TYPE)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('object', typeRef(EObject)) + parameters += model.toParameter('acceptor', typeRef(IAcceptor, typeRef(IEObjectDescription))) + body = [append(model.strategyDoCreateBody.toString)] + ] + } + ] + } + + /** + * Infers the {@code ResourceDescriptionConstants} interface. + */ + def private void inferResourceDescriptionConstants(ExportModel model, IJvmDeclaredTypeAcceptor acceptor) { + acceptor.accept(model.toClass(model.resourceDescriptionConstants)) [ + ^interface = true + for (c : model.exports.filter[!it.type.abstract]) { + for (attr : c.allEAttributes) { + members += model.toField(constantName(attr, c.type), typeRef(String)) [ + visibility = JvmVisibility.PUBLIC + static = true + final = true + initializer = [append('"' + Strings.convertToJavaString(attr.name) + '"')] + ] + } + for (data : c.allUserData) { + members += model.toField(constantName(data, c.type), typeRef(String)) [ + visibility = JvmVisibility.PUBLIC + static = true + final = true + initializer = [append('"' + Strings.convertToJavaString(data.name) + '"')] + ] + } + } + ] + } + + /** + * Infers the {@code FingerprintComputer}. + */ + def private void inferFingerprintComputer(ExportModel model, IJvmDeclaredTypeAcceptor acceptor, Map bodies) { + acceptor.accept(model.toClass(model.fingerprintComputer)) [ + superTypes += typeRef(AbstractStreamingFingerprintComputer) + addSuppressWarningsAll + if (model.interfaces.isEmpty) { + members += model.toMethod('computeFingerprint', typeRef(String)) [ + visibility = JvmVisibility.PUBLIC + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('resource', typeRef(Resource)) + body = [append('// no fingerprint defined\nreturn null;')] + ] + } + members += model.toField('hasherAccess', typeRef(ThreadLocal, typeRef(Hasher))) [ + visibility = JvmVisibility.PRIVATE + initializer = [append('new ThreadLocal()')] + ] + for (p : model.fingerprintPackages) { + val text = bodies.get('fpSwitch:' + p.nsURI) + members += model.toField(p.name + 'Switch', typeRef(Switch, typeRef(Hasher))) [ + visibility = JvmVisibility.PRIVATE + final = true + initializer = [append(text)] + ] + } + members += model.toMethod('fingerprint', typeRef(Void.TYPE)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('object', typeRef(EObject)) + parameters += model.toParameter('hasher', typeRef(Hasher)) + body = [append(model.fingerprintMethodBody.toString)] + ] + ] + } + + /** + * Infers the {@code FragmentProvider} (full provider, short stub, or none, depending on the model). + */ + def private void inferFragmentProvider(ExportModel model, IJvmDeclaredTypeAcceptor acceptor) { + val fingerprintedExports = model.exports.filter[fingerprint && fragmentAttribute !== null].toList + if (!fingerprintedExports.isEmpty || model.extension) { + acceptor.accept(model.toClass(model.fragmentProvider)) [ + superTypes += typeRef(AbstractSelectorFragmentProvider) + addSuppressWarningsAll + if (!fingerprintedExports.isEmpty) { + members += model.toMethod('appendFragmentSegment', typeRef(Boolean.TYPE)) [ + visibility = JvmVisibility.PUBLIC + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('object', typeRef(EObject)) + parameters += model.toParameter('builder', typeRef(StringBuilder)) + body = [append(model.appendFragmentSegmentBody(fingerprintedExports).toString)] + ] + } + if (model.extension) { + members += model.toMethod('appendFragmentSegmentFallback', typeRef(Boolean.TYPE)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += model.toParameter('object', typeRef(EObject)) + parameters += model.toParameter('builder', typeRef(StringBuilder)) + body = [append('// For export extension we must return false, so the logic will try other extensions\nreturn false;')] + ] + } + for (e : fingerprintedExports) { + members += model.toMethod('appendFragmentSegment', typeRef(Boolean.TYPE)) [ + visibility = JvmVisibility.PROTECTED + parameters += model.toParameter('obj', typeRef(genModelUtil.instanceClassName(e.type))) + parameters += model.toParameter('builder', typeRef(StringBuilder)) + body = [append('''return computeSelectorFragmentSegment(obj, «genModelUtil.literalIdentifier(e.fragmentAttribute)», «e.fragmentUnique», builder);''')] + ] + } + ] + } else if (!model.exports.isEmpty) { + acceptor.accept(model.toClass(model.fragmentProvider)) [ + superTypes += typeRef(ShortFragmentProvider) + addSuppressWarningsAll + ] + } + } + + /** + * Infers the {@code ExportFeatureExtension} (extension models only). + */ + def private void inferExportFeatureExtension(ExportModel model, IJvmDeclaredTypeAcceptor acceptor) { + acceptor.accept(model.toClass(model.exportFeatureExtension)) [ + superTypes += typeRef(AbstractExportFeatureExtension) + addSuppressWarningsAll + members += model.toField('namesProvider', typeRef(model.exportedNamesProvider)) [ + visibility = JvmVisibility.PRIVATE + annotations += typeOnlyAnnotation(Inject) + ] + members += model.toField('fingerprintComputer', typeRef(model.fingerprintComputer)) [ + visibility = JvmVisibility.PRIVATE + annotations += typeOnlyAnnotation(Inject) + ] + members += model.toField('fragmentProvider', typeRef(model.fragmentProvider)) [ + visibility = JvmVisibility.PRIVATE + annotations += typeOnlyAnnotation(Inject) + ] + members += model.toField('resourceDescriptionStrategy', typeRef(model.resourceDescriptionStrategy)) [ + visibility = JvmVisibility.PRIVATE + annotations += typeOnlyAnnotation(Inject) + ] + members += model.toMethod('getNamesProvider', typeRef(IQualifiedNameProvider)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + body = [append('return namesProvider;')] + ] + members += model.toMethod('getFingerprintComputer', typeRef(IFingerprintComputer)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + body = [append('return fingerprintComputer;')] + ] + members += model.toMethod('getFragmentProvider', typeRef(AbstractSelectorFragmentProvider)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + body = [append('return fragmentProvider;')] + ] + members += model.toMethod('getResourceDescriptionStrategy', typeRef(AbstractResourceDescriptionStrategy)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + body = [append('return resourceDescriptionStrategy;')] + ] + ] + } + + // ------------------------------------------------------------------------------------------------------------------- + // Body producers (framework types fully qualified so the generated compilation units need no imports) + // ------------------------------------------------------------------------------------------------------------------- + + /** + * Returns the EPackages of the non-abstract exported types, sorted by namespace URI. + */ + def private Iterable strategyPackages(ExportModel model) { + model.exports.filter[!type.abstract].map[type.EPackage].toSet.sortBy[nsURI] + } + + /** + * Returns the EPackages of the fingerprint interfaces, sorted by namespace URI. + */ + def private Iterable fingerprintPackages(ExportModel model) { + model.interfaces.map[type.EPackage].toSet.sortBy[nsURI] + } + + def private CharSequence qualifiedNameDispatchBody(ExportModel model) { + val types = model.exports + val exportedEClasses = types.map[type].toSet + val exportsMap = types.sortedExportsByEPackage + ''' + org.eclipse.emf.ecore.EClass eClass = object.eClass(); + org.eclipse.emf.ecore.EPackage ePackage = eClass.getEPackage(); + «FOR p : exportsMap.keySet.sortBy[nsURI]» + if (ePackage == «genModelUtil.qualifiedPackageInterfaceName(p)».eINSTANCE) { + int classifierID = eClass.getClassifierID(); + switch (classifierID) { + «FOR c : p.EClassifiers.filter(EClass).filter[c|exportedEClasses.exists[e|e.isSuperTypeOf(c)]]» + case «genModelUtil.classifierIdLiteral(c)»: { + return qualifiedName((«genModelUtil.instanceClassName(c)») object); + } + «ENDFOR» + default: + return null; + } + } + «ENDFOR» + return null; + ''' + } + + def private CharSequence qualifiedNameBody(ExportModel model, Export c) { + ''' + «javaContributorComment(c.location)» + «IF c.naming !== null» + final Object name = «javaExpr(c.naming, c.type, model)»; + return name != null ? «IF c.qualifiedName»getConverter().toQualifiedName(String.valueOf(name))«ELSE»qualifyWithContainerName(obj, String.valueOf(name))«ENDIF» : null; + «ELSE» + return «IF c.qualifiedName»getConverter().toQualifiedName(getResolver().apply(obj))«ELSE»qualifyWithContainerName(obj, getResolver().apply(obj))«ENDIF»; // "name" attribute by default + «ENDIF» + ''' + } + + def private CharSequence exportedEClassesInitializer(ExportModel model) { + val e = model.exports.typeMap(model.grammar) + ''' + com.google.common.collect.ImmutableSet.copyOf(new org.eclipse.emf.ecore.EClass[] { + «FOR c : e.keySet.sortBy[genModelUtil.literalIdentifier(it)] SEPARATOR ',\n'»«genModelUtil.literalIdentifier(c)»«ENDFOR» + })''' + } + + def private CharSequence strategySwitchInitializer(ExportModel model, EPackage p) { + val types = model.exports + ''' + new «genModelUtil.qualifiedSwitchClassName(p)»() { + + @Override + public Boolean defaultCase(final org.eclipse.emf.ecore.EObject obj) { + return true; + } + «FOR c : types.filter[!type.abstract && type.EPackage == p]» + + «javaContributorComment(c.location)» + @Override + public Boolean case«c.type.name»(final «genModelUtil.instanceClassName(c.type)» obj) { + «IF c.guard === null» + «generateCaseBody(model, c)» + «ELSE» + «val guard = javaExpr(c.guard, c.type, model)» + «IF !guard.equalsIgnoreCase("false")» + «javaContributorComment(c.guard.location)» + if («guard») { + «generateCaseBody(model, c)» + } + «ENDIF» + «ENDIF» + + // can «c.type.name» contain any nested «types.map[type].filter[!abstract].map[name].toSet» objects ? + return «c.type.canContain(types.map[type].filter[!abstract].toSet, model.grammar)»; + } + «ENDFOR» + }''' + } + + def private CharSequence generateCaseBody(ExportModel model, Export c) { + val a = c.allEAttributes + val d = c.allUserData + ''' + «IF !a.isEmpty || !d.isEmpty || c.fingerprint || c.resourceFingerprint || c.lookup » + // Use a forwarding map to delay calculation as much as possible; otherwise we may get recursive EObject resolution attempts + java.util.Map data = new com.avaloq.tools.ddk.xtext.resource.extensions.AbstractForwardingResourceDescriptionStrategyMap() { + + @Override + protected void fill(final com.google.common.collect.ImmutableMap.Builder builder) { + Object value = null; + «IF c.fingerprint» + // Fingerprint + value = getFingerprint(obj); + if (value != null) { + builder.put(com.avaloq.tools.ddk.xtext.resource.IFingerprintComputer.OBJECT_FINGERPRINT, value.toString()); + } + «ELSEIF c.resourceFingerprint» + // Resource fingerprint + value = getFingerprint(obj); + if (value != null) { + builder.put(com.avaloq.tools.ddk.xtext.resource.IFingerprintComputer.RESOURCE_FINGERPRINT, value.toString()); + } + «ENDIF» + «IF c.lookup» + // Allow lookups + «IF c.lookupPredicate !== null» + «javaContributorComment(c.lookupPredicate.location)» + if («javaExpr(c.lookupPredicate, c.type, model)») { + builder.put(com.avaloq.tools.ddk.xtext.resource.DetachableEObjectDescription.ALLOW_LOOKUP, Boolean.TRUE.toString()); + } + «ELSE» + builder.put(com.avaloq.tools.ddk.xtext.resource.DetachableEObjectDescription.ALLOW_LOOKUP, Boolean.TRUE.toString()); + «ENDIF» + «ENDIF» + «IF !a.isEmpty » + // Exported attributes + «FOR attr : a» + value = obj.eGet(«genModelUtil.literalIdentifier(attr)», false); + if (value != null) { + builder.put(«model.resourceDescriptionConstants».«constantName(attr, c.type)», value.toString()); + } + «ENDFOR» + «ENDIF» + «IF !d.isEmpty » + // User data + «FOR data : d» + value = «javaExpr(data.expr, c.type, model)»; + if (value != null) { + builder.put(«model.resourceDescriptionConstants».«constantName(data, c.type)», value.toString()); + } + «ENDFOR» + «ENDIF» + } + }; + acceptEObjectDescription(obj, data, acceptor.get()); + «ELSE» + acceptEObjectDescription(obj, acceptor.get()); + «ENDIF» + ''' + } + + def private CharSequence strategyDoCreateBody(ExportModel model) { + ''' + try { + this.acceptor.set(acceptor); + final org.eclipse.emf.ecore.EPackage ePackage = object.eClass().getEPackage(); + «FOR p : model.strategyPackages» + if (ePackage == «genModelUtil.qualifiedPackageInterfaceName(p)».eINSTANCE) { + return «p.name»ExportSwitch.doSwitch(object); + } + «ENDFOR» + «IF model.extension» + // Extension does not have to cover all EPackages of the language + return false; + «ELSE» + // TODO: generate code for other possible epackages (as defined by grammar) + return true; + «ENDIF» + } finally { + this.acceptor.set(null); + } + ''' + } + + def private CharSequence fingerprintSwitchInitializer(ExportModel model, EPackage p) { + ''' + new «genModelUtil.qualifiedSwitchClassName(p)»() { + «FOR f : model.interfaces.filter[type.EPackage == p]» + + «javaContributorComment(f.location)» + @Override + public com.google.common.hash.Hasher case«f.type.name»(final «genModelUtil.instanceClassName(f.type)» obj) { + final com.google.common.hash.Hasher hasher = hasherAccess.get(); + «IF f.guard !== null» + if (!(«javaExpr(f.guard, f.type, model)»)) { + return hasher; + } + «ENDIF» + hasher.putUnencodedChars(obj.eClass().getName()).putChar(ITEM_SEP); + «FOR superFingerprint : f.getSuperInterfaces(f.type)» + «FOR superItem : superFingerprint.items» + «doProfile(superItem, model, superFingerprint.type)» + «ENDFOR» + «ENDFOR» + «FOR item : f.items» + «doProfile(item, model, f.type)» + «ENDFOR» + return hasher; + } + «ENDFOR» + }''' + } + + def private CharSequence fingerprintMethodBody(ExportModel model) { + ''' + hasherAccess.set(hasher); + «IF !model.interfaces.isEmpty» + final org.eclipse.emf.ecore.EPackage ePackage = object.eClass().getEPackage(); + «FOR p : model.fingerprintPackages» + if (ePackage == «genModelUtil.qualifiedPackageInterfaceName(p)».eINSTANCE) { + «p.name»Switch.doSwitch(object); + } + «ENDFOR» + «ENDIF» + hasherAccess.set(null); + ''' + } + + def private dispatch CharSequence doProfile(InterfaceItem it, ExportModel model, EClass type) { + 'ERROR' + it.toString + ' ' + javaContributorComment(it.location) + } + + def private dispatch CharSequence doProfile(InterfaceField it, ExportModel model, EClass type) ''' + «IF field.many && (unordered == true) » + fingerprintFeature(obj, «genModelUtil.literalIdentifier(field)», FingerprintOrder.UNORDERED, hasher); + «ELSE» + fingerprintFeature(obj, «genModelUtil.literalIdentifier(field)», hasher); + «ENDIF» + hasher.putChar(ITEM_SEP); + ''' + + def private dispatch CharSequence doProfile(InterfaceNavigation it, ExportModel model, EClass type) ''' + «IF ref.many && (unordered == true) » + fingerprintRef(obj, «genModelUtil.literalIdentifier(ref)», FingerprintOrder.UNORDERED, hasher); + «ELSE» + fingerprintRef(obj, «genModelUtil.literalIdentifier(ref)», hasher); + «ENDIF» + hasher.putChar(ITEM_SEP); + ''' + + def private dispatch CharSequence doProfile(InterfaceExpression it, ExportModel model, EClass type) ''' + fingerprintExpr(«javaExpr(expr, type, model)», obj, FingerprintOrder.«if (unordered) "UNORDERED" else "ORDERED"», FingerprintIndirection.«if (ref) "INDIRECT" else "DIRECT"», hasher); + hasher.putChar(ITEM_SEP); + ''' + + def private CharSequence appendFragmentSegmentBody(ExportModel model, Collection fingerprintedExports) { + val typeMap = fingerprintedExports.typeMap(model.grammar) + val sortedExportsMap = fingerprintedExports.sortedExportsByEPackage + ''' + org.eclipse.emf.ecore.EClass eClass = object.eClass(); + org.eclipse.emf.ecore.EPackage ePackage = eClass.getEPackage(); + «FOR p : sortedExportsMap.keySet» + if (ePackage == «genModelUtil.qualifiedPackageInterfaceName(p)».eINSTANCE) { + int classifierID = eClass.getClassifierID(); + switch (classifierID) { + «FOR c : p.EClassifiers.filter(EClass).filter[c|fingerprintedExports.map[type].exists[e|e.isSuperTypeOf(c)]]» + «val e = typeMap.get(c)» + «javaContributorComment(e.location)» + case «genModelUtil.classifierIdLiteral(c)»: { + return appendFragmentSegment((«genModelUtil.instanceClassName(c)») object, builder); + } + «ENDFOR» + default: + return super.appendFragmentSegment(object, builder); + } + } + «ENDFOR» + return super.appendFragmentSegment(object, builder); + ''' + } + + // ------------------------------------------------------------------------------------------------------------------- + // Helpers + // ------------------------------------------------------------------------------------------------------------------- + + /** + * Compiles an embedded expression to a Java expression string in the context of the implicit variable {@code obj} + * of the given type. + * + * @param expression + * the expression to compile, must not be {@code null} + * @param type + * the type of the implicit {@code obj} variable, must not be {@code null} + * @param model + * the export model, must not be {@code null} + * @return the Java expression, never {@code null} + */ + def private String javaExpr(Expression expression, EClass type, ExportModel model) { + compiler.javaExpression(expression, translator.newCompilationContext('obj', type, >newArrayList, model)).toString + } + + /** + * Adds a {@code @SuppressWarnings("all")} annotation to the given type. + * + * @param type + * the type to annotate, must not be {@code null} + */ + def private void addSuppressWarningsAll(JvmGenericType type) { + val annotation = typesFactory.createJvmAnnotationReference + annotation.annotation = typeRef(SuppressWarnings).type as JvmAnnotationType + val value = typesFactory.createJvmStringAnnotationValue + value.values += 'all' + annotation.explicitValues += value + type.annotations += annotation + } + + /** + * Creates a marker annotation reference (without values) for the given annotation type. + * + * @param annotationClass + * the annotation type, must not be {@code null} + * @return the annotation reference, never {@code null} + */ + def private JvmAnnotationReference typeOnlyAnnotation(Class annotationClass) { + val annotation = typesFactory.createJvmAnnotationReference + annotation.annotation = typeRef(annotationClass).type as JvmAnnotationType + annotation + } + + /** + * Returns the workspace project containing the given export model, if any. + * + * @param model + * the export model, must not be {@code null} + * @return the containing project, or {@code null} if it cannot be determined + */ + def private IProject projectOf(ExportModel model) { + val uri = model.eResource.URI + if (uri.isPlatformResource) { + val resource = ResourcesPlugin.workspace.root.findMember(uri.toPlatformString(true)) + if (resource !== null) { + return resource.project + } + } + null + } + +} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportTranslationContext.xtend b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportTranslationContext.xtend new file mode 100644 index 0000000000..4c503784c4 --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/jvmmodel/ExportTranslationContext.xtend @@ -0,0 +1,190 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.export.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.export.generator.ExportModelTypeResolver +import java.util.List +import java.util.Map +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.common.types.JvmFormalParameter +import org.eclipse.xtext.common.types.JvmType +import org.eclipse.xtext.xbase.lib.Functions.Function1 + +/** + * Carries the information needed while translating an export expression AST into an Xbase + * {@link org.eclipse.xtext.xbase.XExpression} tree. + *

+ * It holds the variables that are in scope (mapping their source names to the {@link JvmFormalParameter}s of the + * enclosing inferred operation) and the implicit variable that an unqualified ({@code this}) feature call refers to. + * The source element the expression originates from is kept for JVM type resolution. + */ +class ExportTranslationContext { + + val Map variables = newLinkedHashMap + + val List extensionClassNames = newArrayList + + Function1 typeResolver + + JvmFormalParameter implicitVariable + + String implicitVariableName + + ExportModelTypeResolver modelTypeResolver + + EObject sourceElement + + /** + * Registers a variable that is in scope for the translated expression. + * + * @param name + * the source name of the variable, must not be {@code null} + * @param parameter + * the inferred formal parameter the variable resolves to, must not be {@code null} + */ + def void putVariable(String name, JvmFormalParameter parameter) { + variables.put(name, parameter) + } + + /** + * Returns the formal parameter a variable name resolves to. + * + * @param name + * the source name of the variable, must not be {@code null} + * @return the matching formal parameter, or {@code null} if no variable with that name is in scope + */ + def JvmFormalParameter getVariable(String name) { + variables.get(name) + } + + /** + * Registers the fully qualified name of a Java class whose {@code static} methods provide extension operations + * (declared in the export model through {@code extension a::b::C}). + * + * @param className + * the fully qualified Java class name, must not be {@code null} + */ + def void addExtensionClassName(String className) { + extensionClassNames.add(className) + } + + /** + * Returns the fully qualified names of the Java classes whose {@code static} methods provide extension operations. + * + * @return the extension class names, never {@code null} + */ + def List getExtensionClassNames() { + extensionClassNames + } + + /** + * Sets the resolver that maps a source DSL {@link Identifier type} to its corresponding JVM type. This decouples + * the translator from the way types are resolved (a plain classpath lookup for Java types, or a gen-model based + * lookup for EMF model types). + * + * @param resolver + * the type resolver, may be {@code null} + */ + def void setTypeResolver(Function1 resolver) { + this.typeResolver = resolver + } + + /** + * Resolves the JVM type a source DSL type identifier refers to. + * + * @param type + * the source type identifier, may be {@code null} + * @return the resolved JVM type, or {@code null} if it cannot be resolved or no resolver is set + */ + def JvmType resolveDslType(Identifier type) { + if (typeResolver === null || type === null) null else typeResolver.apply(type) + } + + /** + * Returns the implicit variable that an unqualified ({@code this}) feature call refers to. + * + * @return the implicit variable, or {@code null} if none is set + */ + def JvmFormalParameter getImplicitVariable() { + implicitVariable + } + + /** + * Sets the implicit variable that an unqualified ({@code this}) feature call refers to. + * + * @param parameter + * the implicit variable, may be {@code null} + */ + def void setImplicitVariable(JvmFormalParameter parameter) { + this.implicitVariable = parameter + } + + /** + * Returns the name of the Java variable that an unqualified ({@code this}) reference compiles to when the + * expression is rendered as Java source text by the {@link ExportExpressionCompiler}. + * + * @return the implicit variable name, or {@code null} if none is set + */ + def String getImplicitVariableName() { + implicitVariableName + } + + /** + * Sets the name of the Java variable that an unqualified ({@code this}) reference compiles to when the expression + * is rendered as Java source text by the {@link ExportExpressionCompiler}. + * + * @param name + * the implicit variable name, may be {@code null} + */ + def void setImplicitVariableName(String name) { + this.implicitVariableName = name + } + + /** + * Returns the resolver used to map model type names in export expressions to their EMF classifiers. + * + * @return the model type resolver, or {@code null} if none is set + */ + def ExportModelTypeResolver getModelTypeResolver() { + modelTypeResolver + } + + /** + * Sets the resolver used to map model type names in export expressions to their EMF classifiers. + * + * @param resolver + * the model type resolver, may be {@code null} + */ + def void setModelTypeResolver(ExportModelTypeResolver resolver) { + this.modelTypeResolver = resolver + } + + /** + * Returns the source element the translated expression originates from. + * + * @return the source element, or {@code null} if none is set + */ + def EObject getSourceElement() { + sourceElement + } + + /** + * Sets the source element the translated expression originates from. + * + * @param element + * the source element, may be {@code null} + */ + def void setSourceElement(EObject element) { + this.sourceElement = element + } + +} diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/scoping/ExportScopeProvider.java b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/scoping/ExportScopeProvider.java index a265a91dc1..6b5b44a5b1 100644 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/scoping/ExportScopeProvider.java +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/scoping/ExportScopeProvider.java @@ -15,14 +15,15 @@ import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EReference; import org.eclipse.emf.ecore.EcorePackage; +import org.eclipse.xtext.EcoreUtil2; import org.eclipse.xtext.naming.QualifiedName; import org.eclipse.xtext.resource.IEObjectDescription; import org.eclipse.xtext.scoping.IScope; -import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; import org.eclipse.xtext.scoping.impl.SimpleScope; import com.avaloq.tools.ddk.xtext.export.export.DeclarationForType; import com.avaloq.tools.ddk.xtext.export.export.ExportModel; +import com.avaloq.tools.ddk.xtext.export.export.ExportPackage; import com.avaloq.tools.ddk.xtext.export.export.Import; import com.avaloq.tools.ddk.xtext.export.export.Interface; import com.avaloq.tools.ddk.xtext.scoping.EObjectDescriptions; @@ -35,7 +36,7 @@ /** * This class implements scoping for the export language. */ -public class ExportScopeProvider extends AbstractDeclarativeScopeProvider { +public class ExportScopeProvider extends AbstractExportScopeProvider { @Inject private EPackageScopeProvider ePackageScopeProvider; @@ -43,6 +44,41 @@ public class ExportScopeProvider extends AbstractDeclarativeScopeProvider { // Note: as with all scope providers, CHECKSTYLE doesn't like the naming scheme prescribed by xtext. // We therefore switch off the checkstyle method naming checks locally. + /** + * {@inheritDoc} + *

+ * Dispatches the export-language specific cross-references to the corresponding declarative + * {@code scope_*} methods. All other references (in particular Xbase feature and type references) + * are delegated to the {@link org.eclipse.xtext.xbase.scoping.batch.XbaseBatchScopeProvider Xbase batch scope provider}. + */ + @Override + public IScope getScope(final EObject context, final EReference reference) { + if (reference == ExportPackage.Literals.IMPORT__PACKAGE) { + return scope_Import_package(context, reference); + } else if (reference == ExportPackage.Literals.INTERFACE_NAVIGATION__REF) { + final Interface interfaceContext = EcoreUtil2.getContainerOfType(context, Interface.class); + if (interfaceContext != null) { + return scope_InterfaceNavigation_ref(interfaceContext, reference); + } + } else if (EcorePackage.Literals.ECLASS.isSuperTypeOf(reference.getEReferenceType())) { + final ExportModel exportModel = EcoreUtil2.getContainerOfType(context, ExportModel.class); + if (exportModel != null) { + return scope_EClass(exportModel, reference); + } + } else if (EcorePackage.Literals.EATTRIBUTE.isSuperTypeOf(reference.getEReferenceType())) { + final DeclarationForType declarationForType = EcoreUtil2.getContainerOfType(context, DeclarationForType.class); + if (declarationForType != null) { + return scope_EAttribute(declarationForType, reference); + } + } else if (EcorePackage.Literals.ESTRUCTURAL_FEATURE.isSuperTypeOf(reference.getEReferenceType())) { + final DeclarationForType declarationForType = EcoreUtil2.getContainerOfType(context, DeclarationForType.class); + if (declarationForType != null) { + return scope_EStructuralFeature(declarationForType, reference); + } + } + return super.getScope(context, reference); + } + /** * Scope for {@link org.eclipse.emf.ecore.EPackage}. These are read from the * registry as well as from the {@link org.eclipse.xtext.Grammar Xtext diff --git a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/validation/ExportValidator.java b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/validation/ExportValidator.java index 288fe62d7b..775388eb42 100644 --- a/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/validation/ExportValidator.java +++ b/com.avaloq.tools.ddk.xtext.export/src/com/avaloq/tools/ddk/xtext/export/validation/ExportValidator.java @@ -13,16 +13,10 @@ import java.util.Collection; import java.util.List; -import org.eclipse.core.runtime.Platform; import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EReference; import org.eclipse.emf.ecore.EStructuralFeature; -import org.eclipse.internal.xtend.xtend.XtendFile; -import org.eclipse.osgi.util.NLS; -import org.eclipse.xtend.expression.Resource; -import org.eclipse.xtend.expression.ResourceManager; -import org.eclipse.xtend.expression.ResourceManagerDefaultImpl; import org.eclipse.xtext.EcoreUtil2; import org.eclipse.xtext.naming.QualifiedName; import org.eclipse.xtext.validation.Check; @@ -32,7 +26,6 @@ import com.avaloq.tools.ddk.xtext.export.export.Export; import com.avaloq.tools.ddk.xtext.export.export.ExportModel; import com.avaloq.tools.ddk.xtext.export.export.ExportPackage; -import com.avaloq.tools.ddk.xtext.export.export.Extension; import com.avaloq.tools.ddk.xtext.export.export.Interface; import com.avaloq.tools.ddk.xtext.export.export.InterfaceField; import com.avaloq.tools.ddk.xtext.export.export.InterfaceNavigation; @@ -50,30 +43,6 @@ @SuppressWarnings("nls") public class ExportValidator extends AbstractExportValidator { - /** - * Verifies that all referenced extensions can be found. - * - * @param model - * export model to check - */ - @Check - public void checkExtensions(final ExportModel model) { - ResourceManager resourceManager = null; - if (!Platform.isRunning()) { - resourceManager = new ResourceManagerDefaultImpl(); - } - - if (resourceManager == null) { - return; - } - for (Extension ext : model.getExtensions()) { - final Resource res = resourceManager.loadResource(ext.getExtension(), XtendFile.FILE_EXTENSION); - if (res == null) { - error(NLS.bind("Extension ''{0}'' not found", ext.getExtension()), ext, ExportPackage.Literals.EXTENSION__EXTENSION, null); - } - } - } - /** * Checks that the interfaces and exports in an export section all are declared for a unique type. * diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.expression.ide/META-INF/MANIFEST.MF index 2be188ac15..93546c9010 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.expression.ide/META-INF/MANIFEST.MF @@ -10,5 +10,6 @@ Export-Package: com.avaloq.tools.ddk.xtext.expression.ide.contentassist.antlr, com.avaloq.tools.ddk.xtext.expression.ide.contentassist.antlr.internal Require-Bundle: org.antlr.runtime;bundle-version="[3.2.0,3.2.1)", org.eclipse.xtext.ide, - com.avaloq.tools.ddk.xtext.expression + com.avaloq.tools.ddk.xtext.expression, + org.eclipse.xtext.xbase.ide Automatic-Module-Name: com.avaloq.tools.ddk.xtext.expression.ide diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/AbstractExpressionIdeModule.java b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/AbstractExpressionIdeModule.java index 814f716f70..896fd5c42a 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/AbstractExpressionIdeModule.java +++ b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/AbstractExpressionIdeModule.java @@ -7,18 +7,18 @@ import com.avaloq.tools.ddk.xtext.expression.ide.contentassist.antlr.internal.InternalExpressionLexer; import com.google.inject.Binder; import com.google.inject.name.Names; -import org.eclipse.xtext.ide.DefaultIdeModule; import org.eclipse.xtext.ide.LexerIdeBindings; import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +import org.eclipse.xtext.xbase.ide.DefaultXbaseIdeModule; /** * Manual modifications go to {@link ExpressionIdeModule}. */ @SuppressWarnings("all") -public abstract class AbstractExpressionIdeModule extends DefaultIdeModule { +public abstract class AbstractExpressionIdeModule extends DefaultXbaseIdeModule { // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 public void configureContentAssistLexer(Binder binder) { diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/ExpressionParser.java b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/ExpressionParser.java index b2aef0c546..6031a4cb04 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/ExpressionParser.java +++ b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/ExpressionParser.java @@ -48,6 +48,45 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0(), "rule__CollectionExpression__NameAlternatives_0_0"); builder.put(grammarAccess.getTypeAccess().getAlternatives(), "rule__Type__Alternatives"); builder.put(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0(), "rule__CollectionType__ClAlternatives_0_0"); + builder.put(grammarAccess.getXAssignmentAccess().getAlternatives(), "rule__XAssignment__Alternatives"); + builder.put(grammarAccess.getOpMultiAssignAccess().getAlternatives(), "rule__OpMultiAssign__Alternatives"); + builder.put(grammarAccess.getOpEqualityAccess().getAlternatives(), "rule__OpEquality__Alternatives"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1(), "rule__XRelationalExpression__Alternatives_1"); + builder.put(grammarAccess.getOpCompareAccess().getAlternatives(), "rule__OpCompare__Alternatives"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives(), "rule__OpOther__Alternatives"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives_5_1(), "rule__OpOther__Alternatives_5_1"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives_6_1(), "rule__OpOther__Alternatives_6_1"); + builder.put(grammarAccess.getOpAddAccess().getAlternatives(), "rule__OpAdd__Alternatives"); + builder.put(grammarAccess.getOpMultiAccess().getAlternatives(), "rule__OpMulti__Alternatives"); + builder.put(grammarAccess.getXUnaryOperationAccess().getAlternatives(), "rule__XUnaryOperation__Alternatives"); + builder.put(grammarAccess.getOpUnaryAccess().getAlternatives(), "rule__OpUnary__Alternatives"); + builder.put(grammarAccess.getOpPostfixAccess().getAlternatives(), "rule__OpPostfix__Alternatives"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1(), "rule__XMemberFeatureCall__Alternatives_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1(), "rule__XMemberFeatureCall__Alternatives_1_1_3_1"); + builder.put(grammarAccess.getXPrimaryExpressionAccess().getAlternatives(), "rule__XPrimaryExpression__Alternatives"); + builder.put(grammarAccess.getXLiteralAccess().getAlternatives(), "rule__XLiteral__Alternatives"); + builder.put(grammarAccess.getXCollectionLiteralAccess().getAlternatives(), "rule__XCollectionLiteral__Alternatives"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2(), "rule__XSwitchExpression__Alternatives_2"); + builder.put(grammarAccess.getXCasePartAccess().getAlternatives_3(), "rule__XCasePart__Alternatives_3"); + builder.put(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives(), "rule__XExpressionOrVarDeclaration__Alternatives"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1(), "rule__XVariableDeclaration__Alternatives_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2(), "rule__XVariableDeclaration__Alternatives_2"); + builder.put(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1(), "rule__XFeatureCall__Alternatives_3_1"); + builder.put(grammarAccess.getFeatureCallIDAccess().getAlternatives(), "rule__FeatureCallID__Alternatives"); + builder.put(grammarAccess.getIdOrSuperAccess().getAlternatives(), "rule__IdOrSuper__Alternatives"); + builder.put(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1(), "rule__XConstructorCall__Alternatives_4_1"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1(), "rule__XBooleanLiteral__Alternatives_1"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3(), "rule__XTryCatchFinallyExpression__Alternatives_3"); + builder.put(grammarAccess.getNumberAccess().getAlternatives(), "rule__Number__Alternatives"); + builder.put(grammarAccess.getNumberAccess().getAlternatives_1_0(), "rule__Number__Alternatives_1_0"); + builder.put(grammarAccess.getNumberAccess().getAlternatives_1_1_1(), "rule__Number__Alternatives_1_1_1"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getAlternatives(), "rule__JvmTypeReference__Alternatives"); + builder.put(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives(), "rule__JvmArgumentTypeReference__Alternatives"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2(), "rule__JvmWildcardTypeReference__Alternatives_2"); + builder.put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1(), "rule__XImportDeclaration__Alternatives_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3(), "rule__XImportDeclaration__Alternatives_1_0_3"); builder.put(grammarAccess.getLetExpressionAccess().getGroup(), "rule__LetExpression__Group__0"); builder.put(grammarAccess.getCastedExpressionAccess().getGroup(), "rule__CastedExpression__Group__0"); builder.put(grammarAccess.getChainExpressionAccess().getGroup(), "rule__ChainExpression__Group__0"); @@ -96,6 +135,185 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionTypeAccess().getGroup(), "rule__CollectionType__Group__0"); builder.put(grammarAccess.getSimpleTypeAccess().getGroup(), "rule__SimpleType__Group__0"); builder.put(grammarAccess.getSimpleTypeAccess().getGroup_1(), "rule__SimpleType__Group_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_0(), "rule__XAssignment__Group_0__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1(), "rule__XAssignment__Group_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1(), "rule__XAssignment__Group_1_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0(), "rule__XAssignment__Group_1_1_0__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0(), "rule__XAssignment__Group_1_1_0_0__0"); + builder.put(grammarAccess.getOpMultiAssignAccess().getGroup_5(), "rule__OpMultiAssign__Group_5__0"); + builder.put(grammarAccess.getOpMultiAssignAccess().getGroup_6(), "rule__OpMultiAssign__Group_6__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup(), "rule__XOrExpression__Group__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1(), "rule__XOrExpression__Group_1__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1_0(), "rule__XOrExpression__Group_1_0__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0(), "rule__XOrExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup(), "rule__XAndExpression__Group__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1(), "rule__XAndExpression__Group_1__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1_0(), "rule__XAndExpression__Group_1_0__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0(), "rule__XAndExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup(), "rule__XEqualityExpression__Group__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1(), "rule__XEqualityExpression__Group_1__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0(), "rule__XEqualityExpression__Group_1_0__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0(), "rule__XEqualityExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup(), "rule__XRelationalExpression__Group__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0(), "rule__XRelationalExpression__Group_1_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0(), "rule__XRelationalExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0(), "rule__XRelationalExpression__Group_1_0_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1(), "rule__XRelationalExpression__Group_1_1__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0(), "rule__XRelationalExpression__Group_1_1_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0(), "rule__XRelationalExpression__Group_1_1_0_0__0"); + builder.put(grammarAccess.getOpCompareAccess().getGroup_1(), "rule__OpCompare__Group_1__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup(), "rule__XOtherOperatorExpression__Group__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1(), "rule__XOtherOperatorExpression__Group_1__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0(), "rule__XOtherOperatorExpression__Group_1_0__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0(), "rule__XOtherOperatorExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_2(), "rule__OpOther__Group_2__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5(), "rule__OpOther__Group_5__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5_1_0(), "rule__OpOther__Group_5_1_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0(), "rule__OpOther__Group_5_1_0_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6(), "rule__OpOther__Group_6__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6_1_0(), "rule__OpOther__Group_6_1_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0(), "rule__OpOther__Group_6_1_0_0__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup(), "rule__XAdditiveExpression__Group__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1(), "rule__XAdditiveExpression__Group_1__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0(), "rule__XAdditiveExpression__Group_1_0__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0(), "rule__XAdditiveExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup(), "rule__XMultiplicativeExpression__Group__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1(), "rule__XMultiplicativeExpression__Group_1__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0(), "rule__XMultiplicativeExpression__Group_1_0__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0(), "rule__XMultiplicativeExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXUnaryOperationAccess().getGroup_0(), "rule__XUnaryOperation__Group_0__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup(), "rule__XCastedExpression__Group__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1(), "rule__XCastedExpression__Group_1__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0(), "rule__XCastedExpression__Group_1_0__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0(), "rule__XCastedExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup(), "rule__XPostfixOperation__Group__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup_1(), "rule__XPostfixOperation__Group_1__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup_1_0(), "rule__XPostfixOperation__Group_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup(), "rule__XMemberFeatureCall__Group__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0(), "rule__XMemberFeatureCall__Group_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0(), "rule__XMemberFeatureCall__Group_1_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0(), "rule__XMemberFeatureCall__Group_1_0_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1(), "rule__XMemberFeatureCall__Group_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0(), "rule__XMemberFeatureCall__Group_1_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0(), "rule__XMemberFeatureCall__Group_1_1_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2(), "rule__XMemberFeatureCall__Group_1_1_1_2__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3(), "rule__XMemberFeatureCall__Group_1_1_3__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup(), "rule__XSetLiteral__Group__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup_3(), "rule__XSetLiteral__Group_3__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup_3_1(), "rule__XSetLiteral__Group_3_1__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup(), "rule__XListLiteral__Group__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup_3(), "rule__XListLiteral__Group_3__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup_3_1(), "rule__XListLiteral__Group_3_1__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup(), "rule__XClosure__Group__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_0(), "rule__XClosure__Group_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_0_0(), "rule__XClosure__Group_0_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1(), "rule__XClosure__Group_1__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0(), "rule__XClosure__Group_1_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0_0(), "rule__XClosure__Group_1_0_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0_0_1(), "rule__XClosure__Group_1_0_0_1__0"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getGroup(), "rule__XExpressionInClosure__Group__0"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getGroup_1(), "rule__XExpressionInClosure__Group_1__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup(), "rule__XShortClosure__Group__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0(), "rule__XShortClosure__Group_0__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0(), "rule__XShortClosure__Group_0_0__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1(), "rule__XShortClosure__Group_0_0_1__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1(), "rule__XShortClosure__Group_0_0_1_1__0"); + builder.put(grammarAccess.getXParenthesizedExpressionAccess().getGroup(), "rule__XParenthesizedExpression__Group__0"); + builder.put(grammarAccess.getXIfExpressionAccess().getGroup(), "rule__XIfExpression__Group__0"); + builder.put(grammarAccess.getXIfExpressionAccess().getGroup_6(), "rule__XIfExpression__Group_6__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup(), "rule__XSwitchExpression__Group__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0(), "rule__XSwitchExpression__Group_2_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0(), "rule__XSwitchExpression__Group_2_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0(), "rule__XSwitchExpression__Group_2_0_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1(), "rule__XSwitchExpression__Group_2_1__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0(), "rule__XSwitchExpression__Group_2_1_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0(), "rule__XSwitchExpression__Group_2_1_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_5(), "rule__XSwitchExpression__Group_5__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup(), "rule__XCasePart__Group__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup_2(), "rule__XCasePart__Group_2__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup_3_0(), "rule__XCasePart__Group_3_0__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup(), "rule__XForLoopExpression__Group__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup_0(), "rule__XForLoopExpression__Group_0__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0(), "rule__XForLoopExpression__Group_0_0__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup(), "rule__XBasicForLoopExpression__Group__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3(), "rule__XBasicForLoopExpression__Group_3__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1(), "rule__XBasicForLoopExpression__Group_3_1__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7(), "rule__XBasicForLoopExpression__Group_7__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1(), "rule__XBasicForLoopExpression__Group_7_1__0"); + builder.put(grammarAccess.getXWhileExpressionAccess().getGroup(), "rule__XWhileExpression__Group__0"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getGroup(), "rule__XDoWhileExpression__Group__0"); + builder.put(grammarAccess.getXBlockExpressionAccess().getGroup(), "rule__XBlockExpression__Group__0"); + builder.put(grammarAccess.getXBlockExpressionAccess().getGroup_2(), "rule__XBlockExpression__Group_2__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup(), "rule__XVariableDeclaration__Group__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0(), "rule__XVariableDeclaration__Group_2_0__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0(), "rule__XVariableDeclaration__Group_2_0_0__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_3(), "rule__XVariableDeclaration__Group_3__0"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getGroup(), "rule__JvmFormalParameter__Group__0"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getGroup(), "rule__FullJvmFormalParameter__Group__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup(), "rule__XFeatureCall__Group__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_1(), "rule__XFeatureCall__Group_1__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_1_2(), "rule__XFeatureCall__Group_1_2__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3(), "rule__XFeatureCall__Group_3__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1(), "rule__XFeatureCall__Group_3_1_1__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1(), "rule__XFeatureCall__Group_3_1_1_1__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup(), "rule__XConstructorCall__Group__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_3(), "rule__XConstructorCall__Group_3__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_3_2(), "rule__XConstructorCall__Group_3_2__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4(), "rule__XConstructorCall__Group_4__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1(), "rule__XConstructorCall__Group_4_1_1__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1(), "rule__XConstructorCall__Group_4_1_1_1__0"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getGroup(), "rule__XBooleanLiteral__Group__0"); + builder.put(grammarAccess.getXNullLiteralAccess().getGroup(), "rule__XNullLiteral__Group__0"); + builder.put(grammarAccess.getXNumberLiteralAccess().getGroup(), "rule__XNumberLiteral__Group__0"); + builder.put(grammarAccess.getXStringLiteralAccess().getGroup(), "rule__XStringLiteral__Group__0"); + builder.put(grammarAccess.getXTypeLiteralAccess().getGroup(), "rule__XTypeLiteral__Group__0"); + builder.put(grammarAccess.getXThrowExpressionAccess().getGroup(), "rule__XThrowExpression__Group__0"); + builder.put(grammarAccess.getXReturnExpressionAccess().getGroup(), "rule__XReturnExpression__Group__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup(), "rule__XTryCatchFinallyExpression__Group__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0(), "rule__XTryCatchFinallyExpression__Group_3_0__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1(), "rule__XTryCatchFinallyExpression__Group_3_0_1__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1(), "rule__XTryCatchFinallyExpression__Group_3_1__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup(), "rule__XSynchronizedExpression__Group__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0(), "rule__XSynchronizedExpression__Group_0__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0(), "rule__XSynchronizedExpression__Group_0_0__0"); + builder.put(grammarAccess.getXCatchClauseAccess().getGroup(), "rule__XCatchClause__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup(), "rule__QualifiedName__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0"); + builder.put(grammarAccess.getNumberAccess().getGroup_1(), "rule__Number__Group_1__0"); + builder.put(grammarAccess.getNumberAccess().getGroup_1_1(), "rule__Number__Group_1_1__0"); + builder.put(grammarAccess.getStaticQualifierAccess().getGroup(), "rule__StaticQualifier__Group__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0(), "rule__JvmTypeReference__Group_0__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1(), "rule__JvmTypeReference__Group_0_1__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0(), "rule__JvmTypeReference__Group_0_1_0__0"); + builder.put(grammarAccess.getArrayBracketsAccess().getGroup(), "rule__ArrayBrackets__Group__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup(), "rule__XFunctionTypeRef__Group__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0(), "rule__XFunctionTypeRef__Group_0__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1(), "rule__XFunctionTypeRef__Group_0_1__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1(), "rule__XFunctionTypeRef__Group_0_1_1__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup(), "rule__JvmParameterizedTypeReference__Group__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1(), "rule__JvmParameterizedTypeReference__Group_1__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2(), "rule__JvmParameterizedTypeReference__Group_1_2__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4(), "rule__JvmParameterizedTypeReference__Group_1_4__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup(), "rule__JvmWildcardTypeReference__Group__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0(), "rule__JvmWildcardTypeReference__Group_2_0__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1(), "rule__JvmWildcardTypeReference__Group_2_1__0"); + builder.put(grammarAccess.getJvmUpperBoundAccess().getGroup(), "rule__JvmUpperBound__Group__0"); + builder.put(grammarAccess.getJvmUpperBoundAndedAccess().getGroup(), "rule__JvmUpperBoundAnded__Group__0"); + builder.put(grammarAccess.getJvmLowerBoundAccess().getGroup(), "rule__JvmLowerBound__Group__0"); + builder.put(grammarAccess.getJvmLowerBoundAndedAccess().getGroup(), "rule__JvmLowerBoundAnded__Group__0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getGroup(), "rule__JvmTypeParameter__Group__0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getGroup_1(), "rule__JvmTypeParameter__Group_1__0"); + builder.put(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup(), "rule__QualifiedNameWithWildcard__Group__0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getGroup(), "rule__XImportDeclaration__Group__0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getGroup_1_0(), "rule__XImportDeclaration__Group_1_0__0"); + builder.put(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup(), "rule__QualifiedNameInStaticImport__Group__0"); builder.put(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1(), "rule__LetExpression__IdentifierAssignment_1"); builder.put(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3(), "rule__LetExpression__VarExprAssignment_3"); builder.put(grammarAccess.getLetExpressionAccess().getTargetAssignment_5(), "rule__LetExpression__TargetAssignment_5"); @@ -157,6 +375,150 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionTypeAccess().getId1Assignment_2(), "rule__CollectionType__Id1Assignment_2"); builder.put(grammarAccess.getSimpleTypeAccess().getIdAssignment_0(), "rule__SimpleType__IdAssignment_0"); builder.put(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1(), "rule__SimpleType__IdAssignment_1_1"); + builder.put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1(), "rule__XAssignment__FeatureAssignment_0_1"); + builder.put(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3(), "rule__XAssignment__ValueAssignment_0_3"); + builder.put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XAssignment__FeatureAssignment_1_1_0_0_1"); + builder.put(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1(), "rule__XAssignment__RightOperandAssignment_1_1_1"); + builder.put(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOrExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOrExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAndExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAndExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1(), "rule__XEqualityExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1(), "rule__XRelationalExpression__TypeAssignment_1_0_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1(), "rule__XRelationalExpression__RightOperandAssignment_1_1_1"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAdditiveExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1(), "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1(), "rule__XUnaryOperation__FeatureAssignment_0_1"); + builder.put(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2(), "rule__XUnaryOperation__OperandAssignment_0_2"); + builder.put(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1(), "rule__XCastedExpression__TypeAssignment_1_1"); + builder.put(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1(), "rule__XPostfixOperation__FeatureAssignment_1_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1(), "rule__XMemberFeatureCall__ValueAssignment_1_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1(), "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0(), "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"); + builder.put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0(), "rule__XSetLiteral__ElementsAssignment_3_0"); + builder.put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1(), "rule__XSetLiteral__ElementsAssignment_3_1_1"); + builder.put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0(), "rule__XListLiteral__ElementsAssignment_3_0"); + builder.put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1(), "rule__XListLiteral__ElementsAssignment_3_1_1"); + builder.put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"); + builder.put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"); + builder.put(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1(), "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"); + builder.put(grammarAccess.getXClosureAccess().getExpressionAssignment_2(), "rule__XClosure__ExpressionAssignment_2"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0(), "rule__XExpressionInClosure__ExpressionsAssignment_1_0"); + builder.put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"); + builder.put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"); + builder.put(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2(), "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"); + builder.put(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1(), "rule__XShortClosure__ExpressionAssignment_1"); + builder.put(grammarAccess.getXIfExpressionAccess().getIfAssignment_3(), "rule__XIfExpression__IfAssignment_3"); + builder.put(grammarAccess.getXIfExpressionAccess().getThenAssignment_5(), "rule__XIfExpression__ThenAssignment_5"); + builder.put(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1(), "rule__XIfExpression__ElseAssignment_6_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1(), "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1(), "rule__XSwitchExpression__SwitchAssignment_2_0_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0(), "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1(), "rule__XSwitchExpression__SwitchAssignment_2_1_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4(), "rule__XSwitchExpression__CasesAssignment_4"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2(), "rule__XSwitchExpression__DefaultAssignment_5_2"); + builder.put(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1(), "rule__XCasePart__TypeGuardAssignment_1"); + builder.put(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1(), "rule__XCasePart__CaseAssignment_2_1"); + builder.put(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1(), "rule__XCasePart__ThenAssignment_3_0_1"); + builder.put(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1(), "rule__XCasePart__FallThroughAssignment_3_1"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3(), "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1(), "rule__XForLoopExpression__ForExpressionAssignment_1"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3(), "rule__XForLoopExpression__EachExpressionAssignment_3"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5(), "rule__XBasicForLoopExpression__ExpressionAssignment_5"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9(), "rule__XBasicForLoopExpression__EachExpressionAssignment_9"); + builder.put(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3(), "rule__XWhileExpression__PredicateAssignment_3"); + builder.put(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5(), "rule__XWhileExpression__BodyAssignment_5"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2(), "rule__XDoWhileExpression__BodyAssignment_2"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5(), "rule__XDoWhileExpression__PredicateAssignment_5"); + builder.put(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0(), "rule__XBlockExpression__ExpressionsAssignment_2_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0(), "rule__XVariableDeclaration__WriteableAssignment_1_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0(), "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1(), "rule__XVariableDeclaration__NameAssignment_2_0_0_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1(), "rule__XVariableDeclaration__NameAssignment_2_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1(), "rule__XVariableDeclaration__RightAssignment_3_1"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__JvmFormalParameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1(), "rule__JvmFormalParameter__NameAssignment_1"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1(), "rule__FullJvmFormalParameter__NameAssignment_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2(), "rule__XFeatureCall__FeatureAssignment_2"); + builder.put(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0(), "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"); + builder.put(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2(), "rule__XConstructorCall__ConstructorAssignment_2"); + builder.put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0(), "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5(), "rule__XConstructorCall__ArgumentsAssignment_5"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1(), "rule__XBooleanLiteral__IsTrueAssignment_1_1"); + builder.put(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1(), "rule__XNumberLiteral__ValueAssignment_1"); + builder.put(grammarAccess.getXStringLiteralAccess().getValueAssignment_1(), "rule__XStringLiteral__ValueAssignment_1"); + builder.put(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3(), "rule__XTypeLiteral__TypeAssignment_3"); + builder.put(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4(), "rule__XTypeLiteral__ArrayDimensionsAssignment_4"); + builder.put(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2(), "rule__XThrowExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2(), "rule__XReturnExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2(), "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0(), "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1(), "rule__XSynchronizedExpression__ParamAssignment_1"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3(), "rule__XSynchronizedExpression__ExpressionAssignment_3"); + builder.put(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2(), "rule__XCatchClause__DeclaredParamAssignment_2"); + builder.put(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4(), "rule__XCatchClause__ExpressionAssignment_4"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2(), "rule__XFunctionTypeRef__ReturnTypeAssignment_2"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0(), "rule__JvmParameterizedTypeReference__TypeAssignment_0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1(), "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"); + builder.put(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBound__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBound__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getNameAssignment_0(), "rule__JvmTypeParameter__NameAssignment_0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_0(), "rule__JvmTypeParameter__ConstraintsAssignment_1_0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_1(), "rule__JvmTypeParameter__ConstraintsAssignment_1_1"); + builder.put(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment(), "rule__XImportSection__ImportDeclarationsAssignment"); + builder.put(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0(), "rule__XImportDeclaration__StaticAssignment_1_0_0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1(), "rule__XImportDeclaration__ExtensionAssignment_1_0_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2(), "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2"); + builder.put(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0(), "rule__XImportDeclaration__WildcardAssignment_1_0_3_0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1(), "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1(), "rule__XImportDeclaration__ImportedTypeAssignment_1_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2(), "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2"); } } diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.g b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.g index 64287de219..ad2426c1c4 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.g +++ b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.g @@ -975,677 +975,17178 @@ finally { restoreStackSize(stackSize); } -rule__Expression__Alternatives +// Entry rule entryRuleXExpression +entryRuleXExpression +: +{ before(grammarAccess.getXExpressionRule()); } + ruleXExpression +{ after(grammarAccess.getXExpressionRule()); } + EOF +; + +// Rule XExpression +ruleXExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } - ruleLetExpression - { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } - (ruleCastedExpression) - { after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } - ruleChainExpression - { after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + { before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } + ruleXAssignment + { after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainedExpression__Alternatives +// Entry rule entryRuleXAssignment +entryRuleXAssignment +: +{ before(grammarAccess.getXAssignmentRule()); } + ruleXAssignment +{ after(grammarAccess.getXAssignmentRule()); } + EOF +; + +// Rule XAssignment +ruleXAssignment @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } - ruleIfExpressionKw - { after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } - ruleIfExpressionTri - { after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } - ruleSwitchExpression - { after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + { before(grammarAccess.getXAssignmentAccess().getAlternatives()); } + (rule__XAssignment__Alternatives) + { after(grammarAccess.getXAssignmentAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAlternatives_1_1_0 +// Entry rule entryRuleOpSingleAssign +entryRuleOpSingleAssign +: +{ before(grammarAccess.getOpSingleAssignRule()); } + ruleOpSingleAssign +{ after(grammarAccess.getOpSingleAssignRule()); } + EOF +; + +// Rule OpSingleAssign +ruleOpSingleAssign @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } - '==' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } - '!=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } - '>=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } - '<=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } - '>' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } - ) - | + : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } - '<' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + { before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } + '=' + { after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__NameAlternatives_1_1_0 +// Entry rule entryRuleOpMultiAssign +entryRuleOpMultiAssign +: +{ before(grammarAccess.getOpMultiAssignRule()); } + ruleOpMultiAssign +{ after(grammarAccess.getOpMultiAssignRule()); } + EOF +; + +// Rule OpMultiAssign +ruleOpMultiAssign @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } - '+' - { after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } - ) - | + : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } - '-' - { after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + { before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } + (rule__OpMultiAssign__Alternatives) + { after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__NameAlternatives_1_1_0 +// Entry rule entryRuleXOrExpression +entryRuleXOrExpression +: +{ before(grammarAccess.getXOrExpressionRule()); } + ruleXOrExpression +{ after(grammarAccess.getXOrExpressionRule()); } + EOF +; + +// Rule XOrExpression +ruleXOrExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } - '*' - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + { before(grammarAccess.getXOrExpressionAccess().getGroup()); } + (rule__XOrExpression__Group__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpOr +entryRuleOpOr +: +{ before(grammarAccess.getOpOrRule()); } + ruleOpOr +{ after(grammarAccess.getOpOrRule()); } + EOF +; + +// Rule OpOr +ruleOpOr + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } - '/' - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + { before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } + '||' + { after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryOrInfixExpression__Alternatives +// Entry rule entryRuleXAndExpression +entryRuleXAndExpression +: +{ before(grammarAccess.getXAndExpressionRule()); } + ruleXAndExpression +{ after(grammarAccess.getXAndExpressionRule()); } + EOF +; + +// Rule XAndExpression +ruleXAndExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } - ruleUnaryExpression - { after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + { before(grammarAccess.getXAndExpressionAccess().getGroup()); } + (rule__XAndExpression__Group__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpAnd +entryRuleOpAnd +: +{ before(grammarAccess.getOpAndRule()); } + ruleOpAnd +{ after(grammarAccess.getOpAndRule()); } + EOF +; + +// Rule OpAnd +ruleOpAnd + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } - ruleInfixExpression - { after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + { before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } + '&&' + { after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__NameAlternatives_0_0 +// Entry rule entryRuleXEqualityExpression +entryRuleXEqualityExpression +: +{ before(grammarAccess.getXEqualityExpressionRule()); } + ruleXEqualityExpression +{ after(grammarAccess.getXEqualityExpressionRule()); } + EOF +; + +// Rule XEqualityExpression +ruleXEqualityExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } - '!' - { after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + { before(grammarAccess.getXEqualityExpressionAccess().getGroup()); } + (rule__XEqualityExpression__Group__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpEquality +entryRuleOpEquality +: +{ before(grammarAccess.getOpEqualityRule()); } + ruleOpEquality +{ after(grammarAccess.getOpEqualityRule()); } + EOF +; + +// Rule OpEquality +ruleOpEquality + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } - '-' - { after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + { before(grammarAccess.getOpEqualityAccess().getAlternatives()); } + (rule__OpEquality__Alternatives) + { after(grammarAccess.getOpEqualityAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Alternatives_1 +// Entry rule entryRuleXRelationalExpression +entryRuleXRelationalExpression +: +{ before(grammarAccess.getXRelationalExpressionRule()); } + ruleXRelationalExpression +{ after(grammarAccess.getXRelationalExpressionRule()); } + EOF +; + +// Rule XRelationalExpression +ruleXRelationalExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } - (rule__InfixExpression__Group_1_0__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + { before(grammarAccess.getXRelationalExpressionAccess().getGroup()); } + (rule__XRelationalExpression__Group__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpCompare +entryRuleOpCompare +: +{ before(grammarAccess.getOpCompareRule()); } + ruleOpCompare +{ after(grammarAccess.getOpCompareRule()); } + EOF +; + +// Rule OpCompare +ruleOpCompare + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } - (rule__InfixExpression__Group_1_1__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + { before(grammarAccess.getOpCompareAccess().getAlternatives()); } + (rule__OpCompare__Alternatives) + { after(grammarAccess.getOpCompareAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXOtherOperatorExpression +entryRuleXOtherOperatorExpression +: +{ before(grammarAccess.getXOtherOperatorExpressionRule()); } + ruleXOtherOperatorExpression +{ after(grammarAccess.getXOtherOperatorExpressionRule()); } + EOF +; + +// Rule XOtherOperatorExpression +ruleXOtherOperatorExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } - (rule__InfixExpression__Group_1_2__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); } + (rule__XOtherOperatorExpression__Group__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpOther +entryRuleOpOther +: +{ before(grammarAccess.getOpOtherRule()); } + ruleOpOther +{ after(grammarAccess.getOpOtherRule()); } + EOF +; + +// Rule OpOther +ruleOpOther + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } - (rule__InfixExpression__Group_1_3__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + { before(grammarAccess.getOpOtherAccess().getAlternatives()); } + (rule__OpOther__Alternatives) + { after(grammarAccess.getOpOtherAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAlternatives_1_3_2_0 +// Entry rule entryRuleXAdditiveExpression +entryRuleXAdditiveExpression +: +{ before(grammarAccess.getXAdditiveExpressionRule()); } + ruleXAdditiveExpression +{ after(grammarAccess.getXAdditiveExpressionRule()); } + EOF +; + +// Rule XAdditiveExpression +ruleXAdditiveExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } - 'collect' - { after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } + (rule__XAdditiveExpression__Group__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } - 'select' - { after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpAdd +entryRuleOpAdd +: +{ before(grammarAccess.getOpAddRule()); } + ruleOpAdd +{ after(grammarAccess.getOpAddRule()); } + EOF +; + +// Rule OpAdd +ruleOpAdd + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getOpAddAccess().getAlternatives()); } + (rule__OpAdd__Alternatives) + { after(grammarAccess.getOpAddAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXMultiplicativeExpression +entryRuleXMultiplicativeExpression +: +{ before(grammarAccess.getXMultiplicativeExpressionRule()); } + ruleXMultiplicativeExpression +{ after(grammarAccess.getXMultiplicativeExpressionRule()); } + EOF +; + +// Rule XMultiplicativeExpression +ruleXMultiplicativeExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } - 'selectFirst' - { after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } + (rule__XMultiplicativeExpression__Group__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpMulti +entryRuleOpMulti +: +{ before(grammarAccess.getOpMultiRule()); } + ruleOpMulti +{ after(grammarAccess.getOpMultiRule()); } + EOF +; + +// Rule OpMulti +ruleOpMulti + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } - 'reject' - { after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + { before(grammarAccess.getOpMultiAccess().getAlternatives()); } + (rule__OpMulti__Alternatives) + { after(grammarAccess.getOpMultiAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXUnaryOperation +entryRuleXUnaryOperation +: +{ before(grammarAccess.getXUnaryOperationRule()); } + ruleXUnaryOperation +{ after(grammarAccess.getXUnaryOperationRule()); } + EOF +; + +// Rule XUnaryOperation +ruleXUnaryOperation + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } - 'exists' - { after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + { before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } + (rule__XUnaryOperation__Alternatives) + { after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpUnary +entryRuleOpUnary +: +{ before(grammarAccess.getOpUnaryRule()); } + ruleOpUnary +{ after(grammarAccess.getOpUnaryRule()); } + EOF +; + +// Rule OpUnary +ruleOpUnary + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } - 'notExists' - { after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + { before(grammarAccess.getOpUnaryAccess().getAlternatives()); } + (rule__OpUnary__Alternatives) + { after(grammarAccess.getOpUnaryAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCastedExpression +entryRuleXCastedExpression +: +{ before(grammarAccess.getXCastedExpressionRule()); } + ruleXCastedExpression +{ after(grammarAccess.getXCastedExpressionRule()); } + EOF +; + +// Rule XCastedExpression +ruleXCastedExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } - 'sortBy' - { after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + { before(grammarAccess.getXCastedExpressionAccess().getGroup()); } + (rule__XCastedExpression__Group__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXPostfixOperation +entryRuleXPostfixOperation +: +{ before(grammarAccess.getXPostfixOperationRule()); } + ruleXPostfixOperation +{ after(grammarAccess.getXPostfixOperationRule()); } + EOF +; + +// Rule XPostfixOperation +ruleXPostfixOperation + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } - 'forAll' - { after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + { before(grammarAccess.getXPostfixOperationAccess().getGroup()); } + (rule__XPostfixOperation__Group__0) + { after(grammarAccess.getXPostfixOperationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpPostfix +entryRuleOpPostfix +: +{ before(grammarAccess.getOpPostfixRule()); } + ruleOpPostfix +{ after(grammarAccess.getOpPostfixRule()); } + EOF +; + +// Rule OpPostfix +ruleOpPostfix + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getOpPostfixAccess().getAlternatives()); } + (rule__OpPostfix__Alternatives) + { after(grammarAccess.getOpPostfixAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXMemberFeatureCall +entryRuleXMemberFeatureCall +: +{ before(grammarAccess.getXMemberFeatureCallRule()); } + ruleXMemberFeatureCall +{ after(grammarAccess.getXMemberFeatureCallRule()); } + EOF +; + +// Rule XMemberFeatureCall +ruleXMemberFeatureCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } + (rule__XMemberFeatureCall__Group__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXPrimaryExpression +entryRuleXPrimaryExpression +: +{ before(grammarAccess.getXPrimaryExpressionRule()); } + ruleXPrimaryExpression +{ after(grammarAccess.getXPrimaryExpressionRule()); } + EOF +; + +// Rule XPrimaryExpression +ruleXPrimaryExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } + (rule__XPrimaryExpression__Alternatives) + { after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXLiteral +entryRuleXLiteral +: +{ before(grammarAccess.getXLiteralRule()); } + ruleXLiteral +{ after(grammarAccess.getXLiteralRule()); } + EOF +; + +// Rule XLiteral +ruleXLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXLiteralAccess().getAlternatives()); } + (rule__XLiteral__Alternatives) + { after(grammarAccess.getXLiteralAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCollectionLiteral +entryRuleXCollectionLiteral +: +{ before(grammarAccess.getXCollectionLiteralRule()); } + ruleXCollectionLiteral +{ after(grammarAccess.getXCollectionLiteralRule()); } + EOF +; + +// Rule XCollectionLiteral +ruleXCollectionLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } + (rule__XCollectionLiteral__Alternatives) + { after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Alternatives +// Entry rule entryRuleXSetLiteral +entryRuleXSetLiteral +: +{ before(grammarAccess.getXSetLiteralRule()); } + ruleXSetLiteral +{ after(grammarAccess.getXSetLiteralRule()); } + EOF +; + +// Rule XSetLiteral +ruleXSetLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSetLiteralAccess().getGroup()); } + (rule__XSetLiteral__Group__0) + { after(grammarAccess.getXSetLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXListLiteral +entryRuleXListLiteral +: +{ before(grammarAccess.getXListLiteralRule()); } + ruleXListLiteral +{ after(grammarAccess.getXListLiteralRule()); } + EOF +; + +// Rule XListLiteral +ruleXListLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXListLiteralAccess().getGroup()); } + (rule__XListLiteral__Group__0) + { after(grammarAccess.getXListLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXClosure +entryRuleXClosure +: +{ before(grammarAccess.getXClosureRule()); } + ruleXClosure +{ after(grammarAccess.getXClosureRule()); } + EOF +; + +// Rule XClosure +ruleXClosure + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXClosureAccess().getGroup()); } + (rule__XClosure__Group__0) + { after(grammarAccess.getXClosureAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXExpressionInClosure +entryRuleXExpressionInClosure +: +{ before(grammarAccess.getXExpressionInClosureRule()); } + ruleXExpressionInClosure +{ after(grammarAccess.getXExpressionInClosureRule()); } + EOF +; + +// Rule XExpressionInClosure +ruleXExpressionInClosure + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXExpressionInClosureAccess().getGroup()); } + (rule__XExpressionInClosure__Group__0) + { after(grammarAccess.getXExpressionInClosureAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXShortClosure +entryRuleXShortClosure +: +{ before(grammarAccess.getXShortClosureRule()); } + ruleXShortClosure +{ after(grammarAccess.getXShortClosureRule()); } + EOF +; + +// Rule XShortClosure +ruleXShortClosure + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXShortClosureAccess().getGroup()); } + (rule__XShortClosure__Group__0) + { after(grammarAccess.getXShortClosureAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXParenthesizedExpression +entryRuleXParenthesizedExpression +: +{ before(grammarAccess.getXParenthesizedExpressionRule()); } + ruleXParenthesizedExpression +{ after(grammarAccess.getXParenthesizedExpressionRule()); } + EOF +; + +// Rule XParenthesizedExpression +ruleXParenthesizedExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } + (rule__XParenthesizedExpression__Group__0) + { after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXIfExpression +entryRuleXIfExpression +: +{ before(grammarAccess.getXIfExpressionRule()); } + ruleXIfExpression +{ after(grammarAccess.getXIfExpressionRule()); } + EOF +; + +// Rule XIfExpression +ruleXIfExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXIfExpressionAccess().getGroup()); } + (rule__XIfExpression__Group__0) + { after(grammarAccess.getXIfExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSwitchExpression +entryRuleXSwitchExpression +: +{ before(grammarAccess.getXSwitchExpressionRule()); } + ruleXSwitchExpression +{ after(grammarAccess.getXSwitchExpressionRule()); } + EOF +; + +// Rule XSwitchExpression +ruleXSwitchExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup()); } + (rule__XSwitchExpression__Group__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCasePart +entryRuleXCasePart +: +{ before(grammarAccess.getXCasePartRule()); } + ruleXCasePart +{ after(grammarAccess.getXCasePartRule()); } + EOF +; + +// Rule XCasePart +ruleXCasePart + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCasePartAccess().getGroup()); } + (rule__XCasePart__Group__0) + { after(grammarAccess.getXCasePartAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXForLoopExpression +entryRuleXForLoopExpression +: +{ before(grammarAccess.getXForLoopExpressionRule()); } + ruleXForLoopExpression +{ after(grammarAccess.getXForLoopExpressionRule()); } + EOF +; + +// Rule XForLoopExpression +ruleXForLoopExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup()); } + (rule__XForLoopExpression__Group__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBasicForLoopExpression +entryRuleXBasicForLoopExpression +: +{ before(grammarAccess.getXBasicForLoopExpressionRule()); } + ruleXBasicForLoopExpression +{ after(grammarAccess.getXBasicForLoopExpressionRule()); } + EOF +; + +// Rule XBasicForLoopExpression +ruleXBasicForLoopExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + (rule__XBasicForLoopExpression__Group__0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXWhileExpression +entryRuleXWhileExpression +: +{ before(grammarAccess.getXWhileExpressionRule()); } + ruleXWhileExpression +{ after(grammarAccess.getXWhileExpressionRule()); } + EOF +; + +// Rule XWhileExpression +ruleXWhileExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXWhileExpressionAccess().getGroup()); } + (rule__XWhileExpression__Group__0) + { after(grammarAccess.getXWhileExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXDoWhileExpression +entryRuleXDoWhileExpression +: +{ before(grammarAccess.getXDoWhileExpressionRule()); } + ruleXDoWhileExpression +{ after(grammarAccess.getXDoWhileExpressionRule()); } + EOF +; + +// Rule XDoWhileExpression +ruleXDoWhileExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } + (rule__XDoWhileExpression__Group__0) + { after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBlockExpression +entryRuleXBlockExpression +: +{ before(grammarAccess.getXBlockExpressionRule()); } + ruleXBlockExpression +{ after(grammarAccess.getXBlockExpressionRule()); } + EOF +; + +// Rule XBlockExpression +ruleXBlockExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBlockExpressionAccess().getGroup()); } + (rule__XBlockExpression__Group__0) + { after(grammarAccess.getXBlockExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXExpressionOrVarDeclaration +entryRuleXExpressionOrVarDeclaration +: +{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); } + ruleXExpressionOrVarDeclaration +{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); } + EOF +; + +// Rule XExpressionOrVarDeclaration +ruleXExpressionOrVarDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } + (rule__XExpressionOrVarDeclaration__Alternatives) + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXVariableDeclaration +entryRuleXVariableDeclaration +: +{ before(grammarAccess.getXVariableDeclarationRule()); } + ruleXVariableDeclaration +{ after(grammarAccess.getXVariableDeclarationRule()); } + EOF +; + +// Rule XVariableDeclaration +ruleXVariableDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup()); } + (rule__XVariableDeclaration__Group__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmFormalParameter +entryRuleJvmFormalParameter +: +{ before(grammarAccess.getJvmFormalParameterRule()); } + ruleJvmFormalParameter +{ after(grammarAccess.getJvmFormalParameterRule()); } + EOF +; + +// Rule JvmFormalParameter +ruleJvmFormalParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmFormalParameterAccess().getGroup()); } + (rule__JvmFormalParameter__Group__0) + { after(grammarAccess.getJvmFormalParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleFullJvmFormalParameter +entryRuleFullJvmFormalParameter +: +{ before(grammarAccess.getFullJvmFormalParameterRule()); } + ruleFullJvmFormalParameter +{ after(grammarAccess.getFullJvmFormalParameterRule()); } + EOF +; + +// Rule FullJvmFormalParameter +ruleFullJvmFormalParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } + (rule__FullJvmFormalParameter__Group__0) + { after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXFeatureCall +entryRuleXFeatureCall +: +{ before(grammarAccess.getXFeatureCallRule()); } + ruleXFeatureCall +{ after(grammarAccess.getXFeatureCallRule()); } + EOF +; + +// Rule XFeatureCall +ruleXFeatureCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXFeatureCallAccess().getGroup()); } + (rule__XFeatureCall__Group__0) + { after(grammarAccess.getXFeatureCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleFeatureCallID +entryRuleFeatureCallID +: +{ before(grammarAccess.getFeatureCallIDRule()); } + ruleFeatureCallID +{ after(grammarAccess.getFeatureCallIDRule()); } + EOF +; + +// Rule FeatureCallID +ruleFeatureCallID + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } + (rule__FeatureCallID__Alternatives) + { after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleIdOrSuper +entryRuleIdOrSuper +: +{ before(grammarAccess.getIdOrSuperRule()); } + ruleIdOrSuper +{ after(grammarAccess.getIdOrSuperRule()); } + EOF +; + +// Rule IdOrSuper +ruleIdOrSuper + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getIdOrSuperAccess().getAlternatives()); } + (rule__IdOrSuper__Alternatives) + { after(grammarAccess.getIdOrSuperAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXConstructorCall +entryRuleXConstructorCall +: +{ before(grammarAccess.getXConstructorCallRule()); } + ruleXConstructorCall +{ after(grammarAccess.getXConstructorCallRule()); } + EOF +; + +// Rule XConstructorCall +ruleXConstructorCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXConstructorCallAccess().getGroup()); } + (rule__XConstructorCall__Group__0) + { after(grammarAccess.getXConstructorCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBooleanLiteral +entryRuleXBooleanLiteral +: +{ before(grammarAccess.getXBooleanLiteralRule()); } + ruleXBooleanLiteral +{ after(grammarAccess.getXBooleanLiteralRule()); } + EOF +; + +// Rule XBooleanLiteral +ruleXBooleanLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBooleanLiteralAccess().getGroup()); } + (rule__XBooleanLiteral__Group__0) + { after(grammarAccess.getXBooleanLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXNullLiteral +entryRuleXNullLiteral +: +{ before(grammarAccess.getXNullLiteralRule()); } + ruleXNullLiteral +{ after(grammarAccess.getXNullLiteralRule()); } + EOF +; + +// Rule XNullLiteral +ruleXNullLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXNullLiteralAccess().getGroup()); } + (rule__XNullLiteral__Group__0) + { after(grammarAccess.getXNullLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXNumberLiteral +entryRuleXNumberLiteral +: +{ before(grammarAccess.getXNumberLiteralRule()); } + ruleXNumberLiteral +{ after(grammarAccess.getXNumberLiteralRule()); } + EOF +; + +// Rule XNumberLiteral +ruleXNumberLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXNumberLiteralAccess().getGroup()); } + (rule__XNumberLiteral__Group__0) + { after(grammarAccess.getXNumberLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXStringLiteral +entryRuleXStringLiteral +: +{ before(grammarAccess.getXStringLiteralRule()); } + ruleXStringLiteral +{ after(grammarAccess.getXStringLiteralRule()); } + EOF +; + +// Rule XStringLiteral +ruleXStringLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXStringLiteralAccess().getGroup()); } + (rule__XStringLiteral__Group__0) + { after(grammarAccess.getXStringLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXTypeLiteral +entryRuleXTypeLiteral +: +{ before(grammarAccess.getXTypeLiteralRule()); } + ruleXTypeLiteral +{ after(grammarAccess.getXTypeLiteralRule()); } + EOF +; + +// Rule XTypeLiteral +ruleXTypeLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXTypeLiteralAccess().getGroup()); } + (rule__XTypeLiteral__Group__0) + { after(grammarAccess.getXTypeLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXThrowExpression +entryRuleXThrowExpression +: +{ before(grammarAccess.getXThrowExpressionRule()); } + ruleXThrowExpression +{ after(grammarAccess.getXThrowExpressionRule()); } + EOF +; + +// Rule XThrowExpression +ruleXThrowExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXThrowExpressionAccess().getGroup()); } + (rule__XThrowExpression__Group__0) + { after(grammarAccess.getXThrowExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXReturnExpression +entryRuleXReturnExpression +: +{ before(grammarAccess.getXReturnExpressionRule()); } + ruleXReturnExpression +{ after(grammarAccess.getXReturnExpressionRule()); } + EOF +; + +// Rule XReturnExpression +ruleXReturnExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXReturnExpressionAccess().getGroup()); } + (rule__XReturnExpression__Group__0) + { after(grammarAccess.getXReturnExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXTryCatchFinallyExpression +entryRuleXTryCatchFinallyExpression +: +{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); } + ruleXTryCatchFinallyExpression +{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); } + EOF +; + +// Rule XTryCatchFinallyExpression +ruleXTryCatchFinallyExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } + (rule__XTryCatchFinallyExpression__Group__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSynchronizedExpression +entryRuleXSynchronizedExpression +: +{ before(grammarAccess.getXSynchronizedExpressionRule()); } + ruleXSynchronizedExpression +{ after(grammarAccess.getXSynchronizedExpressionRule()); } + EOF +; + +// Rule XSynchronizedExpression +ruleXSynchronizedExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } + (rule__XSynchronizedExpression__Group__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCatchClause +entryRuleXCatchClause +: +{ before(grammarAccess.getXCatchClauseRule()); } + ruleXCatchClause +{ after(grammarAccess.getXCatchClauseRule()); } + EOF +; + +// Rule XCatchClause +ruleXCatchClause + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCatchClauseAccess().getGroup()); } + (rule__XCatchClause__Group__0) + { after(grammarAccess.getXCatchClauseAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName +: +{ before(grammarAccess.getQualifiedNameRule()); } + ruleQualifiedName +{ after(grammarAccess.getQualifiedNameRule()); } + EOF +; + +// Rule QualifiedName +ruleQualifiedName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameAccess().getGroup()); } + (rule__QualifiedName__Group__0) + { after(grammarAccess.getQualifiedNameAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleNumber +entryRuleNumber +@init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +} +: +{ before(grammarAccess.getNumberRule()); } + ruleNumber +{ after(grammarAccess.getNumberRule()); } + EOF +; +finally { + myHiddenTokenState.restore(); +} + +// Rule Number +ruleNumber + @init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNumberAccess().getAlternatives()); } + (rule__Number__Alternatives) + { after(grammarAccess.getNumberAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); + myHiddenTokenState.restore(); +} + +// Entry rule entryRuleJvmTypeReference +entryRuleJvmTypeReference +: +{ before(grammarAccess.getJvmTypeReferenceRule()); } + ruleJvmTypeReference +{ after(grammarAccess.getJvmTypeReferenceRule()); } + EOF +; + +// Rule JvmTypeReference +ruleJvmTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } + (rule__JvmTypeReference__Alternatives) + { after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets +: +{ before(grammarAccess.getArrayBracketsRule()); } + ruleArrayBrackets +{ after(grammarAccess.getArrayBracketsRule()); } + EOF +; + +// Rule ArrayBrackets +ruleArrayBrackets + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArrayBracketsAccess().getGroup()); } + (rule__ArrayBrackets__Group__0) + { after(grammarAccess.getArrayBracketsAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef +: +{ before(grammarAccess.getXFunctionTypeRefRule()); } + ruleXFunctionTypeRef +{ after(grammarAccess.getXFunctionTypeRefRule()); } + EOF +; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } + (rule__XFunctionTypeRef__Group__0) + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference +: +{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + ruleJvmParameterizedTypeReference +{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + EOF +; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } + (rule__JvmParameterizedTypeReference__Group__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference +: +{ before(grammarAccess.getJvmArgumentTypeReferenceRule()); } + ruleJvmArgumentTypeReference +{ after(grammarAccess.getJvmArgumentTypeReferenceRule()); } + EOF +; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } + (rule__JvmArgumentTypeReference__Alternatives) + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference +: +{ before(grammarAccess.getJvmWildcardTypeReferenceRule()); } + ruleJvmWildcardTypeReference +{ after(grammarAccess.getJvmWildcardTypeReferenceRule()); } + EOF +; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } + (rule__JvmWildcardTypeReference__Group__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound +: +{ before(grammarAccess.getJvmUpperBoundRule()); } + ruleJvmUpperBound +{ after(grammarAccess.getJvmUpperBoundRule()); } + EOF +; + +// Rule JvmUpperBound +ruleJvmUpperBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + (rule__JvmUpperBound__Group__0) + { after(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded +: +{ before(grammarAccess.getJvmUpperBoundAndedRule()); } + ruleJvmUpperBoundAnded +{ after(grammarAccess.getJvmUpperBoundAndedRule()); } + EOF +; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } + (rule__JvmUpperBoundAnded__Group__0) + { after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound +: +{ before(grammarAccess.getJvmLowerBoundRule()); } + ruleJvmLowerBound +{ after(grammarAccess.getJvmLowerBoundRule()); } + EOF +; + +// Rule JvmLowerBound +ruleJvmLowerBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmLowerBoundAccess().getGroup()); } + (rule__JvmLowerBound__Group__0) + { after(grammarAccess.getJvmLowerBoundAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded +: +{ before(grammarAccess.getJvmLowerBoundAndedRule()); } + ruleJvmLowerBoundAnded +{ after(grammarAccess.getJvmLowerBoundAndedRule()); } + EOF +; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } + (rule__JvmLowerBoundAnded__Group__0) + { after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard +: +{ before(grammarAccess.getQualifiedNameWithWildcardRule()); } + ruleQualifiedNameWithWildcard +{ after(grammarAccess.getQualifiedNameWithWildcardRule()); } + EOF +; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } + (rule__QualifiedNameWithWildcard__Group__0) + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleValidID +entryRuleValidID +: +{ before(grammarAccess.getValidIDRule()); } + ruleValidID +{ after(grammarAccess.getValidIDRule()); } + EOF +; + +// Rule ValidID +ruleValidID + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } + RULE_ID + { after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration +: +{ before(grammarAccess.getXImportDeclarationRule()); } + ruleXImportDeclaration +{ after(grammarAccess.getXImportDeclarationRule()); } + EOF +; + +// Rule XImportDeclaration +ruleXImportDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXImportDeclarationAccess().getGroup()); } + (rule__XImportDeclaration__Group__0) + { after(grammarAccess.getXImportDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport +: +{ before(grammarAccess.getQualifiedNameInStaticImportRule()); } + ruleQualifiedNameInStaticImport +{ after(grammarAccess.getQualifiedNameInStaticImportRule()); } + EOF +; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport + @init { + int stackSize = keepStackSize(); + } + : + ( + ( + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + (rule__QualifiedNameInStaticImport__Group__0) + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + ) + ( + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + (rule__QualifiedNameInStaticImport__Group__0)* + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + ) + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Expression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } + ruleLetExpression + { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } + (ruleCastedExpression) + { after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + ruleChainExpression + { after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainedExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + ruleIfExpressionKw + { after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + ruleIfExpressionTri + { after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + ruleSwitchExpression + { after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__OperatorAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } + '==' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + '!=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } + '>=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + '<=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + '>' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + '<' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__NameAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } + '+' + { after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + '-' + { after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__NameAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + '*' + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + '/' + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryOrInfixExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + ruleUnaryExpression + { after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + ruleInfixExpression + { after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__NameAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + '!' + { after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + '-' + { after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + (rule__InfixExpression__Group_1_0__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + (rule__InfixExpression__Group_1_1__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + (rule__InfixExpression__Group_1_2__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + (rule__InfixExpression__Group_1_3__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__NameAlternatives_1_3_2_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + 'collect' + { after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + 'select' + { after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + 'selectFirst' + { after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + 'reject' + { after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + 'exists' + { after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + 'notExists' + { after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + 'sortBy' + { after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + 'forAll' + { after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrimaryExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + ruleLiteral + { after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } + ruleFeatureCall + { after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + ruleListLiteral + { after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + ruleConstructorCallExpression + { after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + ruleGlobalVarExpression + { after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + ruleParanthesizedExpression + { after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Literal__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + ruleBooleanLiteral + { after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + ruleIntegerLiteral + { after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + ruleNullLiteral + { after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + ruleRealLiteral + { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + ruleStringLiteral + { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__BooleanLiteral__ValAlternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + 'true' + { after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + ) + | + ( + { before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + 'false' + { after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__FeatureCall__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + ruleOperationCall + { after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + (rule__FeatureCall__TypeAssignment_1) + { after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + ruleCollectionExpression + { after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + ruleTypeSelectExpression + { after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__NameAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + 'collect' + { after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } + 'select' + { after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + 'selectFirst' + { after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + 'reject' + { after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + 'exists' + { after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + 'notExists' + { after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + 'sortBy' + { after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + 'forAll' + { after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Type__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } + ruleCollectionType + { after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } + ruleSimpleType + { after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__ClAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } + 'Collection' + { after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } + 'List' + { after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } + ) + | + ( + { before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } + 'Set' + { after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXAssignmentAccess().getGroup_0()); } + (rule__XAssignment__Group_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getXAssignmentAccess().getGroup_1()); } + (rule__XAssignment__Group_1__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); } + '+=' + { after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); } + '-=' + { after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); } + '*=' + { after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); } + '/=' + { after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); } + '%=' + { after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); } + (rule__OpMultiAssign__Group_5__0) + { after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); } + (rule__OpMultiAssign__Group_6__0) + { after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpEquality__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); } + '==' + { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); } + '!=' + { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); } + '===' + { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); } + '!==' + { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); } + (rule__XRelationalExpression__Group_1_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); } + (rule__XRelationalExpression__Group_1_1__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); } + '>=' + { after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getGroup_1()); } + (rule__OpCompare__Group_1__0) + { after(grammarAccess.getOpCompareAccess().getGroup_1()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); } + '>' + { after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); } + '<' + { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); } + '->' + { after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); } + '..<' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_2()); } + (rule__OpOther__Group_2__0) + { after(grammarAccess.getOpOtherAccess().getGroup_2()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); } + '..' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); } + '=>' + { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_5()); } + (rule__OpOther__Group_5__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_6()); } + (rule__OpOther__Group_6__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); } + '<>' + { after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); } + '?:' + { after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); } + (rule__OpOther__Group_5_1_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); } + (rule__OpOther__Group_6_1_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); } + '=>' + { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpAdd__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); } + '+' + { after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); } + '-' + { after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMulti__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); } + '*' + { after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); } + '**' + { after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); } + '/' + { after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); } + '%' + { after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); } + (rule__XUnaryOperation__Group_0__0) + { after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); } + ruleXCastedExpression + { after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpUnary__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); } + '!' + { after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); } + '-' + { after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); } + '+' + { after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpPostfix__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); } + '++' + { after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); } + '--' + { after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); } + (rule__XMemberFeatureCall__Group_1_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); } + (rule__XMemberFeatureCall__Group_1_1__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); } + '.' + { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); } + (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); } + '.' + { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); } + (rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); } + (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_1_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_3_1_1__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPrimaryExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); } + ruleXConstructorCall + { after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); } + ruleXBlockExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); } + ruleXSwitchExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); } + (ruleXSynchronizedExpression) + { after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); } + ruleXFeatureCall + { after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); } + ruleXLiteral + { after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); } + ruleXIfExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); } + (ruleXForLoopExpression) + { after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); } + ruleXBasicForLoopExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); } + ruleXWhileExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); } + ruleXDoWhileExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); } + ruleXThrowExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); } + ruleXReturnExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); } + ruleXTryCatchFinallyExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); } + ruleXParenthesizedExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XLiteral__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); } + ruleXCollectionLiteral + { after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); } + (ruleXClosure) + { after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); } + ruleXBooleanLiteral + { after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); } + ruleXNumberLiteral + { after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); } + ruleXNullLiteral + { after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); } + ruleXStringLiteral + { after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); } + ruleXTypeLiteral + { after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCollectionLiteral__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); } + ruleXSetLiteral + { after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); } + ruleXListLiteral + { after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); } + (rule__XSwitchExpression__Group_2_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); } + (rule__XSwitchExpression__Group_2_1__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXCasePartAccess().getGroup_3_0()); } + (rule__XCasePart__Group_3_0__0) + { after(grammarAccess.getXCasePartAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); } + (rule__XCasePart__FallThroughAssignment_3_1) + { after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionOrVarDeclaration__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); } + ruleXVariableDeclaration + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); } + ruleXExpression + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); } + (rule__XVariableDeclaration__WriteableAssignment_1_0) + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); } + ) + | + ( + { before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); } + 'val' + { after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); } + (rule__XVariableDeclaration__Group_2_0__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); } + (rule__XVariableDeclaration__NameAssignment_2_1) + { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Alternatives_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); } + ) + | + ( + { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); } + (rule__XFeatureCall__Group_3_1_1__0) + { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__FeatureCallID__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); } + 'extends' + { after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); } + 'static' + { after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); } + 'import' + { after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); } + 'extension' + { after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__IdOrSuper__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); } + ruleFeatureCallID + { after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); } + 'super' + { after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Alternatives_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_0) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); } + ) + | + ( + { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); } + (rule__XConstructorCall__Group_4_1_1__0) + { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBooleanLiteral__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); } + 'false' + { after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); } + ) + | + ( + { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); } + (rule__XBooleanLiteral__IsTrueAssignment_1_1) + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); } + (rule__XTryCatchFinallyExpression__Group_3_0__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); } + (rule__XTryCatchFinallyExpression__Group_3_1__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); } + RULE_HEX + { after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getGroup_1()); } + (rule__Number__Group_1__0) + { after(grammarAccess.getNumberAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); } + RULE_INT + { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); } + RULE_DECIMAL + { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives_1_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); } + RULE_INT + { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); } + RULE_DECIMAL + { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmTypeReference__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); } + (rule__JvmTypeReference__Group_0__0) + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); } + ruleXFunctionTypeRef + { after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmArgumentTypeReference__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); } + ruleJvmWildcardTypeReference + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmWildcardTypeReference__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); } + (rule__JvmWildcardTypeReference__Group_2_0__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); } + (rule__JvmWildcardTypeReference__Group_2_1__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } + (rule__XImportDeclaration__Group_1_0__0) + { after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } + (rule__XImportDeclaration__ImportedTypeAssignment_1_1) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } + (rule__XImportDeclaration__ImportedNamespaceAssignment_1_2) + { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1_0_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } + (rule__XImportDeclaration__WildcardAssignment_1_0_3_0) + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } + (rule__XImportDeclaration__MemberNameAssignment_1_0_3_1) + { after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__0__Impl + rule__LetExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } + 'let' + { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__1__Impl + rule__LetExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + (rule__LetExpression__IdentifierAssignment_1) + { after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__2__Impl + rule__LetExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } + '=' + { after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__3__Impl + rule__LetExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } + (rule__LetExpression__VarExprAssignment_3) + { after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__4__Impl + rule__LetExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } + ':' + { after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } + (rule__LetExpression__TargetAssignment_5) + { after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CastedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__0__Impl + rule__CastedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__1__Impl + rule__CastedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } + (rule__CastedExpression__TypeAssignment_1) + { after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__2__Impl + rule__CastedExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } + (rule__CastedExpression__TargetAssignment_3) + { after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ChainExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group__0__Impl + rule__ChainExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } + ruleChainedExpression + { after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getGroup_1()); } + (rule__ChainExpression__Group_1__0)* + { after(grammarAccess.getChainExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ChainExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__0__Impl + rule__ChainExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } + () + { after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__1__Impl + rule__ChainExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } + '->' + { after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } + (rule__ChainExpression__NextAssignment_1_2) + { after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionTri__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group__0__Impl + rule__IfExpressionTri__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } + ruleOrExpression + { after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } + (rule__IfExpressionTri__Group_1__0)? + { after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionTri__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__0__Impl + rule__IfExpressionTri__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + () + { after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__1__Impl + rule__IfExpressionTri__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } + '?' + { after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__2__Impl + rule__IfExpressionTri__Group_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } + (rule__IfExpressionTri__ThenPartAssignment_1_2) + { after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__3__Impl + rule__IfExpressionTri__Group_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } + ':' + { after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } + (rule__IfExpressionTri__ElsePartAssignment_1_4) + { after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__0__Impl + rule__IfExpressionKw__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } + 'if' + { after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__1__Impl + rule__IfExpressionKw__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } + (rule__IfExpressionKw__ConditionAssignment_1) + { after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__2__Impl + rule__IfExpressionKw__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } + 'then' + { after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__3__Impl + rule__IfExpressionKw__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } + (rule__IfExpressionKw__ThenPartAssignment_3) + { after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } + (rule__IfExpressionKw__Group_4__0)? + { after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } + (rule__IfExpressionKw__Group_4_0__0) + { after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group_4_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4_0__0__Impl + rule__IfExpressionKw__Group_4_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } + 'else' + { after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } + (rule__IfExpressionKw__ElsePartAssignment_4_0_1) + { after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SwitchExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__0__Impl + rule__SwitchExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } + 'switch' + { after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__1__Impl + rule__SwitchExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } + (rule__SwitchExpression__Group_1__0)? + { after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__2__Impl + rule__SwitchExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } + '{' + { after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__3__Impl + rule__SwitchExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } + (rule__SwitchExpression__CaseAssignment_3)* + { after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__4__Impl + rule__SwitchExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } + 'default' + { after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__5__Impl + rule__SwitchExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } + ':' + { after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__6__Impl + rule__SwitchExpression__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + (rule__SwitchExpression__DefaultExprAssignment_6) + { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } + '}' + { after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SwitchExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__0__Impl + rule__SwitchExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } + '(' + { after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__1__Impl + rule__SwitchExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + (rule__SwitchExpression__SwitchExprAssignment_1_1) + { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } + ')' + { after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Case__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__0__Impl + rule__Case__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } + 'case' + { after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__1__Impl + rule__Case__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } + (rule__Case__ConditionAssignment_1) + { after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__2__Impl + rule__Case__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getColonKeyword_2()); } + ':' + { after(grammarAccess.getCaseAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + (rule__Case__ThenParAssignment_3) + { after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OrExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group__0__Impl + rule__OrExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + ruleAndExpression + { after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getGroup_1()); } + (rule__OrExpression__Group_1__0)* + { after(grammarAccess.getOrExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OrExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__0__Impl + rule__OrExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__1__Impl + rule__OrExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + (rule__OrExpression__OperatorAssignment_1_1) + { after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + (rule__OrExpression__RightAssignment_1_2) + { after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__AndExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group__0__Impl + rule__AndExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + ruleImpliesExpression + { after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getGroup_1()); } + (rule__AndExpression__Group_1__0)* + { after(grammarAccess.getAndExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__AndExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__0__Impl + rule__AndExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__1__Impl + rule__AndExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + (rule__AndExpression__OperatorAssignment_1_1) + { after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + (rule__AndExpression__RightAssignment_1_2) + { after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ImpliesExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group__0__Impl + rule__ImpliesExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + ruleRelationalExpression + { after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + (rule__ImpliesExpression__Group_1__0)* + { after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ImpliesExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__0__Impl + rule__ImpliesExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__1__Impl + rule__ImpliesExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + (rule__ImpliesExpression__OperatorAssignment_1_1) + { after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + (rule__ImpliesExpression__RightAssignment_1_2) + { after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelationalExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group__0__Impl + rule__RelationalExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + ruleAdditiveExpression + { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + (rule__RelationalExpression__Group_1__0)* + { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelationalExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__0__Impl + rule__RelationalExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__1__Impl + rule__RelationalExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } + (rule__RelationalExpression__OperatorAssignment_1_1) + { after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + (rule__RelationalExpression__RightAssignment_1_2) + { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +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 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group__1__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().getOperationCallParamsAction_1_0()); } + () + { after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group_1__1__Impl + rule__AdditiveExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + (rule__AdditiveExpression__NameAssignment_1_1) + { after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + (rule__AdditiveExpression__ParamsAssignment_1_2) + { after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MultiplicativeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group__0__Impl + rule__MultiplicativeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + ruleUnaryOrInfixExpression + { after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + (rule__MultiplicativeExpression__Group_1__0)* + { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MultiplicativeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__0__Impl + rule__MultiplicativeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } + () + { after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__1__Impl + rule__MultiplicativeExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } + (rule__MultiplicativeExpression__NameAssignment_1_1) + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + (rule__MultiplicativeExpression__ParamsAssignment_1_2) + { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__UnaryExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__UnaryExpression__Group__0__Impl + rule__UnaryExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + (rule__UnaryExpression__NameAssignment_0) + { after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__UnaryExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + (rule__UnaryExpression__ParamsAssignment_1) + { after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group__0__Impl + rule__InfixExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } + rulePrimaryExpression + { after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + (rule__InfixExpression__Alternatives_1)* + { after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__0__Impl + rule__InfixExpression__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__1__Impl + rule__InfixExpression__Group_1_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__2__Impl + rule__InfixExpression__Group_1_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } + (rule__InfixExpression__NameAssignment_1_0_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__3__Impl + rule__InfixExpression__Group_1_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__4__Impl + rule__InfixExpression__Group_1_0__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } + (rule__InfixExpression__Group_1_0_4__0)? + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4__0__Impl + rule__InfixExpression__Group_1_0_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } + (rule__InfixExpression__ParamsAssignment_1_0_4_0) + { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } + (rule__InfixExpression__Group_1_0_4_1__0)* + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0_4_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4_1__0__Impl + rule__InfixExpression__Group_1_0_4_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } + ',' + { after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } + (rule__InfixExpression__ParamsAssignment_1_0_4_1_1) + { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__0__Impl + rule__InfixExpression__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__1__Impl + rule__InfixExpression__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } + (rule__InfixExpression__TypeAssignment_1_1_2) + { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__0__Impl + rule__InfixExpression__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__1__Impl + rule__InfixExpression__Group_1_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__2__Impl + rule__InfixExpression__Group_1_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } + (rule__InfixExpression__NameAssignment_1_2_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__3__Impl + rule__InfixExpression__Group_1_2__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__4__Impl + rule__InfixExpression__Group_1_2__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } + (rule__InfixExpression__TypeAssignment_1_2_4) + { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__0__Impl + rule__InfixExpression__Group_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__1__Impl + rule__InfixExpression__Group_1_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__2__Impl + rule__InfixExpression__Group_1_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } + (rule__InfixExpression__NameAssignment_1_3_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__3__Impl + rule__InfixExpression__Group_1_3__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__4__Impl + rule__InfixExpression__Group_1_3__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } + (rule__InfixExpression__Group_1_3_4__0)? + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__5__Impl + rule__InfixExpression__Group_1_3__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } + (rule__InfixExpression__ExpAssignment_1_3_5) + { after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_3_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3_4__0__Impl + rule__InfixExpression__Group_1_3_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } + (rule__InfixExpression__VarAssignment_1_3_4_0) + { after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } + '|' + { after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParanthesizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__0__Impl + rule__ParanthesizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__1__Impl + rule__ParanthesizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } + ruleExpression + { after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalVarExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalVarExpression__Group__0__Impl + rule__GlobalVarExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } + 'GLOBALVAR' + { after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalVarExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } + (rule__GlobalVarExpression__NameAssignment_1) + { after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__0__Impl + rule__OperationCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } + (rule__OperationCall__NameAssignment_0) + { after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__1__Impl + rule__OperationCall__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__2__Impl + rule__OperationCall__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getGroup_2()); } + (rule__OperationCall__Group_2__0)? + { after(grammarAccess.getOperationCallAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2__0__Impl + rule__OperationCall__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } + (rule__OperationCall__ParamsAssignment_2_0) + { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getGroup_2_1()); } + (rule__OperationCall__Group_2_1__0)* + { after(grammarAccess.getOperationCallAccess().getGroup_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2_1__0__Impl + rule__OperationCall__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } + ',' + { after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } + (rule__OperationCall__ParamsAssignment_2_1_1) + { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__0__Impl + rule__ListLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } + () + { after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__1__Impl + rule__ListLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } + '{' + { after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__2__Impl + rule__ListLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getGroup_2()); } + (rule__ListLiteral__Group_2__0)? + { after(grammarAccess.getListLiteralAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } + '}' + { after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2__0__Impl + rule__ListLiteral__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } + (rule__ListLiteral__ElementsAssignment_2_0) + { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getGroup_2_1()); } + (rule__ListLiteral__Group_2_1__0)* + { after(grammarAccess.getListLiteralAccess().getGroup_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2_1__0__Impl + rule__ListLiteral__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } + ',' + { after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } + (rule__ListLiteral__ElementsAssignment_2_1_1) + { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ConstructorCallExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ConstructorCallExpression__Group__0__Impl + rule__ConstructorCallExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } + 'new' + { after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ConstructorCallExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } + (rule__ConstructorCallExpression__TypeAssignment_1) + { after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TypeSelectExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__0__Impl + rule__TypeSelectExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } + (rule__TypeSelectExpression__NameAssignment_0) + { after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__1__Impl + rule__TypeSelectExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__2__Impl + rule__TypeSelectExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } + (rule__TypeSelectExpression__TypeAssignment_2) + { after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__0__Impl + rule__CollectionExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } + (rule__CollectionExpression__NameAssignment_0) + { after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__1__Impl + rule__CollectionExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__2__Impl + rule__CollectionExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } + (rule__CollectionExpression__Group_2__0)? + { after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__3__Impl + rule__CollectionExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } + (rule__CollectionExpression__ExpAssignment_3) + { after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionExpression__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group_2__0__Impl + rule__CollectionExpression__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } + (rule__CollectionExpression__VarAssignment_2_0) + { after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } + '|' + { after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__0__Impl + rule__CollectionType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } + (rule__CollectionType__ClAssignment_0) + { after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__1__Impl + rule__CollectionType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } + '[' + { after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__2__Impl + rule__CollectionType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } + (rule__CollectionType__Id1Assignment_2) + { after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } + ']' + { after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SimpleType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group__0__Impl + rule__SimpleType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } + (rule__SimpleType__IdAssignment_0) + { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getGroup_1()); } + (rule__SimpleType__Group_1__0)* + { after(grammarAccess.getSimpleTypeAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SimpleType__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group_1__0__Impl + rule__SimpleType__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } + '::' + { after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } + (rule__SimpleType__IdAssignment_1_1) + { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__0__Impl + rule__XAssignment__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); } + () + { after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__1__Impl + rule__XAssignment__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); } + (rule__XAssignment__FeatureAssignment_0_1) + { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__2__Impl + rule__XAssignment__Group_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); } + ruleOpSingleAssign + { after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); } + (rule__XAssignment__ValueAssignment_0_3) + { after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1__0__Impl + rule__XAssignment__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); } + ruleXOrExpression + { after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); } + (rule__XAssignment__Group_1_1__0)? + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1__0__Impl + rule__XAssignment__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); } + (rule__XAssignment__Group_1_1_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); } + (rule__XAssignment__RightOperandAssignment_1_1_1) + { after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); } + (rule__XAssignment__Group_1_1_0_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0_0__0__Impl + rule__XAssignment__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); } + (rule__XAssignment__FeatureAssignment_1_1_0_0_1) + { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpMultiAssign__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__0__Impl + rule__OpMultiAssign__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); } + '<' + { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__1__Impl + rule__OpMultiAssign__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); } + '<' + { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); } + '=' + { after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpMultiAssign__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__0__Impl + rule__OpMultiAssign__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); } + '>' + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__1__Impl + rule__OpMultiAssign__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); } + ('>')? + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); } + '>=' + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group__0__Impl + rule__XOrExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); } + ruleXAndExpression + { after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1()); } + (rule__XOrExpression__Group_1__0)* + { after(grammarAccess.getXOrExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1__0__Impl + rule__XOrExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); } + (rule__XOrExpression__Group_1_0__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XOrExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); } + (rule__XOrExpression__Group_1_0_0__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0_0__0__Impl + rule__XOrExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XOrExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group__0__Impl + rule__XAndExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); } + ruleXEqualityExpression + { after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1()); } + (rule__XAndExpression__Group_1__0)* + { after(grammarAccess.getXAndExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1__0__Impl + rule__XAndExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); } + (rule__XAndExpression__Group_1_0__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XAndExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); } + (rule__XAndExpression__Group_1_0_0__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0_0__0__Impl + rule__XAndExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XAndExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group__0__Impl + rule__XEqualityExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); } + ruleXRelationalExpression + { after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); } + (rule__XEqualityExpression__Group_1__0)* + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1__0__Impl + rule__XEqualityExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); } + (rule__XEqualityExpression__Group_1_0__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XEqualityExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); } + (rule__XEqualityExpression__Group_1_0_0__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0_0__0__Impl + rule__XEqualityExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XEqualityExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group__0__Impl + rule__XRelationalExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); } + ruleXOtherOperatorExpression + { after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); } + (rule__XRelationalExpression__Alternatives_1)* + { after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0__0__Impl + rule__XRelationalExpression__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); } + (rule__XRelationalExpression__Group_1_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); } + (rule__XRelationalExpression__TypeAssignment_1_0_1) + { after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); } + (rule__XRelationalExpression__Group_1_0_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0_0__0__Impl + rule__XRelationalExpression__Group_1_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); } + () + { after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); } + 'instanceof' + { after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1__0__Impl + rule__XRelationalExpression__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); } + (rule__XRelationalExpression__Group_1_1_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); } + (rule__XRelationalExpression__RightOperandAssignment_1_1_1) + { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); } + (rule__XRelationalExpression__Group_1_1_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0_0__0__Impl + rule__XRelationalExpression__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); } + (rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1) + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpCompare__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpCompare__Group_1__0__Impl + rule__OpCompare__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); } + '<' + { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpCompare__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); } + '=' + { after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group__0__Impl + rule__XOtherOperatorExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); } + ruleXAdditiveExpression + { after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); } + (rule__XOtherOperatorExpression__Group_1__0)* + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1__0__Impl + rule__XOtherOperatorExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); } + (rule__XOtherOperatorExpression__Group_1_0__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XOtherOperatorExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); } + (rule__XOtherOperatorExpression__Group_1_0_0__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0_0__0__Impl + rule__XOtherOperatorExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_2__0__Impl + rule__OpOther__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); } + '..' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5__0__Impl + rule__OpOther__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); } + (rule__OpOther__Alternatives_5_1) + { after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); } + (rule__OpOther__Group_5_1_0_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0_0__0__Impl + rule__OpOther__Group_5_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6__0__Impl + rule__OpOther__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); } + (rule__OpOther__Alternatives_6_1) + { after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); } + (rule__OpOther__Group_6_1_0_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0_0__0__Impl + rule__OpOther__Group_6_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group__0__Impl + rule__XAdditiveExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); } + ruleXMultiplicativeExpression + { after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); } + (rule__XAdditiveExpression__Group_1__0)* + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1__0__Impl + rule__XAdditiveExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); } + (rule__XAdditiveExpression__Group_1_0__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XAdditiveExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); } + (rule__XAdditiveExpression__Group_1_0_0__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0_0__0__Impl + rule__XAdditiveExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XAdditiveExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group__0__Impl + rule__XMultiplicativeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); } + (rule__XMultiplicativeExpression__Group_1__0)* + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1__0__Impl + rule__XMultiplicativeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); } + (rule__XMultiplicativeExpression__Group_1_0__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XMultiplicativeExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); } + (rule__XMultiplicativeExpression__Group_1_0_0__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0_0__0__Impl + rule__XMultiplicativeExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XUnaryOperation__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__0__Impl + rule__XUnaryOperation__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); } + () + { after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__1__Impl + rule__XUnaryOperation__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); } + (rule__XUnaryOperation__FeatureAssignment_0_1) + { after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); } + (rule__XUnaryOperation__OperandAssignment_0_2) + { after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group__0__Impl + rule__XCastedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); } + ruleXPostfixOperation + { after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); } + (rule__XCastedExpression__Group_1__0)* + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1__0__Impl + rule__XCastedExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); } + (rule__XCastedExpression__Group_1_0__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); } + (rule__XCastedExpression__TypeAssignment_1_1) + { after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); } + (rule__XCastedExpression__Group_1_0_0__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0_0__0__Impl + rule__XCastedExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); } + () + { after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); } + 'as' + { after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group__0__Impl + rule__XPostfixOperation__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); } + ruleXMemberFeatureCall + { after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); } + (rule__XPostfixOperation__Group_1__0)? + { after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); } + (rule__XPostfixOperation__Group_1_0__0) + { after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1_0__0__Impl + rule__XPostfixOperation__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); } + () + { after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); } + (rule__XPostfixOperation__FeatureAssignment_1_0_1) + { after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group__0__Impl + rule__XMemberFeatureCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); } + ruleXPrimaryExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); } + (rule__XMemberFeatureCall__Alternatives_1)* + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0__0__Impl + rule__XMemberFeatureCall__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); } + (rule__XMemberFeatureCall__Group_1_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); } + (rule__XMemberFeatureCall__ValueAssignment_1_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); } + (rule__XMemberFeatureCall__Group_1_0_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); } + () + { after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); } + (rule__XMemberFeatureCall__Alternatives_1_0_0_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); } + (rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); } + ruleOpSingleAssign + { after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); } + (rule__XMemberFeatureCall__Group_1_1_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__1__Impl + rule__XMemberFeatureCall__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_1__0)? + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__2__Impl + rule__XMemberFeatureCall__Group_1_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); } + (rule__XMemberFeatureCall__FeatureAssignment_1_1_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__3__Impl + rule__XMemberFeatureCall__Group_1_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); } + (rule__XMemberFeatureCall__Group_1_1_3__0)? + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4)? + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); } + (rule__XMemberFeatureCall__Group_1_1_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl + rule__XMemberFeatureCall__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); } + (rule__XMemberFeatureCall__Alternatives_1_1_0_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); } + '<' + { after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__1__Impl + rule__XMemberFeatureCall__Group_1_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); } + (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__2__Impl + rule__XMemberFeatureCall__Group_1_1_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); } + (rule__XMemberFeatureCall__Group_1_1_1_2__0)* + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); } + '>' + { after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl + rule__XMemberFeatureCall__Group_1_1_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); } + ',' + { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); } + (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__0__Impl + rule__XMemberFeatureCall__Group_1_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); } + (rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__1__Impl + rule__XMemberFeatureCall__Group_1_1_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); } + (rule__XMemberFeatureCall__Alternatives_1_1_3_1)? + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); } + ')' + { after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_3_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0)* + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); } + ',' + { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__0__Impl + rule__XSetLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); } + () + { after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__1__Impl + rule__XSetLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); } + '#' + { after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__2__Impl + rule__XSetLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); } + '{' + { after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__3__Impl + rule__XSetLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getGroup_3()); } + (rule__XSetLiteral__Group_3__0)? + { after(grammarAccess.getXSetLiteralAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); } + '}' + { after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3__0__Impl + rule__XSetLiteral__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); } + (rule__XSetLiteral__ElementsAssignment_3_0) + { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); } + (rule__XSetLiteral__Group_3_1__0)* + { after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3_1__0__Impl + rule__XSetLiteral__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); } + (rule__XSetLiteral__ElementsAssignment_3_1_1) + { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__0__Impl + rule__XListLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); } + () + { after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__1__Impl + rule__XListLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); } + '#' + { after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__2__Impl + rule__XListLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); } + '[' + { after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__3__Impl + rule__XListLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getGroup_3()); } + (rule__XListLiteral__Group_3__0)? + { after(grammarAccess.getXListLiteralAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); } + ']' + { after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3__0__Impl + rule__XListLiteral__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); } + (rule__XListLiteral__ElementsAssignment_3_0) + { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); } + (rule__XListLiteral__Group_3_1__0)* + { after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3_1__0__Impl + rule__XListLiteral__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); } + (rule__XListLiteral__ElementsAssignment_3_1_1) + { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__0__Impl + rule__XClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_0()); } + (rule__XClosure__Group_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__1__Impl + rule__XClosure__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1()); } + (rule__XClosure__Group_1__0)? + { after(grammarAccess.getXClosureAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__2__Impl + rule__XClosure__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); } + (rule__XClosure__ExpressionAssignment_2) + { after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); } + ']' + { after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_0_0()); } + (rule__XClosure__Group_0_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0_0__0__Impl + rule__XClosure__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); } + () + { after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); } + '[' + { after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0()); } + (rule__XClosure__Group_1_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0__0__Impl + rule__XClosure__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); } + (rule__XClosure__Group_1_0_0__0)? + { after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); } + (rule__XClosure__ExplicitSyntaxAssignment_1_0_1) + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0__0__Impl + rule__XClosure__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); } + (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0) + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); } + (rule__XClosure__Group_1_0_0_1__0)* + { after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0_1__0__Impl + rule__XClosure__Group_1_0_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); } + ',' + { after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); } + (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1) + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XExpressionInClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group__0__Impl + rule__XExpressionInClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); } + () + { after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); } + (rule__XExpressionInClosure__Group_1__0)* + { after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XExpressionInClosure__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group_1__0__Impl + rule__XExpressionInClosure__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); } + (rule__XExpressionInClosure__ExpressionsAssignment_1_0) + { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); } + (';')? + { after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group__0__Impl + rule__XShortClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0()); } + (rule__XShortClosure__Group_0__0) + { after(grammarAccess.getXShortClosureAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); } + (rule__XShortClosure__ExpressionAssignment_1) + { after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); } + (rule__XShortClosure__Group_0_0__0) + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__0__Impl + rule__XShortClosure__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); } + () + { after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__1__Impl + rule__XShortClosure__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); } + (rule__XShortClosure__Group_0_0_1__0)? + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); } + (rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2) + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1__0__Impl + rule__XShortClosure__Group_0_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); } + (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0) + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); } + (rule__XShortClosure__Group_0_0_1_1__0)* + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1_1__0__Impl + rule__XShortClosure__Group_0_0_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); } + ',' + { after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); } + (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1) + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XParenthesizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__0__Impl + rule__XParenthesizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__1__Impl + rule__XParenthesizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); } + ruleXExpression + { after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XIfExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__0__Impl + rule__XIfExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); } + () + { after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__1__Impl + rule__XIfExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); } + 'if' + { after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__2__Impl + rule__XIfExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__3__Impl + rule__XIfExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); } + (rule__XIfExpression__IfAssignment_3) + { after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__4__Impl + rule__XIfExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__5__Impl + rule__XIfExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); } + (rule__XIfExpression__ThenAssignment_5) + { after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getGroup_6()); } + (rule__XIfExpression__Group_6__0)? + { after(grammarAccess.getXIfExpressionAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XIfExpression__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group_6__0__Impl + rule__XIfExpression__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); } + ('else') + { after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); } + (rule__XIfExpression__ElseAssignment_6_1) + { after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__0__Impl + rule__XSwitchExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); } + () + { after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__1__Impl + rule__XSwitchExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); } + 'switch' + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__2__Impl + rule__XSwitchExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); } + (rule__XSwitchExpression__Alternatives_2) + { after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__3__Impl + rule__XSwitchExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); } + '{' + { after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__4__Impl + rule__XSwitchExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); } + (rule__XSwitchExpression__CasesAssignment_4)* + { after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__5__Impl + rule__XSwitchExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); } + (rule__XSwitchExpression__Group_5__0)? + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); } + '}' + { after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__0__Impl + rule__XSwitchExpression__Group_2_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); } + (rule__XSwitchExpression__Group_2_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__1__Impl + rule__XSwitchExpression__Group_2_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); } + (rule__XSwitchExpression__SwitchAssignment_2_0_1) + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); } + ')' + { after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); } + (rule__XSwitchExpression__Group_2_0_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__0__Impl + rule__XSwitchExpression__Group_2_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); } + '(' + { after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__1__Impl + rule__XSwitchExpression__Group_2_0_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); } + (rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1) + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1__0__Impl + rule__XSwitchExpression__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); } + (rule__XSwitchExpression__Group_2_1_0__0)? + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); } + (rule__XSwitchExpression__SwitchAssignment_2_1_1) + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); } + (rule__XSwitchExpression__Group_2_1_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0_0__0__Impl + rule__XSwitchExpression__Group_2_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); } + (rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0) + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__0__Impl + rule__XSwitchExpression__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); } + 'default' + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__1__Impl + rule__XSwitchExpression__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); } + (rule__XSwitchExpression__DefaultAssignment_5_2) + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__0__Impl + rule__XCasePart__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); } + () + { after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__1__Impl + rule__XCasePart__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); } + (rule__XCasePart__TypeGuardAssignment_1)? + { after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__2__Impl + rule__XCasePart__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getGroup_2()); } + (rule__XCasePart__Group_2__0)? + { after(grammarAccess.getXCasePartAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getAlternatives_3()); } + (rule__XCasePart__Alternatives_3) + { after(grammarAccess.getXCasePartAccess().getAlternatives_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_2__0__Impl + rule__XCasePart__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); } + 'case' + { after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); } + (rule__XCasePart__CaseAssignment_2_1) + { after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group_3_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_3_0__0__Impl + rule__XCasePart__Group_3_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_3_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); } + ':' + { after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_3_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group_3_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group_3_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); } + (rule__XCasePart__ThenAssignment_3_0_1) + { after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XForLoopExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__0__Impl + rule__XForLoopExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); } + (rule__XForLoopExpression__Group_0__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__1__Impl + rule__XForLoopExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); } + (rule__XForLoopExpression__ForExpressionAssignment_1) + { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__2__Impl + rule__XForLoopExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); } + (rule__XForLoopExpression__EachExpressionAssignment_3) + { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XForLoopExpression__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); } + (rule__XForLoopExpression__Group_0_0__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XForLoopExpression__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__0__Impl + rule__XForLoopExpression__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); } + () + { after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__1__Impl + rule__XForLoopExpression__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); } + 'for' + { after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__2__Impl + rule__XForLoopExpression__Group_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } + '(' + { after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__3__Impl + rule__XForLoopExpression__Group_0_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); } + (rule__XForLoopExpression__DeclaredParamAssignment_0_0_3) + { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XForLoopExpression__Group_0_0__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XForLoopExpression__Group_0_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); } + ':' + { after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__0__Impl + rule__XBasicForLoopExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); } + () + { after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__1__Impl + rule__XBasicForLoopExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); } + 'for' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__2__Impl + rule__XBasicForLoopExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__3__Impl + rule__XBasicForLoopExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); } + (rule__XBasicForLoopExpression__Group_3__0)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__4__Impl + rule__XBasicForLoopExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); } + ';' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__5__Impl + rule__XBasicForLoopExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); } + (rule__XBasicForLoopExpression__ExpressionAssignment_5)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__6__Impl + rule__XBasicForLoopExpression__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); } + ';' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__7__Impl + rule__XBasicForLoopExpression__Group__8 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); } + (rule__XBasicForLoopExpression__Group_7__0)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__8 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__8__Impl + rule__XBasicForLoopExpression__Group__9 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__8__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); } + ')' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__9 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group__9__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group__9__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); } + (rule__XBasicForLoopExpression__EachExpressionAssignment_9) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3__0__Impl + rule__XBasicForLoopExpression__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); } + (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); } + (rule__XBasicForLoopExpression__Group_3_1__0)* + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3_1__0__Impl + rule__XBasicForLoopExpression__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); } + (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_7__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7__0__Impl + rule__XBasicForLoopExpression__Group_7__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); } + (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); } + (rule__XBasicForLoopExpression__Group_7_1__0)* + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBasicForLoopExpression__Group_7_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7_1__0__Impl + rule__XBasicForLoopExpression__Group_7_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); } + ',' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBasicForLoopExpression__Group_7_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBasicForLoopExpression__Group_7_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); } + (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XWhileExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__0__Impl + rule__XWhileExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); } + () + { after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__1__Impl + rule__XWhileExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); } + 'while' + { after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__2__Impl + rule__XWhileExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__3__Impl + rule__XWhileExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); } + (rule__XWhileExpression__PredicateAssignment_3) + { after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__4__Impl + rule__XWhileExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XWhileExpression__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XWhileExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); } + (rule__XWhileExpression__BodyAssignment_5) + { after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XDoWhileExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__0__Impl + rule__XDoWhileExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); } + () + { after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__1__Impl + rule__XDoWhileExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); } + 'do' + { after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__2__Impl + rule__XDoWhileExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); } + (rule__XDoWhileExpression__BodyAssignment_2) + { after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__3__Impl + rule__XDoWhileExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); } + 'while' + { after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__4__Impl + rule__XDoWhileExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); } + '(' + { after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__5__Impl + rule__XDoWhileExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); } + (rule__XDoWhileExpression__PredicateAssignment_5) + { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XDoWhileExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XDoWhileExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); } + ')' + { after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBlockExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBlockExpression__Group__0__Impl + rule__XBlockExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); } + () + { after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBlockExpression__Group__1__Impl + rule__XBlockExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); } + '{' + { after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBlockExpression__Group__2__Impl + rule__XBlockExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); } + (rule__XBlockExpression__Group_2__0)* + { after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBlockExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); } + '}' + { after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBlockExpression__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBlockExpression__Group_2__0__Impl + rule__XBlockExpression__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); } + (rule__XBlockExpression__ExpressionsAssignment_2_0) + { after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBlockExpression__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBlockExpression__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); } + (';')? + { after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XVariableDeclaration__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group__0__Impl + rule__XVariableDeclaration__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); } + () + { after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group__1__Impl + rule__XVariableDeclaration__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); } + (rule__XVariableDeclaration__Alternatives_1) + { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group__2__Impl + rule__XVariableDeclaration__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); } + (rule__XVariableDeclaration__Alternatives_2) + { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); } + (rule__XVariableDeclaration__Group_3__0)? + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XVariableDeclaration__Group_2_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group_2_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_2_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); } + (rule__XVariableDeclaration__Group_2_0_0__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XVariableDeclaration__Group_2_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group_2_0_0__0__Impl + rule__XVariableDeclaration__Group_2_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_2_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); } + (rule__XVariableDeclaration__TypeAssignment_2_0_0_0) + { after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_2_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group_2_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_2_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); } + (rule__XVariableDeclaration__NameAssignment_2_0_0_1) + { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XVariableDeclaration__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group_3__0__Impl + rule__XVariableDeclaration__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); } + '=' + { after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XVariableDeclaration__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); } + (rule__XVariableDeclaration__RightAssignment_3_1) + { after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__JvmFormalParameter__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__JvmFormalParameter__Group__0__Impl + rule__JvmFormalParameter__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmFormalParameter__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); } + (rule__JvmFormalParameter__ParameterTypeAssignment_0)? + { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmFormalParameter__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__JvmFormalParameter__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmFormalParameter__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); } + (rule__JvmFormalParameter__NameAssignment_1) + { after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__FullJvmFormalParameter__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__FullJvmFormalParameter__Group__0__Impl + rule__FullJvmFormalParameter__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__FullJvmFormalParameter__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); } + (rule__FullJvmFormalParameter__ParameterTypeAssignment_0) + { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__FullJvmFormalParameter__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__FullJvmFormalParameter__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__FullJvmFormalParameter__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); } + (rule__FullJvmFormalParameter__NameAssignment_1) + { after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XFeatureCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group__0__Impl + rule__XFeatureCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); } + () + { after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group__1__Impl + rule__XFeatureCall__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getGroup_1()); } + (rule__XFeatureCall__Group_1__0)? + { after(grammarAccess.getXFeatureCallAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group__2__Impl + rule__XFeatureCall__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); } + (rule__XFeatureCall__FeatureAssignment_2) + { after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group__3__Impl + rule__XFeatureCall__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getGroup_3()); } + (rule__XFeatureCall__Group_3__0)? + { after(grammarAccess.getXFeatureCallAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_4)? + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XFeatureCall__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_1__0__Impl + rule__XFeatureCall__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); } + '<' + { after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_1__1__Impl + rule__XFeatureCall__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); } + (rule__XFeatureCall__TypeArgumentsAssignment_1_1) + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_1__2__Impl + rule__XFeatureCall__Group_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); } + (rule__XFeatureCall__Group_1_2__0)* + { after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); } + '>' + { after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XFeatureCall__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_1_2__0__Impl + rule__XFeatureCall__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); } + ',' + { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_1_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); } + (rule__XFeatureCall__TypeArgumentsAssignment_1_2_1) + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XFeatureCall__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3__0__Impl + rule__XFeatureCall__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); } + (rule__XFeatureCall__ExplicitOperationCallAssignment_3_0) + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3__1__Impl + rule__XFeatureCall__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); } + (rule__XFeatureCall__Alternatives_3_1)? + { after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); } + ')' + { after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XFeatureCall__Group_3_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3_1_1__0__Impl + rule__XFeatureCall__Group_3_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); } + (rule__XFeatureCall__Group_3_1_1_1__0)* + { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XFeatureCall__Group_3_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3_1_1_1__0__Impl + rule__XFeatureCall__Group_3_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); } + ',' + { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XFeatureCall__Group_3_1_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Group_3_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XConstructorCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group__0__Impl + rule__XConstructorCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); } + () + { after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group__1__Impl + rule__XConstructorCall__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); } + 'new' + { after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group__2__Impl + rule__XConstructorCall__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); } + (rule__XConstructorCall__ConstructorAssignment_2) + { after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group__3__Impl + rule__XConstructorCall__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getGroup_3()); } + (rule__XConstructorCall__Group_3__0)? + { after(grammarAccess.getXConstructorCallAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group__4__Impl + rule__XConstructorCall__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getGroup_4()); } + (rule__XConstructorCall__Group_4__0)? + { after(grammarAccess.getXConstructorCallAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); } + (rule__XConstructorCall__ArgumentsAssignment_5)? + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XConstructorCall__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_3__0__Impl + rule__XConstructorCall__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); } + ('<') + { after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_3__1__Impl + rule__XConstructorCall__Group_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); } + (rule__XConstructorCall__TypeArgumentsAssignment_3_1) + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_3__2__Impl + rule__XConstructorCall__Group_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); } + (rule__XConstructorCall__Group_3_2__0)* + { after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_3__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); } + '>' + { after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XConstructorCall__Group_3_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_3_2__0__Impl + rule__XConstructorCall__Group_3_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); } + ',' + { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_3_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_3_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); } + (rule__XConstructorCall__TypeArgumentsAssignment_3_2_1) + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XConstructorCall__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4__0__Impl + rule__XConstructorCall__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); } + (rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0) + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4__1__Impl + rule__XConstructorCall__Group_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); } + (rule__XConstructorCall__Alternatives_4_1)? + { after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); } + ')' + { after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XConstructorCall__Group_4_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4_1_1__0__Impl + rule__XConstructorCall__Group_4_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_1_0) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); } + (rule__XConstructorCall__Group_4_1_1_1__0)* + { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XConstructorCall__Group_4_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4_1_1_1__0__Impl + rule__XConstructorCall__Group_4_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); } + ',' + { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XConstructorCall__Group_4_1_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Group_4_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XBooleanLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBooleanLiteral__Group__0__Impl + rule__XBooleanLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XBooleanLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); } + () + { after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBooleanLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XBooleanLiteral__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XBooleanLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); } + (rule__XBooleanLiteral__Alternatives_1) + { after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XNullLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XNullLiteral__Group__0__Impl + rule__XNullLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XNullLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); } + () + { after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XNullLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XNullLiteral__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XNullLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); } + 'null' + { after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XNumberLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XNumberLiteral__Group__0__Impl + rule__XNumberLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XNumberLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); } + () + { after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XNumberLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XNumberLiteral__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XNumberLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); } + (rule__XNumberLiteral__ValueAssignment_1) + { after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XStringLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XStringLiteral__Group__0__Impl + rule__XStringLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XStringLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); } + () + { after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XStringLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XStringLiteral__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XStringLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); } + (rule__XStringLiteral__ValueAssignment_1) + { after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XTypeLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTypeLiteral__Group__0__Impl + rule__XTypeLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); } + () + { after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTypeLiteral__Group__1__Impl + rule__XTypeLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); } + 'typeof' + { after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTypeLiteral__Group__2__Impl + rule__XTypeLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTypeLiteral__Group__3__Impl + rule__XTypeLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); } + (rule__XTypeLiteral__TypeAssignment_3) + { after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTypeLiteral__Group__4__Impl + rule__XTypeLiteral__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); } + (rule__XTypeLiteral__ArrayDimensionsAssignment_4)* + { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTypeLiteral__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XTypeLiteral__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); } + ')' + { after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XThrowExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XThrowExpression__Group__0__Impl + rule__XThrowExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XThrowExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); } + () + { after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XThrowExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XThrowExpression__Group__1__Impl + rule__XThrowExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XThrowExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); } + 'throw' + { after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XThrowExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XThrowExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XThrowExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); } + (rule__XThrowExpression__ExpressionAssignment_2) + { after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XReturnExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XReturnExpression__Group__0__Impl + rule__XReturnExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XReturnExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); } + () + { after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XReturnExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XReturnExpression__Group__1__Impl + rule__XReturnExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XReturnExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); } + 'return' + { after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XReturnExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XReturnExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XReturnExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); } + (rule__XReturnExpression__ExpressionAssignment_2)? + { after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XTryCatchFinallyExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group__0__Impl + rule__XTryCatchFinallyExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); } + () + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group__1__Impl + rule__XTryCatchFinallyExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); } + 'try' + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group__2__Impl + rule__XTryCatchFinallyExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); } + (rule__XTryCatchFinallyExpression__ExpressionAssignment_2) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); } + (rule__XTryCatchFinallyExpression__Alternatives_3) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XTryCatchFinallyExpression__Group_3_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group_3_0__0__Impl + rule__XTryCatchFinallyExpression__Group_3_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + ) + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)* + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + ) +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group_3_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); } + (rule__XTryCatchFinallyExpression__Group_3_0_1__0)? + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XTryCatchFinallyExpression__Group_3_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl + rule__XTryCatchFinallyExpression__Group_3_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); } + ('finally') + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); } + (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XTryCatchFinallyExpression__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group_3_1__0__Impl + rule__XTryCatchFinallyExpression__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); } + 'finally' + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XTryCatchFinallyExpression__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); } + (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSynchronizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSynchronizedExpression__Group__0__Impl + rule__XSynchronizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); } + (rule__XSynchronizedExpression__Group_0__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSynchronizedExpression__Group__1__Impl + rule__XSynchronizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); } + (rule__XSynchronizedExpression__ParamAssignment_1) + { after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSynchronizedExpression__Group__2__Impl + rule__XSynchronizedExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group__3 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } - ruleLiteral - { after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } - ruleFeatureCall - { after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } - ruleListLiteral - { after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } - ruleConstructorCallExpression - { after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } - ruleGlobalVarExpression - { after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } - ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } - ruleParanthesizedExpression - { after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } - ) + rule__XSynchronizedExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Literal__Alternatives +rule__XSynchronizedExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } - ruleBooleanLiteral - { after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } - ruleIntegerLiteral - { after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } - ruleNullLiteral - { after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } - ruleRealLiteral - { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } - ruleStringLiteral - { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } - ) +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); } + (rule__XSynchronizedExpression__ExpressionAssignment_3) + { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); } +) ; finally { restoreStackSize(stackSize); } -rule__BooleanLiteral__ValAlternatives_0 + +rule__XSynchronizedExpression__Group_0__0 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } - 'true' - { after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } - ) - | - ( - { before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } - 'false' - { after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } - ) + rule__XSynchronizedExpression__Group_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__FeatureCall__Alternatives +rule__XSynchronizedExpression__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } - ruleOperationCall - { after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } - (rule__FeatureCall__TypeAssignment_1) - { after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } - ) - | - ( - { before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } - ruleCollectionExpression - { after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } - ) - | - ( - { before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } - ruleTypeSelectExpression - { after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } - ) +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); } + (rule__XSynchronizedExpression__Group_0_0__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); } +) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__NameAlternatives_0_0 + +rule__XSynchronizedExpression__Group_0_0__0 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } - 'collect' - { after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } - 'select' - { after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } - 'selectFirst' - { after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } - 'reject' - { after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } - 'exists' - { after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } - 'notExists' - { after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } - 'sortBy' - { after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } - 'forAll' - { after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } - ) + rule__XSynchronizedExpression__Group_0_0__0__Impl + rule__XSynchronizedExpression__Group_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__Type__Alternatives +rule__XSynchronizedExpression__Group_0_0__0__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } - ruleCollectionType - { after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } - ruleSimpleType - { after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } - ) +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); } + () + { after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); } +) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__ClAlternatives_0_0 +rule__XSynchronizedExpression__Group_0_0__1 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } - 'Collection' - { after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } - ) - | - ( - { before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } - 'List' - { after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } - ) - | - ( - { before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } - 'Set' - { after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } - ) + rule__XSynchronizedExpression__Group_0_0__1__Impl + rule__XSynchronizedExpression__Group_0_0__2 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__0 +rule__XSynchronizedExpression__Group_0_0__1__Impl @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__0__Impl - rule__LetExpression__Group__1 +( + { before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); } + 'synchronized' + { after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); } +) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__0__Impl +rule__XSynchronizedExpression__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSynchronizedExpression__Group_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSynchronizedExpression__Group_0_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } - 'let' - { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } + '(' + { after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__1 + +rule__XCatchClause__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__1__Impl - rule__LetExpression__Group__2 + rule__XCatchClause__Group__0__Impl + rule__XCatchClause__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__1__Impl +rule__XCatchClause__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } - (rule__LetExpression__IdentifierAssignment_1) - { after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + { before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); } + ('catch') + { after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__2 +rule__XCatchClause__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__2__Impl - rule__LetExpression__Group__3 + rule__XCatchClause__Group__1__Impl + rule__XCatchClause__Group__2 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__2__Impl +rule__XCatchClause__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } - '=' - { after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } + { before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__3 +rule__XCatchClause__Group__2 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__3__Impl - rule__LetExpression__Group__4 + rule__XCatchClause__Group__2__Impl + rule__XCatchClause__Group__3 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__3__Impl +rule__XCatchClause__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } - (rule__LetExpression__VarExprAssignment_3) - { after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } + { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); } + (rule__XCatchClause__DeclaredParamAssignment_2) + { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__4 +rule__XCatchClause__Group__3 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__4__Impl - rule__LetExpression__Group__5 + rule__XCatchClause__Group__3__Impl + rule__XCatchClause__Group__4 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__4__Impl +rule__XCatchClause__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } - ':' - { after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } + { before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__5 +rule__XCatchClause__Group__4 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__5__Impl + rule__XCatchClause__Group__4__Impl ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__5__Impl +rule__XCatchClause__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } - (rule__LetExpression__TargetAssignment_5) - { after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } + { before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); } + (rule__XCatchClause__ExpressionAssignment_4) + { after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); } ) ; finally { @@ -1653,107 +18154,107 @@ finally { } -rule__CastedExpression__Group__0 +rule__QualifiedName__Group__0 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__0__Impl - rule__CastedExpression__Group__1 + rule__QualifiedName__Group__0__Impl + rule__QualifiedName__Group__1 ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__0__Impl +rule__QualifiedName__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } - '(' - { after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } + { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__1 +rule__QualifiedName__Group__1 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__1__Impl - rule__CastedExpression__Group__2 + rule__QualifiedName__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__1__Impl +rule__QualifiedName__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } - (rule__CastedExpression__TypeAssignment_1) - { after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } + { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } + (rule__QualifiedName__Group_1__0)* + { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__2 + +rule__QualifiedName__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__2__Impl - rule__CastedExpression__Group__3 + rule__QualifiedName__Group_1__0__Impl + rule__QualifiedName__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__2__Impl +rule__QualifiedName__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } - ')' - { after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } + { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } + ('.') + { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__3 +rule__QualifiedName__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__3__Impl + rule__QualifiedName__Group_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__3__Impl +rule__QualifiedName__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } - (rule__CastedExpression__TargetAssignment_3) - { after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } + { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); } + ruleValidID + { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); } ) ; finally { @@ -1761,53 +18262,53 @@ finally { } -rule__ChainExpression__Group__0 +rule__Number__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group__0__Impl - rule__ChainExpression__Group__1 + rule__Number__Group_1__0__Impl + rule__Number__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__0__Impl +rule__Number__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } - ruleChainedExpression - { after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } + { before(grammarAccess.getNumberAccess().getAlternatives_1_0()); } + (rule__Number__Alternatives_1_0) + { after(grammarAccess.getNumberAccess().getAlternatives_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__1 +rule__Number__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group__1__Impl + rule__Number__Group_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__1__Impl +rule__Number__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getGroup_1()); } - (rule__ChainExpression__Group_1__0)* - { after(grammarAccess.getChainExpressionAccess().getGroup_1()); } + { before(grammarAccess.getNumberAccess().getGroup_1_1()); } + (rule__Number__Group_1_1__0)? + { after(grammarAccess.getNumberAccess().getGroup_1_1()); } ) ; finally { @@ -1815,134 +18316,134 @@ finally { } -rule__ChainExpression__Group_1__0 +rule__Number__Group_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__0__Impl - rule__ChainExpression__Group_1__1 + rule__Number__Group_1_1__0__Impl + rule__Number__Group_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__0__Impl +rule__Number__Group_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } - () - { after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } + { before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); } + '.' + { after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__1 +rule__Number__Group_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__1__Impl - rule__ChainExpression__Group_1__2 + rule__Number__Group_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__1__Impl +rule__Number__Group_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } - '->' - { after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } + { before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); } + (rule__Number__Alternatives_1_1_1) + { after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__2 + +rule__JvmTypeReference__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__2__Impl + rule__JvmTypeReference__Group_0__0__Impl + rule__JvmTypeReference__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__2__Impl +rule__JvmTypeReference__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } - (rule__ChainExpression__NextAssignment_1_2) - { after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); } + ruleJvmParameterizedTypeReference + { after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__IfExpressionTri__Group__0 +rule__JvmTypeReference__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group__0__Impl - rule__IfExpressionTri__Group__1 + rule__JvmTypeReference__Group_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__0__Impl +rule__JvmTypeReference__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } - ruleOrExpression - { after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); } + (rule__JvmTypeReference__Group_0_1__0)* + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__1 + +rule__JvmTypeReference__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group__1__Impl + rule__JvmTypeReference__Group_0_1__0__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__1__Impl +rule__JvmTypeReference__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } - (rule__IfExpressionTri__Group_1__0)? - { after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); } + (rule__JvmTypeReference__Group_0_1_0__0) + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); } ) ; finally { @@ -1950,269 +18451,269 @@ finally { } -rule__IfExpressionTri__Group_1__0 +rule__JvmTypeReference__Group_0_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__0__Impl - rule__IfExpressionTri__Group_1__1 + rule__JvmTypeReference__Group_0_1_0__0__Impl + rule__JvmTypeReference__Group_0_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__0__Impl +rule__JvmTypeReference__Group_0_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); } () - { after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + { after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__1 +rule__JvmTypeReference__Group_0_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__1__Impl - rule__IfExpressionTri__Group_1__2 + rule__JvmTypeReference__Group_0_1_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__1__Impl +rule__JvmTypeReference__Group_0_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } - '?' - { after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); } + ruleArrayBrackets + { after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__2 + +rule__ArrayBrackets__Group__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__2__Impl - rule__IfExpressionTri__Group_1__3 + rule__ArrayBrackets__Group__0__Impl + rule__ArrayBrackets__Group__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__2__Impl +rule__ArrayBrackets__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } - (rule__IfExpressionTri__ThenPartAssignment_1_2) - { after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } + { before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); } + '[' + { after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__3 +rule__ArrayBrackets__Group__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__3__Impl - rule__IfExpressionTri__Group_1__4 + rule__ArrayBrackets__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__3__Impl +rule__ArrayBrackets__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } - ':' - { after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } + { before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); } + ']' + { after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__4 + +rule__XFunctionTypeRef__Group__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__4__Impl + rule__XFunctionTypeRef__Group__0__Impl + rule__XFunctionTypeRef__Group__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__4__Impl +rule__XFunctionTypeRef__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } - (rule__IfExpressionTri__ElsePartAssignment_1_4) - { after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); } + (rule__XFunctionTypeRef__Group_0__0)? + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__IfExpressionKw__Group__0 +rule__XFunctionTypeRef__Group__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__0__Impl - rule__IfExpressionKw__Group__1 + rule__XFunctionTypeRef__Group__1__Impl + rule__XFunctionTypeRef__Group__2 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__0__Impl +rule__XFunctionTypeRef__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } - 'if' - { after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); } + '=>' + { after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__1 +rule__XFunctionTypeRef__Group__2 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__1__Impl - rule__IfExpressionKw__Group__2 + rule__XFunctionTypeRef__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__1__Impl +rule__XFunctionTypeRef__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } - (rule__IfExpressionKw__ConditionAssignment_1) - { after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); } + (rule__XFunctionTypeRef__ReturnTypeAssignment_2) + { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__2 + +rule__XFunctionTypeRef__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__2__Impl - rule__IfExpressionKw__Group__3 + rule__XFunctionTypeRef__Group_0__0__Impl + rule__XFunctionTypeRef__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__2__Impl +rule__XFunctionTypeRef__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } - 'then' - { after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); } + '(' + { after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__3 +rule__XFunctionTypeRef__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__3__Impl - rule__IfExpressionKw__Group__4 + rule__XFunctionTypeRef__Group_0__1__Impl + rule__XFunctionTypeRef__Group_0__2 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__3__Impl +rule__XFunctionTypeRef__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } - (rule__IfExpressionKw__ThenPartAssignment_3) - { after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); } + (rule__XFunctionTypeRef__Group_0_1__0)? + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__4 +rule__XFunctionTypeRef__Group_0__2 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__4__Impl + rule__XFunctionTypeRef__Group_0__2__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__4__Impl +rule__XFunctionTypeRef__Group_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } - (rule__IfExpressionKw__Group_4__0)? - { after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); } + ')' + { after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); } ) ; finally { @@ -2220,296 +18721,296 @@ finally { } -rule__IfExpressionKw__Group_4__0 +rule__XFunctionTypeRef__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4__0__Impl + rule__XFunctionTypeRef__Group_0_1__0__Impl + rule__XFunctionTypeRef__Group_0_1__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4__0__Impl +rule__XFunctionTypeRef__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } - (rule__IfExpressionKw__Group_4_0__0) - { after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); } + (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0) + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__IfExpressionKw__Group_4_0__0 +rule__XFunctionTypeRef__Group_0_1__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4_0__0__Impl - rule__IfExpressionKw__Group_4_0__1 + rule__XFunctionTypeRef__Group_0_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__0__Impl +rule__XFunctionTypeRef__Group_0_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } - 'else' - { after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); } + (rule__XFunctionTypeRef__Group_0_1_1__0)* + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__1 + +rule__XFunctionTypeRef__Group_0_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4_0__1__Impl + rule__XFunctionTypeRef__Group_0_1_1__0__Impl + rule__XFunctionTypeRef__Group_0_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__1__Impl +rule__XFunctionTypeRef__Group_0_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } - (rule__IfExpressionKw__ElsePartAssignment_4_0_1) - { after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); } + ',' + { after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__SwitchExpression__Group__0 +rule__XFunctionTypeRef__Group_0_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__0__Impl - rule__SwitchExpression__Group__1 + rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__0__Impl +rule__XFunctionTypeRef__Group_0_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } - 'switch' - { after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); } + (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1) + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__1 + +rule__JvmParameterizedTypeReference__Group__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__1__Impl - rule__SwitchExpression__Group__2 + rule__JvmParameterizedTypeReference__Group__0__Impl + rule__JvmParameterizedTypeReference__Group__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } - (rule__SwitchExpression__Group_1__0)? - { after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); } + (rule__JvmParameterizedTypeReference__TypeAssignment_0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__2 +rule__JvmParameterizedTypeReference__Group__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__2__Impl - rule__SwitchExpression__Group__3 + rule__JvmParameterizedTypeReference__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__2__Impl +rule__JvmParameterizedTypeReference__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); } + (rule__JvmParameterizedTypeReference__Group_1__0)? + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__3 + +rule__JvmParameterizedTypeReference__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__3__Impl - rule__SwitchExpression__Group__4 + rule__JvmParameterizedTypeReference__Group_1__0__Impl + rule__JvmParameterizedTypeReference__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__3__Impl +rule__JvmParameterizedTypeReference__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } - (rule__SwitchExpression__CaseAssignment_3)* - { after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); } + ('<') + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__4 +rule__JvmParameterizedTypeReference__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__4__Impl - rule__SwitchExpression__Group__5 + rule__JvmParameterizedTypeReference__Group_1__1__Impl + rule__JvmParameterizedTypeReference__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__4__Impl +rule__JvmParameterizedTypeReference__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - 'default' - { after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__5 +rule__JvmParameterizedTypeReference__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__5__Impl - rule__SwitchExpression__Group__6 + rule__JvmParameterizedTypeReference__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1__3 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__5__Impl +rule__JvmParameterizedTypeReference__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } - ':' - { after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); } + (rule__JvmParameterizedTypeReference__Group_1_2__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__6 +rule__JvmParameterizedTypeReference__Group_1__3 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__6__Impl - rule__SwitchExpression__Group__7 + rule__JvmParameterizedTypeReference__Group_1__3__Impl + rule__JvmParameterizedTypeReference__Group_1__4 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__6__Impl +rule__JvmParameterizedTypeReference__Group_1__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } - (rule__SwitchExpression__DefaultExprAssignment_6) - { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); } + '>' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__7 +rule__JvmParameterizedTypeReference__Group_1__4 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__7__Impl + rule__JvmParameterizedTypeReference__Group_1__4__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__7__Impl +rule__JvmParameterizedTypeReference__Group_1__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); } + (rule__JvmParameterizedTypeReference__Group_1_4__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); } ) ; finally { @@ -2517,323 +19018,323 @@ finally { } -rule__SwitchExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1_2__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__0__Impl - rule__SwitchExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_2__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } - '(' - { after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); } + ',' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__1 +rule__JvmParameterizedTypeReference__Group_1_2__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__1__Impl - rule__SwitchExpression__Group_1__2 + rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__1__Impl +rule__JvmParameterizedTypeReference__Group_1_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } - (rule__SwitchExpression__SwitchExprAssignment_1_1) - { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__2 + +rule__JvmParameterizedTypeReference__Group_1_4__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } - ')' - { after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); } + (rule__JvmParameterizedTypeReference__Group_1_4_0__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Case__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4__1 @init { int stackSize = keepStackSize(); } -: - rule__Case__Group__0__Impl - rule__Case__Group__1 +: + rule__JvmParameterizedTypeReference__Group_1_4__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4__2 ; finally { restoreStackSize(stackSize); } -rule__Case__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } - 'case' - { after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); } + (rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__1 +rule__JvmParameterizedTypeReference__Group_1_4__2 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__1__Impl - rule__Case__Group__2 + rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Case__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } - (rule__Case__ConditionAssignment_1) - { after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); } + (rule__JvmParameterizedTypeReference__Group_1_4_2__0)? + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__2 + +rule__JvmParameterizedTypeReference__Group_1_4_0__0 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__2__Impl - rule__Case__Group__3 + rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__Case__Group__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getColonKeyword_2()); } - ':' - { after(grammarAccess.getCaseAccess().getColonKeyword_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); } + (rule__JvmParameterizedTypeReference__Group_1_4_0_0__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__3 + +rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__3__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__Case__Group__3__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } - (rule__Case__ThenParAssignment_3) - { after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); } + () + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__OrExpression__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group__0__Impl - rule__OrExpression__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } - ruleAndExpression - { after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); } + '.' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__1 + +rule__JvmParameterizedTypeReference__Group_1_4_2__0 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getGroup_1()); } - (rule__OrExpression__Group_1__0)* - { after(grammarAccess.getOrExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); } + ('<') + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__OrExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1_4_2__1 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__0__Impl - rule__OrExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__1 +rule__JvmParameterizedTypeReference__Group_1_4_2__2 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__1__Impl - rule__OrExpression__Group_1__2 + rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } - (rule__OrExpression__OperatorAssignment_1_1) - { after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); } + (rule__JvmParameterizedTypeReference__Group_1_4_2_2__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__2 +rule__JvmParameterizedTypeReference__Group_1_4_2__3 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } - (rule__OrExpression__RightAssignment_1_2) - { after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); } + '>' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); } ) ; finally { @@ -2841,53 +19342,53 @@ finally { } -rule__AndExpression__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group__0__Impl - rule__AndExpression__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } - ruleImpliesExpression - { after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); } + ',' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__1 +rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getGroup_1()); } - (rule__AndExpression__Group_1__0)* - { after(grammarAccess.getAndExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); } ) ; finally { @@ -2895,80 +19396,80 @@ finally { } -rule__AndExpression__Group_1__0 +rule__JvmWildcardTypeReference__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__0__Impl - rule__AndExpression__Group_1__1 + rule__JvmWildcardTypeReference__Group__0__Impl + rule__JvmWildcardTypeReference__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__0__Impl +rule__JvmWildcardTypeReference__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); } () - { after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__1 +rule__JvmWildcardTypeReference__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__1__Impl - rule__AndExpression__Group_1__2 + rule__JvmWildcardTypeReference__Group__1__Impl + rule__JvmWildcardTypeReference__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__1__Impl +rule__JvmWildcardTypeReference__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } - (rule__AndExpression__OperatorAssignment_1_1) - { after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); } + '?' + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__2 +rule__JvmWildcardTypeReference__Group__2 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__2__Impl + rule__JvmWildcardTypeReference__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__2__Impl +rule__JvmWildcardTypeReference__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } - (rule__AndExpression__RightAssignment_1_2) - { after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); } + (rule__JvmWildcardTypeReference__Alternatives_2)? + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); } ) ; finally { @@ -2976,53 +19477,53 @@ finally { } -rule__ImpliesExpression__Group__0 +rule__JvmWildcardTypeReference__Group_2_0__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group__0__Impl - rule__ImpliesExpression__Group__1 + rule__JvmWildcardTypeReference__Group_2_0__0__Impl + rule__JvmWildcardTypeReference__Group_2_0__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__0__Impl +rule__JvmWildcardTypeReference__Group_2_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } - ruleRelationalExpression - { after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__1 +rule__JvmWildcardTypeReference__Group_2_0__1 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group__1__Impl + rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__1__Impl +rule__JvmWildcardTypeReference__Group_2_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } - (rule__ImpliesExpression__Group_1__0)* - { after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1)* + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); } ) ; finally { @@ -3030,215 +19531,215 @@ finally { } -rule__ImpliesExpression__Group_1__0 +rule__JvmWildcardTypeReference__Group_2_1__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__0__Impl - rule__ImpliesExpression__Group_1__1 + rule__JvmWildcardTypeReference__Group_2_1__0__Impl + rule__JvmWildcardTypeReference__Group_2_1__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__0__Impl +rule__JvmWildcardTypeReference__Group_2_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__1 +rule__JvmWildcardTypeReference__Group_2_1__1 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__1__Impl - rule__ImpliesExpression__Group_1__2 + rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__1__Impl +rule__JvmWildcardTypeReference__Group_2_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } - (rule__ImpliesExpression__OperatorAssignment_1_1) - { after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1)* + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__2 + +rule__JvmUpperBound__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__2__Impl + rule__JvmUpperBound__Group__0__Impl + rule__JvmUpperBound__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__2__Impl +rule__JvmUpperBound__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } - (rule__ImpliesExpression__RightAssignment_1_2) - { after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); } + 'extends' + { after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__RelationalExpression__Group__0 +rule__JvmUpperBound__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__0__Impl - rule__RelationalExpression__Group__1 + rule__JvmUpperBound__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__0__Impl +rule__JvmUpperBound__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); } + (rule__JvmUpperBound__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1 + +rule__JvmUpperBoundAnded__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__1__Impl + rule__JvmUpperBoundAnded__Group__0__Impl + rule__JvmUpperBoundAnded__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1__Impl +rule__JvmUpperBoundAnded__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } - (rule__RelationalExpression__Group_1__0)* - { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); } + '&' + { after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__RelationalExpression__Group_1__0 +rule__JvmUpperBoundAnded__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__0__Impl - rule__RelationalExpression__Group_1__1 + rule__JvmUpperBoundAnded__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__0__Impl +rule__JvmUpperBoundAnded__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); } + (rule__JvmUpperBoundAnded__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1 + +rule__JvmLowerBound__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__1__Impl - rule__RelationalExpression__Group_1__2 + rule__JvmLowerBound__Group__0__Impl + rule__JvmLowerBound__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1__Impl +rule__JvmLowerBound__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } - (rule__RelationalExpression__OperatorAssignment_1_1) - { after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); } + 'super' + { after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2 +rule__JvmLowerBound__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__2__Impl + rule__JvmLowerBound__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2__Impl +rule__JvmLowerBound__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - (rule__RelationalExpression__RightAssignment_1_2) - { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); } + (rule__JvmLowerBound__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); } ) ; finally { @@ -3246,53 +19747,53 @@ finally { } -rule__AdditiveExpression__Group__0 +rule__JvmLowerBoundAnded__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__0__Impl - rule__AdditiveExpression__Group__1 + rule__JvmLowerBoundAnded__Group__0__Impl + rule__JvmLowerBoundAnded__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__0__Impl +rule__JvmLowerBoundAnded__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); } + '&' + { after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1 +rule__JvmLowerBoundAnded__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__1__Impl + rule__JvmLowerBoundAnded__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1__Impl +rule__JvmLowerBoundAnded__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - (rule__AdditiveExpression__Group_1__0)* - { after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); } + (rule__JvmLowerBoundAnded__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); } ) ; finally { @@ -3300,80 +19801,80 @@ finally { } -rule__AdditiveExpression__Group_1__0 +rule__QualifiedNameWithWildcard__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__0__Impl - rule__AdditiveExpression__Group_1__1 + rule__QualifiedNameWithWildcard__Group__0__Impl + rule__QualifiedNameWithWildcard__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__0__Impl +rule__QualifiedNameWithWildcard__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } - () - { after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); } + ruleQualifiedName + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1 +rule__QualifiedNameWithWildcard__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__1__Impl - rule__AdditiveExpression__Group_1__2 + rule__QualifiedNameWithWildcard__Group__1__Impl + rule__QualifiedNameWithWildcard__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1__Impl +rule__QualifiedNameWithWildcard__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } - (rule__AdditiveExpression__NameAssignment_1_1) - { after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2 +rule__QualifiedNameWithWildcard__Group__2 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__2__Impl + rule__QualifiedNameWithWildcard__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2__Impl +rule__QualifiedNameWithWildcard__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } - (rule__AdditiveExpression__ParamsAssignment_1_2) - { after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); } + '*' + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); } ) ; finally { @@ -3381,188 +19882,188 @@ finally { } -rule__MultiplicativeExpression__Group__0 +rule__XImportDeclaration__Group__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__0__Impl - rule__MultiplicativeExpression__Group__1 + rule__XImportDeclaration__Group__0__Impl + rule__XImportDeclaration__Group__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__0__Impl +rule__XImportDeclaration__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } - ruleUnaryOrInfixExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); } + 'import' + { after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1 +rule__XImportDeclaration__Group__1 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__1__Impl + rule__XImportDeclaration__Group__1__Impl + rule__XImportDeclaration__Group__2 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1__Impl +rule__XImportDeclaration__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - (rule__MultiplicativeExpression__Group_1__0)* - { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); } + (rule__XImportDeclaration__Alternatives_1) + { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MultiplicativeExpression__Group_1__0 +rule__XImportDeclaration__Group__2 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__0__Impl - rule__MultiplicativeExpression__Group_1__1 + rule__XImportDeclaration__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__0__Impl +rule__XImportDeclaration__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } - () - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); } + (';')? + { after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1 + +rule__XImportDeclaration__Group_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__1__Impl - rule__MultiplicativeExpression__Group_1__2 + rule__XImportDeclaration__Group_1_0__0__Impl + rule__XImportDeclaration__Group_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1__Impl +rule__XImportDeclaration__Group_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } - (rule__MultiplicativeExpression__NameAssignment_1_1) - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); } + (rule__XImportDeclaration__StaticAssignment_1_0_0) + { after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2 +rule__XImportDeclaration__Group_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__2__Impl + rule__XImportDeclaration__Group_1_0__1__Impl + rule__XImportDeclaration__Group_1_0__2 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2__Impl +rule__XImportDeclaration__Group_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } - (rule__MultiplicativeExpression__ParamsAssignment_1_2) - { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + { before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); } + (rule__XImportDeclaration__ExtensionAssignment_1_0_1)? + { after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__UnaryExpression__Group__0 +rule__XImportDeclaration__Group_1_0__2 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group__0__Impl - rule__UnaryExpression__Group__1 + rule__XImportDeclaration__Group_1_0__2__Impl + rule__XImportDeclaration__Group_1_0__3 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__0__Impl +rule__XImportDeclaration__Group_1_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } - (rule__UnaryExpression__NameAssignment_0) - { after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); } + (rule__XImportDeclaration__ImportedTypeAssignment_1_0_2) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__1 +rule__XImportDeclaration__Group_1_0__3 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group__1__Impl + rule__XImportDeclaration__Group_1_0__3__Impl ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__1__Impl +rule__XImportDeclaration__Group_1_0__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } - (rule__UnaryExpression__ParamsAssignment_1) - { after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); } + (rule__XImportDeclaration__Alternatives_1_0_3) + { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); } ) ; finally { @@ -3570,53 +20071,53 @@ finally { } -rule__InfixExpression__Group__0 +rule__QualifiedNameInStaticImport__Group__0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group__0__Impl - rule__InfixExpression__Group__1 + rule__QualifiedNameInStaticImport__Group__0__Impl + rule__QualifiedNameInStaticImport__Group__1 ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__0__Impl +rule__QualifiedNameInStaticImport__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } - rulePrimaryExpression - { after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__1 +rule__QualifiedNameInStaticImport__Group__1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group__1__Impl + rule__QualifiedNameInStaticImport__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__1__Impl +rule__QualifiedNameInStaticImport__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } - (rule__InfixExpression__Alternatives_1)* - { after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); } ) ; finally { @@ -3624,2829 +20125,3175 @@ finally { } -rule__InfixExpression__Group_1_0__0 +rule__LetExpression__IdentifierAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__0__Impl - rule__InfixExpression__Group_1_0__1 + ( + { before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__0__Impl +rule__LetExpression__VarExprAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } -) + ( + { before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__1 +rule__LetExpression__TargetAssignment_5 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__1__Impl - rule__InfixExpression__Group_1_0__2 + ( + { before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + ruleExpression + { after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__1__Impl +rule__CastedExpression__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } -) + ( + { before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + ruleType + { after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__2 +rule__CastedExpression__TargetAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__2__Impl - rule__InfixExpression__Group_1_0__3 + ( + { before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__2__Impl +rule__ChainExpression__NextAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } - (rule__InfixExpression__NameAssignment_1_0_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } -) + ( + { before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + ruleChainedExpression + { after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__3 +rule__IfExpressionTri__ThenPartAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__3__Impl - rule__InfixExpression__Group_1_0__4 + ( + { before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__3__Impl +rule__IfExpressionTri__ElsePartAssignment_1_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } -) + ( + { before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__4 +rule__IfExpressionKw__ConditionAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__4__Impl - rule__InfixExpression__Group_1_0__5 + ( + { before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__4__Impl +rule__IfExpressionKw__ThenPartAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } - (rule__InfixExpression__Group_1_0_4__0)? - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } -) + ( + { before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__5 +rule__IfExpressionKw__ElsePartAssignment_4_0_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__5__Impl + ( + { before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__5__Impl +rule__SwitchExpression__SwitchExprAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } -) + ( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + ruleOrExpression + { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0_4__0 +rule__SwitchExpression__CaseAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4__0__Impl - rule__InfixExpression__Group_1_0_4__1 + ( + { before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + ruleCase + { after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__0__Impl +rule__SwitchExpression__DefaultExprAssignment_6 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } - (rule__InfixExpression__ParamsAssignment_1_0_4_0) - { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } -) + ( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + ruleOrExpression + { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__1 +rule__Case__ConditionAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4__1__Impl + ( + { before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + ruleOrExpression + { after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__1__Impl +rule__Case__ThenParAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } - (rule__InfixExpression__Group_1_0_4_1__0)* - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } -) + ( + { before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + ruleOrExpression + { after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0_4_1__0 +rule__OrExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4_1__0__Impl - rule__InfixExpression__Group_1_0_4_1__1 + ( + { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ( + { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + '||' + { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ) + { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__0__Impl +rule__OrExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } - ',' - { after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } -) + ( + { before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + ruleAndExpression + { after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__1 +rule__AndExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4_1__1__Impl + ( + { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ( + { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + '&&' + { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ) + { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__1__Impl +rule__AndExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } - (rule__InfixExpression__ParamsAssignment_1_0_4_1_1) - { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } -) + ( + { before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + ruleImpliesExpression + { after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_1__0 +rule__ImpliesExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__0__Impl - rule__InfixExpression__Group_1_1__1 + ( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + 'implies' + { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ) + { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__0__Impl +rule__ImpliesExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } -) + ( + { before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + ruleRelationalExpression + { after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__1 +rule__RelationalExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__1__Impl - rule__InfixExpression__Group_1_1__2 + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + (rule__RelationalExpression__OperatorAlternatives_1_1_0) + { after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__1__Impl +rule__RelationalExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } -) + ( + { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + ruleAdditiveExpression + { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__2 +rule__AdditiveExpression__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__2__Impl + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + (rule__AdditiveExpression__NameAlternatives_1_1_0) + { after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__2__Impl +rule__AdditiveExpression__ParamsAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } - (rule__InfixExpression__TypeAssignment_1_1_2) - { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } -) + ( + { before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + ruleMultiplicativeExpression + { after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_2__0 +rule__MultiplicativeExpression__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__0__Impl - rule__InfixExpression__Group_1_2__1 + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + (rule__MultiplicativeExpression__NameAlternatives_1_1_0) + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__0__Impl +rule__MultiplicativeExpression__ParamsAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } -) + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + ruleUnaryOrInfixExpression + { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__1 +rule__UnaryExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__1__Impl - rule__InfixExpression__Group_1_2__2 + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + (rule__UnaryExpression__NameAlternatives_0_0) + { after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__1__Impl +rule__UnaryExpression__ParamsAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } -) + ( + { before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + ruleInfixExpression + { after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__2 +rule__InfixExpression__NameAssignment_1_0_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__2__Impl - rule__InfixExpression__Group_1_2__3 + ( + { before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + ruleIdentifier + { after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__2__Impl +rule__InfixExpression__ParamsAssignment_1_0_4_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } - (rule__InfixExpression__NameAssignment_1_2_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__3 +rule__InfixExpression__ParamsAssignment_1_0_4_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__3__Impl - rule__InfixExpression__Group_1_2__4 + ( + { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__3__Impl +rule__InfixExpression__TypeAssignment_1_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + ruleType + { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__4 +rule__InfixExpression__NameAssignment_1_2_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__4__Impl - rule__InfixExpression__Group_1_2__5 + ( + { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ( + { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + 'typeSelect' + { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ) + { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__4__Impl +rule__InfixExpression__TypeAssignment_1_2_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } - (rule__InfixExpression__TypeAssignment_1_2_4) - { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + ruleType + { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__5 +rule__InfixExpression__NameAssignment_1_3_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__5__Impl + ( + { before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + (rule__InfixExpression__NameAlternatives_1_3_2_0) + { after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__5__Impl +rule__InfixExpression__VarAssignment_1_3_4_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + ruleIdentifier + { after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_3__0 +rule__InfixExpression__ExpAssignment_1_3_5 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__0__Impl - rule__InfixExpression__Group_1_3__1 + ( + { before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__0__Impl +rule__BooleanLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } -) + ( + { before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + (rule__BooleanLiteral__ValAlternatives_0) + { after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__1 +rule__IntegerLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__1__Impl - rule__InfixExpression__Group_1_3__2 + ( + { before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + RULE_INT + { after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__1__Impl +rule__NullLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } -) + ( + { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ( + { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + 'null' + { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ) + { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__2 +rule__RealLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__2__Impl - rule__InfixExpression__Group_1_3__3 + ( + { before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + RULE_REAL + { after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__2__Impl +rule__StringLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } - (rule__InfixExpression__NameAssignment_1_3_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } -) + ( + { before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + RULE_STRING + { after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__3 +rule__GlobalVarExpression__NameAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__3__Impl - rule__InfixExpression__Group_1_3__4 + ( + { before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__3__Impl +rule__FeatureCall__TypeAssignment_1 @init { - int stackSize = keepStackSize(); - } -: -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } -) + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + ruleType + { after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__4 +rule__OperationCall__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__4__Impl - rule__InfixExpression__Group_1_3__5 + ( + { before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__4__Impl +rule__OperationCall__ParamsAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } - (rule__InfixExpression__Group_1_3_4__0)? - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } -) + ( + { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__5 +rule__OperationCall__ParamsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__5__Impl - rule__InfixExpression__Group_1_3__6 + ( + { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + ruleExpression + { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__5__Impl +rule__ListLiteral__ElementsAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } - (rule__InfixExpression__ExpAssignment_1_3_5) - { after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } -) + ( + { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__6 +rule__ListLiteral__ElementsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__6__Impl + ( + { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + ruleExpression + { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__6__Impl +rule__ConstructorCallExpression__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } -) + ( + { before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + ruleSimpleType + { after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_3_4__0 +rule__TypeSelectExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3_4__0__Impl - rule__InfixExpression__Group_1_3_4__1 + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + 'typeSelect' + { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ) + { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__0__Impl +rule__TypeSelectExpression__TypeAssignment_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } - (rule__InfixExpression__VarAssignment_1_3_4_0) - { after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } -) + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + ruleType + { after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__1 +rule__CollectionExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3_4__1__Impl + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + (rule__CollectionExpression__NameAlternatives_0_0) + { after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__1__Impl +rule__CollectionExpression__VarAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } - '|' - { after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } -) + ( + { before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + ruleIdentifier + { after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ParanthesizedExpression__Group__0 +rule__CollectionExpression__ExpAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__0__Impl - rule__ParanthesizedExpression__Group__1 + ( + { before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__0__Impl +rule__CollectionType__ClAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } - '(' - { after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } -) + ( + { before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + (rule__CollectionType__ClAlternatives_0_0) + { after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__1 +rule__CollectionType__Id1Assignment_2 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__1__Impl - rule__ParanthesizedExpression__Group__2 + ( + { before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + ruleSimpleType + { after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__1__Impl +rule__SimpleType__IdAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } - ruleExpression - { after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } -) + ( + { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__2 +rule__SimpleType__IdAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__2__Impl + ( + { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + ruleIdentifier + { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__2__Impl +rule__XAssignment__FeatureAssignment_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } - ')' - { after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } -) + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); } + ruleFeatureCallID + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalVarExpression__Group__0 +rule__XAssignment__ValueAssignment_0_3 @init { int stackSize = keepStackSize(); } : - rule__GlobalVarExpression__Group__0__Impl - rule__GlobalVarExpression__Group__1 + ( + { before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); } + ruleXAssignment + { after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__0__Impl +rule__XAssignment__FeatureAssignment_1_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } - 'GLOBALVAR' - { after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } -) + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); } + ruleOpMultiAssign + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__1 +rule__XAssignment__RightOperandAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : - rule__GlobalVarExpression__Group__1__Impl + ( + { before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); } + ruleXAssignment + { after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__1__Impl +rule__XOrExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } - (rule__GlobalVarExpression__NameAssignment_1) - { after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } -) + ( + { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); } + ruleOpOr + { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group__0 +rule__XOrExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__0__Impl - rule__OperationCall__Group__1 + ( + { before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); } + ruleXAndExpression + { after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__0__Impl +rule__XAndExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } - (rule__OperationCall__NameAssignment_0) - { after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); } + ruleOpAnd + { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__1 +rule__XAndExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__1__Impl - rule__OperationCall__Group__2 + ( + { before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); } + ruleXEqualityExpression + { after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__1__Impl +rule__XEqualityExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); } + ruleOpEquality + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__2 +rule__XEqualityExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__2__Impl - rule__OperationCall__Group__3 + ( + { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); } + ruleXRelationalExpression + { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__2__Impl +rule__XRelationalExpression__TypeAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getGroup_2()); } - (rule__OperationCall__Group_2__0)? - { after(grammarAccess.getOperationCallAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__3 +rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__3__Impl + ( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); } + ruleOpCompare + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__3__Impl +rule__XRelationalExpression__RightOperandAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } - ')' - { after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } -) + ( + { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); } + ruleXOtherOperatorExpression + { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group_2__0 +rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2__0__Impl - rule__OperationCall__Group_2__1 + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); } + ruleOpOther + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__0__Impl +rule__XOtherOperatorExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } - (rule__OperationCall__ParamsAssignment_2_0) - { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } -) + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); } + ruleXAdditiveExpression + { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__1 +rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2__1__Impl + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); } + ruleOpAdd + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__1__Impl +rule__XAdditiveExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getGroup_2_1()); } - (rule__OperationCall__Group_2_1__0)* - { after(grammarAccess.getOperationCallAccess().getGroup_2_1()); } -) + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); } + ruleXMultiplicativeExpression + { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group_2_1__0 +rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2_1__0__Impl - rule__OperationCall__Group_2_1__1 + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); } + ruleOpMulti + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__0__Impl +rule__XMultiplicativeExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } - ',' - { after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } -) + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__1 +rule__XUnaryOperation__FeatureAssignment_0_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2_1__1__Impl + ( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); } + ruleOpUnary + { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__1__Impl +rule__XUnaryOperation__OperandAssignment_0_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } - (rule__OperationCall__ParamsAssignment_2_1_1) - { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } -) + ( + { before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group__0 +rule__XCastedExpression__TypeAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__0__Impl - rule__ListLiteral__Group__1 + ( + { before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__0__Impl +rule__XPostfixOperation__FeatureAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } - () - { after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } -) + ( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); } + ( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); } + ruleOpPostfix + { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); } + ) + { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__1 +rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__1__Impl - rule__ListLiteral__Group__2 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + '::' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__1__Impl +rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); } + ruleFeatureCallID + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__2 +rule__XMemberFeatureCall__ValueAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__2__Impl - rule__ListLiteral__Group__3 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); } + ruleXAssignment + { after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__2__Impl +rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getGroup_2()); } - (rule__ListLiteral__Group_2__0)? - { after(grammarAccess.getListLiteralAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + '?.' + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__3 +rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__3__Impl + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + '::' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__3__Impl +rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } - '}' - { after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group_2__0 +rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2__0__Impl - rule__ListLiteral__Group_2__1 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__0__Impl +rule__XMemberFeatureCall__FeatureAssignment_1_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } - (rule__ListLiteral__ElementsAssignment_2_0) - { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); } + ruleIdOrSuper + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__1 +rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2__1__Impl + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + '(' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__1__Impl +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getGroup_2_1()); } - (rule__ListLiteral__Group_2_1__0)* - { after(grammarAccess.getListLiteralAccess().getGroup_2_1()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group_2_1__0 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2_1__0__Impl - rule__ListLiteral__Group_2_1__1 + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__0__Impl +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } - ',' - { after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } -) + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__1 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2_1__1__Impl + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); } + ruleXClosure + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__1__Impl +rule__XSetLiteral__ElementsAssignment_3_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } - (rule__ListLiteral__ElementsAssignment_2_1_1) - { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } -) + ( + { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ruleXExpression + { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ConstructorCallExpression__Group__0 +rule__XSetLiteral__ElementsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : - rule__ConstructorCallExpression__Group__0__Impl - rule__ConstructorCallExpression__Group__1 + ( + { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__0__Impl +rule__XListLiteral__ElementsAssignment_3_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } - 'new' - { after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } -) + ( + { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ruleXExpression + { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__1 +rule__XListLiteral__ElementsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : - rule__ConstructorCallExpression__Group__1__Impl + ( + { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__1__Impl +rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } - (rule__ConstructorCallExpression__TypeAssignment_1) - { after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } -) + ( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__TypeSelectExpression__Group__0 +rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__0__Impl - rule__TypeSelectExpression__Group__1 + ( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__0__Impl +rule__XClosure__ExplicitSyntaxAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } - (rule__TypeSelectExpression__NameAssignment_0) - { after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } + ( + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } + '|' + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } + ) + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__1 +rule__XClosure__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__1__Impl - rule__TypeSelectExpression__Group__2 + ( + { before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); } + ruleXExpressionInClosure + { after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__1__Impl +rule__XExpressionInClosure__ExpressionsAssignment_1_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__2 +rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__2__Impl - rule__TypeSelectExpression__Group__3 + ( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__2__Impl +rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } - (rule__TypeSelectExpression__TypeAssignment_2) - { after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } -) + ( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__3 +rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__3__Impl + ( + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + ( + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + '|' + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + ) + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__3__Impl +rule__XShortClosure__ExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } - ')' - { after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } -) + ( + { before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionExpression__Group__0 +rule__XIfExpression__IfAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__0__Impl - rule__CollectionExpression__Group__1 + ( + { before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__0__Impl +rule__XIfExpression__ThenAssignment_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } - (rule__CollectionExpression__NameAssignment_0) - { after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__1 +rule__XIfExpression__ElseAssignment_6_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__1__Impl - rule__CollectionExpression__Group__2 + ( + { before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__1__Impl +rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__2 +rule__XSwitchExpression__SwitchAssignment_2_0_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__2__Impl - rule__CollectionExpression__Group__3 + ( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__2__Impl +rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } - (rule__CollectionExpression__Group_2__0)? - { after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__3 +rule__XSwitchExpression__SwitchAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__3__Impl - rule__CollectionExpression__Group__4 + ( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__3__Impl +rule__XSwitchExpression__CasesAssignment_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } - (rule__CollectionExpression__ExpAssignment_3) - { after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } -) + ( + { before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); } + ruleXCasePart + { after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__4 +rule__XSwitchExpression__DefaultAssignment_5_2 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__4__Impl + ( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__4__Impl +rule__XCasePart__TypeGuardAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } - ')' - { after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } -) + ( + { before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionExpression__Group_2__0 +rule__XCasePart__CaseAssignment_2_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group_2__0__Impl - rule__CollectionExpression__Group_2__1 + ( + { before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); } + ruleXExpression + { after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__0__Impl +rule__XCasePart__ThenAssignment_3_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } - (rule__CollectionExpression__VarAssignment_2_0) - { after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } -) + ( + { before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); } + ruleXExpression + { after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__1 +rule__XCasePart__FallThroughAssignment_3_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group_2__1__Impl + ( + { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ( + { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ) + { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__1__Impl +rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } - '|' - { after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } -) + ( + { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionType__Group__0 +rule__XForLoopExpression__ForExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__0__Impl - rule__CollectionType__Group__1 + ( + { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__0__Impl +rule__XForLoopExpression__EachExpressionAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } - (rule__CollectionType__ClAssignment_0) - { after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } -) + ( + { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__1 +rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__1__Impl - rule__CollectionType__Group__2 + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__1__Impl +rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } - '[' - { after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } -) + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__2 +rule__XBasicForLoopExpression__ExpressionAssignment_5 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__2__Impl - rule__CollectionType__Group__3 + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__2__Impl +rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } - (rule__CollectionType__Id1Assignment_2) - { after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } -) + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__3 +rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__3__Impl + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__3__Impl +rule__XBasicForLoopExpression__EachExpressionAssignment_9 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } - ']' - { after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } -) + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__SimpleType__Group__0 +rule__XWhileExpression__PredicateAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group__0__Impl - rule__SimpleType__Group__1 + ( + { before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__0__Impl +rule__XWhileExpression__BodyAssignment_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } - (rule__SimpleType__IdAssignment_0) - { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } -) + ( + { before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__1 +rule__XDoWhileExpression__BodyAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group__1__Impl + ( + { before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__1__Impl +rule__XDoWhileExpression__PredicateAssignment_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getGroup_1()); } - (rule__SimpleType__Group_1__0)* - { after(grammarAccess.getSimpleTypeAccess().getGroup_1()); } -) + ( + { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__SimpleType__Group_1__0 +rule__XBlockExpression__ExpressionsAssignment_2_0 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group_1__0__Impl - rule__SimpleType__Group_1__1 + ( + { before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__0__Impl +rule__XVariableDeclaration__WriteableAssignment_1_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } - '::' - { after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } -) + ( + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + ( + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + 'var' + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + ) + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__1 +rule__XVariableDeclaration__TypeAssignment_2_0_0_0 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group_1__1__Impl + ( + { before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__1__Impl +rule__XVariableDeclaration__NameAssignment_2_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } - (rule__SimpleType__IdAssignment_1_1) - { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } -) + ( + { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); } + ruleValidID + { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__LetExpression__IdentifierAssignment_1 +rule__XVariableDeclaration__NameAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); } + ruleValidID + { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__VarExprAssignment_3 +rule__XVariableDeclaration__RightAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); } + ruleXExpression + { after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__TargetAssignment_5 +rule__JvmFormalParameter__ParameterTypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } - ruleExpression - { after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__TypeAssignment_1 +rule__JvmFormalParameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } - ruleType - { after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } + ruleValidID + { after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__TargetAssignment_3 +rule__FullJvmFormalParameter__ParameterTypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__NextAssignment_1_2 +rule__FullJvmFormalParameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } - ruleChainedExpression - { after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } + ruleValidID + { after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__ThenPartAssignment_1_2 +rule__XFeatureCall__TypeArgumentsAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__ElsePartAssignment_1_4 +rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ConditionAssignment_1 +rule__XFeatureCall__FeatureAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); } + ruleIdOrSuper + { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ThenPartAssignment_3 +rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + '(' + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + ) + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ElsePartAssignment_4_0_1 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__SwitchExprAssignment_1_1 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } - ruleOrExpression - { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__CaseAssignment_3 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } - ruleCase - { after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__DefaultExprAssignment_6 +rule__XFeatureCall__FeatureCallArgumentsAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } - ruleOrExpression - { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); } + ruleXClosure + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__ConditionAssignment_1 +rule__XConstructorCall__ConstructorAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } - ruleOrExpression - { after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); } + ( + { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__ThenParAssignment_3 +rule__XConstructorCall__TypeArgumentsAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } - ruleOrExpression - { after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__OperatorAssignment_1_1 +rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - ( - { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - '||' - { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - ) - { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__RightAssignment_1_2 +rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } - ruleAndExpression - { after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + ( + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + '(' + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + ) + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__OperatorAssignment_1_1 +rule__XConstructorCall__ArgumentsAssignment_4_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - '&&' - { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - ) - { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__RightAssignment_1_2 +rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } - ruleImpliesExpression - { after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__OperatorAssignment_1_1 +rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - 'implies' - { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - ) - { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__RightAssignment_1_2 +rule__XConstructorCall__ArgumentsAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } - ruleRelationalExpression - { after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); } + ruleXClosure + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAssignment_1_1 +rule__XBooleanLiteral__IsTrueAssignment_1_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.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + ( + { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + 'true' + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + ) + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__RightAssignment_1_2 +rule__XNumberLiteral__ValueAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); } + ruleNumber + { after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__NameAssignment_1_1 +rule__XStringLiteral__ValueAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } - (rule__AdditiveExpression__NameAlternatives_1_1_0) - { after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + { before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); } + RULE_STRING + { after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__ParamsAssignment_1_2 +rule__XTypeLiteral__TypeAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); } + ( + { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); } + ) + { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__NameAssignment_1_1 +rule__XTypeLiteral__ArrayDimensionsAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } - (rule__MultiplicativeExpression__NameAlternatives_1_1_0) - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); } + ruleArrayBrackets + { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__ParamsAssignment_1_2 +rule__XThrowExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } - ruleUnaryOrInfixExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__NameAssignment_0 +rule__XReturnExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } - (rule__UnaryExpression__NameAlternatives_0_0) - { after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + { before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__ParamsAssignment_1 +rule__XTryCatchFinallyExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } - ruleInfixExpression - { after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_0_2 +rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } - ruleIdentifier - { after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); } + ruleXCatchClause + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ParamsAssignment_1_0_4_0 +rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ParamsAssignment_1_0_4_1_1 +rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__TypeAssignment_1_1_2 +rule__XSynchronizedExpression__ParamAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } - ruleType - { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_2_2 +rule__XSynchronizedExpression__ExpressionAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - ( - { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - 'typeSelect' - { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - ) - { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__TypeAssignment_1_2_4 +rule__XCatchClause__DeclaredParamAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } - ruleType - { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); } + ruleFullJvmFormalParameter + { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_3_2 +rule__XCatchClause__ExpressionAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } - (rule__InfixExpression__NameAlternatives_1_3_2_0) - { after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + { before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); } + ruleXExpression + { after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__VarAssignment_1_3_4_0 +rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } - ruleIdentifier - { after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ExpAssignment_1_3_5 +rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__BooleanLiteral__ValAssignment +rule__XFunctionTypeRef__ReturnTypeAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } - (rule__BooleanLiteral__ValAlternatives_0) - { after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IntegerLiteral__ValAssignment +rule__JvmParameterizedTypeReference__TypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } - RULE_INT - { after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); } + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NullLiteral__ValAssignment +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - ( - { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - 'null' - { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - ) - { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RealLiteral__ValAssignment +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } - RULE_REAL - { after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__StringLiteral__ValAssignment +rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } - RULE_STRING - { after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); } + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); } + ruleValidID + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); } + ) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__NameAssignment_1 +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__FeatureCall__TypeAssignment_1 +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } - ruleType - { after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__NameAssignment_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); } + ruleJvmUpperBound + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__ParamsAssignment_2_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); } + ruleJvmUpperBoundAnded + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__ParamsAssignment_2_1_1 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } - ruleExpression - { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); } + ruleJvmLowerBound + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__ElementsAssignment_2_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); } + ruleJvmLowerBoundAnded + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__ElementsAssignment_2_1_1 +rule__JvmUpperBound__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } - ruleExpression - { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__TypeAssignment_1 +rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } - ruleSimpleType - { after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__NameAssignment_0 +rule__JvmLowerBound__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - ( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - 'typeSelect' - { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - ) - { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__TypeAssignment_2 +rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } - ruleType - { after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__NameAssignment_0 +rule__XImportDeclaration__StaticAssignment_1_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } - (rule__CollectionExpression__NameAlternatives_0_0) - { after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + 'static' + { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__VarAssignment_2_0 +rule__XImportDeclaration__ExtensionAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } - ruleIdentifier - { after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + 'extension' + { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__ExpAssignment_3 +rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); } + ruleQualifiedNameInStaticImport + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__ClAssignment_0 +rule__XImportDeclaration__WildcardAssignment_1_0_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } - (rule__CollectionType__ClAlternatives_0_0) - { after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + '*' + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Id1Assignment_2 +rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } - ruleSimpleType - { after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); } + ruleValidID + { after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__IdAssignment_0 +rule__XImportDeclaration__ImportedTypeAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__IdAssignment_1_1 +rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } - ruleIdentifier - { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); } + ruleQualifiedNameWithWildcard + { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); } ) ; finally { @@ -6455,11 +23302,15 @@ finally { RULE_REAL : ('0'..'9')* '.' ('0'..'9')*; -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; +RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?; + +RULE_INT : '0'..'9' ('0'..'9'|'_')*; + +RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?; -RULE_INT : ('0'..'9')+; +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.tokens b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.tokens index 32c4b9600c..4e3d39bfab 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.tokens +++ b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpression.tokens @@ -1,65 +1,109 @@ -'!'=22 -'!='=13 -'&&'=60 -'('=39 -')'=40 -'*'=20 -'+'=18 -','=52 -'-'=19 -'->'=41 -'.'=51 -'/'=21 -':'=38 -'::'=58 -'<'=17 -'<='=15 -'='=37 -'=='=12 -'>'=16 -'>='=14 -'?'=42 -'Collection'=33 -'GLOBALVAR'=54 -'List'=34 -'Set'=35 -'['=56 -']'=57 -'case'=50 -'collect'=23 -'default'=48 -'else'=45 -'exists'=27 -'false'=32 -'forAll'=30 -'if'=43 -'implies'=61 -'let'=36 -'new'=55 -'notExists'=28 -'null'=63 -'reject'=26 -'select'=24 -'selectFirst'=25 -'sortBy'=29 -'switch'=46 -'then'=44 -'true'=31 -'typeSelect'=62 -'{'=47 -'|'=53 -'||'=59 -'}'=49 -RULE_ANY_OTHER=11 +'!'=27 +'!='=18 +'!=='=47 +'#'=87 +'%'=55 +'%='=45 +'&&'=16 +'&'=100 +'('=67 +')'=68 +'*'=25 +'**'=54 +'*='=43 +'+'=23 +'++'=56 +'+='=41 +','=78 +'-'=24 +'--'=57 +'-='=42 +'->'=48 +'.'=58 +'..'=50 +'..<'=49 +'/'=26 +'/='=44 +':'=66 +'::'=84 +';'=88 +'<'=22 +'<='=20 +'<>'=52 +'='=14 +'=='=17 +'==='=46 +'=>'=51 +'>'=21 +'>='=19 +'?'=69 +'?.'=103 +'?:'=53 +'Collection'=38 +'GLOBALVAR'=80 +'List'=39 +'Set'=40 +'['=82 +']'=83 +'as'=86 +'case'=77 +'catch'=99 +'collect'=28 +'default'=75 +'do'=91 +'else'=72 +'exists'=32 +'extends'=60 +'extension'=63 +'false'=37 +'finally'=97 +'for'=89 +'forAll'=35 +'if'=70 +'implies'=101 +'import'=62 +'instanceof'=85 +'let'=65 +'new'=81 +'notExists'=33 +'null'=92 +'reject'=31 +'return'=95 +'select'=29 +'selectFirst'=30 +'sortBy'=34 +'static'=61 +'super'=64 +'switch'=73 +'synchronized'=98 +'then'=71 +'throw'=94 +'true'=36 +'try'=96 +'typeSelect'=102 +'typeof'=93 +'val'=59 +'var'=104 +'while'=90 +'{'=74 +'|'=79 +'||'=15 +'}'=76 +RULE_ANY_OTHER=13 +RULE_DECIMAL=7 +RULE_HEX=5 RULE_ID=4 -RULE_INT=5 -RULE_ML_COMMENT=8 -RULE_REAL=6 -RULE_SL_COMMENT=9 -RULE_STRING=7 -RULE_WS=10 -T__12=12 -T__13=13 +RULE_INT=6 +RULE_ML_COMMENT=10 +RULE_REAL=8 +RULE_SL_COMMENT=11 +RULE_STRING=9 +RULE_WS=12 +T__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 T__14=14 T__15=15 T__16=16 @@ -110,3 +154,39 @@ T__60=60 T__61=61 T__62=62 T__63=63 +T__64=64 +T__65=65 +T__66=66 +T__67=67 +T__68=68 +T__69=69 +T__70=70 +T__71=71 +T__72=72 +T__73=73 +T__74=74 +T__75=75 +T__76=76 +T__77=77 +T__78=78 +T__79=79 +T__80=80 +T__81=81 +T__82=82 +T__83=83 +T__84=84 +T__85=85 +T__86=86 +T__87=87 +T__88=88 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionLexer.java b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionLexer.java index 513eb51dfd..093361db74 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionLexer.java +++ b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionLexer.java @@ -12,19 +12,12 @@ @SuppressWarnings("all") public class InternalExpressionLexer extends Lexer { + public static final int RULE_HEX=5; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -33,23 +26,17 @@ public class InternalExpressionLexer extends Lexer { public static final int T__60=60; public static final int T__61=61; public static final int RULE_ID=4; - public static final int RULE_REAL=6; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; - public static final int RULE_INT=5; - public static final int T__29=29; - public static final int T__22=22; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; - public static final int T__24=24; - public static final int T__25=25; + public static final int RULE_REAL=8; + public static final int RULE_INT=6; + public static final int T__66=66; + public static final int RULE_ML_COMMENT=10; + public static final int T__67=67; + public static final int T__68=68; + public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; - public static final int T__21=21; - public static final int RULE_STRING=7; - public static final int RULE_SL_COMMENT=9; + public static final int T__64=64; + public static final int T__65=65; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; @@ -57,12 +44,9 @@ public class InternalExpressionLexer extends Lexer { public static final int T__34=34; public static final int T__35=35; public static final int T__36=36; - public static final int EOF=-1; public static final int T__30=30; public static final int T__31=31; public static final int T__32=32; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -73,6 +57,63 @@ public class InternalExpressionLexer extends Lexer { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=9; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__75=75; + public static final int T__76=76; + public static final int T__80=80; + public static final int T__81=81; + public static final int T__82=82; + public static final int T__83=83; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__89=89; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__87=87; // delegates // delegators @@ -87,58 +128,15 @@ public InternalExpressionLexer(CharStream input, RecognizerSharedState state) { } public String getGrammarFileName() { return "InternalExpression.g"; } - // $ANTLR start "T__12" - public final void mT__12() throws RecognitionException { - try { - int _type = T__12; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:11:7: ( '==' ) - // InternalExpression.g:11:9: '==' - { - match("=="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__12" - - // $ANTLR start "T__13" - public final void mT__13() throws RecognitionException { - try { - int _type = T__13; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:12:7: ( '!=' ) - // InternalExpression.g:12:9: '!=' - { - match("!="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__13" - // $ANTLR start "T__14" public final void mT__14() throws RecognitionException { try { int _type = T__14; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:13:7: ( '>=' ) - // InternalExpression.g:13:9: '>=' + // InternalExpression.g:11:7: ( '=' ) + // InternalExpression.g:11:9: '=' { - match(">="); - + match('='); } @@ -155,10 +153,10 @@ public final void mT__15() throws RecognitionException { try { int _type = T__15; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:14:7: ( '<=' ) - // InternalExpression.g:14:9: '<=' + // InternalExpression.g:12:7: ( '||' ) + // InternalExpression.g:12:9: '||' { - match("<="); + match("||"); } @@ -176,10 +174,11 @@ public final void mT__16() throws RecognitionException { try { int _type = T__16; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:15:7: ( '>' ) - // InternalExpression.g:15:9: '>' + // InternalExpression.g:13:7: ( '&&' ) + // InternalExpression.g:13:9: '&&' { - match('>'); + match("&&"); + } @@ -196,10 +195,11 @@ public final void mT__17() throws RecognitionException { try { int _type = T__17; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:16:7: ( '<' ) - // InternalExpression.g:16:9: '<' + // InternalExpression.g:14:7: ( '==' ) + // InternalExpression.g:14:9: '==' { - match('<'); + match("=="); + } @@ -216,10 +216,11 @@ public final void mT__18() throws RecognitionException { try { int _type = T__18; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:17:7: ( '+' ) - // InternalExpression.g:17:9: '+' + // InternalExpression.g:15:7: ( '!=' ) + // InternalExpression.g:15:9: '!=' { - match('+'); + match("!="); + } @@ -236,10 +237,11 @@ public final void mT__19() throws RecognitionException { try { int _type = T__19; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:18:7: ( '-' ) - // InternalExpression.g:18:9: '-' + // InternalExpression.g:16:7: ( '>=' ) + // InternalExpression.g:16:9: '>=' { - match('-'); + match(">="); + } @@ -256,10 +258,11 @@ public final void mT__20() throws RecognitionException { try { int _type = T__20; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:19:7: ( '*' ) - // InternalExpression.g:19:9: '*' + // InternalExpression.g:17:7: ( '<=' ) + // InternalExpression.g:17:9: '<=' { - match('*'); + match("<="); + } @@ -276,10 +279,10 @@ public final void mT__21() throws RecognitionException { try { int _type = T__21; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:20:7: ( '/' ) - // InternalExpression.g:20:9: '/' + // InternalExpression.g:18:7: ( '>' ) + // InternalExpression.g:18:9: '>' { - match('/'); + match('>'); } @@ -296,10 +299,10 @@ public final void mT__22() throws RecognitionException { try { int _type = T__22; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:21:7: ( '!' ) - // InternalExpression.g:21:9: '!' + // InternalExpression.g:19:7: ( '<' ) + // InternalExpression.g:19:9: '<' { - match('!'); + match('<'); } @@ -316,11 +319,10 @@ public final void mT__23() throws RecognitionException { try { int _type = T__23; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:22:7: ( 'collect' ) - // InternalExpression.g:22:9: 'collect' + // InternalExpression.g:20:7: ( '+' ) + // InternalExpression.g:20:9: '+' { - match("collect"); - + match('+'); } @@ -337,11 +339,10 @@ public final void mT__24() throws RecognitionException { try { int _type = T__24; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:23:7: ( 'select' ) - // InternalExpression.g:23:9: 'select' + // InternalExpression.g:21:7: ( '-' ) + // InternalExpression.g:21:9: '-' { - match("select"); - + match('-'); } @@ -358,11 +359,10 @@ public final void mT__25() throws RecognitionException { try { int _type = T__25; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:24:7: ( 'selectFirst' ) - // InternalExpression.g:24:9: 'selectFirst' + // InternalExpression.g:22:7: ( '*' ) + // InternalExpression.g:22:9: '*' { - match("selectFirst"); - + match('*'); } @@ -379,11 +379,10 @@ public final void mT__26() throws RecognitionException { try { int _type = T__26; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:25:7: ( 'reject' ) - // InternalExpression.g:25:9: 'reject' + // InternalExpression.g:23:7: ( '/' ) + // InternalExpression.g:23:9: '/' { - match("reject"); - + match('/'); } @@ -400,11 +399,10 @@ public final void mT__27() throws RecognitionException { try { int _type = T__27; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:26:7: ( 'exists' ) - // InternalExpression.g:26:9: 'exists' + // InternalExpression.g:24:7: ( '!' ) + // InternalExpression.g:24:9: '!' { - match("exists"); - + match('!'); } @@ -421,10 +419,10 @@ public final void mT__28() throws RecognitionException { try { int _type = T__28; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:27:7: ( 'notExists' ) - // InternalExpression.g:27:9: 'notExists' + // InternalExpression.g:25:7: ( 'collect' ) + // InternalExpression.g:25:9: 'collect' { - match("notExists"); + match("collect"); } @@ -442,10 +440,10 @@ public final void mT__29() throws RecognitionException { try { int _type = T__29; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:28:7: ( 'sortBy' ) - // InternalExpression.g:28:9: 'sortBy' + // InternalExpression.g:26:7: ( 'select' ) + // InternalExpression.g:26:9: 'select' { - match("sortBy"); + match("select"); } @@ -463,10 +461,10 @@ public final void mT__30() throws RecognitionException { try { int _type = T__30; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:29:7: ( 'forAll' ) - // InternalExpression.g:29:9: 'forAll' + // InternalExpression.g:27:7: ( 'selectFirst' ) + // InternalExpression.g:27:9: 'selectFirst' { - match("forAll"); + match("selectFirst"); } @@ -484,10 +482,10 @@ public final void mT__31() throws RecognitionException { try { int _type = T__31; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:30:7: ( 'true' ) - // InternalExpression.g:30:9: 'true' + // InternalExpression.g:28:7: ( 'reject' ) + // InternalExpression.g:28:9: 'reject' { - match("true"); + match("reject"); } @@ -505,10 +503,10 @@ public final void mT__32() throws RecognitionException { try { int _type = T__32; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:31:7: ( 'false' ) - // InternalExpression.g:31:9: 'false' + // InternalExpression.g:29:7: ( 'exists' ) + // InternalExpression.g:29:9: 'exists' { - match("false"); + match("exists"); } @@ -526,10 +524,10 @@ public final void mT__33() throws RecognitionException { try { int _type = T__33; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:32:7: ( 'Collection' ) - // InternalExpression.g:32:9: 'Collection' + // InternalExpression.g:30:7: ( 'notExists' ) + // InternalExpression.g:30:9: 'notExists' { - match("Collection"); + match("notExists"); } @@ -547,10 +545,10 @@ public final void mT__34() throws RecognitionException { try { int _type = T__34; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:33:7: ( 'List' ) - // InternalExpression.g:33:9: 'List' + // InternalExpression.g:31:7: ( 'sortBy' ) + // InternalExpression.g:31:9: 'sortBy' { - match("List"); + match("sortBy"); } @@ -568,10 +566,10 @@ public final void mT__35() throws RecognitionException { try { int _type = T__35; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:34:7: ( 'Set' ) - // InternalExpression.g:34:9: 'Set' + // InternalExpression.g:32:7: ( 'forAll' ) + // InternalExpression.g:32:9: 'forAll' { - match("Set"); + match("forAll"); } @@ -589,10 +587,10 @@ public final void mT__36() throws RecognitionException { try { int _type = T__36; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:35:7: ( 'let' ) - // InternalExpression.g:35:9: 'let' + // InternalExpression.g:33:7: ( 'true' ) + // InternalExpression.g:33:9: 'true' { - match("let"); + match("true"); } @@ -610,10 +608,11 @@ public final void mT__37() throws RecognitionException { try { int _type = T__37; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:36:7: ( '=' ) - // InternalExpression.g:36:9: '=' + // InternalExpression.g:34:7: ( 'false' ) + // InternalExpression.g:34:9: 'false' { - match('='); + match("false"); + } @@ -630,10 +629,11 @@ public final void mT__38() throws RecognitionException { try { int _type = T__38; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:37:7: ( ':' ) - // InternalExpression.g:37:9: ':' + // InternalExpression.g:35:7: ( 'Collection' ) + // InternalExpression.g:35:9: 'Collection' { - match(':'); + match("Collection"); + } @@ -650,10 +650,11 @@ public final void mT__39() throws RecognitionException { try { int _type = T__39; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:38:7: ( '(' ) - // InternalExpression.g:38:9: '(' + // InternalExpression.g:36:7: ( 'List' ) + // InternalExpression.g:36:9: 'List' { - match('('); + match("List"); + } @@ -670,10 +671,11 @@ public final void mT__40() throws RecognitionException { try { int _type = T__40; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:39:7: ( ')' ) - // InternalExpression.g:39:9: ')' + // InternalExpression.g:37:7: ( 'Set' ) + // InternalExpression.g:37:9: 'Set' { - match(')'); + match("Set"); + } @@ -690,10 +692,10 @@ public final void mT__41() throws RecognitionException { try { int _type = T__41; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:40:7: ( '->' ) - // InternalExpression.g:40:9: '->' + // InternalExpression.g:38:7: ( '+=' ) + // InternalExpression.g:38:9: '+=' { - match("->"); + match("+="); } @@ -711,10 +713,11 @@ public final void mT__42() throws RecognitionException { try { int _type = T__42; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:41:7: ( '?' ) - // InternalExpression.g:41:9: '?' + // InternalExpression.g:39:7: ( '-=' ) + // InternalExpression.g:39:9: '-=' { - match('?'); + match("-="); + } @@ -731,10 +734,10 @@ public final void mT__43() throws RecognitionException { try { int _type = T__43; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:42:7: ( 'if' ) - // InternalExpression.g:42:9: 'if' + // InternalExpression.g:40:7: ( '*=' ) + // InternalExpression.g:40:9: '*=' { - match("if"); + match("*="); } @@ -752,10 +755,10 @@ public final void mT__44() throws RecognitionException { try { int _type = T__44; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:43:7: ( 'then' ) - // InternalExpression.g:43:9: 'then' + // InternalExpression.g:41:7: ( '/=' ) + // InternalExpression.g:41:9: '/=' { - match("then"); + match("/="); } @@ -773,10 +776,10 @@ public final void mT__45() throws RecognitionException { try { int _type = T__45; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:44:7: ( 'else' ) - // InternalExpression.g:44:9: 'else' + // InternalExpression.g:42:7: ( '%=' ) + // InternalExpression.g:42:9: '%=' { - match("else"); + match("%="); } @@ -794,10 +797,10 @@ public final void mT__46() throws RecognitionException { try { int _type = T__46; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:45:7: ( 'switch' ) - // InternalExpression.g:45:9: 'switch' + // InternalExpression.g:43:7: ( '===' ) + // InternalExpression.g:43:9: '===' { - match("switch"); + match("==="); } @@ -815,10 +818,11 @@ public final void mT__47() throws RecognitionException { try { int _type = T__47; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:46:7: ( '{' ) - // InternalExpression.g:46:9: '{' + // InternalExpression.g:44:7: ( '!==' ) + // InternalExpression.g:44:9: '!==' { - match('{'); + match("!=="); + } @@ -835,10 +839,10 @@ public final void mT__48() throws RecognitionException { try { int _type = T__48; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:47:7: ( 'default' ) - // InternalExpression.g:47:9: 'default' + // InternalExpression.g:45:7: ( '->' ) + // InternalExpression.g:45:9: '->' { - match("default"); + match("->"); } @@ -856,10 +860,11 @@ public final void mT__49() throws RecognitionException { try { int _type = T__49; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:48:7: ( '}' ) - // InternalExpression.g:48:9: '}' + // InternalExpression.g:46:7: ( '..<' ) + // InternalExpression.g:46:9: '..<' { - match('}'); + match("..<"); + } @@ -876,10 +881,10 @@ public final void mT__50() throws RecognitionException { try { int _type = T__50; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:49:7: ( 'case' ) - // InternalExpression.g:49:9: 'case' + // InternalExpression.g:47:7: ( '..' ) + // InternalExpression.g:47:9: '..' { - match("case"); + match(".."); } @@ -897,10 +902,11 @@ public final void mT__51() throws RecognitionException { try { int _type = T__51; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:50:7: ( '.' ) - // InternalExpression.g:50:9: '.' + // InternalExpression.g:48:7: ( '=>' ) + // InternalExpression.g:48:9: '=>' { - match('.'); + match("=>"); + } @@ -917,10 +923,11 @@ public final void mT__52() throws RecognitionException { try { int _type = T__52; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:51:7: ( ',' ) - // InternalExpression.g:51:9: ',' + // InternalExpression.g:49:7: ( '<>' ) + // InternalExpression.g:49:9: '<>' { - match(','); + match("<>"); + } @@ -937,10 +944,11 @@ public final void mT__53() throws RecognitionException { try { int _type = T__53; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:52:7: ( '|' ) - // InternalExpression.g:52:9: '|' + // InternalExpression.g:50:7: ( '?:' ) + // InternalExpression.g:50:9: '?:' { - match('|'); + match("?:"); + } @@ -957,10 +965,10 @@ public final void mT__54() throws RecognitionException { try { int _type = T__54; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:53:7: ( 'GLOBALVAR' ) - // InternalExpression.g:53:9: 'GLOBALVAR' + // InternalExpression.g:51:7: ( '**' ) + // InternalExpression.g:51:9: '**' { - match("GLOBALVAR"); + match("**"); } @@ -978,11 +986,10 @@ public final void mT__55() throws RecognitionException { try { int _type = T__55; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:54:7: ( 'new' ) - // InternalExpression.g:54:9: 'new' + // InternalExpression.g:52:7: ( '%' ) + // InternalExpression.g:52:9: '%' { - match("new"); - + match('%'); } @@ -999,10 +1006,11 @@ public final void mT__56() throws RecognitionException { try { int _type = T__56; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:55:7: ( '[' ) - // InternalExpression.g:55:9: '[' + // InternalExpression.g:53:7: ( '++' ) + // InternalExpression.g:53:9: '++' { - match('['); + match("++"); + } @@ -1019,10 +1027,11 @@ public final void mT__57() throws RecognitionException { try { int _type = T__57; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:56:7: ( ']' ) - // InternalExpression.g:56:9: ']' + // InternalExpression.g:54:7: ( '--' ) + // InternalExpression.g:54:9: '--' { - match(']'); + match("--"); + } @@ -1039,11 +1048,10 @@ public final void mT__58() throws RecognitionException { try { int _type = T__58; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:57:7: ( '::' ) - // InternalExpression.g:57:9: '::' + // InternalExpression.g:55:7: ( '.' ) + // InternalExpression.g:55:9: '.' { - match("::"); - + match('.'); } @@ -1060,10 +1068,10 @@ public final void mT__59() throws RecognitionException { try { int _type = T__59; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:58:7: ( '||' ) - // InternalExpression.g:58:9: '||' + // InternalExpression.g:56:7: ( 'val' ) + // InternalExpression.g:56:9: 'val' { - match("||"); + match("val"); } @@ -1081,10 +1089,10 @@ public final void mT__60() throws RecognitionException { try { int _type = T__60; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:59:7: ( '&&' ) - // InternalExpression.g:59:9: '&&' + // InternalExpression.g:57:7: ( 'extends' ) + // InternalExpression.g:57:9: 'extends' { - match("&&"); + match("extends"); } @@ -1102,10 +1110,10 @@ public final void mT__61() throws RecognitionException { try { int _type = T__61; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:60:7: ( 'implies' ) - // InternalExpression.g:60:9: 'implies' + // InternalExpression.g:58:7: ( 'static' ) + // InternalExpression.g:58:9: 'static' { - match("implies"); + match("static"); } @@ -1123,10 +1131,10 @@ public final void mT__62() throws RecognitionException { try { int _type = T__62; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:61:7: ( 'typeSelect' ) - // InternalExpression.g:61:9: 'typeSelect' + // InternalExpression.g:59:7: ( 'import' ) + // InternalExpression.g:59:9: 'import' { - match("typeSelect"); + match("import"); } @@ -1144,10 +1152,10 @@ public final void mT__63() throws RecognitionException { try { int _type = T__63; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:62:7: ( 'null' ) - // InternalExpression.g:62:9: 'null' + // InternalExpression.g:60:7: ( 'extension' ) + // InternalExpression.g:60:9: 'extension' { - match("null"); + match("extension"); } @@ -1160,65 +1168,57 @@ public final void mT__63() throws RecognitionException { } // $ANTLR end "T__63" - // $ANTLR start "RULE_REAL" - public final void mRULE_REAL() throws RecognitionException { + // $ANTLR start "T__64" + public final void mT__64() throws RecognitionException { try { - int _type = RULE_REAL; + int _type = T__64; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6456:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) - // InternalExpression.g:6456:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + // InternalExpression.g:61:7: ( 'super' ) + // InternalExpression.g:61:9: 'super' { - // InternalExpression.g:6456:13: ( '0' .. '9' )* - loop1: - do { - int alt1=2; - int LA1_0 = input.LA(1); - - if ( ((LA1_0>='0' && LA1_0<='9')) ) { - alt1=1; - } - - - switch (alt1) { - case 1 : - // InternalExpression.g:6456:14: '0' .. '9' - { - matchRange('0','9'); - - } - break; + match("super"); - default : - break loop1; - } - } while (true); - match('.'); - // InternalExpression.g:6456:29: ( '0' .. '9' )* - loop2: - do { - int alt2=2; - int LA2_0 = input.LA(1); + } - if ( ((LA2_0>='0' && LA2_0<='9')) ) { - alt2=1; - } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__64" + // $ANTLR start "T__65" + public final void mT__65() throws RecognitionException { + try { + int _type = T__65; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:62:7: ( 'let' ) + // InternalExpression.g:62:9: 'let' + { + match("let"); - switch (alt2) { - case 1 : - // InternalExpression.g:6456:30: '0' .. '9' - { - matchRange('0','9'); - } - break; + } - default : - break loop2; - } - } while (true); + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__65" + // $ANTLR start "T__66" + public final void mT__66() throws RecognitionException { + try { + int _type = T__66; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:63:7: ( ':' ) + // InternalExpression.g:63:9: ':' + { + match(':'); } @@ -1228,50 +1228,926 @@ public final void mRULE_REAL() throws RecognitionException { finally { } } - // $ANTLR end "RULE_REAL" + // $ANTLR end "T__66" - // $ANTLR start "RULE_ID" - public final void mRULE_ID() throws RecognitionException { + // $ANTLR start "T__67" + public final void mT__67() throws RecognitionException { try { - int _type = RULE_ID; + int _type = T__67; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6458:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalExpression.g:6458:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalExpression.g:64:7: ( '(' ) + // InternalExpression.g:64:9: '(' { - // InternalExpression.g:6458:11: ( '^' )? - int alt3=2; - int LA3_0 = input.LA(1); + match('('); - if ( (LA3_0=='^') ) { - alt3=1; } - switch (alt3) { - case 1 : - // InternalExpression.g:6458:11: '^' - { - match('^'); - } - break; + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__67" + + // $ANTLR start "T__68" + public final void mT__68() throws RecognitionException { + try { + int _type = T__68; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:65:7: ( ')' ) + // InternalExpression.g:65:9: ')' + { + match(')'); } - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { - input.consume(); + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__68" + + // $ANTLR start "T__69" + public final void mT__69() throws RecognitionException { + try { + int _type = T__69; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:66:7: ( '?' ) + // InternalExpression.g:66:9: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__69" + + // $ANTLR start "T__70" + public final void mT__70() throws RecognitionException { + try { + int _type = T__70; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:67:7: ( 'if' ) + // InternalExpression.g:67:9: 'if' + { + match("if"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__70" + + // $ANTLR start "T__71" + public final void mT__71() throws RecognitionException { + try { + int _type = T__71; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:68:7: ( 'then' ) + // InternalExpression.g:68:9: 'then' + { + match("then"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__71" + + // $ANTLR start "T__72" + public final void mT__72() throws RecognitionException { + try { + int _type = T__72; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:69:7: ( 'else' ) + // InternalExpression.g:69:9: 'else' + { + match("else"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__72" + + // $ANTLR start "T__73" + public final void mT__73() throws RecognitionException { + try { + int _type = T__73; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:70:7: ( 'switch' ) + // InternalExpression.g:70:9: 'switch' + { + match("switch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__73" + + // $ANTLR start "T__74" + public final void mT__74() throws RecognitionException { + try { + int _type = T__74; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:71:7: ( '{' ) + // InternalExpression.g:71:9: '{' + { + match('{'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__74" + + // $ANTLR start "T__75" + public final void mT__75() throws RecognitionException { + try { + int _type = T__75; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:72:7: ( 'default' ) + // InternalExpression.g:72:9: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__75" + + // $ANTLR start "T__76" + public final void mT__76() throws RecognitionException { + try { + int _type = T__76; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:73:7: ( '}' ) + // InternalExpression.g:73:9: '}' + { + match('}'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__76" + + // $ANTLR start "T__77" + public final void mT__77() throws RecognitionException { + try { + int _type = T__77; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:74:7: ( 'case' ) + // InternalExpression.g:74:9: 'case' + { + match("case"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__77" + + // $ANTLR start "T__78" + public final void mT__78() throws RecognitionException { + try { + int _type = T__78; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:75:7: ( ',' ) + // InternalExpression.g:75:9: ',' + { + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__78" + + // $ANTLR start "T__79" + public final void mT__79() throws RecognitionException { + try { + int _type = T__79; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:76:7: ( '|' ) + // InternalExpression.g:76:9: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__79" + + // $ANTLR start "T__80" + public final void mT__80() throws RecognitionException { + try { + int _type = T__80; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:77:7: ( 'GLOBALVAR' ) + // InternalExpression.g:77:9: 'GLOBALVAR' + { + match("GLOBALVAR"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__80" + + // $ANTLR start "T__81" + public final void mT__81() throws RecognitionException { + try { + int _type = T__81; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:78:7: ( 'new' ) + // InternalExpression.g:78:9: 'new' + { + match("new"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__81" + + // $ANTLR start "T__82" + public final void mT__82() throws RecognitionException { + try { + int _type = T__82; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:79:7: ( '[' ) + // InternalExpression.g:79:9: '[' + { + match('['); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__82" + + // $ANTLR start "T__83" + public final void mT__83() throws RecognitionException { + try { + int _type = T__83; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:80:7: ( ']' ) + // InternalExpression.g:80:9: ']' + { + match(']'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__83" + + // $ANTLR start "T__84" + public final void mT__84() throws RecognitionException { + try { + int _type = T__84; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:81:7: ( '::' ) + // InternalExpression.g:81:9: '::' + { + match("::"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__84" + + // $ANTLR start "T__85" + public final void mT__85() throws RecognitionException { + try { + int _type = T__85; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:82:7: ( 'instanceof' ) + // InternalExpression.g:82:9: 'instanceof' + { + match("instanceof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__85" + + // $ANTLR start "T__86" + public final void mT__86() throws RecognitionException { + try { + int _type = T__86; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:83:7: ( 'as' ) + // InternalExpression.g:83:9: 'as' + { + match("as"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__86" + + // $ANTLR start "T__87" + public final void mT__87() throws RecognitionException { + try { + int _type = T__87; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:84:7: ( '#' ) + // InternalExpression.g:84:9: '#' + { + match('#'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__87" + + // $ANTLR start "T__88" + public final void mT__88() throws RecognitionException { + try { + int _type = T__88; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:85:7: ( ';' ) + // InternalExpression.g:85:9: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:86:7: ( 'for' ) + // InternalExpression.g:86:9: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" + + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:87:7: ( 'while' ) + // InternalExpression.g:87:9: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__90" + + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { + try { + int _type = T__91; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:88:7: ( 'do' ) + // InternalExpression.g:88:9: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" + + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:89:7: ( 'null' ) + // InternalExpression.g:89:9: 'null' + { + match("null"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" + + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:90:7: ( 'typeof' ) + // InternalExpression.g:90:9: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:91:7: ( 'throw' ) + // InternalExpression.g:91:9: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:92:7: ( 'return' ) + // InternalExpression.g:92:9: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__95" + + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { + try { + int _type = T__96; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:93:7: ( 'try' ) + // InternalExpression.g:93:9: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" + + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:94:7: ( 'finally' ) + // InternalExpression.g:94:9: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__97" + + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { + try { + int _type = T__98; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:95:7: ( 'synchronized' ) + // InternalExpression.g:95:9: 'synchronized' + { + match("synchronized"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:96:7: ( 'catch' ) + // InternalExpression.g:96:9: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:97:8: ( '&' ) + // InternalExpression.g:97:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:98:8: ( 'implies' ) + // InternalExpression.g:98:10: 'implies' + { + match("implies"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:99:8: ( 'typeSelect' ) + // InternalExpression.g:99:10: 'typeSelect' + { + match("typeSelect"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:100:8: ( '?.' ) + // InternalExpression.g:100:10: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:101:8: ( 'var' ) + // InternalExpression.g:101:10: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "RULE_REAL" + public final void mRULE_REAL() throws RecognitionException { + try { + int _type = RULE_REAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:23303:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) + // InternalExpression.g:23303:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + { + // InternalExpression.g:23303:13: ( '0' .. '9' )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( ((LA1_0>='0' && LA1_0<='9')) ) { + alt1=1; + } + + switch (alt1) { + case 1 : + // InternalExpression.g:23303:14: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop1; + } + } while (true); + + match('.'); + // InternalExpression.g:23303:29: ( '0' .. '9' )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( ((LA2_0>='0' && LA2_0<='9')) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalExpression.g:23303:30: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_REAL" + + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:23305:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // InternalExpression.g:23305:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // InternalExpression.g:23305:12: ( '0x' | '0X' ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='0') ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1=='x') ) { + alt3=1; + } + else if ( (LA3_1=='X') ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } } else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalExpression.g:23305:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // InternalExpression.g:23305:18: '0X' + { + match("0X"); + + + } + break; + + } - // InternalExpression.g:6458:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalExpression.g:23305:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ + int cnt4=0; loop4: do { int alt4=2; int LA4_0 = input.LA(1); - if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='f')) ) { alt4=1; } @@ -1280,7 +2156,7 @@ public final void mRULE_ID() throws RecognitionException { case 1 : // InternalExpression.g: { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) { input.consume(); } @@ -1294,10 +2170,91 @@ public final void mRULE_ID() throws RecognitionException { break; default : - break loop4; + if ( cnt4 >= 1 ) break loop4; + EarlyExitException eee = + new EarlyExitException(4, input); + throw eee; } + cnt4++; } while (true); + // InternalExpression.g:23305:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='#') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalExpression.g:23305:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // InternalExpression.g:23305:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='B'||LA5_0=='b') ) { + alt5=1; + } + else if ( (LA5_0=='L'||LA5_0=='l') ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalExpression.g:23305:64: ( 'b' | 'B' ) ( 'i' | 'I' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='I'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExpression.g:23305:84: ( 'l' | 'L' ) + { + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + break; + + } + } @@ -1307,44 +2264,253 @@ public final void mRULE_ID() throws RecognitionException { finally { } } - // $ANTLR end "RULE_ID" + // $ANTLR end "RULE_HEX" // $ANTLR start "RULE_INT" public final void mRULE_INT() throws RecognitionException { try { int _type = RULE_INT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6460:10: ( ( '0' .. '9' )+ ) - // InternalExpression.g:6460:12: ( '0' .. '9' )+ + // InternalExpression.g:23307:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // InternalExpression.g:23307:12: '0' .. '9' ( '0' .. '9' | '_' )* { - // InternalExpression.g:6460:12: ( '0' .. '9' )+ - int cnt5=0; - loop5: + matchRange('0','9'); + // InternalExpression.g:23307:21: ( '0' .. '9' | '_' )* + loop7: do { - int alt5=2; - int LA5_0 = input.LA(1); + int alt7=2; + int LA7_0 = input.LA(1); - if ( ((LA5_0>='0' && LA5_0<='9')) ) { - alt5=1; + if ( ((LA7_0>='0' && LA7_0<='9')||LA7_0=='_') ) { + alt7=1; } - switch (alt5) { + switch (alt7) { case 1 : - // InternalExpression.g:6460:13: '0' .. '9' + // InternalExpression.g: { - matchRange('0','9'); + if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + } break; default : - if ( cnt5 >= 1 ) break loop5; - EarlyExitException eee = - new EarlyExitException(5, input); - throw eee; + break loop7; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_DECIMAL" + public final void mRULE_DECIMAL() throws RecognitionException { + try { + int _type = RULE_DECIMAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:23309:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // InternalExpression.g:23309:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // InternalExpression.g:23309:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='E'||LA9_0=='e') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalExpression.g:23309:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalExpression.g:23309:36: ( '+' | '-' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='+'||LA8_0=='-') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalExpression.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_INT(); + + } + break; + + } + + // InternalExpression.g:23309:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='B'||LA10_0=='b') ) { + alt10=1; + } + else if ( (LA10_0=='D'||LA10_0=='F'||LA10_0=='L'||LA10_0=='d'||LA10_0=='f'||LA10_0=='l') ) { + alt10=2; + } + switch (alt10) { + case 1 : + // InternalExpression.g:23309:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExpression.g:23309:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) + { + if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECIMAL" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:23311:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalExpression.g:23311:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + { + // InternalExpression.g:23311:11: ( '^' )? + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0=='^') ) { + alt11=1; + } + switch (alt11) { + case 1 : + // InternalExpression.g:23311:11: '^' + { + match('^'); + + } + break; + + } + + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalExpression.g:23311:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0=='$'||(LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalExpression.g: + { + if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop12; } - cnt5++; } while (true); @@ -1356,54 +2522,54 @@ public final void mRULE_INT() throws RecognitionException { finally { } } - // $ANTLR end "RULE_INT" + // $ANTLR end "RULE_ID" // $ANTLR start "RULE_STRING" public final void mRULE_STRING() throws RecognitionException { try { int _type = RULE_STRING; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6462:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalExpression.g:6462:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalExpression.g:23313:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalExpression.g:23313:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) { - // InternalExpression.g:6462:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt8=2; - int LA8_0 = input.LA(1); + // InternalExpression.g:23313:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA8_0=='\"') ) { - alt8=1; + if ( (LA17_0=='\"') ) { + alt17=1; } - else if ( (LA8_0=='\'') ) { - alt8=2; + else if ( (LA17_0=='\'') ) { + alt17=2; } else { NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + new NoViableAltException("", 17, 0, input); throw nvae; } - switch (alt8) { + switch (alt17) { case 1 : - // InternalExpression.g:6462:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + // InternalExpression.g:23313:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? { match('\"'); - // InternalExpression.g:6462:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop6: + // InternalExpression.g:23313:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop13: do { - int alt6=3; - int LA6_0 = input.LA(1); + int alt13=3; + int LA13_0 = input.LA(1); - if ( (LA6_0=='\\') ) { - alt6=1; + if ( (LA13_0=='\\') ) { + alt13=1; } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; + else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) { + alt13=2; } - switch (alt6) { + switch (alt13) { case 1 : - // InternalExpression.g:6462:21: '\\\\' . + // InternalExpression.g:23313:21: '\\\\' . { match('\\'); matchAny(); @@ -1411,7 +2577,7 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= } break; case 2 : - // InternalExpression.g:6462:28: ~ ( ( '\\\\' | '\"' ) ) + // InternalExpression.g:23313:28: ~ ( ( '\\\\' | '\"' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1427,35 +2593,52 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= break; default : - break loop6; + break loop13; } } while (true); - match('\"'); + // InternalExpression.g:23313:44: ( '\"' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\"') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalExpression.g:23313:44: '\"' + { + match('\"'); + + } + break; + + } + } break; case 2 : - // InternalExpression.g:6462:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + // InternalExpression.g:23313:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? { match('\''); - // InternalExpression.g:6462:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop7: + // InternalExpression.g:23313:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop15: do { - int alt7=3; - int LA7_0 = input.LA(1); + int alt15=3; + int LA15_0 = input.LA(1); - if ( (LA7_0=='\\') ) { - alt7=1; + if ( (LA15_0=='\\') ) { + alt15=1; } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; + else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) { + alt15=2; } - switch (alt7) { + switch (alt15) { case 1 : - // InternalExpression.g:6462:54: '\\\\' . + // InternalExpression.g:23313:55: '\\\\' . { match('\\'); matchAny(); @@ -1463,7 +2646,7 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= } break; case 2 : - // InternalExpression.g:6462:61: ~ ( ( '\\\\' | '\\'' ) ) + // InternalExpression.g:23313:62: ~ ( ( '\\\\' | '\\'' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1479,11 +2662,28 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= break; default : - break loop7; + break loop15; } } while (true); - match('\''); + // InternalExpression.g:23313:79: ( '\\'' )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalExpression.g:23313:79: '\\'' + { + match('\''); + + } + break; + + } + } break; @@ -1506,37 +2706,37 @@ public final void mRULE_ML_COMMENT() throws RecognitionException { try { int _type = RULE_ML_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6464:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalExpression.g:6464:19: '/*' ( options {greedy=false; } : . )* '*/' + // InternalExpression.g:23315:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalExpression.g:23315:19: '/*' ( options {greedy=false; } : . )* '*/' { match("/*"); - // InternalExpression.g:6464:24: ( options {greedy=false; } : . )* - loop9: + // InternalExpression.g:23315:24: ( options {greedy=false; } : . )* + loop18: do { - int alt9=2; - int LA9_0 = input.LA(1); + int alt18=2; + int LA18_0 = input.LA(1); - if ( (LA9_0=='*') ) { - int LA9_1 = input.LA(2); + if ( (LA18_0=='*') ) { + int LA18_1 = input.LA(2); - if ( (LA9_1=='/') ) { - alt9=2; + if ( (LA18_1=='/') ) { + alt18=2; } - else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) { + alt18=1; } } - else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) { + alt18=1; } - switch (alt9) { + switch (alt18) { case 1 : - // InternalExpression.g:6464:52: . + // InternalExpression.g:23315:52: . { matchAny(); @@ -1544,7 +2744,7 @@ else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { break; default : - break loop9; + break loop18; } } while (true); @@ -1566,25 +2766,25 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { try { int _type = RULE_SL_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6466:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalExpression.g:6466:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + // InternalExpression.g:23317:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalExpression.g:23317:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? { match("//"); - // InternalExpression.g:6466:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop10: + // InternalExpression.g:23317:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop19: do { - int alt10=2; - int LA10_0 = input.LA(1); + int alt19=2; + int LA19_0 = input.LA(1); - if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\uFFFF')) ) { - alt10=1; + if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { + alt19=1; } - switch (alt10) { + switch (alt19) { case 1 : - // InternalExpression.g:6466:24: ~ ( ( '\\n' | '\\r' ) ) + // InternalExpression.g:23317:24: ~ ( ( '\\n' | '\\r' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1600,31 +2800,31 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { break; default : - break loop10; + break loop19; } } while (true); - // InternalExpression.g:6466:40: ( ( '\\r' )? '\\n' )? - int alt12=2; - int LA12_0 = input.LA(1); + // InternalExpression.g:23317:40: ( ( '\\r' )? '\\n' )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA12_0=='\n'||LA12_0=='\r') ) { - alt12=1; + if ( (LA21_0=='\n'||LA21_0=='\r') ) { + alt21=1; } - switch (alt12) { + switch (alt21) { case 1 : - // InternalExpression.g:6466:41: ( '\\r' )? '\\n' + // InternalExpression.g:23317:41: ( '\\r' )? '\\n' { - // InternalExpression.g:6466:41: ( '\\r' )? - int alt11=2; - int LA11_0 = input.LA(1); + // InternalExpression.g:23317:41: ( '\\r' )? + int alt20=2; + int LA20_0 = input.LA(1); - if ( (LA11_0=='\r') ) { - alt11=1; + if ( (LA20_0=='\r') ) { + alt20=1; } - switch (alt11) { + switch (alt20) { case 1 : - // InternalExpression.g:6466:41: '\\r' + // InternalExpression.g:23317:41: '\\r' { match('\r'); @@ -1656,22 +2856,22 @@ public final void mRULE_WS() throws RecognitionException { try { int _type = RULE_WS; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6468:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalExpression.g:6468:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + // InternalExpression.g:23319:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalExpression.g:23319:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ { - // InternalExpression.g:6468:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt13=0; - loop13: + // InternalExpression.g:23319:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt22=0; + loop22: do { - int alt13=2; - int LA13_0 = input.LA(1); + int alt22=2; + int LA22_0 = input.LA(1); - if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) { - alt13=1; + if ( ((LA22_0>='\t' && LA22_0<='\n')||LA22_0=='\r'||LA22_0==' ') ) { + alt22=1; } - switch (alt13) { + switch (alt22) { case 1 : // InternalExpression.g: { @@ -1689,12 +2889,12 @@ public final void mRULE_WS() throws RecognitionException { break; default : - if ( cnt13 >= 1 ) break loop13; + if ( cnt22 >= 1 ) break loop22; EarlyExitException eee = - new EarlyExitException(13, input); + new EarlyExitException(22, input); throw eee; } - cnt13++; + cnt22++; } while (true); @@ -1713,8 +2913,8 @@ public final void mRULE_ANY_OTHER() throws RecognitionException { try { int _type = RULE_ANY_OTHER; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:6470:16: ( . ) - // InternalExpression.g:6470:18: . + // InternalExpression.g:23321:16: ( . ) + // InternalExpression.g:23321:18: . { matchAny(); @@ -1729,425 +2929,712 @@ public final void mRULE_ANY_OTHER() throws RecognitionException { // $ANTLR end "RULE_ANY_OTHER" public void mTokens() throws RecognitionException { - // InternalExpression.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | RULE_REAL | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt14=60; - alt14 = dfa14.predict(input); - switch (alt14) { + // InternalExpression.g:1:8: ( T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | RULE_REAL | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt23=101; + alt23 = dfa23.predict(input); + switch (alt23) { case 1 : - // InternalExpression.g:1:10: T__12 + // InternalExpression.g:1:10: T__14 + { + mT__14(); + + } + break; + case 2 : + // InternalExpression.g:1:16: T__15 + { + mT__15(); + + } + break; + case 3 : + // InternalExpression.g:1:22: T__16 + { + mT__16(); + + } + break; + case 4 : + // InternalExpression.g:1:28: T__17 + { + mT__17(); + + } + break; + case 5 : + // InternalExpression.g:1:34: T__18 + { + mT__18(); + + } + break; + case 6 : + // InternalExpression.g:1:40: T__19 + { + mT__19(); + + } + break; + case 7 : + // InternalExpression.g:1:46: T__20 + { + mT__20(); + + } + break; + case 8 : + // InternalExpression.g:1:52: T__21 + { + mT__21(); + + } + break; + case 9 : + // InternalExpression.g:1:58: T__22 + { + mT__22(); + + } + break; + case 10 : + // InternalExpression.g:1:64: T__23 + { + mT__23(); + + } + break; + case 11 : + // InternalExpression.g:1:70: T__24 + { + mT__24(); + + } + break; + case 12 : + // InternalExpression.g:1:76: T__25 + { + mT__25(); + + } + break; + case 13 : + // InternalExpression.g:1:82: T__26 + { + mT__26(); + + } + break; + case 14 : + // InternalExpression.g:1:88: T__27 + { + mT__27(); + + } + break; + case 15 : + // InternalExpression.g:1:94: T__28 + { + mT__28(); + + } + break; + case 16 : + // InternalExpression.g:1:100: T__29 + { + mT__29(); + + } + break; + case 17 : + // InternalExpression.g:1:106: T__30 + { + mT__30(); + + } + break; + case 18 : + // InternalExpression.g:1:112: T__31 + { + mT__31(); + + } + break; + case 19 : + // InternalExpression.g:1:118: T__32 + { + mT__32(); + + } + break; + case 20 : + // InternalExpression.g:1:124: T__33 + { + mT__33(); + + } + break; + case 21 : + // InternalExpression.g:1:130: T__34 + { + mT__34(); + + } + break; + case 22 : + // InternalExpression.g:1:136: T__35 + { + mT__35(); + + } + break; + case 23 : + // InternalExpression.g:1:142: T__36 + { + mT__36(); + + } + break; + case 24 : + // InternalExpression.g:1:148: T__37 + { + mT__37(); + + } + break; + case 25 : + // InternalExpression.g:1:154: T__38 + { + mT__38(); + + } + break; + case 26 : + // InternalExpression.g:1:160: T__39 + { + mT__39(); + + } + break; + case 27 : + // InternalExpression.g:1:166: T__40 + { + mT__40(); + + } + break; + case 28 : + // InternalExpression.g:1:172: T__41 + { + mT__41(); + + } + break; + case 29 : + // InternalExpression.g:1:178: T__42 + { + mT__42(); + + } + break; + case 30 : + // InternalExpression.g:1:184: T__43 + { + mT__43(); + + } + break; + case 31 : + // InternalExpression.g:1:190: T__44 + { + mT__44(); + + } + break; + case 32 : + // InternalExpression.g:1:196: T__45 + { + mT__45(); + + } + break; + case 33 : + // InternalExpression.g:1:202: T__46 + { + mT__46(); + + } + break; + case 34 : + // InternalExpression.g:1:208: T__47 + { + mT__47(); + + } + break; + case 35 : + // InternalExpression.g:1:214: T__48 + { + mT__48(); + + } + break; + case 36 : + // InternalExpression.g:1:220: T__49 + { + mT__49(); + + } + break; + case 37 : + // InternalExpression.g:1:226: T__50 + { + mT__50(); + + } + break; + case 38 : + // InternalExpression.g:1:232: T__51 + { + mT__51(); + + } + break; + case 39 : + // InternalExpression.g:1:238: T__52 + { + mT__52(); + + } + break; + case 40 : + // InternalExpression.g:1:244: T__53 { - mT__12(); + mT__53(); } break; - case 2 : - // InternalExpression.g:1:16: T__13 + case 41 : + // InternalExpression.g:1:250: T__54 { - mT__13(); + mT__54(); } break; - case 3 : - // InternalExpression.g:1:22: T__14 + case 42 : + // InternalExpression.g:1:256: T__55 { - mT__14(); + mT__55(); } break; - case 4 : - // InternalExpression.g:1:28: T__15 + case 43 : + // InternalExpression.g:1:262: T__56 { - mT__15(); + mT__56(); } break; - case 5 : - // InternalExpression.g:1:34: T__16 + case 44 : + // InternalExpression.g:1:268: T__57 { - mT__16(); + mT__57(); } break; - case 6 : - // InternalExpression.g:1:40: T__17 + case 45 : + // InternalExpression.g:1:274: T__58 { - mT__17(); + mT__58(); } break; - case 7 : - // InternalExpression.g:1:46: T__18 + case 46 : + // InternalExpression.g:1:280: T__59 { - mT__18(); + mT__59(); } break; - case 8 : - // InternalExpression.g:1:52: T__19 + case 47 : + // InternalExpression.g:1:286: T__60 { - mT__19(); + mT__60(); } break; - case 9 : - // InternalExpression.g:1:58: T__20 + case 48 : + // InternalExpression.g:1:292: T__61 { - mT__20(); + mT__61(); } break; - case 10 : - // InternalExpression.g:1:64: T__21 + case 49 : + // InternalExpression.g:1:298: T__62 { - mT__21(); + mT__62(); } break; - case 11 : - // InternalExpression.g:1:70: T__22 + case 50 : + // InternalExpression.g:1:304: T__63 { - mT__22(); + mT__63(); } break; - case 12 : - // InternalExpression.g:1:76: T__23 + case 51 : + // InternalExpression.g:1:310: T__64 { - mT__23(); + mT__64(); } break; - case 13 : - // InternalExpression.g:1:82: T__24 + case 52 : + // InternalExpression.g:1:316: T__65 { - mT__24(); + mT__65(); } break; - case 14 : - // InternalExpression.g:1:88: T__25 + case 53 : + // InternalExpression.g:1:322: T__66 { - mT__25(); + mT__66(); } break; - case 15 : - // InternalExpression.g:1:94: T__26 + case 54 : + // InternalExpression.g:1:328: T__67 { - mT__26(); + mT__67(); } break; - case 16 : - // InternalExpression.g:1:100: T__27 + case 55 : + // InternalExpression.g:1:334: T__68 { - mT__27(); + mT__68(); } break; - case 17 : - // InternalExpression.g:1:106: T__28 + case 56 : + // InternalExpression.g:1:340: T__69 { - mT__28(); + mT__69(); } break; - case 18 : - // InternalExpression.g:1:112: T__29 + case 57 : + // InternalExpression.g:1:346: T__70 { - mT__29(); + mT__70(); } break; - case 19 : - // InternalExpression.g:1:118: T__30 + case 58 : + // InternalExpression.g:1:352: T__71 { - mT__30(); + mT__71(); } break; - case 20 : - // InternalExpression.g:1:124: T__31 + case 59 : + // InternalExpression.g:1:358: T__72 { - mT__31(); + mT__72(); } break; - case 21 : - // InternalExpression.g:1:130: T__32 + case 60 : + // InternalExpression.g:1:364: T__73 { - mT__32(); + mT__73(); } break; - case 22 : - // InternalExpression.g:1:136: T__33 + case 61 : + // InternalExpression.g:1:370: T__74 { - mT__33(); + mT__74(); } break; - case 23 : - // InternalExpression.g:1:142: T__34 + case 62 : + // InternalExpression.g:1:376: T__75 { - mT__34(); + mT__75(); } break; - case 24 : - // InternalExpression.g:1:148: T__35 + case 63 : + // InternalExpression.g:1:382: T__76 { - mT__35(); + mT__76(); } break; - case 25 : - // InternalExpression.g:1:154: T__36 + case 64 : + // InternalExpression.g:1:388: T__77 { - mT__36(); + mT__77(); } break; - case 26 : - // InternalExpression.g:1:160: T__37 + case 65 : + // InternalExpression.g:1:394: T__78 { - mT__37(); + mT__78(); } break; - case 27 : - // InternalExpression.g:1:166: T__38 + case 66 : + // InternalExpression.g:1:400: T__79 { - mT__38(); + mT__79(); } break; - case 28 : - // InternalExpression.g:1:172: T__39 + case 67 : + // InternalExpression.g:1:406: T__80 { - mT__39(); + mT__80(); } break; - case 29 : - // InternalExpression.g:1:178: T__40 + case 68 : + // InternalExpression.g:1:412: T__81 { - mT__40(); + mT__81(); } break; - case 30 : - // InternalExpression.g:1:184: T__41 + case 69 : + // InternalExpression.g:1:418: T__82 { - mT__41(); + mT__82(); } break; - case 31 : - // InternalExpression.g:1:190: T__42 + case 70 : + // InternalExpression.g:1:424: T__83 { - mT__42(); + mT__83(); } break; - case 32 : - // InternalExpression.g:1:196: T__43 + case 71 : + // InternalExpression.g:1:430: T__84 { - mT__43(); + mT__84(); } break; - case 33 : - // InternalExpression.g:1:202: T__44 + case 72 : + // InternalExpression.g:1:436: T__85 { - mT__44(); + mT__85(); } break; - case 34 : - // InternalExpression.g:1:208: T__45 + case 73 : + // InternalExpression.g:1:442: T__86 { - mT__45(); + mT__86(); } break; - case 35 : - // InternalExpression.g:1:214: T__46 + case 74 : + // InternalExpression.g:1:448: T__87 { - mT__46(); + mT__87(); } break; - case 36 : - // InternalExpression.g:1:220: T__47 + case 75 : + // InternalExpression.g:1:454: T__88 { - mT__47(); + mT__88(); } break; - case 37 : - // InternalExpression.g:1:226: T__48 + case 76 : + // InternalExpression.g:1:460: T__89 { - mT__48(); + mT__89(); } break; - case 38 : - // InternalExpression.g:1:232: T__49 + case 77 : + // InternalExpression.g:1:466: T__90 { - mT__49(); + mT__90(); } break; - case 39 : - // InternalExpression.g:1:238: T__50 + case 78 : + // InternalExpression.g:1:472: T__91 { - mT__50(); + mT__91(); } break; - case 40 : - // InternalExpression.g:1:244: T__51 + case 79 : + // InternalExpression.g:1:478: T__92 { - mT__51(); + mT__92(); } break; - case 41 : - // InternalExpression.g:1:250: T__52 + case 80 : + // InternalExpression.g:1:484: T__93 { - mT__52(); + mT__93(); } break; - case 42 : - // InternalExpression.g:1:256: T__53 + case 81 : + // InternalExpression.g:1:490: T__94 { - mT__53(); + mT__94(); } break; - case 43 : - // InternalExpression.g:1:262: T__54 + case 82 : + // InternalExpression.g:1:496: T__95 { - mT__54(); + mT__95(); } break; - case 44 : - // InternalExpression.g:1:268: T__55 + case 83 : + // InternalExpression.g:1:502: T__96 { - mT__55(); + mT__96(); } break; - case 45 : - // InternalExpression.g:1:274: T__56 + case 84 : + // InternalExpression.g:1:508: T__97 { - mT__56(); + mT__97(); } break; - case 46 : - // InternalExpression.g:1:280: T__57 + case 85 : + // InternalExpression.g:1:514: T__98 { - mT__57(); + mT__98(); } break; - case 47 : - // InternalExpression.g:1:286: T__58 + case 86 : + // InternalExpression.g:1:520: T__99 { - mT__58(); + mT__99(); } break; - case 48 : - // InternalExpression.g:1:292: T__59 + case 87 : + // InternalExpression.g:1:526: T__100 { - mT__59(); + mT__100(); } break; - case 49 : - // InternalExpression.g:1:298: T__60 + case 88 : + // InternalExpression.g:1:533: T__101 { - mT__60(); + mT__101(); } break; - case 50 : - // InternalExpression.g:1:304: T__61 + case 89 : + // InternalExpression.g:1:540: T__102 { - mT__61(); + mT__102(); } break; - case 51 : - // InternalExpression.g:1:310: T__62 + case 90 : + // InternalExpression.g:1:547: T__103 { - mT__62(); + mT__103(); } break; - case 52 : - // InternalExpression.g:1:316: T__63 + case 91 : + // InternalExpression.g:1:554: T__104 { - mT__63(); + mT__104(); } break; - case 53 : - // InternalExpression.g:1:322: RULE_REAL + case 92 : + // InternalExpression.g:1:561: RULE_REAL { mRULE_REAL(); } break; - case 54 : - // InternalExpression.g:1:332: RULE_ID + case 93 : + // InternalExpression.g:1:571: RULE_HEX { - mRULE_ID(); + mRULE_HEX(); } break; - case 55 : - // InternalExpression.g:1:340: RULE_INT + case 94 : + // InternalExpression.g:1:580: RULE_INT { mRULE_INT(); } break; - case 56 : - // InternalExpression.g:1:349: RULE_STRING + case 95 : + // InternalExpression.g:1:589: RULE_DECIMAL + { + mRULE_DECIMAL(); + + } + break; + case 96 : + // InternalExpression.g:1:602: RULE_ID + { + mRULE_ID(); + + } + break; + case 97 : + // InternalExpression.g:1:610: RULE_STRING { mRULE_STRING(); } break; - case 57 : - // InternalExpression.g:1:361: RULE_ML_COMMENT + case 98 : + // InternalExpression.g:1:622: RULE_ML_COMMENT { mRULE_ML_COMMENT(); } break; - case 58 : - // InternalExpression.g:1:377: RULE_SL_COMMENT + case 99 : + // InternalExpression.g:1:638: RULE_SL_COMMENT { mRULE_SL_COMMENT(); } break; - case 59 : - // InternalExpression.g:1:393: RULE_WS + case 100 : + // InternalExpression.g:1:654: RULE_WS { mRULE_WS(); } break; - case 60 : - // InternalExpression.g:1:401: RULE_ANY_OTHER + case 101 : + // InternalExpression.g:1:662: RULE_ANY_OTHER { mRULE_ANY_OTHER(); @@ -2159,387 +3646,502 @@ public void mTokens() throws RecognitionException { } - protected DFA14 dfa14 = new DFA14(this); - static final String DFA14_eotS = - "\1\uffff\1\53\1\55\1\57\1\61\1\uffff\1\64\1\uffff\1\70\13\73\1\117\3\uffff\1\73\1\uffff\1\73\1\uffff\1\130\1\uffff\1\134\1\73\2\uffff\1\51\1\141\1\51\1\uffff\2\51\21\uffff\2\73\1\uffff\22\73\5\uffff\1\171\1\73\1\uffff\1\73\6\uffff\1\73\4\uffff\1\141\2\uffff\11\73\1\u0086\10\73\1\u008f\1\u0090\1\uffff\4\73\1\u0095\5\73\1\u009b\1\73\1\uffff\1\u009d\2\73\1\u00a0\1\u00a1\2\73\1\u00a4\2\uffff\4\73\1\uffff\5\73\1\uffff\1\73\1\uffff\1\73\1\u00b0\2\uffff\2\73\1\uffff\4\73\1\u00b8\1\u00b9\1\u00ba\1\u00bb\1\u00bc\1\73\1\u00be\1\uffff\5\73\1\u00c4\1\73\5\uffff\1\73\1\uffff\2\73\1\u00c9\1\u00ca\1\73\1\uffff\4\73\2\uffff\2\73\1\u00d2\2\73\1\u00d5\1\73\1\uffff\1\u00d7\1\u00d8\1\uffff\1\u00d9\3\uffff"; - static final String DFA14_eofS = - "\u00da\uffff"; - static final String DFA14_minS = - "\1\0\4\75\1\uffff\1\76\1\uffff\1\52\1\141\2\145\1\154\1\145\1\141\1\150\1\157\1\151\2\145\1\72\3\uffff\1\146\1\uffff\1\145\1\uffff\1\60\1\uffff\1\174\1\114\2\uffff\1\46\1\56\1\101\1\uffff\2\0\21\uffff\1\154\1\163\1\uffff\1\154\1\162\1\151\1\152\1\151\1\163\1\164\1\167\1\154\1\162\1\154\1\165\1\145\1\160\1\154\1\163\2\164\5\uffff\1\60\1\160\1\uffff\1\146\6\uffff\1\117\4\uffff\1\56\2\uffff\1\154\2\145\2\164\1\145\1\163\1\145\1\105\1\60\1\154\1\101\1\163\1\145\1\156\1\145\1\154\1\164\2\60\1\uffff\1\154\1\141\1\102\1\145\1\60\1\143\1\102\2\143\1\164\1\60\1\170\1\uffff\1\60\1\154\1\145\2\60\1\123\1\145\1\60\2\uffff\1\151\1\165\1\101\1\143\1\uffff\1\164\1\171\1\150\1\164\1\163\1\uffff\1\151\1\uffff\1\154\1\60\2\uffff\1\145\1\143\1\uffff\1\145\1\154\1\114\1\164\5\60\1\163\1\60\1\uffff\1\154\1\164\1\163\1\164\1\126\1\60\1\151\5\uffff\1\164\1\uffff\1\145\1\151\2\60\1\101\1\uffff\1\162\1\163\1\143\1\157\2\uffff\1\122\1\163\1\60\1\164\1\156\1\60\1\164\1\uffff\2\60\1\uffff\1\60\3\uffff"; - static final String DFA14_maxS = - "\1\uffff\4\75\1\uffff\1\76\1\uffff\1\57\1\157\1\167\1\145\1\170\1\165\1\157\1\171\1\157\1\151\2\145\1\72\3\uffff\1\155\1\uffff\1\145\1\uffff\1\71\1\uffff\1\174\1\114\2\uffff\1\46\1\71\1\172\1\uffff\2\uffff\21\uffff\1\154\1\163\1\uffff\1\154\1\162\1\151\1\152\1\151\1\163\1\164\1\167\1\154\1\162\1\154\1\165\1\145\1\160\1\154\1\163\2\164\5\uffff\1\172\1\160\1\uffff\1\146\6\uffff\1\117\4\uffff\1\71\2\uffff\1\154\2\145\2\164\1\145\1\163\1\145\1\105\1\172\1\154\1\101\1\163\1\145\1\156\1\145\1\154\1\164\2\172\1\uffff\1\154\1\141\1\102\1\145\1\172\1\143\1\102\2\143\1\164\1\172\1\170\1\uffff\1\172\1\154\1\145\2\172\1\123\1\145\1\172\2\uffff\1\151\1\165\1\101\1\143\1\uffff\1\164\1\171\1\150\1\164\1\163\1\uffff\1\151\1\uffff\1\154\1\172\2\uffff\1\145\1\143\1\uffff\1\145\1\154\1\114\1\164\5\172\1\163\1\172\1\uffff\1\154\1\164\1\163\1\164\1\126\1\172\1\151\5\uffff\1\164\1\uffff\1\145\1\151\2\172\1\101\1\uffff\1\162\1\163\1\143\1\157\2\uffff\1\122\1\163\1\172\1\164\1\156\1\172\1\164\1\uffff\2\172\1\uffff\1\172\3\uffff"; - static final String DFA14_acceptS = - "\5\uffff\1\7\1\uffff\1\11\15\uffff\1\34\1\35\1\37\1\uffff\1\44\1\uffff\1\46\1\uffff\1\51\2\uffff\1\55\1\56\3\uffff\1\66\2\uffff\1\73\1\74\1\1\1\32\1\2\1\13\1\3\1\5\1\4\1\6\1\7\1\36\1\10\1\11\1\71\1\72\1\12\2\uffff\1\66\22\uffff\1\57\1\33\1\34\1\35\1\37\2\uffff\1\44\1\uffff\1\46\1\50\1\65\1\51\1\60\1\52\1\uffff\1\55\1\56\1\61\1\67\1\uffff\1\70\1\73\24\uffff\1\40\14\uffff\1\54\10\uffff\1\30\1\31\4\uffff\1\47\5\uffff\1\42\1\uffff\1\64\2\uffff\1\24\1\41\2\uffff\1\27\13\uffff\1\25\7\uffff\1\15\1\22\1\43\1\17\1\20\1\uffff\1\23\5\uffff\1\14\4\uffff\1\62\1\45\7\uffff\1\21\2\uffff\1\53\1\uffff\1\63\1\26\1\16"; - static final String DFA14_specialS = - "\1\0\45\uffff\1\1\1\2\u00b2\uffff}>"; - static final String[] DFA14_transitionS = { - "\11\51\2\50\2\51\1\50\22\51\1\50\1\2\1\46\3\51\1\42\1\47\1\25\1\26\1\7\1\5\1\35\1\6\1\34\1\10\12\43\1\24\1\51\1\4\1\1\1\3\1\27\1\51\2\45\1\20\3\45\1\37\4\45\1\21\6\45\1\22\7\45\1\40\1\51\1\41\1\44\1\45\1\51\2\45\1\11\1\32\1\14\1\16\2\45\1\30\2\45\1\23\1\45\1\15\3\45\1\13\1\12\1\17\6\45\1\31\1\36\1\33\uff82\51", - "\1\52", - "\1\54", - "\1\56", - "\1\60", - "", - "\1\63", - "", - "\1\66\4\uffff\1\67", - "\1\72\15\uffff\1\71", - "\1\74\11\uffff\1\75\7\uffff\1\76", - "\1\77", - "\1\101\13\uffff\1\100", - "\1\103\11\uffff\1\102\5\uffff\1\104", - "\1\106\15\uffff\1\105", - "\1\110\11\uffff\1\107\6\uffff\1\111", - "\1\112", - "\1\113", - "\1\114", - "\1\115", - "\1\116", - "", - "", - "", - "\1\123\6\uffff\1\124", - "", + protected DFA23 dfa23 = new DFA23(this); + static final String DFA23_eotS = + "\1\uffff\1\63\1\65\1\67\1\71\1\73\1\76\1\101\1\105\1\110\1\114\12\117\1\146\1\150\1\154\3\117\1\163\3\uffff\1\117\2\uffff\1\117\2\uffff\1\117\2\uffff\1\117\2\u0083\1\60\5\uffff\1\u008a\6\uffff\1\u008c\24\uffff\2\117\1\uffff\25\117\2\uffff\1\u00aa\5\uffff\2\117\1\u00ae\2\117\5\uffff\1\117\1\u00b2\2\uffff\1\117\2\uffff\1\u00b4\2\uffff\1\117\2\uffff\2\u0083\7\uffff\17\117\1\u00c5\1\117\1\u00c8\3\117\1\u00cc\5\117\1\u00d2\2\uffff\1\u00d3\1\u00d4\1\117\1\uffff\1\117\1\u00d8\1\117\1\uffff\1\117\1\uffff\2\117\1\u00dd\13\117\1\u00e9\1\117\1\uffff\1\u00eb\1\117\1\uffff\2\117\1\u00ef\1\uffff\1\u00f0\3\117\1\u00f5\3\uffff\3\117\1\uffff\4\117\1\uffff\1\u00fd\3\117\1\u0101\6\117\1\uffff\1\117\1\uffff\1\117\1\u010b\1\117\2\uffff\1\u010d\3\117\1\uffff\5\117\1\u0116\1\117\1\uffff\1\u0119\1\u011a\1\u011b\1\uffff\1\u011c\1\117\1\u011e\1\u011f\1\u0120\3\117\1\u0124\1\uffff\1\117\1\uffff\1\u0126\2\117\1\u0129\4\117\1\uffff\1\u012e\1\117\4\uffff\1\117\3\uffff\1\u0131\2\117\1\uffff\1\u0134\1\uffff\2\117\1\uffff\1\u0137\1\117\1\u0139\1\117\1\uffff\2\117\1\uffff\2\117\1\uffff\2\117\1\uffff\1\117\1\uffff\3\117\1\u0145\1\u0146\3\117\1\u014a\2\117\2\uffff\1\u014d\1\u014e\1\u014f\1\uffff\1\u0150\1\117\4\uffff\1\u0152\1\uffff"; + static final String DFA23_eofS = + "\u0153\uffff"; + static final String DFA23_minS = + "\1\0\1\75\1\174\1\46\3\75\1\53\1\55\2\52\1\141\2\145\1\154\1\145\1\141\1\150\1\157\1\151\1\145\1\75\2\56\1\141\1\146\1\145\1\72\3\uffff\1\145\2\uffff\1\114\2\uffff\1\163\2\uffff\1\150\2\56\1\44\5\uffff\1\75\6\uffff\1\75\24\uffff\1\154\1\163\1\uffff\1\154\1\162\1\141\1\160\1\151\1\156\1\152\1\151\1\163\1\164\1\167\1\154\1\162\1\154\1\156\1\165\1\145\1\160\1\154\1\163\1\164\2\uffff\1\74\5\uffff\1\154\1\160\1\44\1\163\1\164\5\uffff\1\146\1\44\2\uffff\1\117\2\uffff\1\44\2\uffff\1\151\2\uffff\1\56\1\60\7\uffff\1\154\1\145\1\143\1\145\2\164\1\145\1\164\1\143\1\145\1\165\1\163\2\145\1\105\1\44\1\154\1\44\1\163\1\141\1\145\1\44\1\156\1\157\1\145\1\154\1\164\1\44\2\uffff\2\44\1\154\1\uffff\1\164\1\44\1\141\1\uffff\1\102\1\uffff\1\154\1\145\1\44\1\150\1\143\1\102\1\151\1\162\1\143\1\150\1\143\1\162\1\164\1\156\1\44\1\170\1\uffff\1\44\1\154\1\uffff\1\145\1\154\1\44\1\uffff\1\44\1\167\1\123\1\145\1\44\3\uffff\1\162\1\151\1\141\1\uffff\1\165\1\101\1\145\1\143\1\uffff\1\44\1\164\1\171\1\143\1\44\1\150\1\162\1\164\1\156\1\163\1\144\1\uffff\1\151\1\uffff\1\154\1\44\1\154\2\uffff\1\44\1\146\1\145\1\143\1\uffff\1\164\1\145\1\156\1\154\1\114\1\44\1\164\1\uffff\3\44\1\uffff\1\44\1\157\3\44\1\163\1\151\1\163\1\44\1\uffff\1\171\1\uffff\1\44\1\154\1\164\1\44\1\163\1\143\1\164\1\126\1\uffff\1\44\1\151\4\uffff\1\156\3\uffff\1\44\1\157\1\164\1\uffff\1\44\1\uffff\1\145\1\151\1\uffff\1\44\1\145\1\44\1\101\1\uffff\1\162\1\151\1\uffff\1\156\1\163\1\uffff\1\143\1\157\1\uffff\1\157\1\uffff\1\122\1\163\1\172\2\44\1\164\1\156\1\146\1\44\1\164\1\145\2\uffff\3\44\1\uffff\1\44\1\144\4\uffff\1\44\1\uffff"; + static final String DFA23_maxS = + "\1\uffff\1\76\1\174\1\46\2\75\1\76\1\75\1\76\2\75\1\157\1\171\1\145\1\170\1\165\1\157\1\171\1\157\1\151\1\145\1\75\1\71\1\72\1\141\1\156\1\145\1\72\3\uffff\1\157\2\uffff\1\114\2\uffff\1\163\2\uffff\1\150\1\170\1\154\1\172\5\uffff\1\75\6\uffff\1\75\24\uffff\1\154\1\164\1\uffff\1\154\1\162\1\141\1\160\1\151\1\156\2\164\1\163\1\164\1\167\1\154\1\162\1\154\1\156\1\171\1\162\1\160\1\154\1\163\1\164\2\uffff\1\74\5\uffff\1\162\1\160\1\172\1\163\1\164\5\uffff\1\146\1\172\2\uffff\1\117\2\uffff\1\172\2\uffff\1\151\2\uffff\2\154\7\uffff\1\154\1\145\1\143\1\145\2\164\1\145\1\164\1\143\1\145\1\165\1\163\2\145\1\105\1\172\1\154\1\172\1\163\1\141\1\145\1\172\1\156\1\157\1\145\1\154\1\164\1\172\2\uffff\2\172\1\157\1\uffff\1\164\1\172\1\141\1\uffff\1\102\1\uffff\1\154\1\145\1\172\1\150\1\143\1\102\1\151\1\162\1\143\1\150\1\143\1\162\1\164\1\156\1\172\1\170\1\uffff\1\172\1\154\1\uffff\1\145\1\154\1\172\1\uffff\1\172\1\167\1\157\1\145\1\172\3\uffff\1\162\1\151\1\141\1\uffff\1\165\1\101\1\145\1\143\1\uffff\1\172\1\164\1\171\1\143\1\172\1\150\1\162\1\164\1\156\2\163\1\uffff\1\151\1\uffff\1\154\1\172\1\154\2\uffff\1\172\1\146\1\145\1\143\1\uffff\1\164\1\145\1\156\1\154\1\114\1\172\1\164\1\uffff\3\172\1\uffff\1\172\1\157\3\172\1\163\1\151\1\163\1\172\1\uffff\1\171\1\uffff\1\172\1\154\1\164\1\172\1\163\1\143\1\164\1\126\1\uffff\1\172\1\151\4\uffff\1\156\3\uffff\1\172\1\157\1\164\1\uffff\1\172\1\uffff\1\145\1\151\1\uffff\1\172\1\145\1\172\1\101\1\uffff\1\162\1\151\1\uffff\1\156\1\163\1\uffff\1\143\1\157\1\uffff\1\157\1\uffff\1\122\1\163\3\172\1\164\1\156\1\146\1\172\1\164\1\145\2\uffff\3\172\1\uffff\1\172\1\144\4\uffff\1\172\1\uffff"; + static final String DFA23_acceptS = + "\34\uffff\1\66\1\67\1\75\1\uffff\1\77\1\101\1\uffff\1\105\1\106\1\uffff\1\112\1\113\4\uffff\1\140\2\141\1\144\1\145\1\uffff\1\46\1\1\1\2\1\102\1\3\1\127\1\uffff\1\16\1\6\1\10\1\7\1\47\1\11\1\34\1\53\1\12\1\35\1\43\1\54\1\13\1\36\1\51\1\14\1\37\1\142\1\143\1\15\2\uffff\1\140\25\uffff\1\40\1\52\1\uffff\1\55\1\134\1\50\1\132\1\70\5\uffff\1\107\1\65\1\66\1\67\1\75\2\uffff\1\77\1\101\1\uffff\1\105\1\106\1\uffff\1\112\1\113\1\uffff\1\135\1\136\2\uffff\1\137\1\141\1\144\1\41\1\4\1\42\1\5\34\uffff\1\44\1\45\3\uffff\1\71\3\uffff\1\116\1\uffff\1\111\20\uffff\1\104\2\uffff\1\114\3\uffff\1\123\5\uffff\1\33\1\56\1\133\3\uffff\1\64\4\uffff\1\100\13\uffff\1\73\1\uffff\1\117\3\uffff\1\27\1\72\4\uffff\1\32\7\uffff\1\126\3\uffff\1\63\11\uffff\1\30\1\uffff\1\121\10\uffff\1\115\2\uffff\1\20\1\25\1\60\1\74\1\uffff\1\22\1\122\1\23\3\uffff\1\26\1\uffff\1\120\2\uffff\1\61\4\uffff\1\17\2\uffff\1\57\2\uffff\1\124\2\uffff\1\130\1\uffff\1\76\13\uffff\1\62\1\24\3\uffff\1\103\2\uffff\1\131\1\31\1\110\1\21\1\uffff\1\125"; + static final String DFA23_specialS = + "\1\0\u0152\uffff}>"; + static final String[] DFA23_transitionS = { + "\11\60\2\57\2\60\1\57\22\60\1\57\1\4\1\55\1\46\1\54\1\25\1\3\1\56\1\34\1\35\1\11\1\7\1\41\1\10\1\26\1\12\1\51\11\52\1\33\1\47\1\6\1\1\1\5\1\27\1\60\2\54\1\22\3\54\1\42\4\54\1\23\6\54\1\24\7\54\1\43\1\60\1\44\1\53\1\54\1\60\1\45\1\54\1\13\1\37\1\16\1\20\2\54\1\31\2\54\1\32\1\54\1\17\3\54\1\15\1\14\1\21\1\54\1\30\1\50\3\54\1\36\1\2\1\40\uff82\60", + "\1\61\1\62", + "\1\64", + "\1\66", + "\1\70", + "\1\72", + "\1\74\1\75", + "\1\100\21\uffff\1\77", + "\1\104\17\uffff\1\102\1\103", + "\1\107\22\uffff\1\106", + "\1\112\4\uffff\1\113\15\uffff\1\111", + "\1\116\15\uffff\1\115", + "\1\120\11\uffff\1\121\4\uffff\1\122\1\123\1\uffff\1\124\1\uffff\1\125", "\1\126", + "\1\130\13\uffff\1\127", + "\1\132\11\uffff\1\131\5\uffff\1\133", + "\1\135\7\uffff\1\136\5\uffff\1\134", + "\1\140\11\uffff\1\137\6\uffff\1\141", + "\1\142", + "\1\143", + "\1\144", + "\1\145", + "\1\147\1\uffff\12\151", + "\1\153\13\uffff\1\152", + "\1\155", + "\1\157\6\uffff\1\156\1\160", + "\1\161", + "\1\162", "", - "\12\131", "", - "\1\133", - "\1\135", "", + "\1\167\11\uffff\1\170", "", - "\1\140", - "\1\131\1\uffff\12\142", - "\32\73\4\uffff\1\73\1\uffff\32\73", "", - "\0\143", - "\0\143", + "\1\173", "", "", + "\1\176", "", "", + "\1\u0081", + "\1\151\1\uffff\12\u0084\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\13\uffff\1\u0082\6\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\13\uffff\1\u0082", + "\1\151\1\uffff\12\u0084\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\22\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086", + "\1\117\34\uffff\32\117\4\uffff\1\117\1\uffff\32\117", "", "", "", "", "", + "\1\u0089", "", "", "", "", "", "", + "\1\u008b", "", "", - "\1\145", - "\1\146", - "", - "\1\147", - "\1\150", - "\1\151", - "\1\152", - "\1\153", - "\1\154", - "\1\155", - "\1\156", - "\1\157", - "\1\160", - "\1\161", - "\1\162", - "\1\163", - "\1\164", - "\1\165", - "\1\166", - "\1\167", - "\1\170", "", "", "", "", "", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\172", "", - "\1\173", "", "", "", "", "", "", - "\1\174", "", "", "", "", - "\1\131\1\uffff\12\142", "", "", - "\1\175", - "\1\176", - "\1\177", - "\1\u0080", - "\1\u0081", - "\1\u0082", - "\1\u0083", - "\1\u0084", - "\1\u0085", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u0087", - "\1\u0088", - "\1\u0089", - "\1\u008a", - "\1\u008b", - "\1\u008c", "\1\u008d", - "\1\u008e", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\u008e\1\u008f", "", + "\1\u0090", "\1\u0091", "\1\u0092", "\1\u0093", "\1\u0094", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u0096", - "\1\u0097", - "\1\u0098", - "\1\u0099", + "\1\u0095", + "\1\u0096\11\uffff\1\u0097", + "\1\u0098\12\uffff\1\u0099", "\1\u009a", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\u009b", "\1\u009c", - "", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\u009d", "\1\u009e", "\1\u009f", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u00a2", - "\1\u00a3", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "", - "", + "\1\u00a0", + "\1\u00a1\3\uffff\1\u00a2", + "\1\u00a3\14\uffff\1\u00a4", "\1\u00a5", "\1\u00a6", "\1\u00a7", "\1\u00a8", "", + "", "\1\u00a9", - "\1\u00aa", - "\1\u00ab", - "\1\u00ac", - "\1\u00ad", "", - "\1\u00ae", "", + "", + "", + "", + "\1\u00ab\5\uffff\1\u00ac", + "\1\u00ad", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", "\1\u00af", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\u00b0", + "", + "", + "", "", "", "\1\u00b1", - "\1\u00b2", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "", "", "\1\u00b3", - "\1\u00b4", + "", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "", + "", "\1\u00b5", + "", + "", + "\1\151\1\uffff\12\u0084\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\22\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086", + "\12\u0085\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\22\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086", + "", + "", + "", + "", + "", + "", + "", "\1\u00b6", - "\12\73\7\uffff\5\73\1\u00b7\24\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\u00b7", + "\1\u00b8", + "\1\u00b9", + "\1\u00ba", + "\1\u00bb", + "\1\u00bc", "\1\u00bd", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "", + "\1\u00be", "\1\u00bf", "\1\u00c0", "\1\u00c1", "\1\u00c2", "\1\u00c3", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u00c5", + "\1\u00c4", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00c6", + "\1\117\13\uffff\12\117\7\uffff\1\u00c7\31\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00c9", + "\1\u00ca", + "\1\u00cb", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00cd", + "\1\u00ce", + "\1\u00cf", + "\1\u00d0", + "\1\u00d1", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", "", "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00d6\2\uffff\1\u00d5", "", + "\1\u00d7", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00d9", "", + "\1\u00da", "", - "\1\u00c6", + "\1\u00db", + "\1\u00dc", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00de", + "\1\u00df", + "\1\u00e0", + "\1\u00e1", + "\1\u00e2", + "\1\u00e3", + "\1\u00e4", + "\1\u00e5", + "\1\u00e6", + "\1\u00e7", + "\1\u00e8", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00ea", "", - "\1\u00c7", - "\1\u00c8", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u00cb", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00ec", "", - "\1\u00cc", - "\1\u00cd", - "\1\u00ce", - "\1\u00cf", + "\1\u00ed", + "\1\u00ee", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00f1", + "\1\u00f3\33\uffff\1\u00f2", + "\1\u00f4", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "", + "", + "", + "\1\u00f6", + "\1\u00f7", + "\1\u00f8", + "", + "\1\u00f9", + "\1\u00fa", + "\1\u00fb", + "\1\u00fc", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u00fe", + "\1\u00ff", + "\1\u0100", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0102", + "\1\u0103", + "\1\u0104", + "\1\u0105", + "\1\u0106", + "\1\u0107\16\uffff\1\u0108", + "", + "\1\u0109", + "", + "\1\u010a", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u010c", "", - "\1\u00d0", - "\1\u00d1", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u00d3", - "\1\u00d4", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\1\u00d6", "", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u010e", + "\1\u010f", + "\1\u0110", "", - "\12\73\7\uffff\32\73\4\uffff\1\73\1\uffff\32\73", + "\1\u0111", + "\1\u0112", + "\1\u0113", + "\1\u0114", + "\1\u0115", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0117", "", + "\1\117\13\uffff\12\117\7\uffff\5\117\1\u0118\24\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u011d", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0121", + "\1\u0122", + "\1\u0123", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "", + "\1\u0125", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0127", + "\1\u0128", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u012a", + "\1\u012b", + "\1\u012c", + "\1\u012d", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u012f", + "", + "", + "", + "", + "\1\u0130", + "", + "", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0132", + "\1\u0133", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "", + "\1\u0135", + "\1\u0136", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0138", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u013a", + "", + "\1\u013b", + "\1\u013c", + "", + "\1\u013d", + "\1\u013e", + "", + "\1\u013f", + "\1\u0140", + "", + "\1\u0141", + "", + "\1\u0142", + "\1\u0143", + "\1\u0144", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0147", + "\1\u0148", + "\1\u0149", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u014b", + "\1\u014c", + "", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", + "\1\u0151", + "", + "", + "", + "", + "\1\117\13\uffff\12\117\7\uffff\32\117\4\uffff\1\117\1\uffff\32\117", "" }; - static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); - static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); - static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); - static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); - static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); - static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); - static final short[][] DFA14_transition; + static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); + static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); + static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); + static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); + static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); + static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); + static final short[][] DFA23_transition; static { - int numStates = DFA14_transitionS.length; - DFA14_transition = new short[numStates][]; + int numStates = DFA23_transitionS.length; + DFA23_transition = new short[numStates][]; for (int i=0; i') ) {s = 3;} + else if ( (LA23_0=='&') ) {s = 3;} - else if ( (LA14_0=='<') ) {s = 4;} + else if ( (LA23_0=='!') ) {s = 4;} - else if ( (LA14_0=='+') ) {s = 5;} + else if ( (LA23_0=='>') ) {s = 5;} - else if ( (LA14_0=='-') ) {s = 6;} + else if ( (LA23_0=='<') ) {s = 6;} - else if ( (LA14_0=='*') ) {s = 7;} + else if ( (LA23_0=='+') ) {s = 7;} - else if ( (LA14_0=='/') ) {s = 8;} + else if ( (LA23_0=='-') ) {s = 8;} - else if ( (LA14_0=='c') ) {s = 9;} + else if ( (LA23_0=='*') ) {s = 9;} - else if ( (LA14_0=='s') ) {s = 10;} + else if ( (LA23_0=='/') ) {s = 10;} - else if ( (LA14_0=='r') ) {s = 11;} + else if ( (LA23_0=='c') ) {s = 11;} - else if ( (LA14_0=='e') ) {s = 12;} + else if ( (LA23_0=='s') ) {s = 12;} - else if ( (LA14_0=='n') ) {s = 13;} + else if ( (LA23_0=='r') ) {s = 13;} - else if ( (LA14_0=='f') ) {s = 14;} + else if ( (LA23_0=='e') ) {s = 14;} - else if ( (LA14_0=='t') ) {s = 15;} + else if ( (LA23_0=='n') ) {s = 15;} - else if ( (LA14_0=='C') ) {s = 16;} + else if ( (LA23_0=='f') ) {s = 16;} - else if ( (LA14_0=='L') ) {s = 17;} + else if ( (LA23_0=='t') ) {s = 17;} - else if ( (LA14_0=='S') ) {s = 18;} + else if ( (LA23_0=='C') ) {s = 18;} - else if ( (LA14_0=='l') ) {s = 19;} + else if ( (LA23_0=='L') ) {s = 19;} - else if ( (LA14_0==':') ) {s = 20;} + else if ( (LA23_0=='S') ) {s = 20;} - else if ( (LA14_0=='(') ) {s = 21;} + else if ( (LA23_0=='%') ) {s = 21;} - else if ( (LA14_0==')') ) {s = 22;} + else if ( (LA23_0=='.') ) {s = 22;} - else if ( (LA14_0=='?') ) {s = 23;} + else if ( (LA23_0=='?') ) {s = 23;} - else if ( (LA14_0=='i') ) {s = 24;} + else if ( (LA23_0=='v') ) {s = 24;} - else if ( (LA14_0=='{') ) {s = 25;} + else if ( (LA23_0=='i') ) {s = 25;} - else if ( (LA14_0=='d') ) {s = 26;} + else if ( (LA23_0=='l') ) {s = 26;} - else if ( (LA14_0=='}') ) {s = 27;} + else if ( (LA23_0==':') ) {s = 27;} - else if ( (LA14_0=='.') ) {s = 28;} + else if ( (LA23_0=='(') ) {s = 28;} - else if ( (LA14_0==',') ) {s = 29;} + else if ( (LA23_0==')') ) {s = 29;} - else if ( (LA14_0=='|') ) {s = 30;} + else if ( (LA23_0=='{') ) {s = 30;} - else if ( (LA14_0=='G') ) {s = 31;} + else if ( (LA23_0=='d') ) {s = 31;} - else if ( (LA14_0=='[') ) {s = 32;} + else if ( (LA23_0=='}') ) {s = 32;} - else if ( (LA14_0==']') ) {s = 33;} + else if ( (LA23_0==',') ) {s = 33;} - else if ( (LA14_0=='&') ) {s = 34;} + else if ( (LA23_0=='G') ) {s = 34;} - else if ( ((LA14_0>='0' && LA14_0<='9')) ) {s = 35;} + else if ( (LA23_0=='[') ) {s = 35;} - else if ( (LA14_0=='^') ) {s = 36;} + else if ( (LA23_0==']') ) {s = 36;} - else if ( ((LA14_0>='A' && LA14_0<='B')||(LA14_0>='D' && LA14_0<='F')||(LA14_0>='H' && LA14_0<='K')||(LA14_0>='M' && LA14_0<='R')||(LA14_0>='T' && LA14_0<='Z')||LA14_0=='_'||(LA14_0>='a' && LA14_0<='b')||(LA14_0>='g' && LA14_0<='h')||(LA14_0>='j' && LA14_0<='k')||LA14_0=='m'||(LA14_0>='o' && LA14_0<='q')||(LA14_0>='u' && LA14_0<='z')) ) {s = 37;} + else if ( (LA23_0=='a') ) {s = 37;} - else if ( (LA14_0=='\"') ) {s = 38;} + else if ( (LA23_0=='#') ) {s = 38;} - else if ( (LA14_0=='\'') ) {s = 39;} + else if ( (LA23_0==';') ) {s = 39;} - else if ( ((LA14_0>='\t' && LA14_0<='\n')||LA14_0=='\r'||LA14_0==' ') ) {s = 40;} + else if ( (LA23_0=='w') ) {s = 40;} - else if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||(LA14_0>='#' && LA14_0<='%')||LA14_0==';'||LA14_0=='@'||LA14_0=='\\'||LA14_0=='`'||(LA14_0>='~' && LA14_0<='\uFFFF')) ) {s = 41;} + else if ( (LA23_0=='0') ) {s = 41;} - if ( s>=0 ) return s; - break; - case 1 : - int LA14_38 = input.LA(1); + else if ( ((LA23_0>='1' && LA23_0<='9')) ) {s = 42;} - s = -1; - if ( ((LA14_38>='\u0000' && LA14_38<='\uFFFF')) ) {s = 99;} + else if ( (LA23_0=='^') ) {s = 43;} - else s = 41; + else if ( (LA23_0=='$'||(LA23_0>='A' && LA23_0<='B')||(LA23_0>='D' && LA23_0<='F')||(LA23_0>='H' && LA23_0<='K')||(LA23_0>='M' && LA23_0<='R')||(LA23_0>='T' && LA23_0<='Z')||LA23_0=='_'||LA23_0=='b'||(LA23_0>='g' && LA23_0<='h')||(LA23_0>='j' && LA23_0<='k')||LA23_0=='m'||(LA23_0>='o' && LA23_0<='q')||LA23_0=='u'||(LA23_0>='x' && LA23_0<='z')) ) {s = 44;} - if ( s>=0 ) return s; - break; - case 2 : - int LA14_39 = input.LA(1); + else if ( (LA23_0=='\"') ) {s = 45;} - s = -1; - if ( ((LA14_39>='\u0000' && LA14_39<='\uFFFF')) ) {s = 99;} + else if ( (LA23_0=='\'') ) {s = 46;} + + else if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {s = 47;} - else s = 41; + else if ( ((LA23_0>='\u0000' && LA23_0<='\b')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\u001F')||LA23_0=='@'||LA23_0=='\\'||LA23_0=='`'||(LA23_0>='~' && LA23_0<='\uFFFF')) ) {s = 48;} if ( s>=0 ) return s; break; } NoViableAltException nvae = - new NoViableAltException(getDescription(), 14, _s, input); + new NoViableAltException(getDescription(), 23, _s, input); error(nvae); throw nvae; } diff --git a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionParser.java b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionParser.java index 64e687b025..48a6e3b3e7 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionParser.java +++ b/com.avaloq.tools.ddk.xtext.expression.ide/src-gen/com/avaloq/tools/ddk/xtext/expression/ide/contentassist/antlr/internal/InternalExpressionParser.java @@ -23,21 +23,14 @@ @SuppressWarnings("all") public class InternalExpressionParser extends AbstractInternalContentAssistParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_ID", "RULE_INT", "RULE_REAL", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'Collection'", "'List'", "'Set'", "'let'", "'='", "':'", "'('", "')'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'{'", "'default'", "'}'", "'case'", "'.'", "','", "'|'", "'GLOBALVAR'", "'new'", "'['", "']'", "'::'", "'||'", "'&&'", "'implies'", "'typeSelect'", "'null'" + "", "", "", "", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_REAL", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'='", "'||'", "'&&'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'Collection'", "'List'", "'Set'", "'+='", "'-='", "'*='", "'/='", "'%='", "'==='", "'!=='", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'**'", "'%'", "'++'", "'--'", "'.'", "'val'", "'extends'", "'static'", "'import'", "'extension'", "'super'", "'let'", "':'", "'('", "')'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'{'", "'default'", "'}'", "'case'", "','", "'|'", "'GLOBALVAR'", "'new'", "'['", "']'", "'::'", "'instanceof'", "'as'", "'#'", "';'", "'for'", "'while'", "'do'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'&'", "'implies'", "'typeSelect'", "'?.'", "'var'" }; + public static final int RULE_HEX=5; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -46,23 +39,17 @@ public class InternalExpressionParser extends AbstractInternalContentAssistParse public static final int T__60=60; public static final int T__61=61; public static final int RULE_ID=4; - public static final int RULE_REAL=6; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; - public static final int RULE_INT=5; - public static final int T__29=29; - public static final int T__22=22; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; - public static final int T__24=24; - public static final int T__25=25; + public static final int RULE_REAL=8; + public static final int RULE_INT=6; + public static final int T__66=66; + public static final int RULE_ML_COMMENT=10; + public static final int T__67=67; + public static final int T__68=68; + public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; - public static final int T__21=21; - public static final int RULE_STRING=7; - public static final int RULE_SL_COMMENT=9; + public static final int T__64=64; + public static final int T__65=65; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; @@ -70,12 +57,9 @@ public class InternalExpressionParser extends AbstractInternalContentAssistParse public static final int T__34=34; public static final int T__35=35; public static final int T__36=36; - public static final int EOF=-1; public static final int T__30=30; public static final int T__31=31; public static final int T__32=32; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -86,6 +70,63 @@ public class InternalExpressionParser extends AbstractInternalContentAssistParse public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=9; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__75=75; + public static final int T__76=76; + public static final int T__80=80; + public static final int T__81=81; + public static final int T__82=82; + public static final int T__83=83; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__89=89; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__87=87; // delegates // delegators @@ -3257,418 +3298,315 @@ public final void ruleIdentifier() throws RecognitionException { // $ANTLR end "ruleIdentifier" - // $ANTLR start "rule__Expression__Alternatives" - // InternalExpression.g:978:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ); - public final void rule__Expression__Alternatives() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpression" + // InternalExpression.g:979:1: entryRuleXExpression : ruleXExpression EOF ; + public final void entryRuleXExpression() throws RecognitionException { try { - // InternalExpression.g:982:1: ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ) - int alt1=3; - alt1 = dfa1.predict(input); - switch (alt1) { - case 1 : - // InternalExpression.g:983:2: ( ruleLetExpression ) - { - // InternalExpression.g:983:2: ( ruleLetExpression ) - // InternalExpression.g:984:3: ruleLetExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleLetExpression(); + // InternalExpression.g:980:1: ( ruleXExpression EOF ) + // InternalExpression.g:981:1: ruleXExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - } + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXExpression" - } - break; - case 2 : - // InternalExpression.g:989:2: ( ( ruleCastedExpression ) ) - { - // InternalExpression.g:989:2: ( ( ruleCastedExpression ) ) - // InternalExpression.g:990:3: ( ruleCastedExpression ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - // InternalExpression.g:991:3: ( ruleCastedExpression ) - // InternalExpression.g:991:4: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + // $ANTLR start "ruleXExpression" + // InternalExpression.g:988:1: ruleXExpression : ( ruleXAssignment ) ; + public final void ruleXExpression() throws RecognitionException { - state._fsp--; - if (state.failed) return ; + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:992:2: ( ( ruleXAssignment ) ) + // InternalExpression.g:993:2: ( ruleXAssignment ) + { + // InternalExpression.g:993:2: ( ruleXAssignment ) + // InternalExpression.g:994:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } + } - } + } - } - break; - case 3 : - // InternalExpression.g:995:2: ( ruleChainExpression ) - { - // InternalExpression.g:995:2: ( ruleChainExpression ) - // InternalExpression.g:996:3: ruleChainExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleChainExpression(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleXExpression" - } - break; + // $ANTLR start "entryRuleXAssignment" + // InternalExpression.g:1004:1: entryRuleXAssignment : ruleXAssignment EOF ; + public final void entryRuleXAssignment() throws RecognitionException { + try { + // InternalExpression.g:1005:1: ( ruleXAssignment EOF ) + // InternalExpression.g:1006:1: ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_1); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Expression__Alternatives" + // $ANTLR end "entryRuleXAssignment" - // $ANTLR start "rule__ChainedExpression__Alternatives" - // InternalExpression.g:1005:1: rule__ChainedExpression__Alternatives : ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ); - public final void rule__ChainedExpression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXAssignment" + // InternalExpression.g:1013:1: ruleXAssignment : ( ( rule__XAssignment__Alternatives ) ) ; + public final void ruleXAssignment() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1009:1: ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ) - int alt2=3; - switch ( input.LA(1) ) { - case 43: - { - alt2=1; - } - break; - case RULE_ID: - case RULE_INT: - case RULE_REAL: - case RULE_STRING: - case 19: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 39: - case 47: - case 54: - case 55: - case 62: - case 63: - { - alt2=2; - } - break; - case 46: - { - alt2=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 2, 0, input); - - throw nvae; + // InternalExpression.g:1017:2: ( ( ( rule__XAssignment__Alternatives ) ) ) + // InternalExpression.g:1018:2: ( ( rule__XAssignment__Alternatives ) ) + { + // InternalExpression.g:1018:2: ( ( rule__XAssignment__Alternatives ) ) + // InternalExpression.g:1019:3: ( rule__XAssignment__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getAlternatives()); } + // InternalExpression.g:1020:3: ( rule__XAssignment__Alternatives ) + // InternalExpression.g:1020:4: rule__XAssignment__Alternatives + { + pushFollow(FOLLOW_2); + rule__XAssignment__Alternatives(); - switch (alt2) { - case 1 : - // InternalExpression.g:1010:2: ( ruleIfExpressionKw ) - { - // InternalExpression.g:1010:2: ( ruleIfExpressionKw ) - // InternalExpression.g:1011:3: ruleIfExpressionKw - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleIfExpressionKw(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getAlternatives()); + } - } - break; - case 2 : - // InternalExpression.g:1016:2: ( ruleIfExpressionTri ) - { - // InternalExpression.g:1016:2: ( ruleIfExpressionTri ) - // InternalExpression.g:1017:3: ruleIfExpressionTri - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleIfExpressionTri(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 3 : - // InternalExpression.g:1022:2: ( ruleSwitchExpression ) - { - // InternalExpression.g:1022:2: ( ruleSwitchExpression ) - // InternalExpression.g:1023:3: ruleSwitchExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleSwitchExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); - } + } + return ; + } + // $ANTLR end "ruleXAssignment" - } + // $ANTLR start "entryRuleOpSingleAssign" + // InternalExpression.g:1029:1: entryRuleOpSingleAssign : ruleOpSingleAssign EOF ; + public final void entryRuleOpSingleAssign() throws RecognitionException { + try { + // InternalExpression.g:1030:1: ( ruleOpSingleAssign EOF ) + // InternalExpression.g:1031:1: ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignRule()); + } + pushFollow(FOLLOW_1); + ruleOpSingleAssign(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainedExpression__Alternatives" + // $ANTLR end "entryRuleOpSingleAssign" - // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // InternalExpression.g:1032:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ); - public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "ruleOpSingleAssign" + // InternalExpression.g:1038:1: ruleOpSingleAssign : ( '=' ) ; + public final void ruleOpSingleAssign() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1036:1: ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ) - int alt3=6; - switch ( input.LA(1) ) { - case 12: - { - alt3=1; - } - break; - case 13: - { - alt3=2; - } - break; - case 14: - { - alt3=3; - } - break; - case 15: - { - alt3=4; - } - break; - case 16: - { - alt3=5; - } - break; - case 17: - { - alt3=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); - - throw nvae; + // InternalExpression.g:1042:2: ( ( '=' ) ) + // InternalExpression.g:1043:2: ( '=' ) + { + // InternalExpression.g:1043:2: ( '=' ) + // InternalExpression.g:1044:3: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } - switch (alt3) { - case 1 : - // InternalExpression.g:1037:2: ( '==' ) - { - // InternalExpression.g:1037:2: ( '==' ) - // InternalExpression.g:1038:3: '==' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); - } - match(input,12,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); - } + } - } + } - } - break; - case 2 : - // InternalExpression.g:1043:2: ( '!=' ) - { - // InternalExpression.g:1043:2: ( '!=' ) - // InternalExpression.g:1044:3: '!=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } - match(input,13,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleOpSingleAssign" - } - break; - case 3 : - // InternalExpression.g:1049:2: ( '>=' ) - { - // InternalExpression.g:1049:2: ( '>=' ) - // InternalExpression.g:1050:3: '>=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); - } - match(input,14,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); - } - } + // $ANTLR start "entryRuleOpMultiAssign" + // InternalExpression.g:1054:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ; + public final void entryRuleOpMultiAssign() throws RecognitionException { + try { + // InternalExpression.g:1055:1: ( ruleOpMultiAssign EOF ) + // InternalExpression.g:1056:1: ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_1); + ruleOpMultiAssign(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - } - break; - case 4 : - // InternalExpression.g:1055:2: ( '<=' ) - { - // InternalExpression.g:1055:2: ( '<=' ) - // InternalExpression.g:1056:3: '<=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - } - match(input,15,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpMultiAssign" - } - break; - case 5 : - // InternalExpression.g:1061:2: ( '>' ) - { - // InternalExpression.g:1061:2: ( '>' ) - // InternalExpression.g:1062:3: '>' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } - match(input,16,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } + // $ANTLR start "ruleOpMultiAssign" + // InternalExpression.g:1063:1: ruleOpMultiAssign : ( ( rule__OpMultiAssign__Alternatives ) ) ; + public final void ruleOpMultiAssign() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1067:2: ( ( ( rule__OpMultiAssign__Alternatives ) ) ) + // InternalExpression.g:1068:2: ( ( rule__OpMultiAssign__Alternatives ) ) + { + // InternalExpression.g:1068:2: ( ( rule__OpMultiAssign__Alternatives ) ) + // InternalExpression.g:1069:3: ( rule__OpMultiAssign__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); + } + // InternalExpression.g:1070:3: ( rule__OpMultiAssign__Alternatives ) + // InternalExpression.g:1070:4: rule__OpMultiAssign__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Alternatives(); + state._fsp--; + if (state.failed) return ; - } - break; - case 6 : - // InternalExpression.g:1067:2: ( '<' ) - { - // InternalExpression.g:1067:2: ( '<' ) - // InternalExpression.g:1068:3: '<' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); - } - match(input,17,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -3681,154 +3619,79 @@ public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throw } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // $ANTLR end "ruleOpMultiAssign" - // $ANTLR start "rule__AdditiveExpression__NameAlternatives_1_1_0" - // InternalExpression.g:1077:1: rule__AdditiveExpression__NameAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) ); - public final void rule__AdditiveExpression__NameAlternatives_1_1_0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXOrExpression" + // InternalExpression.g:1079:1: entryRuleXOrExpression : ruleXOrExpression EOF ; + public final void entryRuleXOrExpression() throws RecognitionException { try { - // InternalExpression.g:1081:1: ( ( '+' ) | ( '-' ) ) - int alt4=2; - int LA4_0 = input.LA(1); - - if ( (LA4_0==18) ) { - alt4=1; - } - else if ( (LA4_0==19) ) { - alt4=2; + // InternalExpression.g:1080:1: ( ruleXOrExpression EOF ) + // InternalExpression.g:1081:1: ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 4, 0, input); + pushFollow(FOLLOW_1); + ruleXOrExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionRule()); } - switch (alt4) { - case 1 : - // InternalExpression.g:1082:2: ( '+' ) - { - // InternalExpression.g:1082:2: ( '+' ) - // InternalExpression.g:1083:3: '+' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); - } - match(input,18,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExpression.g:1088:2: ( '-' ) - { - // InternalExpression.g:1088:2: ( '-' ) - // InternalExpression.g:1089:3: '-' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); - } - match(input,19,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); - } - - } - - - } - break; + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__AdditiveExpression__NameAlternatives_1_1_0" + // $ANTLR end "entryRuleXOrExpression" - // $ANTLR start "rule__MultiplicativeExpression__NameAlternatives_1_1_0" - // InternalExpression.g:1098:1: rule__MultiplicativeExpression__NameAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) ); - public final void rule__MultiplicativeExpression__NameAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "ruleXOrExpression" + // InternalExpression.g:1088:1: ruleXOrExpression : ( ( rule__XOrExpression__Group__0 ) ) ; + public final void ruleXOrExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1102:1: ( ( '*' ) | ( '/' ) ) - int alt5=2; - int LA5_0 = input.LA(1); - - if ( (LA5_0==20) ) { - alt5=1; - } - else if ( (LA5_0==21) ) { - alt5=2; + // InternalExpression.g:1092:2: ( ( ( rule__XOrExpression__Group__0 ) ) ) + // InternalExpression.g:1093:2: ( ( rule__XOrExpression__Group__0 ) ) + { + // InternalExpression.g:1093:2: ( ( rule__XOrExpression__Group__0 ) ) + // InternalExpression.g:1094:3: ( rule__XOrExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 5, 0, input); - - throw nvae; - } - switch (alt5) { - case 1 : - // InternalExpression.g:1103:2: ( '*' ) - { - // InternalExpression.g:1103:2: ( '*' ) - // InternalExpression.g:1104:3: '*' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); - } - match(input,20,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); - } - - } + // InternalExpression.g:1095:3: ( rule__XOrExpression__Group__0 ) + // InternalExpression.g:1095:4: rule__XOrExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__0(); + state._fsp--; + if (state.failed) return ; - } - break; - case 2 : - // InternalExpression.g:1109:2: ( '/' ) - { - // InternalExpression.g:1109:2: ( '/' ) - // InternalExpression.g:1110:3: '/' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); - } - match(input,21,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -3841,368 +3704,399 @@ else if ( (LA5_0==21) ) { } return ; } - // $ANTLR end "rule__MultiplicativeExpression__NameAlternatives_1_1_0" + // $ANTLR end "ruleXOrExpression" - // $ANTLR start "rule__UnaryOrInfixExpression__Alternatives" - // InternalExpression.g:1119:1: rule__UnaryOrInfixExpression__Alternatives : ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ); - public final void rule__UnaryOrInfixExpression__Alternatives() throws RecognitionException { + // $ANTLR start "entryRuleOpOr" + // InternalExpression.g:1104:1: entryRuleOpOr : ruleOpOr EOF ; + public final void entryRuleOpOr() throws RecognitionException { + try { + // InternalExpression.g:1105:1: ( ruleOpOr EOF ) + // InternalExpression.g:1106:1: ruleOpOr EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_1); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpOr" + + + // $ANTLR start "ruleOpOr" + // InternalExpression.g:1113:1: ruleOpOr : ( '||' ) ; + public final void ruleOpOr() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1123:1: ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ) - int alt6=2; - int LA6_0 = input.LA(1); - - if ( (LA6_0==19||LA6_0==22) ) { - alt6=1; + // InternalExpression.g:1117:2: ( ( '||' ) ) + // InternalExpression.g:1118:2: ( '||' ) + { + // InternalExpression.g:1118:2: ( '||' ) + // InternalExpression.g:1119:3: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } - else if ( ((LA6_0>=RULE_ID && LA6_0<=RULE_STRING)||(LA6_0>=23 && LA6_0<=35)||LA6_0==39||LA6_0==47||(LA6_0>=54 && LA6_0<=55)||(LA6_0>=62 && LA6_0<=63)) ) { - alt6=2; + match(input,15,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 6, 0, input); - throw nvae; } - switch (alt6) { - case 1 : - // InternalExpression.g:1124:2: ( ruleUnaryExpression ) - { - // InternalExpression.g:1124:2: ( ruleUnaryExpression ) - // InternalExpression.g:1125:3: ruleUnaryExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleUnaryExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalExpression.g:1130:2: ( ruleInfixExpression ) - { - // InternalExpression.g:1130:2: ( ruleInfixExpression ) - // InternalExpression.g:1131:3: ruleInfixExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleInfixExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); - } + } + return ; + } + // $ANTLR end "ruleOpOr" - } + // $ANTLR start "entryRuleXAndExpression" + // InternalExpression.g:1129:1: entryRuleXAndExpression : ruleXAndExpression EOF ; + public final void entryRuleXAndExpression() throws RecognitionException { + try { + // InternalExpression.g:1130:1: ( ruleXAndExpression EOF ) + // InternalExpression.g:1131:1: ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXAndExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__UnaryOrInfixExpression__Alternatives" + // $ANTLR end "entryRuleXAndExpression" - // $ANTLR start "rule__UnaryExpression__NameAlternatives_0_0" - // InternalExpression.g:1140:1: rule__UnaryExpression__NameAlternatives_0_0 : ( ( '!' ) | ( '-' ) ); - public final void rule__UnaryExpression__NameAlternatives_0_0() throws RecognitionException { + // $ANTLR start "ruleXAndExpression" + // InternalExpression.g:1138:1: ruleXAndExpression : ( ( rule__XAndExpression__Group__0 ) ) ; + public final void ruleXAndExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1144:1: ( ( '!' ) | ( '-' ) ) - int alt7=2; - int LA7_0 = input.LA(1); + // InternalExpression.g:1142:2: ( ( ( rule__XAndExpression__Group__0 ) ) ) + // InternalExpression.g:1143:2: ( ( rule__XAndExpression__Group__0 ) ) + { + // InternalExpression.g:1143:2: ( ( rule__XAndExpression__Group__0 ) ) + // InternalExpression.g:1144:3: ( rule__XAndExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup()); + } + // InternalExpression.g:1145:3: ( rule__XAndExpression__Group__0 ) + // InternalExpression.g:1145:4: rule__XAndExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( (LA7_0==22) ) { - alt7=1; } - else if ( (LA7_0==19) ) { - alt7=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 7, 0, input); - throw nvae; } - switch (alt7) { - case 1 : - // InternalExpression.g:1145:2: ( '!' ) - { - // InternalExpression.g:1145:2: ( '!' ) - // InternalExpression.g:1146:3: '!' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); - } - match(input,22,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); - } - } + } - } - break; - case 2 : - // InternalExpression.g:1151:2: ( '-' ) - { - // InternalExpression.g:1151:2: ( '-' ) - // InternalExpression.g:1152:3: '-' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); - } - match(input,19,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleXAndExpression" - } - break; + // $ANTLR start "entryRuleOpAnd" + // InternalExpression.g:1154:1: entryRuleOpAnd : ruleOpAnd EOF ; + public final void entryRuleOpAnd() throws RecognitionException { + try { + // InternalExpression.g:1155:1: ( ruleOpAnd EOF ) + // InternalExpression.g:1156:1: ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_1); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__UnaryExpression__NameAlternatives_0_0" + // $ANTLR end "entryRuleOpAnd" - // $ANTLR start "rule__InfixExpression__Alternatives_1" - // InternalExpression.g:1161:1: rule__InfixExpression__Alternatives_1 : ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ); - public final void rule__InfixExpression__Alternatives_1() throws RecognitionException { + // $ANTLR start "ruleOpAnd" + // InternalExpression.g:1163:1: ruleOpAnd : ( '&&' ) ; + public final void ruleOpAnd() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1165:1: ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ) - int alt8=4; - int LA8_0 = input.LA(1); + // InternalExpression.g:1167:2: ( ( '&&' ) ) + // InternalExpression.g:1168:2: ( '&&' ) + { + // InternalExpression.g:1168:2: ( '&&' ) + // InternalExpression.g:1169:3: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } + match(input,16,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } - if ( (LA8_0==51) ) { - switch ( input.LA(2) ) { - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - { - alt8=4; - } - break; - case 33: - case 34: - case 35: - { - alt8=2; - } - break; - case RULE_ID: - { - int LA8_4 = input.LA(3); + } - if ( (LA8_4==EOF||(LA8_4>=12 && LA8_4<=21)||LA8_4==38||(LA8_4>=40 && LA8_4<=42)||(LA8_4>=44 && LA8_4<=45)||(LA8_4>=48 && LA8_4<=52)||(LA8_4>=58 && LA8_4<=61)) ) { - alt8=2; - } - else if ( (LA8_4==39) ) { - alt8=1; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 8, 4, input); - throw nvae; - } - } - break; - case 62: - { - alt8=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 8, 1, input); + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleOpAnd" - throw nvae; - } + // $ANTLR start "entryRuleXEqualityExpression" + // InternalExpression.g:1179:1: entryRuleXEqualityExpression : ruleXEqualityExpression EOF ; + public final void entryRuleXEqualityExpression() throws RecognitionException { + try { + // InternalExpression.g:1180:1: ( ruleXEqualityExpression EOF ) + // InternalExpression.g:1181:1: ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + pushFollow(FOLLOW_1); + ruleXEqualityExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionRule()); } - switch (alt8) { - case 1 : - // InternalExpression.g:1166:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) - { - // InternalExpression.g:1166:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) - // InternalExpression.g:1167:3: ( rule__InfixExpression__Group_1_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); - } - // InternalExpression.g:1168:3: ( rule__InfixExpression__Group_1_0__0 ) - // InternalExpression.g:1168:4: rule__InfixExpression__Group_1_0__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__0(); + match(input,EOF,FOLLOW_2); if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXEqualityExpression" - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); - } - } + // $ANTLR start "ruleXEqualityExpression" + // InternalExpression.g:1188:1: ruleXEqualityExpression : ( ( rule__XEqualityExpression__Group__0 ) ) ; + public final void ruleXEqualityExpression() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1192:2: ( ( ( rule__XEqualityExpression__Group__0 ) ) ) + // InternalExpression.g:1193:2: ( ( rule__XEqualityExpression__Group__0 ) ) + { + // InternalExpression.g:1193:2: ( ( rule__XEqualityExpression__Group__0 ) ) + // InternalExpression.g:1194:3: ( rule__XEqualityExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup()); + } + // InternalExpression.g:1195:3: ( rule__XEqualityExpression__Group__0 ) + // InternalExpression.g:1195:4: rule__XEqualityExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__0(); - } - break; - case 2 : - // InternalExpression.g:1172:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) - { - // InternalExpression.g:1172:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) - // InternalExpression.g:1173:3: ( rule__InfixExpression__Group_1_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); - } - // InternalExpression.g:1174:3: ( rule__InfixExpression__Group_1_1__0 ) - // InternalExpression.g:1174:4: rule__InfixExpression__Group_1_1__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__0(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); - } + } - } + } - } - break; - case 3 : - // InternalExpression.g:1178:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) - { - // InternalExpression.g:1178:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) - // InternalExpression.g:1179:3: ( rule__InfixExpression__Group_1_2__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); - } - // InternalExpression.g:1180:3: ( rule__InfixExpression__Group_1_2__0 ) - // InternalExpression.g:1180:4: rule__InfixExpression__Group_1_2__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__0(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - state._fsp--; - if (state.failed) return ; + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleXEqualityExpression" - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); - } - } + // $ANTLR start "entryRuleOpEquality" + // InternalExpression.g:1204:1: entryRuleOpEquality : ruleOpEquality EOF ; + public final void entryRuleOpEquality() throws RecognitionException { + try { + // InternalExpression.g:1205:1: ( ruleOpEquality EOF ) + // InternalExpression.g:1206:1: ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_1); + ruleOpEquality(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - } - break; - case 4 : - // InternalExpression.g:1184:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) - { - // InternalExpression.g:1184:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) - // InternalExpression.g:1185:3: ( rule__InfixExpression__Group_1_3__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); - } - // InternalExpression.g:1186:3: ( rule__InfixExpression__Group_1_3__0 ) - // InternalExpression.g:1186:4: rule__InfixExpression__Group_1_3__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__0(); + } - state._fsp--; - if (state.failed) return ; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpEquality" - } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); - } + // $ANTLR start "ruleOpEquality" + // InternalExpression.g:1213:1: ruleOpEquality : ( ( rule__OpEquality__Alternatives ) ) ; + public final void ruleOpEquality() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1217:2: ( ( ( rule__OpEquality__Alternatives ) ) ) + // InternalExpression.g:1218:2: ( ( rule__OpEquality__Alternatives ) ) + { + // InternalExpression.g:1218:2: ( ( rule__OpEquality__Alternatives ) ) + // InternalExpression.g:1219:3: ( rule__OpEquality__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getAlternatives()); + } + // InternalExpression.g:1220:3: ( rule__OpEquality__Alternatives ) + // InternalExpression.g:1220:4: rule__OpEquality__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpEquality__Alternatives(); + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getAlternatives()); + } + + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -4215,222 +4109,164 @@ else if ( (LA8_4==39) ) { } return ; } - // $ANTLR end "rule__InfixExpression__Alternatives_1" + // $ANTLR end "ruleOpEquality" - // $ANTLR start "rule__InfixExpression__NameAlternatives_1_3_2_0" - // InternalExpression.g:1194:1: rule__InfixExpression__NameAlternatives_1_3_2_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); - public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws RecognitionException { + // $ANTLR start "entryRuleXRelationalExpression" + // InternalExpression.g:1229:1: entryRuleXRelationalExpression : ruleXRelationalExpression EOF ; + public final void entryRuleXRelationalExpression() throws RecognitionException { + try { + // InternalExpression.g:1230:1: ( ruleXRelationalExpression EOF ) + // InternalExpression.g:1231:1: ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXRelationalExpression" + + + // $ANTLR start "ruleXRelationalExpression" + // InternalExpression.g:1238:1: ruleXRelationalExpression : ( ( rule__XRelationalExpression__Group__0 ) ) ; + public final void ruleXRelationalExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1198:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) - int alt9=8; - switch ( input.LA(1) ) { - case 23: - { - alt9=1; - } - break; - case 24: - { - alt9=2; - } - break; - case 25: - { - alt9=3; - } - break; - case 26: - { - alt9=4; - } - break; - case 27: - { - alt9=5; - } - break; - case 28: - { - alt9=6; - } - break; - case 29: - { - alt9=7; - } - break; - case 30: - { - alt9=8; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 9, 0, input); - - throw nvae; + // InternalExpression.g:1242:2: ( ( ( rule__XRelationalExpression__Group__0 ) ) ) + // InternalExpression.g:1243:2: ( ( rule__XRelationalExpression__Group__0 ) ) + { + // InternalExpression.g:1243:2: ( ( rule__XRelationalExpression__Group__0 ) ) + // InternalExpression.g:1244:3: ( rule__XRelationalExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup()); } + // InternalExpression.g:1245:3: ( rule__XRelationalExpression__Group__0 ) + // InternalExpression.g:1245:4: rule__XRelationalExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__0(); - switch (alt9) { - case 1 : - // InternalExpression.g:1199:2: ( 'collect' ) - { - // InternalExpression.g:1199:2: ( 'collect' ) - // InternalExpression.g:1200:3: 'collect' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); - } - match(input,23,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExpression.g:1205:2: ( 'select' ) - { - // InternalExpression.g:1205:2: ( 'select' ) - // InternalExpression.g:1206:3: 'select' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); - } - match(input,24,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup()); + } - } - break; - case 3 : - // InternalExpression.g:1211:2: ( 'selectFirst' ) - { - // InternalExpression.g:1211:2: ( 'selectFirst' ) - // InternalExpression.g:1212:3: 'selectFirst' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); - } - match(input,25,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); - } + } - } + } - } - break; - case 4 : - // InternalExpression.g:1217:2: ( 'reject' ) - { - // InternalExpression.g:1217:2: ( 'reject' ) - // InternalExpression.g:1218:3: 'reject' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); - } - match(input,26,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXRelationalExpression" - } - break; - case 5 : - // InternalExpression.g:1223:2: ( 'exists' ) - { - // InternalExpression.g:1223:2: ( 'exists' ) - // InternalExpression.g:1224:3: 'exists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); - } - match(input,27,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); - } - } + // $ANTLR start "entryRuleOpCompare" + // InternalExpression.g:1254:1: entryRuleOpCompare : ruleOpCompare EOF ; + public final void entryRuleOpCompare() throws RecognitionException { + try { + // InternalExpression.g:1255:1: ( ruleOpCompare EOF ) + // InternalExpression.g:1256:1: ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_1); + ruleOpCompare(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - } - break; - case 6 : - // InternalExpression.g:1229:2: ( 'notExists' ) - { - // InternalExpression.g:1229:2: ( 'notExists' ) - // InternalExpression.g:1230:3: 'notExists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); - } - match(input,28,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpCompare" - } - break; - case 7 : - // InternalExpression.g:1235:2: ( 'sortBy' ) - { - // InternalExpression.g:1235:2: ( 'sortBy' ) - // InternalExpression.g:1236:3: 'sortBy' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); - } - match(input,29,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); - } + // $ANTLR start "ruleOpCompare" + // InternalExpression.g:1263:1: ruleOpCompare : ( ( rule__OpCompare__Alternatives ) ) ; + public final void ruleOpCompare() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1267:2: ( ( ( rule__OpCompare__Alternatives ) ) ) + // InternalExpression.g:1268:2: ( ( rule__OpCompare__Alternatives ) ) + { + // InternalExpression.g:1268:2: ( ( rule__OpCompare__Alternatives ) ) + // InternalExpression.g:1269:3: ( rule__OpCompare__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getAlternatives()); + } + // InternalExpression.g:1270:3: ( rule__OpCompare__Alternatives ) + // InternalExpression.g:1270:4: rule__OpCompare__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpCompare__Alternatives(); + state._fsp--; + if (state.failed) return ; - } - break; - case 8 : - // InternalExpression.g:1241:2: ( 'forAll' ) - { - // InternalExpression.g:1241:2: ( 'forAll' ) - // InternalExpression.g:1242:3: 'forAll' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); - } - match(input,30,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -4443,215 +4279,164 @@ public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws Recog } return ; } - // $ANTLR end "rule__InfixExpression__NameAlternatives_1_3_2_0" - + // $ANTLR end "ruleOpCompare" - // $ANTLR start "rule__PrimaryExpression__Alternatives" - // InternalExpression.g:1251:1: rule__PrimaryExpression__Alternatives : ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ); - public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXOtherOperatorExpression" + // InternalExpression.g:1279:1: entryRuleXOtherOperatorExpression : ruleXOtherOperatorExpression EOF ; + public final void entryRuleXOtherOperatorExpression() throws RecognitionException { try { - // InternalExpression.g:1255:1: ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ) - int alt10=6; - switch ( input.LA(1) ) { - case RULE_INT: - case RULE_REAL: - case RULE_STRING: - case 31: - case 32: - case 63: - { - alt10=1; - } - break; - case RULE_ID: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 33: - case 34: - case 35: - case 62: - { - alt10=2; - } - break; - case 47: - { - alt10=3; - } - break; - case 55: - { - alt10=4; - } - break; - case 54: - { - alt10=5; - } - break; - case 39: - { - alt10=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 10, 0, input); + // InternalExpression.g:1280:1: ( ruleXOtherOperatorExpression EOF ) + // InternalExpression.g:1281:1: ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXOtherOperatorExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionRule()); } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - switch (alt10) { - case 1 : - // InternalExpression.g:1256:2: ( ruleLiteral ) - { - // InternalExpression.g:1256:2: ( ruleLiteral ) - // InternalExpression.g:1257:3: ruleLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" - } + // $ANTLR start "ruleXOtherOperatorExpression" + // InternalExpression.g:1288:1: ruleXOtherOperatorExpression : ( ( rule__XOtherOperatorExpression__Group__0 ) ) ; + public final void ruleXOtherOperatorExpression() throws RecognitionException { - } - break; - case 2 : - // InternalExpression.g:1262:2: ( ruleFeatureCall ) - { - // InternalExpression.g:1262:2: ( ruleFeatureCall ) - // InternalExpression.g:1263:3: ruleFeatureCall - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleFeatureCall(); + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1292:2: ( ( ( rule__XOtherOperatorExpression__Group__0 ) ) ) + // InternalExpression.g:1293:2: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + { + // InternalExpression.g:1293:2: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + // InternalExpression.g:1294:3: ( rule__XOtherOperatorExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } + // InternalExpression.g:1295:3: ( rule__XOtherOperatorExpression__Group__0 ) + // InternalExpression.g:1295:4: rule__XOtherOperatorExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__0(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } - } - break; - case 3 : - // InternalExpression.g:1268:2: ( ruleListLiteral ) - { - // InternalExpression.g:1268:2: ( ruleListLiteral ) - // InternalExpression.g:1269:3: ruleListLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleListLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 4 : - // InternalExpression.g:1274:2: ( ruleConstructorCallExpression ) - { - // InternalExpression.g:1274:2: ( ruleConstructorCallExpression ) - // InternalExpression.g:1275:3: ruleConstructorCallExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleConstructorCallExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); - } + } + return ; + } + // $ANTLR end "ruleXOtherOperatorExpression" - } + // $ANTLR start "entryRuleOpOther" + // InternalExpression.g:1304:1: entryRuleOpOther : ruleOpOther EOF ; + public final void entryRuleOpOther() throws RecognitionException { + try { + // InternalExpression.g:1305:1: ( ruleOpOther EOF ) + // InternalExpression.g:1306:1: ruleOpOther EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherRule()); + } + pushFollow(FOLLOW_1); + ruleOpOther(); - } - break; - case 5 : - // InternalExpression.g:1280:2: ( ruleGlobalVarExpression ) - { - // InternalExpression.g:1280:2: ( ruleGlobalVarExpression ) - // InternalExpression.g:1281:3: ruleGlobalVarExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); - } - pushFollow(FOLLOW_2); - ruleGlobalVarExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpOther" - } - break; - case 6 : - // InternalExpression.g:1286:2: ( ruleParanthesizedExpression ) - { - // InternalExpression.g:1286:2: ( ruleParanthesizedExpression ) - // InternalExpression.g:1287:3: ruleParanthesizedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); - } - pushFollow(FOLLOW_2); - ruleParanthesizedExpression(); + // $ANTLR start "ruleOpOther" + // InternalExpression.g:1313:1: ruleOpOther : ( ( rule__OpOther__Alternatives ) ) ; + public final void ruleOpOther() throws RecognitionException { - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); - } + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1317:2: ( ( ( rule__OpOther__Alternatives ) ) ) + // InternalExpression.g:1318:2: ( ( rule__OpOther__Alternatives ) ) + { + // InternalExpression.g:1318:2: ( ( rule__OpOther__Alternatives ) ) + // InternalExpression.g:1319:3: ( rule__OpOther__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives()); + } + // InternalExpression.g:1320:3: ( rule__OpOther__Alternatives ) + // InternalExpression.g:1320:4: rule__OpOther__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives(); - } + state._fsp--; + if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives()); + } + + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -4664,171 +4449,164 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce } return ; } - // $ANTLR end "rule__PrimaryExpression__Alternatives" + // $ANTLR end "ruleOpOther" - // $ANTLR start "rule__Literal__Alternatives" - // InternalExpression.g:1296:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ); - public final void rule__Literal__Alternatives() throws RecognitionException { + // $ANTLR start "entryRuleXAdditiveExpression" + // InternalExpression.g:1329:1: entryRuleXAdditiveExpression : ruleXAdditiveExpression EOF ; + public final void entryRuleXAdditiveExpression() throws RecognitionException { + try { + // InternalExpression.g:1330:1: ( ruleXAdditiveExpression EOF ) + // InternalExpression.g:1331:1: ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAdditiveExpression" + + + // $ANTLR start "ruleXAdditiveExpression" + // InternalExpression.g:1338:1: ruleXAdditiveExpression : ( ( rule__XAdditiveExpression__Group__0 ) ) ; + public final void ruleXAdditiveExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1300:1: ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ) - int alt11=5; - switch ( input.LA(1) ) { - case 31: - case 32: - { - alt11=1; - } - break; - case RULE_INT: - { - alt11=2; - } - break; - case 63: - { - alt11=3; - } - break; - case RULE_REAL: - { - alt11=4; - } - break; - case RULE_STRING: - { - alt11=5; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 11, 0, input); + // InternalExpression.g:1342:2: ( ( ( rule__XAdditiveExpression__Group__0 ) ) ) + // InternalExpression.g:1343:2: ( ( rule__XAdditiveExpression__Group__0 ) ) + { + // InternalExpression.g:1343:2: ( ( rule__XAdditiveExpression__Group__0 ) ) + // InternalExpression.g:1344:3: ( rule__XAdditiveExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); + } + // InternalExpression.g:1345:3: ( rule__XAdditiveExpression__Group__0 ) + // InternalExpression.g:1345:4: rule__XAdditiveExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - throw nvae; } - switch (alt11) { - case 1 : - // InternalExpression.g:1301:2: ( ruleBooleanLiteral ) - { - // InternalExpression.g:1301:2: ( ruleBooleanLiteral ) - // InternalExpression.g:1302:3: ruleBooleanLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleBooleanLiteral(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); - } + } - } + } - } - break; - case 2 : - // InternalExpression.g:1307:2: ( ruleIntegerLiteral ) - { - // InternalExpression.g:1307:2: ( ruleIntegerLiteral ) - // InternalExpression.g:1308:3: ruleIntegerLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleIntegerLiteral(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleXAdditiveExpression" - } - break; - case 3 : - // InternalExpression.g:1313:2: ( ruleNullLiteral ) - { - // InternalExpression.g:1313:2: ( ruleNullLiteral ) - // InternalExpression.g:1314:3: ruleNullLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleNullLiteral(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); - } + // $ANTLR start "entryRuleOpAdd" + // InternalExpression.g:1354:1: entryRuleOpAdd : ruleOpAdd EOF ; + public final void entryRuleOpAdd() throws RecognitionException { + try { + // InternalExpression.g:1355:1: ( ruleOpAdd EOF ) + // InternalExpression.g:1356:1: ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_1); + ruleOpAdd(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 4 : - // InternalExpression.g:1319:2: ( ruleRealLiteral ) - { - // InternalExpression.g:1319:2: ( ruleRealLiteral ) - // InternalExpression.g:1320:3: ruleRealLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleRealLiteral(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpAdd" - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); - } - } + // $ANTLR start "ruleOpAdd" + // InternalExpression.g:1363:1: ruleOpAdd : ( ( rule__OpAdd__Alternatives ) ) ; + public final void ruleOpAdd() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1367:2: ( ( ( rule__OpAdd__Alternatives ) ) ) + // InternalExpression.g:1368:2: ( ( rule__OpAdd__Alternatives ) ) + { + // InternalExpression.g:1368:2: ( ( rule__OpAdd__Alternatives ) ) + // InternalExpression.g:1369:3: ( rule__OpAdd__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getAlternatives()); + } + // InternalExpression.g:1370:3: ( rule__OpAdd__Alternatives ) + // InternalExpression.g:1370:4: rule__OpAdd__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpAdd__Alternatives(); - } - break; - case 5 : - // InternalExpression.g:1325:2: ( ruleStringLiteral ) - { - // InternalExpression.g:1325:2: ( ruleStringLiteral ) - // InternalExpression.g:1326:3: ruleStringLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); - } - pushFollow(FOLLOW_2); - ruleStringLiteral(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -4841,251 +4619,249 @@ public final void rule__Literal__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__Literal__Alternatives" + // $ANTLR end "ruleOpAdd" - // $ANTLR start "rule__BooleanLiteral__ValAlternatives_0" - // InternalExpression.g:1335:1: rule__BooleanLiteral__ValAlternatives_0 : ( ( 'true' ) | ( 'false' ) ); - public final void rule__BooleanLiteral__ValAlternatives_0() throws RecognitionException { + // $ANTLR start "entryRuleXMultiplicativeExpression" + // InternalExpression.g:1379:1: entryRuleXMultiplicativeExpression : ruleXMultiplicativeExpression EOF ; + public final void entryRuleXMultiplicativeExpression() throws RecognitionException { + try { + // InternalExpression.g:1380:1: ( ruleXMultiplicativeExpression EOF ) + // InternalExpression.g:1381:1: ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // InternalExpression.g:1388:1: ruleXMultiplicativeExpression : ( ( rule__XMultiplicativeExpression__Group__0 ) ) ; + public final void ruleXMultiplicativeExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1339:1: ( ( 'true' ) | ( 'false' ) ) - int alt12=2; - int LA12_0 = input.LA(1); + // InternalExpression.g:1392:2: ( ( ( rule__XMultiplicativeExpression__Group__0 ) ) ) + // InternalExpression.g:1393:2: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + { + // InternalExpression.g:1393:2: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + // InternalExpression.g:1394:3: ( rule__XMultiplicativeExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); + } + // InternalExpression.g:1395:3: ( rule__XMultiplicativeExpression__Group__0 ) + // InternalExpression.g:1395:4: rule__XMultiplicativeExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( (LA12_0==31) ) { - alt12=1; } - else if ( (LA12_0==32) ) { - alt12=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 12, 0, input); - throw nvae; } - switch (alt12) { - case 1 : - // InternalExpression.g:1340:2: ( 'true' ) - { - // InternalExpression.g:1340:2: ( 'true' ) - // InternalExpression.g:1341:3: 'true' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); - } - match(input,31,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); - } - } + } - } - break; - case 2 : - // InternalExpression.g:1346:2: ( 'false' ) - { - // InternalExpression.g:1346:2: ( 'false' ) - // InternalExpression.g:1347:3: 'false' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); - } - match(input,32,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleXMultiplicativeExpression" - } - break; + // $ANTLR start "entryRuleOpMulti" + // InternalExpression.g:1404:1: entryRuleOpMulti : ruleOpMulti EOF ; + public final void entryRuleOpMulti() throws RecognitionException { + try { + // InternalExpression.g:1405:1: ( ruleOpMulti EOF ) + // InternalExpression.g:1406:1: ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_1); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__BooleanLiteral__ValAlternatives_0" + // $ANTLR end "entryRuleOpMulti" - // $ANTLR start "rule__FeatureCall__Alternatives" - // InternalExpression.g:1356:1: rule__FeatureCall__Alternatives : ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ); - public final void rule__FeatureCall__Alternatives() throws RecognitionException { + // $ANTLR start "ruleOpMulti" + // InternalExpression.g:1413:1: ruleOpMulti : ( ( rule__OpMulti__Alternatives ) ) ; + public final void ruleOpMulti() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1360:1: ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ) - int alt13=4; - switch ( input.LA(1) ) { - case RULE_ID: - { - int LA13_1 = input.LA(2); + // InternalExpression.g:1417:2: ( ( ( rule__OpMulti__Alternatives ) ) ) + // InternalExpression.g:1418:2: ( ( rule__OpMulti__Alternatives ) ) + { + // InternalExpression.g:1418:2: ( ( rule__OpMulti__Alternatives ) ) + // InternalExpression.g:1419:3: ( rule__OpMulti__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAlternatives()); + } + // InternalExpression.g:1420:3: ( rule__OpMulti__Alternatives ) + // InternalExpression.g:1420:4: rule__OpMulti__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpMulti__Alternatives(); - if ( (LA13_1==EOF||(LA13_1>=12 && LA13_1<=21)||LA13_1==38||(LA13_1>=40 && LA13_1<=42)||(LA13_1>=44 && LA13_1<=45)||(LA13_1>=48 && LA13_1<=52)||(LA13_1>=58 && LA13_1<=61)) ) { - alt13=2; - } - else if ( (LA13_1==39) ) { - alt13=1; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 13, 1, input); + state._fsp--; + if (state.failed) return ; - throw nvae; - } - } - break; - case 33: - case 34: - case 35: - { - alt13=2; - } - break; - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - { - alt13=3; - } - break; - case 62: - { - alt13=4; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 13, 0, input); + } - throw nvae; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAlternatives()); } - switch (alt13) { - case 1 : - // InternalExpression.g:1361:2: ( ruleOperationCall ) - { - // InternalExpression.g:1361:2: ( ruleOperationCall ) - // InternalExpression.g:1362:3: ruleOperationCall - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleOperationCall(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalExpression.g:1367:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) - { - // InternalExpression.g:1367:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) - // InternalExpression.g:1368:3: ( rule__FeatureCall__TypeAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); - } - // InternalExpression.g:1369:3: ( rule__FeatureCall__TypeAssignment_1 ) - // InternalExpression.g:1369:4: rule__FeatureCall__TypeAssignment_1 - { - pushFollow(FOLLOW_2); - rule__FeatureCall__TypeAssignment_1(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; + } + return ; + } + // $ANTLR end "ruleOpMulti" - } - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); - } + // $ANTLR start "entryRuleXUnaryOperation" + // InternalExpression.g:1429:1: entryRuleXUnaryOperation : ruleXUnaryOperation EOF ; + public final void entryRuleXUnaryOperation() throws RecognitionException { + try { + // InternalExpression.g:1430:1: ( ruleXUnaryOperation EOF ) + // InternalExpression.g:1431:1: ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_1); + ruleXUnaryOperation(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 3 : - // InternalExpression.g:1373:2: ( ruleCollectionExpression ) - { - // InternalExpression.g:1373:2: ( ruleCollectionExpression ) - // InternalExpression.g:1374:3: ruleCollectionExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleCollectionExpression(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXUnaryOperation" - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); - } - } + // $ANTLR start "ruleXUnaryOperation" + // InternalExpression.g:1438:1: ruleXUnaryOperation : ( ( rule__XUnaryOperation__Alternatives ) ) ; + public final void ruleXUnaryOperation() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1442:2: ( ( ( rule__XUnaryOperation__Alternatives ) ) ) + // InternalExpression.g:1443:2: ( ( rule__XUnaryOperation__Alternatives ) ) + { + // InternalExpression.g:1443:2: ( ( rule__XUnaryOperation__Alternatives ) ) + // InternalExpression.g:1444:3: ( rule__XUnaryOperation__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); + } + // InternalExpression.g:1445:3: ( rule__XUnaryOperation__Alternatives ) + // InternalExpression.g:1445:4: rule__XUnaryOperation__Alternatives + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Alternatives(); - } - break; - case 4 : - // InternalExpression.g:1379:2: ( ruleTypeSelectExpression ) - { - // InternalExpression.g:1379:2: ( ruleTypeSelectExpression ) - // InternalExpression.g:1380:3: ruleTypeSelectExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleTypeSelectExpression(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5098,418 +4874,249 @@ else if ( (LA13_1==39) ) { } return ; } - // $ANTLR end "rule__FeatureCall__Alternatives" - + // $ANTLR end "ruleXUnaryOperation" - // $ANTLR start "rule__CollectionExpression__NameAlternatives_0_0" - // InternalExpression.g:1389:1: rule__CollectionExpression__NameAlternatives_0_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); - public final void rule__CollectionExpression__NameAlternatives_0_0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpUnary" + // InternalExpression.g:1454:1: entryRuleOpUnary : ruleOpUnary EOF ; + public final void entryRuleOpUnary() throws RecognitionException { try { - // InternalExpression.g:1393:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) - int alt14=8; - switch ( input.LA(1) ) { - case 23: - { - alt14=1; - } - break; - case 24: - { - alt14=2; - } - break; - case 25: - { - alt14=3; - } - break; - case 26: - { - alt14=4; - } - break; - case 27: - { - alt14=5; - } - break; - case 28: - { - alt14=6; - } - break; - case 29: - { - alt14=7; - } - break; - case 30: - { - alt14=8; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 14, 0, input); + // InternalExpression.g:1455:1: ( ruleOpUnary EOF ) + // InternalExpression.g:1456:1: ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_1); + ruleOpUnary(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryRule()); } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - switch (alt14) { - case 1 : - // InternalExpression.g:1394:2: ( 'collect' ) - { - // InternalExpression.g:1394:2: ( 'collect' ) - // InternalExpression.g:1395:3: 'collect' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); - } - match(input,23,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpUnary" - } - break; - case 2 : - // InternalExpression.g:1400:2: ( 'select' ) - { - // InternalExpression.g:1400:2: ( 'select' ) - // InternalExpression.g:1401:3: 'select' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); - } - match(input,24,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); - } + // $ANTLR start "ruleOpUnary" + // InternalExpression.g:1463:1: ruleOpUnary : ( ( rule__OpUnary__Alternatives ) ) ; + public final void ruleOpUnary() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:1467:2: ( ( ( rule__OpUnary__Alternatives ) ) ) + // InternalExpression.g:1468:2: ( ( rule__OpUnary__Alternatives ) ) + { + // InternalExpression.g:1468:2: ( ( rule__OpUnary__Alternatives ) ) + // InternalExpression.g:1469:3: ( rule__OpUnary__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getAlternatives()); + } + // InternalExpression.g:1470:3: ( rule__OpUnary__Alternatives ) + // InternalExpression.g:1470:4: rule__OpUnary__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpUnary__Alternatives(); + state._fsp--; + if (state.failed) return ; - } - break; - case 3 : - // InternalExpression.g:1406:2: ( 'selectFirst' ) - { - // InternalExpression.g:1406:2: ( 'selectFirst' ) - // InternalExpression.g:1407:3: 'selectFirst' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); - } - match(input,25,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getAlternatives()); + } + } - } - break; - case 4 : - // InternalExpression.g:1412:2: ( 'reject' ) - { - // InternalExpression.g:1412:2: ( 'reject' ) - // InternalExpression.g:1413:3: 'reject' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); - } - match(input,26,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 5 : - // InternalExpression.g:1418:2: ( 'exists' ) - { - // InternalExpression.g:1418:2: ( 'exists' ) - // InternalExpression.g:1419:3: 'exists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); - } - match(input,27,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleOpUnary" - } - break; - case 6 : - // InternalExpression.g:1424:2: ( 'notExists' ) - { - // InternalExpression.g:1424:2: ( 'notExists' ) - // InternalExpression.g:1425:3: 'notExists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); - } - match(input,28,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); - } - - } - - - } - break; - case 7 : - // InternalExpression.g:1430:2: ( 'sortBy' ) - { - // InternalExpression.g:1430:2: ( 'sortBy' ) - // InternalExpression.g:1431:3: 'sortBy' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); - } - match(input,29,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); - } - - } - - - } - break; - case 8 : - // InternalExpression.g:1436:2: ( 'forAll' ) - { - // InternalExpression.g:1436:2: ( 'forAll' ) - // InternalExpression.g:1437:3: 'forAll' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); - } - match(input,30,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); - } - - } - + // $ANTLR start "entryRuleXCastedExpression" + // InternalExpression.g:1479:1: entryRuleXCastedExpression : ruleXCastedExpression EOF ; + public final void entryRuleXCastedExpression() throws RecognitionException { + try { + // InternalExpression.g:1480:1: ( ruleXCastedExpression EOF ) + // InternalExpression.g:1481:1: ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXCastedExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__CollectionExpression__NameAlternatives_0_0" + // $ANTLR end "entryRuleXCastedExpression" - // $ANTLR start "rule__Type__Alternatives" - // InternalExpression.g:1446:1: rule__Type__Alternatives : ( ( ruleCollectionType ) | ( ruleSimpleType ) ); - public final void rule__Type__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXCastedExpression" + // InternalExpression.g:1488:1: ruleXCastedExpression : ( ( rule__XCastedExpression__Group__0 ) ) ; + public final void ruleXCastedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1450:1: ( ( ruleCollectionType ) | ( ruleSimpleType ) ) - int alt15=2; - int LA15_0 = input.LA(1); + // InternalExpression.g:1492:2: ( ( ( rule__XCastedExpression__Group__0 ) ) ) + // InternalExpression.g:1493:2: ( ( rule__XCastedExpression__Group__0 ) ) + { + // InternalExpression.g:1493:2: ( ( rule__XCastedExpression__Group__0 ) ) + // InternalExpression.g:1494:3: ( rule__XCastedExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup()); + } + // InternalExpression.g:1495:3: ( rule__XCastedExpression__Group__0 ) + // InternalExpression.g:1495:4: rule__XCastedExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( ((LA15_0>=33 && LA15_0<=35)) ) { - alt15=1; } - else if ( (LA15_0==RULE_ID) ) { - alt15=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 15, 0, input); - throw nvae; } - switch (alt15) { - case 1 : - // InternalExpression.g:1451:2: ( ruleCollectionType ) - { - // InternalExpression.g:1451:2: ( ruleCollectionType ) - // InternalExpression.g:1452:3: ruleCollectionType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleCollectionType(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalExpression.g:1457:2: ( ruleSimpleType ) - { - // InternalExpression.g:1457:2: ( ruleSimpleType ) - // InternalExpression.g:1458:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); - } + } + return ; + } + // $ANTLR end "ruleXCastedExpression" - } + // $ANTLR start "entryRuleXPostfixOperation" + // InternalExpression.g:1504:1: entryRuleXPostfixOperation : ruleXPostfixOperation EOF ; + public final void entryRuleXPostfixOperation() throws RecognitionException { + try { + // InternalExpression.g:1505:1: ( ruleXPostfixOperation EOF ) + // InternalExpression.g:1506:1: ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationRule()); + } + pushFollow(FOLLOW_1); + ruleXPostfixOperation(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Type__Alternatives" + // $ANTLR end "entryRuleXPostfixOperation" - // $ANTLR start "rule__CollectionType__ClAlternatives_0_0" - // InternalExpression.g:1467:1: rule__CollectionType__ClAlternatives_0_0 : ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ); - public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionException { + // $ANTLR start "ruleXPostfixOperation" + // InternalExpression.g:1513:1: ruleXPostfixOperation : ( ( rule__XPostfixOperation__Group__0 ) ) ; + public final void ruleXPostfixOperation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1471:1: ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ) - int alt16=3; - switch ( input.LA(1) ) { - case 33: - { - alt16=1; - } - break; - case 34: - { - alt16=2; - } - break; - case 35: - { - alt16=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 16, 0, input); - - throw nvae; + // InternalExpression.g:1517:2: ( ( ( rule__XPostfixOperation__Group__0 ) ) ) + // InternalExpression.g:1518:2: ( ( rule__XPostfixOperation__Group__0 ) ) + { + // InternalExpression.g:1518:2: ( ( rule__XPostfixOperation__Group__0 ) ) + // InternalExpression.g:1519:3: ( rule__XPostfixOperation__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup()); } + // InternalExpression.g:1520:3: ( rule__XPostfixOperation__Group__0 ) + // InternalExpression.g:1520:4: rule__XPostfixOperation__Group__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__0(); - switch (alt16) { - case 1 : - // InternalExpression.g:1472:2: ( 'Collection' ) - { - // InternalExpression.g:1472:2: ( 'Collection' ) - // InternalExpression.g:1473:3: 'Collection' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); - } - match(input,33,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); - } - - } - - - } - break; - case 2 : - // InternalExpression.g:1478:2: ( 'List' ) - { - // InternalExpression.g:1478:2: ( 'List' ) - // InternalExpression.g:1479:3: 'List' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); - } - match(input,34,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); - } - - } - + state._fsp--; + if (state.failed) return ; - } - break; - case 3 : - // InternalExpression.g:1484:2: ( 'Set' ) - { - // InternalExpression.g:1484:2: ( 'Set' ) - // InternalExpression.g:1485:3: 'Set' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); - } - match(input,35,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5522,29 +5129,28 @@ public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionE } return ; } - // $ANTLR end "rule__CollectionType__ClAlternatives_0_0" - + // $ANTLR end "ruleXPostfixOperation" - // $ANTLR start "rule__LetExpression__Group__0" - // InternalExpression.g:1494:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ; - public final void rule__LetExpression__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpPostfix" + // InternalExpression.g:1529:1: entryRuleOpPostfix : ruleOpPostfix EOF ; + public final void entryRuleOpPostfix() throws RecognitionException { try { - // InternalExpression.g:1498:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ) - // InternalExpression.g:1499:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 + // InternalExpression.g:1530:1: ( ruleOpPostfix EOF ) + // InternalExpression.g:1531:1: ruleOpPostfix EOF { - pushFollow(FOLLOW_3); - rule__LetExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_1); + ruleOpPostfix(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -5554,34 +5160,41 @@ public final void rule__LetExpression__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__LetExpression__Group__0" + // $ANTLR end "entryRuleOpPostfix" - // $ANTLR start "rule__LetExpression__Group__0__Impl" - // InternalExpression.g:1506:1: rule__LetExpression__Group__0__Impl : ( 'let' ) ; - public final void rule__LetExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleOpPostfix" + // InternalExpression.g:1538:1: ruleOpPostfix : ( ( rule__OpPostfix__Alternatives ) ) ; + public final void ruleOpPostfix() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1510:1: ( ( 'let' ) ) - // InternalExpression.g:1511:1: ( 'let' ) + // InternalExpression.g:1542:2: ( ( ( rule__OpPostfix__Alternatives ) ) ) + // InternalExpression.g:1543:2: ( ( rule__OpPostfix__Alternatives ) ) { - // InternalExpression.g:1511:1: ( 'let' ) - // InternalExpression.g:1512:2: 'let' + // InternalExpression.g:1543:2: ( ( rule__OpPostfix__Alternatives ) ) + // InternalExpression.g:1544:3: ( rule__OpPostfix__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); + before(grammarAccess.getOpPostfixAccess().getAlternatives()); } - match(input,36,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:1545:3: ( rule__OpPostfix__Alternatives ) + // InternalExpression.g:1545:4: rule__OpPostfix__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpPostfix__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); + after(grammarAccess.getOpPostfixAccess().getAlternatives()); } } @@ -5601,29 +5214,28 @@ public final void rule__LetExpression__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__0__Impl" - + // $ANTLR end "ruleOpPostfix" - // $ANTLR start "rule__LetExpression__Group__1" - // InternalExpression.g:1521:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ; - public final void rule__LetExpression__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXMemberFeatureCall" + // InternalExpression.g:1554:1: entryRuleXMemberFeatureCall : ruleXMemberFeatureCall EOF ; + public final void entryRuleXMemberFeatureCall() throws RecognitionException { try { - // InternalExpression.g:1525:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ) - // InternalExpression.g:1526:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 + // InternalExpression.g:1555:1: ( ruleXMemberFeatureCall EOF ) + // InternalExpression.g:1556:1: ruleXMemberFeatureCall EOF { - pushFollow(FOLLOW_4); - rule__LetExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallRule()); + } + pushFollow(FOLLOW_1); + ruleXMemberFeatureCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -5633,36 +5245,33 @@ public final void rule__LetExpression__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__LetExpression__Group__1" + // $ANTLR end "entryRuleXMemberFeatureCall" - // $ANTLR start "rule__LetExpression__Group__1__Impl" - // InternalExpression.g:1533:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ; - public final void rule__LetExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXMemberFeatureCall" + // InternalExpression.g:1563:1: ruleXMemberFeatureCall : ( ( rule__XMemberFeatureCall__Group__0 ) ) ; + public final void ruleXMemberFeatureCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1537:1: ( ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ) - // InternalExpression.g:1538:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) + // InternalExpression.g:1567:2: ( ( ( rule__XMemberFeatureCall__Group__0 ) ) ) + // InternalExpression.g:1568:2: ( ( rule__XMemberFeatureCall__Group__0 ) ) { - // InternalExpression.g:1538:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) - // InternalExpression.g:1539:2: ( rule__LetExpression__IdentifierAssignment_1 ) + // InternalExpression.g:1568:2: ( ( rule__XMemberFeatureCall__Group__0 ) ) + // InternalExpression.g:1569:3: ( rule__XMemberFeatureCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); + before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } - // InternalExpression.g:1540:2: ( rule__LetExpression__IdentifierAssignment_1 ) - // InternalExpression.g:1540:3: rule__LetExpression__IdentifierAssignment_1 + // InternalExpression.g:1570:3: ( rule__XMemberFeatureCall__Group__0 ) + // InternalExpression.g:1570:4: rule__XMemberFeatureCall__Group__0 { pushFollow(FOLLOW_2); - rule__LetExpression__IdentifierAssignment_1(); + rule__XMemberFeatureCall__Group__0(); state._fsp--; if (state.failed) return ; @@ -5670,7 +5279,7 @@ public final void rule__LetExpression__Group__1__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); + after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } } @@ -5690,29 +5299,28 @@ public final void rule__LetExpression__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__1__Impl" - + // $ANTLR end "ruleXMemberFeatureCall" - // $ANTLR start "rule__LetExpression__Group__2" - // InternalExpression.g:1548:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ; - public final void rule__LetExpression__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXPrimaryExpression" + // InternalExpression.g:1579:1: entryRuleXPrimaryExpression : ruleXPrimaryExpression EOF ; + public final void entryRuleXPrimaryExpression() throws RecognitionException { try { - // InternalExpression.g:1552:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ) - // InternalExpression.g:1553:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 + // InternalExpression.g:1580:1: ( ruleXPrimaryExpression EOF ) + // InternalExpression.g:1581:1: ruleXPrimaryExpression EOF { - pushFollow(FOLLOW_5); - rule__LetExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXPrimaryExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -5722,34 +5330,41 @@ public final void rule__LetExpression__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__LetExpression__Group__2" + // $ANTLR end "entryRuleXPrimaryExpression" - // $ANTLR start "rule__LetExpression__Group__2__Impl" - // InternalExpression.g:1560:1: rule__LetExpression__Group__2__Impl : ( '=' ) ; - public final void rule__LetExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXPrimaryExpression" + // InternalExpression.g:1588:1: ruleXPrimaryExpression : ( ( rule__XPrimaryExpression__Alternatives ) ) ; + public final void ruleXPrimaryExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1564:1: ( ( '=' ) ) - // InternalExpression.g:1565:1: ( '=' ) + // InternalExpression.g:1592:2: ( ( ( rule__XPrimaryExpression__Alternatives ) ) ) + // InternalExpression.g:1593:2: ( ( rule__XPrimaryExpression__Alternatives ) ) { - // InternalExpression.g:1565:1: ( '=' ) - // InternalExpression.g:1566:2: '=' + // InternalExpression.g:1593:2: ( ( rule__XPrimaryExpression__Alternatives ) ) + // InternalExpression.g:1594:3: ( rule__XPrimaryExpression__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); + before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); + } + // InternalExpression.g:1595:3: ( rule__XPrimaryExpression__Alternatives ) + // InternalExpression.g:1595:4: rule__XPrimaryExpression__Alternatives + { + pushFollow(FOLLOW_2); + rule__XPrimaryExpression__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); + after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } } @@ -5769,29 +5384,28 @@ public final void rule__LetExpression__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__2__Impl" + // $ANTLR end "ruleXPrimaryExpression" - // $ANTLR start "rule__LetExpression__Group__3" - // InternalExpression.g:1575:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ; - public final void rule__LetExpression__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXLiteral" + // InternalExpression.g:1604:1: entryRuleXLiteral : ruleXLiteral EOF ; + public final void entryRuleXLiteral() throws RecognitionException { try { - // InternalExpression.g:1579:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ) - // InternalExpression.g:1580:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 + // InternalExpression.g:1605:1: ( ruleXLiteral EOF ) + // InternalExpression.g:1606:1: ruleXLiteral EOF { - pushFollow(FOLLOW_6); - rule__LetExpression__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -5801,36 +5415,33 @@ public final void rule__LetExpression__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__LetExpression__Group__3" + // $ANTLR end "entryRuleXLiteral" - // $ANTLR start "rule__LetExpression__Group__3__Impl" - // InternalExpression.g:1587:1: rule__LetExpression__Group__3__Impl : ( ( rule__LetExpression__VarExprAssignment_3 ) ) ; - public final void rule__LetExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXLiteral" + // InternalExpression.g:1613:1: ruleXLiteral : ( ( rule__XLiteral__Alternatives ) ) ; + public final void ruleXLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1591:1: ( ( ( rule__LetExpression__VarExprAssignment_3 ) ) ) - // InternalExpression.g:1592:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) + // InternalExpression.g:1617:2: ( ( ( rule__XLiteral__Alternatives ) ) ) + // InternalExpression.g:1618:2: ( ( rule__XLiteral__Alternatives ) ) { - // InternalExpression.g:1592:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) - // InternalExpression.g:1593:2: ( rule__LetExpression__VarExprAssignment_3 ) + // InternalExpression.g:1618:2: ( ( rule__XLiteral__Alternatives ) ) + // InternalExpression.g:1619:3: ( rule__XLiteral__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); + before(grammarAccess.getXLiteralAccess().getAlternatives()); } - // InternalExpression.g:1594:2: ( rule__LetExpression__VarExprAssignment_3 ) - // InternalExpression.g:1594:3: rule__LetExpression__VarExprAssignment_3 + // InternalExpression.g:1620:3: ( rule__XLiteral__Alternatives ) + // InternalExpression.g:1620:4: rule__XLiteral__Alternatives { pushFollow(FOLLOW_2); - rule__LetExpression__VarExprAssignment_3(); + rule__XLiteral__Alternatives(); state._fsp--; if (state.failed) return ; @@ -5838,7 +5449,7 @@ public final void rule__LetExpression__Group__3__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); + after(grammarAccess.getXLiteralAccess().getAlternatives()); } } @@ -5858,29 +5469,28 @@ public final void rule__LetExpression__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__3__Impl" + // $ANTLR end "ruleXLiteral" - // $ANTLR start "rule__LetExpression__Group__4" - // InternalExpression.g:1602:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ; - public final void rule__LetExpression__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCollectionLiteral" + // InternalExpression.g:1629:1: entryRuleXCollectionLiteral : ruleXCollectionLiteral EOF ; + public final void entryRuleXCollectionLiteral() throws RecognitionException { try { - // InternalExpression.g:1606:1: ( rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ) - // InternalExpression.g:1607:2: rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 + // InternalExpression.g:1630:1: ( ruleXCollectionLiteral EOF ) + // InternalExpression.g:1631:1: ruleXCollectionLiteral EOF { - pushFollow(FOLLOW_5); - rule__LetExpression__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__LetExpression__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXCollectionLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -5890,34 +5500,41 @@ public final void rule__LetExpression__Group__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__LetExpression__Group__4" + // $ANTLR end "entryRuleXCollectionLiteral" - // $ANTLR start "rule__LetExpression__Group__4__Impl" - // InternalExpression.g:1614:1: rule__LetExpression__Group__4__Impl : ( ':' ) ; - public final void rule__LetExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXCollectionLiteral" + // InternalExpression.g:1638:1: ruleXCollectionLiteral : ( ( rule__XCollectionLiteral__Alternatives ) ) ; + public final void ruleXCollectionLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1618:1: ( ( ':' ) ) - // InternalExpression.g:1619:1: ( ':' ) + // InternalExpression.g:1642:2: ( ( ( rule__XCollectionLiteral__Alternatives ) ) ) + // InternalExpression.g:1643:2: ( ( rule__XCollectionLiteral__Alternatives ) ) { - // InternalExpression.g:1619:1: ( ':' ) - // InternalExpression.g:1620:2: ':' + // InternalExpression.g:1643:2: ( ( rule__XCollectionLiteral__Alternatives ) ) + // InternalExpression.g:1644:3: ( rule__XCollectionLiteral__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); + before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); + } + // InternalExpression.g:1645:3: ( rule__XCollectionLiteral__Alternatives ) + // InternalExpression.g:1645:4: rule__XCollectionLiteral__Alternatives + { + pushFollow(FOLLOW_2); + rule__XCollectionLiteral__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); + after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } } @@ -5937,24 +5554,28 @@ public final void rule__LetExpression__Group__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__4__Impl" - + // $ANTLR end "ruleXCollectionLiteral" - // $ANTLR start "rule__LetExpression__Group__5" - // InternalExpression.g:1629:1: rule__LetExpression__Group__5 : rule__LetExpression__Group__5__Impl ; - public final void rule__LetExpression__Group__5() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSetLiteral" + // InternalExpression.g:1654:1: entryRuleXSetLiteral : ruleXSetLiteral EOF ; + public final void entryRuleXSetLiteral() throws RecognitionException { try { - // InternalExpression.g:1633:1: ( rule__LetExpression__Group__5__Impl ) - // InternalExpression.g:1634:2: rule__LetExpression__Group__5__Impl + // InternalExpression.g:1655:1: ( ruleXSetLiteral EOF ) + // InternalExpression.g:1656:1: ruleXSetLiteral EOF { - pushFollow(FOLLOW_2); - rule__LetExpression__Group__5__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXSetLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -5964,36 +5585,33 @@ public final void rule__LetExpression__Group__5() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__LetExpression__Group__5" + // $ANTLR end "entryRuleXSetLiteral" - // $ANTLR start "rule__LetExpression__Group__5__Impl" - // InternalExpression.g:1640:1: rule__LetExpression__Group__5__Impl : ( ( rule__LetExpression__TargetAssignment_5 ) ) ; - public final void rule__LetExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleXSetLiteral" + // InternalExpression.g:1663:1: ruleXSetLiteral : ( ( rule__XSetLiteral__Group__0 ) ) ; + public final void ruleXSetLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1644:1: ( ( ( rule__LetExpression__TargetAssignment_5 ) ) ) - // InternalExpression.g:1645:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) + // InternalExpression.g:1667:2: ( ( ( rule__XSetLiteral__Group__0 ) ) ) + // InternalExpression.g:1668:2: ( ( rule__XSetLiteral__Group__0 ) ) { - // InternalExpression.g:1645:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) - // InternalExpression.g:1646:2: ( rule__LetExpression__TargetAssignment_5 ) + // InternalExpression.g:1668:2: ( ( rule__XSetLiteral__Group__0 ) ) + // InternalExpression.g:1669:3: ( rule__XSetLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); + before(grammarAccess.getXSetLiteralAccess().getGroup()); } - // InternalExpression.g:1647:2: ( rule__LetExpression__TargetAssignment_5 ) - // InternalExpression.g:1647:3: rule__LetExpression__TargetAssignment_5 + // InternalExpression.g:1670:3: ( rule__XSetLiteral__Group__0 ) + // InternalExpression.g:1670:4: rule__XSetLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__LetExpression__TargetAssignment_5(); + rule__XSetLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -6001,7 +5619,7 @@ public final void rule__LetExpression__Group__5__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); + after(grammarAccess.getXSetLiteralAccess().getGroup()); } } @@ -6021,29 +5639,28 @@ public final void rule__LetExpression__Group__5__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__5__Impl" + // $ANTLR end "ruleXSetLiteral" - // $ANTLR start "rule__CastedExpression__Group__0" - // InternalExpression.g:1656:1: rule__CastedExpression__Group__0 : rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ; - public final void rule__CastedExpression__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXListLiteral" + // InternalExpression.g:1679:1: entryRuleXListLiteral : ruleXListLiteral EOF ; + public final void entryRuleXListLiteral() throws RecognitionException { try { - // InternalExpression.g:1660:1: ( rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ) - // InternalExpression.g:1661:2: rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 + // InternalExpression.g:1680:1: ( ruleXListLiteral EOF ) + // InternalExpression.g:1681:1: ruleXListLiteral EOF { - pushFollow(FOLLOW_7); - rule__CastedExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXListLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6053,34 +5670,41 @@ public final void rule__CastedExpression__Group__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__CastedExpression__Group__0" + // $ANTLR end "entryRuleXListLiteral" - // $ANTLR start "rule__CastedExpression__Group__0__Impl" - // InternalExpression.g:1668:1: rule__CastedExpression__Group__0__Impl : ( '(' ) ; - public final void rule__CastedExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXListLiteral" + // InternalExpression.g:1688:1: ruleXListLiteral : ( ( rule__XListLiteral__Group__0 ) ) ; + public final void ruleXListLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1672:1: ( ( '(' ) ) - // InternalExpression.g:1673:1: ( '(' ) + // InternalExpression.g:1692:2: ( ( ( rule__XListLiteral__Group__0 ) ) ) + // InternalExpression.g:1693:2: ( ( rule__XListLiteral__Group__0 ) ) { - // InternalExpression.g:1673:1: ( '(' ) - // InternalExpression.g:1674:2: '(' + // InternalExpression.g:1693:2: ( ( rule__XListLiteral__Group__0 ) ) + // InternalExpression.g:1694:3: ( rule__XListLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); + before(grammarAccess.getXListLiteralAccess().getGroup()); + } + // InternalExpression.g:1695:3: ( rule__XListLiteral__Group__0 ) + // InternalExpression.g:1695:4: rule__XListLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); + after(grammarAccess.getXListLiteralAccess().getGroup()); } } @@ -6100,29 +5724,28 @@ public final void rule__CastedExpression__Group__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__0__Impl" - + // $ANTLR end "ruleXListLiteral" - // $ANTLR start "rule__CastedExpression__Group__1" - // InternalExpression.g:1683:1: rule__CastedExpression__Group__1 : rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ; - public final void rule__CastedExpression__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXClosure" + // InternalExpression.g:1704:1: entryRuleXClosure : ruleXClosure EOF ; + public final void entryRuleXClosure() throws RecognitionException { try { - // InternalExpression.g:1687:1: ( rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ) - // InternalExpression.g:1688:2: rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 + // InternalExpression.g:1705:1: ( ruleXClosure EOF ) + // InternalExpression.g:1706:1: ruleXClosure EOF { - pushFollow(FOLLOW_8); - rule__CastedExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXClosure(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6132,36 +5755,33 @@ public final void rule__CastedExpression__Group__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__CastedExpression__Group__1" + // $ANTLR end "entryRuleXClosure" - // $ANTLR start "rule__CastedExpression__Group__1__Impl" - // InternalExpression.g:1695:1: rule__CastedExpression__Group__1__Impl : ( ( rule__CastedExpression__TypeAssignment_1 ) ) ; - public final void rule__CastedExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXClosure" + // InternalExpression.g:1713:1: ruleXClosure : ( ( rule__XClosure__Group__0 ) ) ; + public final void ruleXClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1699:1: ( ( ( rule__CastedExpression__TypeAssignment_1 ) ) ) - // InternalExpression.g:1700:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) + // InternalExpression.g:1717:2: ( ( ( rule__XClosure__Group__0 ) ) ) + // InternalExpression.g:1718:2: ( ( rule__XClosure__Group__0 ) ) { - // InternalExpression.g:1700:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) - // InternalExpression.g:1701:2: ( rule__CastedExpression__TypeAssignment_1 ) + // InternalExpression.g:1718:2: ( ( rule__XClosure__Group__0 ) ) + // InternalExpression.g:1719:3: ( rule__XClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); + before(grammarAccess.getXClosureAccess().getGroup()); } - // InternalExpression.g:1702:2: ( rule__CastedExpression__TypeAssignment_1 ) - // InternalExpression.g:1702:3: rule__CastedExpression__TypeAssignment_1 + // InternalExpression.g:1720:3: ( rule__XClosure__Group__0 ) + // InternalExpression.g:1720:4: rule__XClosure__Group__0 { pushFollow(FOLLOW_2); - rule__CastedExpression__TypeAssignment_1(); + rule__XClosure__Group__0(); state._fsp--; if (state.failed) return ; @@ -6169,7 +5789,7 @@ public final void rule__CastedExpression__Group__1__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); + after(grammarAccess.getXClosureAccess().getGroup()); } } @@ -6189,29 +5809,28 @@ public final void rule__CastedExpression__Group__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__1__Impl" - + // $ANTLR end "ruleXClosure" - // $ANTLR start "rule__CastedExpression__Group__2" - // InternalExpression.g:1710:1: rule__CastedExpression__Group__2 : rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ; - public final void rule__CastedExpression__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpressionInClosure" + // InternalExpression.g:1729:1: entryRuleXExpressionInClosure : ruleXExpressionInClosure EOF ; + public final void entryRuleXExpressionInClosure() throws RecognitionException { try { - // InternalExpression.g:1714:1: ( rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ) - // InternalExpression.g:1715:2: rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 + // InternalExpression.g:1730:1: ( ruleXExpressionInClosure EOF ) + // InternalExpression.g:1731:1: ruleXExpressionInClosure EOF { - pushFollow(FOLLOW_5); - rule__CastedExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXExpressionInClosure(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6221,34 +5840,41 @@ public final void rule__CastedExpression__Group__2() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__CastedExpression__Group__2" + // $ANTLR end "entryRuleXExpressionInClosure" - // $ANTLR start "rule__CastedExpression__Group__2__Impl" - // InternalExpression.g:1722:1: rule__CastedExpression__Group__2__Impl : ( ')' ) ; - public final void rule__CastedExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXExpressionInClosure" + // InternalExpression.g:1738:1: ruleXExpressionInClosure : ( ( rule__XExpressionInClosure__Group__0 ) ) ; + public final void ruleXExpressionInClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1726:1: ( ( ')' ) ) - // InternalExpression.g:1727:1: ( ')' ) + // InternalExpression.g:1742:2: ( ( ( rule__XExpressionInClosure__Group__0 ) ) ) + // InternalExpression.g:1743:2: ( ( rule__XExpressionInClosure__Group__0 ) ) { - // InternalExpression.g:1727:1: ( ')' ) - // InternalExpression.g:1728:2: ')' + // InternalExpression.g:1743:2: ( ( rule__XExpressionInClosure__Group__0 ) ) + // InternalExpression.g:1744:3: ( rule__XExpressionInClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + before(grammarAccess.getXExpressionInClosureAccess().getGroup()); + } + // InternalExpression.g:1745:3: ( rule__XExpressionInClosure__Group__0 ) + // InternalExpression.g:1745:4: rule__XExpressionInClosure__Group__0 + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + after(grammarAccess.getXExpressionInClosureAccess().getGroup()); } } @@ -6268,24 +5894,28 @@ public final void rule__CastedExpression__Group__2__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__2__Impl" + // $ANTLR end "ruleXExpressionInClosure" - // $ANTLR start "rule__CastedExpression__Group__3" - // InternalExpression.g:1737:1: rule__CastedExpression__Group__3 : rule__CastedExpression__Group__3__Impl ; - public final void rule__CastedExpression__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXShortClosure" + // InternalExpression.g:1754:1: entryRuleXShortClosure : ruleXShortClosure EOF ; + public final void entryRuleXShortClosure() throws RecognitionException { try { - // InternalExpression.g:1741:1: ( rule__CastedExpression__Group__3__Impl ) - // InternalExpression.g:1742:2: rule__CastedExpression__Group__3__Impl + // InternalExpression.g:1755:1: ( ruleXShortClosure EOF ) + // InternalExpression.g:1756:1: ruleXShortClosure EOF { - pushFollow(FOLLOW_2); - rule__CastedExpression__Group__3__Impl(); - + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXShortClosure(); + state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6295,36 +5925,33 @@ public final void rule__CastedExpression__Group__3() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__CastedExpression__Group__3" + // $ANTLR end "entryRuleXShortClosure" - // $ANTLR start "rule__CastedExpression__Group__3__Impl" - // InternalExpression.g:1748:1: rule__CastedExpression__Group__3__Impl : ( ( rule__CastedExpression__TargetAssignment_3 ) ) ; - public final void rule__CastedExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXShortClosure" + // InternalExpression.g:1763:1: ruleXShortClosure : ( ( rule__XShortClosure__Group__0 ) ) ; + public final void ruleXShortClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1752:1: ( ( ( rule__CastedExpression__TargetAssignment_3 ) ) ) - // InternalExpression.g:1753:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) + // InternalExpression.g:1767:2: ( ( ( rule__XShortClosure__Group__0 ) ) ) + // InternalExpression.g:1768:2: ( ( rule__XShortClosure__Group__0 ) ) { - // InternalExpression.g:1753:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) - // InternalExpression.g:1754:2: ( rule__CastedExpression__TargetAssignment_3 ) + // InternalExpression.g:1768:2: ( ( rule__XShortClosure__Group__0 ) ) + // InternalExpression.g:1769:3: ( rule__XShortClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); + before(grammarAccess.getXShortClosureAccess().getGroup()); } - // InternalExpression.g:1755:2: ( rule__CastedExpression__TargetAssignment_3 ) - // InternalExpression.g:1755:3: rule__CastedExpression__TargetAssignment_3 + // InternalExpression.g:1770:3: ( rule__XShortClosure__Group__0 ) + // InternalExpression.g:1770:4: rule__XShortClosure__Group__0 { pushFollow(FOLLOW_2); - rule__CastedExpression__TargetAssignment_3(); + rule__XShortClosure__Group__0(); state._fsp--; if (state.failed) return ; @@ -6332,7 +5959,7 @@ public final void rule__CastedExpression__Group__3__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); + after(grammarAccess.getXShortClosureAccess().getGroup()); } } @@ -6352,29 +5979,28 @@ public final void rule__CastedExpression__Group__3__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__3__Impl" - + // $ANTLR end "ruleXShortClosure" - // $ANTLR start "rule__ChainExpression__Group__0" - // InternalExpression.g:1764:1: rule__ChainExpression__Group__0 : rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ; - public final void rule__ChainExpression__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXParenthesizedExpression" + // InternalExpression.g:1779:1: entryRuleXParenthesizedExpression : ruleXParenthesizedExpression EOF ; + public final void entryRuleXParenthesizedExpression() throws RecognitionException { try { - // InternalExpression.g:1768:1: ( rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ) - // InternalExpression.g:1769:2: rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 + // InternalExpression.g:1780:1: ( ruleXParenthesizedExpression EOF ) + // InternalExpression.g:1781:1: ruleXParenthesizedExpression EOF { - pushFollow(FOLLOW_9); - rule__ChainExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ChainExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXParenthesizedExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6384,38 +6010,41 @@ public final void rule__ChainExpression__Group__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainExpression__Group__0" + // $ANTLR end "entryRuleXParenthesizedExpression" - // $ANTLR start "rule__ChainExpression__Group__0__Impl" - // InternalExpression.g:1776:1: rule__ChainExpression__Group__0__Impl : ( ruleChainedExpression ) ; - public final void rule__ChainExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXParenthesizedExpression" + // InternalExpression.g:1788:1: ruleXParenthesizedExpression : ( ( rule__XParenthesizedExpression__Group__0 ) ) ; + public final void ruleXParenthesizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1780:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:1781:1: ( ruleChainedExpression ) + // InternalExpression.g:1792:2: ( ( ( rule__XParenthesizedExpression__Group__0 ) ) ) + // InternalExpression.g:1793:2: ( ( rule__XParenthesizedExpression__Group__0 ) ) { - // InternalExpression.g:1781:1: ( ruleChainedExpression ) - // InternalExpression.g:1782:2: ruleChainedExpression + // InternalExpression.g:1793:2: ( ( rule__XParenthesizedExpression__Group__0 ) ) + // InternalExpression.g:1794:3: ( rule__XParenthesizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); + before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } + // InternalExpression.g:1795:3: ( rule__XParenthesizedExpression__Group__0 ) + // InternalExpression.g:1795:4: rule__XParenthesizedExpression__Group__0 + { pushFollow(FOLLOW_2); - ruleChainedExpression(); + rule__XParenthesizedExpression__Group__0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); + after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } } @@ -6435,24 +6064,28 @@ public final void rule__ChainExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ChainExpression__Group__0__Impl" - + // $ANTLR end "ruleXParenthesizedExpression" - // $ANTLR start "rule__ChainExpression__Group__1" - // InternalExpression.g:1791:1: rule__ChainExpression__Group__1 : rule__ChainExpression__Group__1__Impl ; - public final void rule__ChainExpression__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXIfExpression" + // InternalExpression.g:1804:1: entryRuleXIfExpression : ruleXIfExpression EOF ; + public final void entryRuleXIfExpression() throws RecognitionException { try { - // InternalExpression.g:1795:1: ( rule__ChainExpression__Group__1__Impl ) - // InternalExpression.g:1796:2: rule__ChainExpression__Group__1__Impl + // InternalExpression.g:1805:1: ( ruleXIfExpression EOF ) + // InternalExpression.g:1806:1: ruleXIfExpression EOF { - pushFollow(FOLLOW_2); - rule__ChainExpression__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXIfExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6462,62 +6095,41 @@ public final void rule__ChainExpression__Group__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainExpression__Group__1" + // $ANTLR end "entryRuleXIfExpression" - // $ANTLR start "rule__ChainExpression__Group__1__Impl" - // InternalExpression.g:1802:1: rule__ChainExpression__Group__1__Impl : ( ( rule__ChainExpression__Group_1__0 )* ) ; - public final void rule__ChainExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXIfExpression" + // InternalExpression.g:1813:1: ruleXIfExpression : ( ( rule__XIfExpression__Group__0 ) ) ; + public final void ruleXIfExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1806:1: ( ( ( rule__ChainExpression__Group_1__0 )* ) ) - // InternalExpression.g:1807:1: ( ( rule__ChainExpression__Group_1__0 )* ) + // InternalExpression.g:1817:2: ( ( ( rule__XIfExpression__Group__0 ) ) ) + // InternalExpression.g:1818:2: ( ( rule__XIfExpression__Group__0 ) ) { - // InternalExpression.g:1807:1: ( ( rule__ChainExpression__Group_1__0 )* ) - // InternalExpression.g:1808:2: ( rule__ChainExpression__Group_1__0 )* + // InternalExpression.g:1818:2: ( ( rule__XIfExpression__Group__0 ) ) + // InternalExpression.g:1819:3: ( rule__XIfExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getGroup_1()); + before(grammarAccess.getXIfExpressionAccess().getGroup()); } - // InternalExpression.g:1809:2: ( rule__ChainExpression__Group_1__0 )* - loop17: - do { - int alt17=2; - int LA17_0 = input.LA(1); - - if ( (LA17_0==41) ) { - alt17=1; - } - - - switch (alt17) { - case 1 : - // InternalExpression.g:1809:3: rule__ChainExpression__Group_1__0 - { - pushFollow(FOLLOW_10); - rule__ChainExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:1820:3: ( rule__XIfExpression__Group__0 ) + // InternalExpression.g:1820:4: rule__XIfExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop17; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getGroup_1()); + after(grammarAccess.getXIfExpressionAccess().getGroup()); } } @@ -6537,29 +6149,28 @@ public final void rule__ChainExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ChainExpression__Group__1__Impl" + // $ANTLR end "ruleXIfExpression" - // $ANTLR start "rule__ChainExpression__Group_1__0" - // InternalExpression.g:1818:1: rule__ChainExpression__Group_1__0 : rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ; - public final void rule__ChainExpression__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSwitchExpression" + // InternalExpression.g:1829:1: entryRuleXSwitchExpression : ruleXSwitchExpression EOF ; + public final void entryRuleXSwitchExpression() throws RecognitionException { try { - // InternalExpression.g:1822:1: ( rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ) - // InternalExpression.g:1823:2: rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 + // InternalExpression.g:1830:1: ( ruleXSwitchExpression EOF ) + // InternalExpression.g:1831:1: ruleXSwitchExpression EOF { - pushFollow(FOLLOW_9); - rule__ChainExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXSwitchExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6569,38 +6180,41 @@ public final void rule__ChainExpression__Group_1__0() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__0" + // $ANTLR end "entryRuleXSwitchExpression" - // $ANTLR start "rule__ChainExpression__Group_1__0__Impl" - // InternalExpression.g:1830:1: rule__ChainExpression__Group_1__0__Impl : ( () ) ; - public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXSwitchExpression" + // InternalExpression.g:1838:1: ruleXSwitchExpression : ( ( rule__XSwitchExpression__Group__0 ) ) ; + public final void ruleXSwitchExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1834:1: ( ( () ) ) - // InternalExpression.g:1835:1: ( () ) + // InternalExpression.g:1842:2: ( ( ( rule__XSwitchExpression__Group__0 ) ) ) + // InternalExpression.g:1843:2: ( ( rule__XSwitchExpression__Group__0 ) ) { - // InternalExpression.g:1835:1: ( () ) - // InternalExpression.g:1836:2: () + // InternalExpression.g:1843:2: ( ( rule__XSwitchExpression__Group__0 ) ) + // InternalExpression.g:1844:3: ( rule__XSwitchExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); + before(grammarAccess.getXSwitchExpressionAccess().getGroup()); } - // InternalExpression.g:1837:2: () - // InternalExpression.g:1837:3: + // InternalExpression.g:1845:3: ( rule__XSwitchExpression__Group__0 ) + // InternalExpression.g:1845:4: rule__XSwitchExpression__Group__0 { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); + after(grammarAccess.getXSwitchExpressionAccess().getGroup()); } } @@ -6609,6 +6223,10 @@ public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionEx } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -6616,29 +6234,28 @@ public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__0__Impl" + // $ANTLR end "ruleXSwitchExpression" - // $ANTLR start "rule__ChainExpression__Group_1__1" - // InternalExpression.g:1845:1: rule__ChainExpression__Group_1__1 : rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ; - public final void rule__ChainExpression__Group_1__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCasePart" + // InternalExpression.g:1854:1: entryRuleXCasePart : ruleXCasePart EOF ; + public final void entryRuleXCasePart() throws RecognitionException { try { - // InternalExpression.g:1849:1: ( rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ) - // InternalExpression.g:1850:2: rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 + // InternalExpression.g:1855:1: ( ruleXCasePart EOF ) + // InternalExpression.g:1856:1: ruleXCasePart EOF { - pushFollow(FOLLOW_5); - rule__ChainExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_1); + ruleXCasePart(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6648,34 +6265,41 @@ public final void rule__ChainExpression__Group_1__1() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__1" + // $ANTLR end "entryRuleXCasePart" - // $ANTLR start "rule__ChainExpression__Group_1__1__Impl" - // InternalExpression.g:1857:1: rule__ChainExpression__Group_1__1__Impl : ( '->' ) ; - public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXCasePart" + // InternalExpression.g:1863:1: ruleXCasePart : ( ( rule__XCasePart__Group__0 ) ) ; + public final void ruleXCasePart() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1861:1: ( ( '->' ) ) - // InternalExpression.g:1862:1: ( '->' ) + // InternalExpression.g:1867:2: ( ( ( rule__XCasePart__Group__0 ) ) ) + // InternalExpression.g:1868:2: ( ( rule__XCasePart__Group__0 ) ) { - // InternalExpression.g:1862:1: ( '->' ) - // InternalExpression.g:1863:2: '->' + // InternalExpression.g:1868:2: ( ( rule__XCasePart__Group__0 ) ) + // InternalExpression.g:1869:3: ( rule__XCasePart__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); + before(grammarAccess.getXCasePartAccess().getGroup()); + } + // InternalExpression.g:1870:3: ( rule__XCasePart__Group__0 ) + // InternalExpression.g:1870:4: rule__XCasePart__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,41,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); + after(grammarAccess.getXCasePartAccess().getGroup()); } } @@ -6695,24 +6319,28 @@ public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__1__Impl" - + // $ANTLR end "ruleXCasePart" - // $ANTLR start "rule__ChainExpression__Group_1__2" - // InternalExpression.g:1872:1: rule__ChainExpression__Group_1__2 : rule__ChainExpression__Group_1__2__Impl ; - public final void rule__ChainExpression__Group_1__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXForLoopExpression" + // InternalExpression.g:1879:1: entryRuleXForLoopExpression : ruleXForLoopExpression EOF ; + public final void entryRuleXForLoopExpression() throws RecognitionException { try { - // InternalExpression.g:1876:1: ( rule__ChainExpression__Group_1__2__Impl ) - // InternalExpression.g:1877:2: rule__ChainExpression__Group_1__2__Impl + // InternalExpression.g:1880:1: ( ruleXForLoopExpression EOF ) + // InternalExpression.g:1881:1: ruleXForLoopExpression EOF { - pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXForLoopExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6722,36 +6350,33 @@ public final void rule__ChainExpression__Group_1__2() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__2" + // $ANTLR end "entryRuleXForLoopExpression" - // $ANTLR start "rule__ChainExpression__Group_1__2__Impl" - // InternalExpression.g:1883:1: rule__ChainExpression__Group_1__2__Impl : ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ; - public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXForLoopExpression" + // InternalExpression.g:1888:1: ruleXForLoopExpression : ( ( rule__XForLoopExpression__Group__0 ) ) ; + public final void ruleXForLoopExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1887:1: ( ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ) - // InternalExpression.g:1888:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) + // InternalExpression.g:1892:2: ( ( ( rule__XForLoopExpression__Group__0 ) ) ) + // InternalExpression.g:1893:2: ( ( rule__XForLoopExpression__Group__0 ) ) { - // InternalExpression.g:1888:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) - // InternalExpression.g:1889:2: ( rule__ChainExpression__NextAssignment_1_2 ) + // InternalExpression.g:1893:2: ( ( rule__XForLoopExpression__Group__0 ) ) + // InternalExpression.g:1894:3: ( rule__XForLoopExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); + before(grammarAccess.getXForLoopExpressionAccess().getGroup()); } - // InternalExpression.g:1890:2: ( rule__ChainExpression__NextAssignment_1_2 ) - // InternalExpression.g:1890:3: rule__ChainExpression__NextAssignment_1_2 + // InternalExpression.g:1895:3: ( rule__XForLoopExpression__Group__0 ) + // InternalExpression.g:1895:4: rule__XForLoopExpression__Group__0 { pushFollow(FOLLOW_2); - rule__ChainExpression__NextAssignment_1_2(); + rule__XForLoopExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -6759,7 +6384,7 @@ public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); + after(grammarAccess.getXForLoopExpressionAccess().getGroup()); } } @@ -6779,29 +6404,28 @@ public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__2__Impl" + // $ANTLR end "ruleXForLoopExpression" - // $ANTLR start "rule__IfExpressionTri__Group__0" - // InternalExpression.g:1899:1: rule__IfExpressionTri__Group__0 : rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ; - public final void rule__IfExpressionTri__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBasicForLoopExpression" + // InternalExpression.g:1904:1: entryRuleXBasicForLoopExpression : ruleXBasicForLoopExpression EOF ; + public final void entryRuleXBasicForLoopExpression() throws RecognitionException { try { - // InternalExpression.g:1903:1: ( rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ) - // InternalExpression.g:1904:2: rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 + // InternalExpression.g:1905:1: ( ruleXBasicForLoopExpression EOF ) + // InternalExpression.g:1906:1: ruleXBasicForLoopExpression EOF { - pushFollow(FOLLOW_11); - rule__IfExpressionTri__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXBasicForLoopExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6811,38 +6435,41 @@ public final void rule__IfExpressionTri__Group__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__0" + // $ANTLR end "entryRuleXBasicForLoopExpression" - // $ANTLR start "rule__IfExpressionTri__Group__0__Impl" - // InternalExpression.g:1911:1: rule__IfExpressionTri__Group__0__Impl : ( ruleOrExpression ) ; - public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXBasicForLoopExpression" + // InternalExpression.g:1913:1: ruleXBasicForLoopExpression : ( ( rule__XBasicForLoopExpression__Group__0 ) ) ; + public final void ruleXBasicForLoopExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1915:1: ( ( ruleOrExpression ) ) - // InternalExpression.g:1916:1: ( ruleOrExpression ) + // InternalExpression.g:1917:2: ( ( ( rule__XBasicForLoopExpression__Group__0 ) ) ) + // InternalExpression.g:1918:2: ( ( rule__XBasicForLoopExpression__Group__0 ) ) { - // InternalExpression.g:1916:1: ( ruleOrExpression ) - // InternalExpression.g:1917:2: ruleOrExpression + // InternalExpression.g:1918:2: ( ( rule__XBasicForLoopExpression__Group__0 ) ) + // InternalExpression.g:1919:3: ( rule__XBasicForLoopExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + // InternalExpression.g:1920:3: ( rule__XBasicForLoopExpression__Group__0 ) + // InternalExpression.g:1920:4: rule__XBasicForLoopExpression__Group__0 + { pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__XBasicForLoopExpression__Group__0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } } @@ -6862,24 +6489,28 @@ public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__0__Impl" - + // $ANTLR end "ruleXBasicForLoopExpression" - // $ANTLR start "rule__IfExpressionTri__Group__1" - // InternalExpression.g:1926:1: rule__IfExpressionTri__Group__1 : rule__IfExpressionTri__Group__1__Impl ; - public final void rule__IfExpressionTri__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXWhileExpression" + // InternalExpression.g:1929:1: entryRuleXWhileExpression : ruleXWhileExpression EOF ; + public final void entryRuleXWhileExpression() throws RecognitionException { try { - // InternalExpression.g:1930:1: ( rule__IfExpressionTri__Group__1__Impl ) - // InternalExpression.g:1931:2: rule__IfExpressionTri__Group__1__Impl + // InternalExpression.g:1930:1: ( ruleXWhileExpression EOF ) + // InternalExpression.g:1931:1: ruleXWhileExpression EOF { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXWhileExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6889,55 +6520,41 @@ public final void rule__IfExpressionTri__Group__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__1" + // $ANTLR end "entryRuleXWhileExpression" - // $ANTLR start "rule__IfExpressionTri__Group__1__Impl" - // InternalExpression.g:1937:1: rule__IfExpressionTri__Group__1__Impl : ( ( rule__IfExpressionTri__Group_1__0 )? ) ; - public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXWhileExpression" + // InternalExpression.g:1938:1: ruleXWhileExpression : ( ( rule__XWhileExpression__Group__0 ) ) ; + public final void ruleXWhileExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1941:1: ( ( ( rule__IfExpressionTri__Group_1__0 )? ) ) - // InternalExpression.g:1942:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) + // InternalExpression.g:1942:2: ( ( ( rule__XWhileExpression__Group__0 ) ) ) + // InternalExpression.g:1943:2: ( ( rule__XWhileExpression__Group__0 ) ) { - // InternalExpression.g:1942:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) - // InternalExpression.g:1943:2: ( rule__IfExpressionTri__Group_1__0 )? + // InternalExpression.g:1943:2: ( ( rule__XWhileExpression__Group__0 ) ) + // InternalExpression.g:1944:3: ( rule__XWhileExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); - } - // InternalExpression.g:1944:2: ( rule__IfExpressionTri__Group_1__0 )? - int alt18=2; - int LA18_0 = input.LA(1); - - if ( (LA18_0==42) ) { - alt18=1; + before(grammarAccess.getXWhileExpressionAccess().getGroup()); } - switch (alt18) { - case 1 : - // InternalExpression.g:1944:3: rule__IfExpressionTri__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:1945:3: ( rule__XWhileExpression__Group__0 ) + // InternalExpression.g:1945:4: rule__XWhileExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); + after(grammarAccess.getXWhileExpressionAccess().getGroup()); } } @@ -6957,29 +6574,28 @@ public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__1__Impl" + // $ANTLR end "ruleXWhileExpression" - // $ANTLR start "rule__IfExpressionTri__Group_1__0" - // InternalExpression.g:1953:1: rule__IfExpressionTri__Group_1__0 : rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ; - public final void rule__IfExpressionTri__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXDoWhileExpression" + // InternalExpression.g:1954:1: entryRuleXDoWhileExpression : ruleXDoWhileExpression EOF ; + public final void entryRuleXDoWhileExpression() throws RecognitionException { try { - // InternalExpression.g:1957:1: ( rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ) - // InternalExpression.g:1958:2: rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 + // InternalExpression.g:1955:1: ( ruleXDoWhileExpression EOF ) + // InternalExpression.g:1956:1: ruleXDoWhileExpression EOF { - pushFollow(FOLLOW_11); - rule__IfExpressionTri__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXDoWhileExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -6989,38 +6605,41 @@ public final void rule__IfExpressionTri__Group_1__0() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__0" + // $ANTLR end "entryRuleXDoWhileExpression" - // $ANTLR start "rule__IfExpressionTri__Group_1__0__Impl" - // InternalExpression.g:1965:1: rule__IfExpressionTri__Group_1__0__Impl : ( () ) ; - public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXDoWhileExpression" + // InternalExpression.g:1963:1: ruleXDoWhileExpression : ( ( rule__XDoWhileExpression__Group__0 ) ) ; + public final void ruleXDoWhileExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1969:1: ( ( () ) ) - // InternalExpression.g:1970:1: ( () ) + // InternalExpression.g:1967:2: ( ( ( rule__XDoWhileExpression__Group__0 ) ) ) + // InternalExpression.g:1968:2: ( ( rule__XDoWhileExpression__Group__0 ) ) { - // InternalExpression.g:1970:1: ( () ) - // InternalExpression.g:1971:2: () + // InternalExpression.g:1968:2: ( ( rule__XDoWhileExpression__Group__0 ) ) + // InternalExpression.g:1969:3: ( rule__XDoWhileExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); + before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } - // InternalExpression.g:1972:2: () - // InternalExpression.g:1972:3: + // InternalExpression.g:1970:3: ( rule__XDoWhileExpression__Group__0 ) + // InternalExpression.g:1970:4: rule__XDoWhileExpression__Group__0 { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); + after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } } @@ -7029,6 +6648,10 @@ public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionEx } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -7036,29 +6659,28 @@ public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__0__Impl" - + // $ANTLR end "ruleXDoWhileExpression" - // $ANTLR start "rule__IfExpressionTri__Group_1__1" - // InternalExpression.g:1980:1: rule__IfExpressionTri__Group_1__1 : rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ; - public final void rule__IfExpressionTri__Group_1__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBlockExpression" + // InternalExpression.g:1979:1: entryRuleXBlockExpression : ruleXBlockExpression EOF ; + public final void entryRuleXBlockExpression() throws RecognitionException { try { - // InternalExpression.g:1984:1: ( rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ) - // InternalExpression.g:1985:2: rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 + // InternalExpression.g:1980:1: ( ruleXBlockExpression EOF ) + // InternalExpression.g:1981:1: ruleXBlockExpression EOF { - pushFollow(FOLLOW_5); - rule__IfExpressionTri__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXBlockExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7068,34 +6690,41 @@ public final void rule__IfExpressionTri__Group_1__1() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__1" + // $ANTLR end "entryRuleXBlockExpression" - // $ANTLR start "rule__IfExpressionTri__Group_1__1__Impl" - // InternalExpression.g:1992:1: rule__IfExpressionTri__Group_1__1__Impl : ( '?' ) ; - public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXBlockExpression" + // InternalExpression.g:1988:1: ruleXBlockExpression : ( ( rule__XBlockExpression__Group__0 ) ) ; + public final void ruleXBlockExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:1996:1: ( ( '?' ) ) - // InternalExpression.g:1997:1: ( '?' ) + // InternalExpression.g:1992:2: ( ( ( rule__XBlockExpression__Group__0 ) ) ) + // InternalExpression.g:1993:2: ( ( rule__XBlockExpression__Group__0 ) ) { - // InternalExpression.g:1997:1: ( '?' ) - // InternalExpression.g:1998:2: '?' + // InternalExpression.g:1993:2: ( ( rule__XBlockExpression__Group__0 ) ) + // InternalExpression.g:1994:3: ( rule__XBlockExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); + before(grammarAccess.getXBlockExpressionAccess().getGroup()); + } + // InternalExpression.g:1995:3: ( rule__XBlockExpression__Group__0 ) + // InternalExpression.g:1995:4: rule__XBlockExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,42,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); + after(grammarAccess.getXBlockExpressionAccess().getGroup()); } } @@ -7115,29 +6744,28 @@ public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__1__Impl" + // $ANTLR end "ruleXBlockExpression" - // $ANTLR start "rule__IfExpressionTri__Group_1__2" - // InternalExpression.g:2007:1: rule__IfExpressionTri__Group_1__2 : rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ; - public final void rule__IfExpressionTri__Group_1__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpressionOrVarDeclaration" + // InternalExpression.g:2004:1: entryRuleXExpressionOrVarDeclaration : ruleXExpressionOrVarDeclaration EOF ; + public final void entryRuleXExpressionOrVarDeclaration() throws RecognitionException { try { - // InternalExpression.g:2011:1: ( rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ) - // InternalExpression.g:2012:2: rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 + // InternalExpression.g:2005:1: ( ruleXExpressionOrVarDeclaration EOF ) + // InternalExpression.g:2006:1: ruleXExpressionOrVarDeclaration EOF { - pushFollow(FOLLOW_6); - rule__IfExpressionTri__Group_1__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXExpressionOrVarDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7147,36 +6775,33 @@ public final void rule__IfExpressionTri__Group_1__2() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__2" + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" - // $ANTLR start "rule__IfExpressionTri__Group_1__2__Impl" - // InternalExpression.g:2019:1: rule__IfExpressionTri__Group_1__2__Impl : ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ; - public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // InternalExpression.g:2013:1: ruleXExpressionOrVarDeclaration : ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ; + public final void ruleXExpressionOrVarDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2023:1: ( ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ) - // InternalExpression.g:2024:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) + // InternalExpression.g:2017:2: ( ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ) + // InternalExpression.g:2018:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) { - // InternalExpression.g:2024:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) - // InternalExpression.g:2025:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) + // InternalExpression.g:2018:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) + // InternalExpression.g:2019:3: ( rule__XExpressionOrVarDeclaration__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } - // InternalExpression.g:2026:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) - // InternalExpression.g:2026:3: rule__IfExpressionTri__ThenPartAssignment_1_2 + // InternalExpression.g:2020:3: ( rule__XExpressionOrVarDeclaration__Alternatives ) + // InternalExpression.g:2020:4: rule__XExpressionOrVarDeclaration__Alternatives { pushFollow(FOLLOW_2); - rule__IfExpressionTri__ThenPartAssignment_1_2(); + rule__XExpressionOrVarDeclaration__Alternatives(); state._fsp--; if (state.failed) return ; @@ -7184,7 +6809,7 @@ public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } } @@ -7204,29 +6829,28 @@ public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__2__Impl" + // $ANTLR end "ruleXExpressionOrVarDeclaration" - // $ANTLR start "rule__IfExpressionTri__Group_1__3" - // InternalExpression.g:2034:1: rule__IfExpressionTri__Group_1__3 : rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ; - public final void rule__IfExpressionTri__Group_1__3() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXVariableDeclaration" + // InternalExpression.g:2029:1: entryRuleXVariableDeclaration : ruleXVariableDeclaration EOF ; + public final void entryRuleXVariableDeclaration() throws RecognitionException { try { - // InternalExpression.g:2038:1: ( rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ) - // InternalExpression.g:2039:2: rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 + // InternalExpression.g:2030:1: ( ruleXVariableDeclaration EOF ) + // InternalExpression.g:2031:1: ruleXVariableDeclaration EOF { - pushFollow(FOLLOW_5); - rule__IfExpressionTri__Group_1__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXVariableDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7236,34 +6860,41 @@ public final void rule__IfExpressionTri__Group_1__3() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__3" + // $ANTLR end "entryRuleXVariableDeclaration" - // $ANTLR start "rule__IfExpressionTri__Group_1__3__Impl" - // InternalExpression.g:2046:1: rule__IfExpressionTri__Group_1__3__Impl : ( ':' ) ; - public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXVariableDeclaration" + // InternalExpression.g:2038:1: ruleXVariableDeclaration : ( ( rule__XVariableDeclaration__Group__0 ) ) ; + public final void ruleXVariableDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2050:1: ( ( ':' ) ) - // InternalExpression.g:2051:1: ( ':' ) + // InternalExpression.g:2042:2: ( ( ( rule__XVariableDeclaration__Group__0 ) ) ) + // InternalExpression.g:2043:2: ( ( rule__XVariableDeclaration__Group__0 ) ) { - // InternalExpression.g:2051:1: ( ':' ) - // InternalExpression.g:2052:2: ':' + // InternalExpression.g:2043:2: ( ( rule__XVariableDeclaration__Group__0 ) ) + // InternalExpression.g:2044:3: ( rule__XVariableDeclaration__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); + before(grammarAccess.getXVariableDeclarationAccess().getGroup()); + } + // InternalExpression.g:2045:3: ( rule__XVariableDeclaration__Group__0 ) + // InternalExpression.g:2045:4: rule__XVariableDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); + after(grammarAccess.getXVariableDeclarationAccess().getGroup()); } } @@ -7283,24 +6914,28 @@ public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__3__Impl" - + // $ANTLR end "ruleXVariableDeclaration" - // $ANTLR start "rule__IfExpressionTri__Group_1__4" - // InternalExpression.g:2061:1: rule__IfExpressionTri__Group_1__4 : rule__IfExpressionTri__Group_1__4__Impl ; - public final void rule__IfExpressionTri__Group_1__4() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmFormalParameter" + // InternalExpression.g:2054:1: entryRuleJvmFormalParameter : ruleJvmFormalParameter EOF ; + public final void entryRuleJvmFormalParameter() throws RecognitionException { try { - // InternalExpression.g:2065:1: ( rule__IfExpressionTri__Group_1__4__Impl ) - // InternalExpression.g:2066:2: rule__IfExpressionTri__Group_1__4__Impl + // InternalExpression.g:2055:1: ( ruleJvmFormalParameter EOF ) + // InternalExpression.g:2056:1: ruleJvmFormalParameter EOF { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__4__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + ruleJvmFormalParameter(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7310,36 +6945,33 @@ public final void rule__IfExpressionTri__Group_1__4() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__4" + // $ANTLR end "entryRuleJvmFormalParameter" - // $ANTLR start "rule__IfExpressionTri__Group_1__4__Impl" - // InternalExpression.g:2072:1: rule__IfExpressionTri__Group_1__4__Impl : ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ; - public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmFormalParameter" + // InternalExpression.g:2063:1: ruleJvmFormalParameter : ( ( rule__JvmFormalParameter__Group__0 ) ) ; + public final void ruleJvmFormalParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2076:1: ( ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ) - // InternalExpression.g:2077:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) + // InternalExpression.g:2067:2: ( ( ( rule__JvmFormalParameter__Group__0 ) ) ) + // InternalExpression.g:2068:2: ( ( rule__JvmFormalParameter__Group__0 ) ) { - // InternalExpression.g:2077:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) - // InternalExpression.g:2078:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) + // InternalExpression.g:2068:2: ( ( rule__JvmFormalParameter__Group__0 ) ) + // InternalExpression.g:2069:3: ( rule__JvmFormalParameter__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + before(grammarAccess.getJvmFormalParameterAccess().getGroup()); } - // InternalExpression.g:2079:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) - // InternalExpression.g:2079:3: rule__IfExpressionTri__ElsePartAssignment_1_4 + // InternalExpression.g:2070:3: ( rule__JvmFormalParameter__Group__0 ) + // InternalExpression.g:2070:4: rule__JvmFormalParameter__Group__0 { pushFollow(FOLLOW_2); - rule__IfExpressionTri__ElsePartAssignment_1_4(); + rule__JvmFormalParameter__Group__0(); state._fsp--; if (state.failed) return ; @@ -7347,7 +6979,7 @@ public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + after(grammarAccess.getJvmFormalParameterAccess().getGroup()); } } @@ -7367,29 +6999,28 @@ public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__4__Impl" + // $ANTLR end "ruleJvmFormalParameter" - // $ANTLR start "rule__IfExpressionKw__Group__0" - // InternalExpression.g:2088:1: rule__IfExpressionKw__Group__0 : rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ; - public final void rule__IfExpressionKw__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleFullJvmFormalParameter" + // InternalExpression.g:2079:1: entryRuleFullJvmFormalParameter : ruleFullJvmFormalParameter EOF ; + public final void entryRuleFullJvmFormalParameter() throws RecognitionException { try { - // InternalExpression.g:2092:1: ( rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ) - // InternalExpression.g:2093:2: rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 + // InternalExpression.g:2080:1: ( ruleFullJvmFormalParameter EOF ) + // InternalExpression.g:2081:1: ruleFullJvmFormalParameter EOF { - pushFollow(FOLLOW_5); - rule__IfExpressionKw__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + ruleFullJvmFormalParameter(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7399,34 +7030,41 @@ public final void rule__IfExpressionKw__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__0" + // $ANTLR end "entryRuleFullJvmFormalParameter" - // $ANTLR start "rule__IfExpressionKw__Group__0__Impl" - // InternalExpression.g:2100:1: rule__IfExpressionKw__Group__0__Impl : ( 'if' ) ; - public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleFullJvmFormalParameter" + // InternalExpression.g:2088:1: ruleFullJvmFormalParameter : ( ( rule__FullJvmFormalParameter__Group__0 ) ) ; + public final void ruleFullJvmFormalParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2104:1: ( ( 'if' ) ) - // InternalExpression.g:2105:1: ( 'if' ) + // InternalExpression.g:2092:2: ( ( ( rule__FullJvmFormalParameter__Group__0 ) ) ) + // InternalExpression.g:2093:2: ( ( rule__FullJvmFormalParameter__Group__0 ) ) { - // InternalExpression.g:2105:1: ( 'if' ) - // InternalExpression.g:2106:2: 'if' + // InternalExpression.g:2093:2: ( ( rule__FullJvmFormalParameter__Group__0 ) ) + // InternalExpression.g:2094:3: ( rule__FullJvmFormalParameter__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); + } + // InternalExpression.g:2095:3: ( rule__FullJvmFormalParameter__Group__0 ) + // InternalExpression.g:2095:4: rule__FullJvmFormalParameter__Group__0 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,43,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } } @@ -7446,29 +7084,28 @@ public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__0__Impl" - + // $ANTLR end "ruleFullJvmFormalParameter" - // $ANTLR start "rule__IfExpressionKw__Group__1" - // InternalExpression.g:2115:1: rule__IfExpressionKw__Group__1 : rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ; - public final void rule__IfExpressionKw__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXFeatureCall" + // InternalExpression.g:2104:1: entryRuleXFeatureCall : ruleXFeatureCall EOF ; + public final void entryRuleXFeatureCall() throws RecognitionException { try { - // InternalExpression.g:2119:1: ( rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ) - // InternalExpression.g:2120:2: rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 + // InternalExpression.g:2105:1: ( ruleXFeatureCall EOF ) + // InternalExpression.g:2106:1: ruleXFeatureCall EOF { - pushFollow(FOLLOW_12); - rule__IfExpressionKw__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_1); + ruleXFeatureCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7478,36 +7115,33 @@ public final void rule__IfExpressionKw__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__1" + // $ANTLR end "entryRuleXFeatureCall" - // $ANTLR start "rule__IfExpressionKw__Group__1__Impl" - // InternalExpression.g:2127:1: rule__IfExpressionKw__Group__1__Impl : ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ; - public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXFeatureCall" + // InternalExpression.g:2113:1: ruleXFeatureCall : ( ( rule__XFeatureCall__Group__0 ) ) ; + public final void ruleXFeatureCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2131:1: ( ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ) - // InternalExpression.g:2132:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) + // InternalExpression.g:2117:2: ( ( ( rule__XFeatureCall__Group__0 ) ) ) + // InternalExpression.g:2118:2: ( ( rule__XFeatureCall__Group__0 ) ) { - // InternalExpression.g:2132:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) - // InternalExpression.g:2133:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) + // InternalExpression.g:2118:2: ( ( rule__XFeatureCall__Group__0 ) ) + // InternalExpression.g:2119:3: ( rule__XFeatureCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); + before(grammarAccess.getXFeatureCallAccess().getGroup()); } - // InternalExpression.g:2134:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) - // InternalExpression.g:2134:3: rule__IfExpressionKw__ConditionAssignment_1 + // InternalExpression.g:2120:3: ( rule__XFeatureCall__Group__0 ) + // InternalExpression.g:2120:4: rule__XFeatureCall__Group__0 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__ConditionAssignment_1(); + rule__XFeatureCall__Group__0(); state._fsp--; if (state.failed) return ; @@ -7515,7 +7149,7 @@ public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); + after(grammarAccess.getXFeatureCallAccess().getGroup()); } } @@ -7535,29 +7169,28 @@ public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__1__Impl" - + // $ANTLR end "ruleXFeatureCall" - // $ANTLR start "rule__IfExpressionKw__Group__2" - // InternalExpression.g:2142:1: rule__IfExpressionKw__Group__2 : rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ; - public final void rule__IfExpressionKw__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleFeatureCallID" + // InternalExpression.g:2129:1: entryRuleFeatureCallID : ruleFeatureCallID EOF ; + public final void entryRuleFeatureCallID() throws RecognitionException { try { - // InternalExpression.g:2146:1: ( rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ) - // InternalExpression.g:2147:2: rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 + // InternalExpression.g:2130:1: ( ruleFeatureCallID EOF ) + // InternalExpression.g:2131:1: ruleFeatureCallID EOF { - pushFollow(FOLLOW_5); - rule__IfExpressionKw__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_1); + ruleFeatureCallID(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7567,34 +7200,41 @@ public final void rule__IfExpressionKw__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__2" + // $ANTLR end "entryRuleFeatureCallID" - // $ANTLR start "rule__IfExpressionKw__Group__2__Impl" - // InternalExpression.g:2154:1: rule__IfExpressionKw__Group__2__Impl : ( 'then' ) ; - public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleFeatureCallID" + // InternalExpression.g:2138:1: ruleFeatureCallID : ( ( rule__FeatureCallID__Alternatives ) ) ; + public final void ruleFeatureCallID() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2158:1: ( ( 'then' ) ) - // InternalExpression.g:2159:1: ( 'then' ) + // InternalExpression.g:2142:2: ( ( ( rule__FeatureCallID__Alternatives ) ) ) + // InternalExpression.g:2143:2: ( ( rule__FeatureCallID__Alternatives ) ) { - // InternalExpression.g:2159:1: ( 'then' ) - // InternalExpression.g:2160:2: 'then' + // InternalExpression.g:2143:2: ( ( rule__FeatureCallID__Alternatives ) ) + // InternalExpression.g:2144:3: ( rule__FeatureCallID__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); + before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); + } + // InternalExpression.g:2145:3: ( rule__FeatureCallID__Alternatives ) + // InternalExpression.g:2145:4: rule__FeatureCallID__Alternatives + { + pushFollow(FOLLOW_2); + rule__FeatureCallID__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,44,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); + after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } } @@ -7614,29 +7254,28 @@ public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__2__Impl" + // $ANTLR end "ruleFeatureCallID" - // $ANTLR start "rule__IfExpressionKw__Group__3" - // InternalExpression.g:2169:1: rule__IfExpressionKw__Group__3 : rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ; - public final void rule__IfExpressionKw__Group__3() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleIdOrSuper" + // InternalExpression.g:2154:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ; + public final void entryRuleIdOrSuper() throws RecognitionException { try { - // InternalExpression.g:2173:1: ( rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ) - // InternalExpression.g:2174:2: rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 + // InternalExpression.g:2155:1: ( ruleIdOrSuper EOF ) + // InternalExpression.g:2156:1: ruleIdOrSuper EOF { - pushFollow(FOLLOW_13); - rule__IfExpressionKw__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_1); + ruleIdOrSuper(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7646,36 +7285,33 @@ public final void rule__IfExpressionKw__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__3" + // $ANTLR end "entryRuleIdOrSuper" - // $ANTLR start "rule__IfExpressionKw__Group__3__Impl" - // InternalExpression.g:2181:1: rule__IfExpressionKw__Group__3__Impl : ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ; - public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleIdOrSuper" + // InternalExpression.g:2163:1: ruleIdOrSuper : ( ( rule__IdOrSuper__Alternatives ) ) ; + public final void ruleIdOrSuper() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2185:1: ( ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ) - // InternalExpression.g:2186:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) + // InternalExpression.g:2167:2: ( ( ( rule__IdOrSuper__Alternatives ) ) ) + // InternalExpression.g:2168:2: ( ( rule__IdOrSuper__Alternatives ) ) { - // InternalExpression.g:2186:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) - // InternalExpression.g:2187:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) + // InternalExpression.g:2168:2: ( ( rule__IdOrSuper__Alternatives ) ) + // InternalExpression.g:2169:3: ( rule__IdOrSuper__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); + before(grammarAccess.getIdOrSuperAccess().getAlternatives()); } - // InternalExpression.g:2188:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) - // InternalExpression.g:2188:3: rule__IfExpressionKw__ThenPartAssignment_3 + // InternalExpression.g:2170:3: ( rule__IdOrSuper__Alternatives ) + // InternalExpression.g:2170:4: rule__IdOrSuper__Alternatives { pushFollow(FOLLOW_2); - rule__IfExpressionKw__ThenPartAssignment_3(); + rule__IdOrSuper__Alternatives(); state._fsp--; if (state.failed) return ; @@ -7683,7 +7319,7 @@ public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); + after(grammarAccess.getIdOrSuperAccess().getAlternatives()); } } @@ -7703,24 +7339,28 @@ public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__3__Impl" + // $ANTLR end "ruleIdOrSuper" - // $ANTLR start "rule__IfExpressionKw__Group__4" - // InternalExpression.g:2196:1: rule__IfExpressionKw__Group__4 : rule__IfExpressionKw__Group__4__Impl ; - public final void rule__IfExpressionKw__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXConstructorCall" + // InternalExpression.g:2179:1: entryRuleXConstructorCall : ruleXConstructorCall EOF ; + public final void entryRuleXConstructorCall() throws RecognitionException { try { - // InternalExpression.g:2200:1: ( rule__IfExpressionKw__Group__4__Impl ) - // InternalExpression.g:2201:2: rule__IfExpressionKw__Group__4__Impl + // InternalExpression.g:2180:1: ( ruleXConstructorCall EOF ) + // InternalExpression.g:2181:1: ruleXConstructorCall EOF { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__4__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_1); + ruleXConstructorCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7730,59 +7370,41 @@ public final void rule__IfExpressionKw__Group__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__4" + // $ANTLR end "entryRuleXConstructorCall" - // $ANTLR start "rule__IfExpressionKw__Group__4__Impl" - // InternalExpression.g:2207:1: rule__IfExpressionKw__Group__4__Impl : ( ( rule__IfExpressionKw__Group_4__0 )? ) ; - public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXConstructorCall" + // InternalExpression.g:2188:1: ruleXConstructorCall : ( ( rule__XConstructorCall__Group__0 ) ) ; + public final void ruleXConstructorCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2211:1: ( ( ( rule__IfExpressionKw__Group_4__0 )? ) ) - // InternalExpression.g:2212:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) + // InternalExpression.g:2192:2: ( ( ( rule__XConstructorCall__Group__0 ) ) ) + // InternalExpression.g:2193:2: ( ( rule__XConstructorCall__Group__0 ) ) { - // InternalExpression.g:2212:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) - // InternalExpression.g:2213:2: ( rule__IfExpressionKw__Group_4__0 )? + // InternalExpression.g:2193:2: ( ( rule__XConstructorCall__Group__0 ) ) + // InternalExpression.g:2194:3: ( rule__XConstructorCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); - } - // InternalExpression.g:2214:2: ( rule__IfExpressionKw__Group_4__0 )? - int alt19=2; - int LA19_0 = input.LA(1); - - if ( (LA19_0==45) ) { - int LA19_1 = input.LA(2); - - if ( (synpred49_InternalExpression()) ) { - alt19=1; - } + before(grammarAccess.getXConstructorCallAccess().getGroup()); } - switch (alt19) { - case 1 : - // InternalExpression.g:2214:3: rule__IfExpressionKw__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:2195:3: ( rule__XConstructorCall__Group__0 ) + // InternalExpression.g:2195:4: rule__XConstructorCall__Group__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); + after(grammarAccess.getXConstructorCallAccess().getGroup()); } } @@ -7802,24 +7424,28 @@ public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__4__Impl" + // $ANTLR end "ruleXConstructorCall" - // $ANTLR start "rule__IfExpressionKw__Group_4__0" - // InternalExpression.g:2223:1: rule__IfExpressionKw__Group_4__0 : rule__IfExpressionKw__Group_4__0__Impl ; - public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBooleanLiteral" + // InternalExpression.g:2204:1: entryRuleXBooleanLiteral : ruleXBooleanLiteral EOF ; + public final void entryRuleXBooleanLiteral() throws RecognitionException { try { - // InternalExpression.g:2227:1: ( rule__IfExpressionKw__Group_4__0__Impl ) - // InternalExpression.g:2228:2: rule__IfExpressionKw__Group_4__0__Impl + // InternalExpression.g:2205:1: ( ruleXBooleanLiteral EOF ) + // InternalExpression.g:2206:1: ruleXBooleanLiteral EOF { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXBooleanLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7829,36 +7455,33 @@ public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4__0" + // $ANTLR end "entryRuleXBooleanLiteral" - // $ANTLR start "rule__IfExpressionKw__Group_4__0__Impl" - // InternalExpression.g:2234:1: rule__IfExpressionKw__Group_4__0__Impl : ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ; - public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXBooleanLiteral" + // InternalExpression.g:2213:1: ruleXBooleanLiteral : ( ( rule__XBooleanLiteral__Group__0 ) ) ; + public final void ruleXBooleanLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2238:1: ( ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ) - // InternalExpression.g:2239:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) + // InternalExpression.g:2217:2: ( ( ( rule__XBooleanLiteral__Group__0 ) ) ) + // InternalExpression.g:2218:2: ( ( rule__XBooleanLiteral__Group__0 ) ) { - // InternalExpression.g:2239:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) - // InternalExpression.g:2240:2: ( rule__IfExpressionKw__Group_4_0__0 ) + // InternalExpression.g:2218:2: ( ( rule__XBooleanLiteral__Group__0 ) ) + // InternalExpression.g:2219:3: ( rule__XBooleanLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + before(grammarAccess.getXBooleanLiteralAccess().getGroup()); } - // InternalExpression.g:2241:2: ( rule__IfExpressionKw__Group_4_0__0 ) - // InternalExpression.g:2241:3: rule__IfExpressionKw__Group_4_0__0 + // InternalExpression.g:2220:3: ( rule__XBooleanLiteral__Group__0 ) + // InternalExpression.g:2220:4: rule__XBooleanLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__0(); + rule__XBooleanLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -7866,7 +7489,7 @@ public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + after(grammarAccess.getXBooleanLiteralAccess().getGroup()); } } @@ -7886,29 +7509,28 @@ public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4__0__Impl" - + // $ANTLR end "ruleXBooleanLiteral" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__0" - // InternalExpression.g:2250:1: rule__IfExpressionKw__Group_4_0__0 : rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ; - public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXNullLiteral" + // InternalExpression.g:2229:1: entryRuleXNullLiteral : ruleXNullLiteral EOF ; + public final void entryRuleXNullLiteral() throws RecognitionException { try { - // InternalExpression.g:2254:1: ( rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ) - // InternalExpression.g:2255:2: rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 + // InternalExpression.g:2230:1: ( ruleXNullLiteral EOF ) + // InternalExpression.g:2231:1: ruleXNullLiteral EOF { - pushFollow(FOLLOW_5); - rule__IfExpressionKw__Group_4_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXNullLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7918,34 +7540,41 @@ public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionExcepti recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__0" + // $ANTLR end "entryRuleXNullLiteral" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__0__Impl" - // InternalExpression.g:2262:1: rule__IfExpressionKw__Group_4_0__0__Impl : ( 'else' ) ; - public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXNullLiteral" + // InternalExpression.g:2238:1: ruleXNullLiteral : ( ( rule__XNullLiteral__Group__0 ) ) ; + public final void ruleXNullLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2266:1: ( ( 'else' ) ) - // InternalExpression.g:2267:1: ( 'else' ) + // InternalExpression.g:2242:2: ( ( ( rule__XNullLiteral__Group__0 ) ) ) + // InternalExpression.g:2243:2: ( ( rule__XNullLiteral__Group__0 ) ) { - // InternalExpression.g:2267:1: ( 'else' ) - // InternalExpression.g:2268:2: 'else' + // InternalExpression.g:2243:2: ( ( rule__XNullLiteral__Group__0 ) ) + // InternalExpression.g:2244:3: ( rule__XNullLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); + before(grammarAccess.getXNullLiteralAccess().getGroup()); + } + // InternalExpression.g:2245:3: ( rule__XNullLiteral__Group__0 ) + // InternalExpression.g:2245:4: rule__XNullLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); + after(grammarAccess.getXNullLiteralAccess().getGroup()); } } @@ -7965,24 +7594,28 @@ public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__0__Impl" + // $ANTLR end "ruleXNullLiteral" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__1" - // InternalExpression.g:2277:1: rule__IfExpressionKw__Group_4_0__1 : rule__IfExpressionKw__Group_4_0__1__Impl ; - public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXNumberLiteral" + // InternalExpression.g:2254:1: entryRuleXNumberLiteral : ruleXNumberLiteral EOF ; + public final void entryRuleXNumberLiteral() throws RecognitionException { try { - // InternalExpression.g:2281:1: ( rule__IfExpressionKw__Group_4_0__1__Impl ) - // InternalExpression.g:2282:2: rule__IfExpressionKw__Group_4_0__1__Impl + // InternalExpression.g:2255:1: ( ruleXNumberLiteral EOF ) + // InternalExpression.g:2256:1: ruleXNumberLiteral EOF { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXNumberLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -7992,36 +7625,33 @@ public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionExcepti recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__1" + // $ANTLR end "entryRuleXNumberLiteral" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__1__Impl" - // InternalExpression.g:2288:1: rule__IfExpressionKw__Group_4_0__1__Impl : ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ; - public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXNumberLiteral" + // InternalExpression.g:2263:1: ruleXNumberLiteral : ( ( rule__XNumberLiteral__Group__0 ) ) ; + public final void ruleXNumberLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2292:1: ( ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ) - // InternalExpression.g:2293:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) + // InternalExpression.g:2267:2: ( ( ( rule__XNumberLiteral__Group__0 ) ) ) + // InternalExpression.g:2268:2: ( ( rule__XNumberLiteral__Group__0 ) ) { - // InternalExpression.g:2293:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) - // InternalExpression.g:2294:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) + // InternalExpression.g:2268:2: ( ( rule__XNumberLiteral__Group__0 ) ) + // InternalExpression.g:2269:3: ( rule__XNumberLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); + before(grammarAccess.getXNumberLiteralAccess().getGroup()); } - // InternalExpression.g:2295:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) - // InternalExpression.g:2295:3: rule__IfExpressionKw__ElsePartAssignment_4_0_1 + // InternalExpression.g:2270:3: ( rule__XNumberLiteral__Group__0 ) + // InternalExpression.g:2270:4: rule__XNumberLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__ElsePartAssignment_4_0_1(); + rule__XNumberLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -8029,7 +7659,7 @@ public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionE } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); + after(grammarAccess.getXNumberLiteralAccess().getGroup()); } } @@ -8049,29 +7679,28 @@ public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__1__Impl" - + // $ANTLR end "ruleXNumberLiteral" - // $ANTLR start "rule__SwitchExpression__Group__0" - // InternalExpression.g:2304:1: rule__SwitchExpression__Group__0 : rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ; - public final void rule__SwitchExpression__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXStringLiteral" + // InternalExpression.g:2279:1: entryRuleXStringLiteral : ruleXStringLiteral EOF ; + public final void entryRuleXStringLiteral() throws RecognitionException { try { - // InternalExpression.g:2308:1: ( rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ) - // InternalExpression.g:2309:2: rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 + // InternalExpression.g:2280:1: ( ruleXStringLiteral EOF ) + // InternalExpression.g:2281:1: ruleXStringLiteral EOF { - pushFollow(FOLLOW_14); - rule__SwitchExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXStringLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8081,34 +7710,41 @@ public final void rule__SwitchExpression__Group__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__0" + // $ANTLR end "entryRuleXStringLiteral" - // $ANTLR start "rule__SwitchExpression__Group__0__Impl" - // InternalExpression.g:2316:1: rule__SwitchExpression__Group__0__Impl : ( 'switch' ) ; - public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXStringLiteral" + // InternalExpression.g:2288:1: ruleXStringLiteral : ( ( rule__XStringLiteral__Group__0 ) ) ; + public final void ruleXStringLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2320:1: ( ( 'switch' ) ) - // InternalExpression.g:2321:1: ( 'switch' ) + // InternalExpression.g:2292:2: ( ( ( rule__XStringLiteral__Group__0 ) ) ) + // InternalExpression.g:2293:2: ( ( rule__XStringLiteral__Group__0 ) ) { - // InternalExpression.g:2321:1: ( 'switch' ) - // InternalExpression.g:2322:2: 'switch' + // InternalExpression.g:2293:2: ( ( rule__XStringLiteral__Group__0 ) ) + // InternalExpression.g:2294:3: ( rule__XStringLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); + before(grammarAccess.getXStringLiteralAccess().getGroup()); + } + // InternalExpression.g:2295:3: ( rule__XStringLiteral__Group__0 ) + // InternalExpression.g:2295:4: rule__XStringLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); + after(grammarAccess.getXStringLiteralAccess().getGroup()); } } @@ -8128,29 +7764,28 @@ public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__0__Impl" + // $ANTLR end "ruleXStringLiteral" - // $ANTLR start "rule__SwitchExpression__Group__1" - // InternalExpression.g:2331:1: rule__SwitchExpression__Group__1 : rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ; - public final void rule__SwitchExpression__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXTypeLiteral" + // InternalExpression.g:2304:1: entryRuleXTypeLiteral : ruleXTypeLiteral EOF ; + public final void entryRuleXTypeLiteral() throws RecognitionException { try { - // InternalExpression.g:2335:1: ( rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ) - // InternalExpression.g:2336:2: rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 + // InternalExpression.g:2305:1: ( ruleXTypeLiteral EOF ) + // InternalExpression.g:2306:1: ruleXTypeLiteral EOF { - pushFollow(FOLLOW_14); - rule__SwitchExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXTypeLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8160,55 +7795,41 @@ public final void rule__SwitchExpression__Group__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__1" + // $ANTLR end "entryRuleXTypeLiteral" - // $ANTLR start "rule__SwitchExpression__Group__1__Impl" - // InternalExpression.g:2343:1: rule__SwitchExpression__Group__1__Impl : ( ( rule__SwitchExpression__Group_1__0 )? ) ; - public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXTypeLiteral" + // InternalExpression.g:2313:1: ruleXTypeLiteral : ( ( rule__XTypeLiteral__Group__0 ) ) ; + public final void ruleXTypeLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2347:1: ( ( ( rule__SwitchExpression__Group_1__0 )? ) ) - // InternalExpression.g:2348:1: ( ( rule__SwitchExpression__Group_1__0 )? ) + // InternalExpression.g:2317:2: ( ( ( rule__XTypeLiteral__Group__0 ) ) ) + // InternalExpression.g:2318:2: ( ( rule__XTypeLiteral__Group__0 ) ) { - // InternalExpression.g:2348:1: ( ( rule__SwitchExpression__Group_1__0 )? ) - // InternalExpression.g:2349:2: ( rule__SwitchExpression__Group_1__0 )? + // InternalExpression.g:2318:2: ( ( rule__XTypeLiteral__Group__0 ) ) + // InternalExpression.g:2319:3: ( rule__XTypeLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); - } - // InternalExpression.g:2350:2: ( rule__SwitchExpression__Group_1__0 )? - int alt20=2; - int LA20_0 = input.LA(1); - - if ( (LA20_0==39) ) { - alt20=1; + before(grammarAccess.getXTypeLiteralAccess().getGroup()); } - switch (alt20) { - case 1 : - // InternalExpression.g:2350:3: rule__SwitchExpression__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:2320:3: ( rule__XTypeLiteral__Group__0 ) + // InternalExpression.g:2320:4: rule__XTypeLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); + after(grammarAccess.getXTypeLiteralAccess().getGroup()); } } @@ -8228,29 +7849,28 @@ public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__1__Impl" + // $ANTLR end "ruleXTypeLiteral" - // $ANTLR start "rule__SwitchExpression__Group__2" - // InternalExpression.g:2358:1: rule__SwitchExpression__Group__2 : rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ; - public final void rule__SwitchExpression__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXThrowExpression" + // InternalExpression.g:2329:1: entryRuleXThrowExpression : ruleXThrowExpression EOF ; + public final void entryRuleXThrowExpression() throws RecognitionException { try { - // InternalExpression.g:2362:1: ( rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ) - // InternalExpression.g:2363:2: rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 + // InternalExpression.g:2330:1: ( ruleXThrowExpression EOF ) + // InternalExpression.g:2331:1: ruleXThrowExpression EOF { - pushFollow(FOLLOW_15); - rule__SwitchExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXThrowExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8260,34 +7880,41 @@ public final void rule__SwitchExpression__Group__2() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__2" + // $ANTLR end "entryRuleXThrowExpression" - // $ANTLR start "rule__SwitchExpression__Group__2__Impl" - // InternalExpression.g:2370:1: rule__SwitchExpression__Group__2__Impl : ( '{' ) ; - public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXThrowExpression" + // InternalExpression.g:2338:1: ruleXThrowExpression : ( ( rule__XThrowExpression__Group__0 ) ) ; + public final void ruleXThrowExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2374:1: ( ( '{' ) ) - // InternalExpression.g:2375:1: ( '{' ) + // InternalExpression.g:2342:2: ( ( ( rule__XThrowExpression__Group__0 ) ) ) + // InternalExpression.g:2343:2: ( ( rule__XThrowExpression__Group__0 ) ) { - // InternalExpression.g:2375:1: ( '{' ) - // InternalExpression.g:2376:2: '{' + // InternalExpression.g:2343:2: ( ( rule__XThrowExpression__Group__0 ) ) + // InternalExpression.g:2344:3: ( rule__XThrowExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); + before(grammarAccess.getXThrowExpressionAccess().getGroup()); + } + // InternalExpression.g:2345:3: ( rule__XThrowExpression__Group__0 ) + // InternalExpression.g:2345:4: rule__XThrowExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); + after(grammarAccess.getXThrowExpressionAccess().getGroup()); } } @@ -8307,29 +7934,28 @@ public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__2__Impl" - + // $ANTLR end "ruleXThrowExpression" - // $ANTLR start "rule__SwitchExpression__Group__3" - // InternalExpression.g:2385:1: rule__SwitchExpression__Group__3 : rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ; - public final void rule__SwitchExpression__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXReturnExpression" + // InternalExpression.g:2354:1: entryRuleXReturnExpression : ruleXReturnExpression EOF ; + public final void entryRuleXReturnExpression() throws RecognitionException { try { - // InternalExpression.g:2389:1: ( rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ) - // InternalExpression.g:2390:2: rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 + // InternalExpression.g:2355:1: ( ruleXReturnExpression EOF ) + // InternalExpression.g:2356:1: ruleXReturnExpression EOF { - pushFollow(FOLLOW_15); - rule__SwitchExpression__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXReturnExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8339,62 +7965,41 @@ public final void rule__SwitchExpression__Group__3() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__3" + // $ANTLR end "entryRuleXReturnExpression" - // $ANTLR start "rule__SwitchExpression__Group__3__Impl" - // InternalExpression.g:2397:1: rule__SwitchExpression__Group__3__Impl : ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ; - public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXReturnExpression" + // InternalExpression.g:2363:1: ruleXReturnExpression : ( ( rule__XReturnExpression__Group__0 ) ) ; + public final void ruleXReturnExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2401:1: ( ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ) - // InternalExpression.g:2402:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) + // InternalExpression.g:2367:2: ( ( ( rule__XReturnExpression__Group__0 ) ) ) + // InternalExpression.g:2368:2: ( ( rule__XReturnExpression__Group__0 ) ) { - // InternalExpression.g:2402:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) - // InternalExpression.g:2403:2: ( rule__SwitchExpression__CaseAssignment_3 )* + // InternalExpression.g:2368:2: ( ( rule__XReturnExpression__Group__0 ) ) + // InternalExpression.g:2369:3: ( rule__XReturnExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); + before(grammarAccess.getXReturnExpressionAccess().getGroup()); } - // InternalExpression.g:2404:2: ( rule__SwitchExpression__CaseAssignment_3 )* - loop21: - do { - int alt21=2; - int LA21_0 = input.LA(1); - - if ( (LA21_0==50) ) { - alt21=1; - } - - - switch (alt21) { - case 1 : - // InternalExpression.g:2404:3: rule__SwitchExpression__CaseAssignment_3 - { - pushFollow(FOLLOW_16); - rule__SwitchExpression__CaseAssignment_3(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:2370:3: ( rule__XReturnExpression__Group__0 ) + // InternalExpression.g:2370:4: rule__XReturnExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop21; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); + after(grammarAccess.getXReturnExpressionAccess().getGroup()); } } @@ -8414,29 +8019,28 @@ public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__3__Impl" - + // $ANTLR end "ruleXReturnExpression" - // $ANTLR start "rule__SwitchExpression__Group__4" - // InternalExpression.g:2412:1: rule__SwitchExpression__Group__4 : rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ; - public final void rule__SwitchExpression__Group__4() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXTryCatchFinallyExpression" + // InternalExpression.g:2379:1: entryRuleXTryCatchFinallyExpression : ruleXTryCatchFinallyExpression EOF ; + public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException { try { - // InternalExpression.g:2416:1: ( rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ) - // InternalExpression.g:2417:2: rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 + // InternalExpression.g:2380:1: ( ruleXTryCatchFinallyExpression EOF ) + // InternalExpression.g:2381:1: ruleXTryCatchFinallyExpression EOF { - pushFollow(FOLLOW_6); - rule__SwitchExpression__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXTryCatchFinallyExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8446,34 +8050,41 @@ public final void rule__SwitchExpression__Group__4() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__4" + // $ANTLR end "entryRuleXTryCatchFinallyExpression" - // $ANTLR start "rule__SwitchExpression__Group__4__Impl" - // InternalExpression.g:2424:1: rule__SwitchExpression__Group__4__Impl : ( 'default' ) ; - public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXTryCatchFinallyExpression" + // InternalExpression.g:2388:1: ruleXTryCatchFinallyExpression : ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ; + public final void ruleXTryCatchFinallyExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2428:1: ( ( 'default' ) ) - // InternalExpression.g:2429:1: ( 'default' ) + // InternalExpression.g:2392:2: ( ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ) + // InternalExpression.g:2393:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) { - // InternalExpression.g:2429:1: ( 'default' ) - // InternalExpression.g:2430:2: 'default' + // InternalExpression.g:2393:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) + // InternalExpression.g:2394:3: ( rule__XTryCatchFinallyExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:2395:3: ( rule__XTryCatchFinallyExpression__Group__0 ) + // InternalExpression.g:2395:4: rule__XTryCatchFinallyExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } } @@ -8493,29 +8104,28 @@ public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__4__Impl" - + // $ANTLR end "ruleXTryCatchFinallyExpression" - // $ANTLR start "rule__SwitchExpression__Group__5" - // InternalExpression.g:2439:1: rule__SwitchExpression__Group__5 : rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ; - public final void rule__SwitchExpression__Group__5() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSynchronizedExpression" + // InternalExpression.g:2404:1: entryRuleXSynchronizedExpression : ruleXSynchronizedExpression EOF ; + public final void entryRuleXSynchronizedExpression() throws RecognitionException { try { - // InternalExpression.g:2443:1: ( rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ) - // InternalExpression.g:2444:2: rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 + // InternalExpression.g:2405:1: ( ruleXSynchronizedExpression EOF ) + // InternalExpression.g:2406:1: ruleXSynchronizedExpression EOF { - pushFollow(FOLLOW_17); - rule__SwitchExpression__Group__5__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__6(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXSynchronizedExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8525,34 +8135,41 @@ public final void rule__SwitchExpression__Group__5() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__5" + // $ANTLR end "entryRuleXSynchronizedExpression" - // $ANTLR start "rule__SwitchExpression__Group__5__Impl" - // InternalExpression.g:2451:1: rule__SwitchExpression__Group__5__Impl : ( ':' ) ; - public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleXSynchronizedExpression" + // InternalExpression.g:2413:1: ruleXSynchronizedExpression : ( ( rule__XSynchronizedExpression__Group__0 ) ) ; + public final void ruleXSynchronizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2455:1: ( ( ':' ) ) - // InternalExpression.g:2456:1: ( ':' ) + // InternalExpression.g:2417:2: ( ( ( rule__XSynchronizedExpression__Group__0 ) ) ) + // InternalExpression.g:2418:2: ( ( rule__XSynchronizedExpression__Group__0 ) ) { - // InternalExpression.g:2456:1: ( ':' ) - // InternalExpression.g:2457:2: ':' + // InternalExpression.g:2418:2: ( ( rule__XSynchronizedExpression__Group__0 ) ) + // InternalExpression.g:2419:3: ( rule__XSynchronizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); + } + // InternalExpression.g:2420:3: ( rule__XSynchronizedExpression__Group__0 ) + // InternalExpression.g:2420:4: rule__XSynchronizedExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } } @@ -8572,29 +8189,28 @@ public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__5__Impl" - + // $ANTLR end "ruleXSynchronizedExpression" - // $ANTLR start "rule__SwitchExpression__Group__6" - // InternalExpression.g:2466:1: rule__SwitchExpression__Group__6 : rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ; - public final void rule__SwitchExpression__Group__6() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCatchClause" + // InternalExpression.g:2429:1: entryRuleXCatchClause : ruleXCatchClause EOF ; + public final void entryRuleXCatchClause() throws RecognitionException { try { - // InternalExpression.g:2470:1: ( rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ) - // InternalExpression.g:2471:2: rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 + // InternalExpression.g:2430:1: ( ruleXCatchClause EOF ) + // InternalExpression.g:2431:1: ruleXCatchClause EOF { - pushFollow(FOLLOW_18); - rule__SwitchExpression__Group__6__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__7(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_1); + ruleXCatchClause(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8604,36 +8220,33 @@ public final void rule__SwitchExpression__Group__6() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__6" + // $ANTLR end "entryRuleXCatchClause" - // $ANTLR start "rule__SwitchExpression__Group__6__Impl" - // InternalExpression.g:2478:1: rule__SwitchExpression__Group__6__Impl : ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ; - public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionException { + // $ANTLR start "ruleXCatchClause" + // InternalExpression.g:2438:1: ruleXCatchClause : ( ( rule__XCatchClause__Group__0 ) ) ; + public final void ruleXCatchClause() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2482:1: ( ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ) - // InternalExpression.g:2483:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) + // InternalExpression.g:2442:2: ( ( ( rule__XCatchClause__Group__0 ) ) ) + // InternalExpression.g:2443:2: ( ( rule__XCatchClause__Group__0 ) ) { - // InternalExpression.g:2483:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) - // InternalExpression.g:2484:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) + // InternalExpression.g:2443:2: ( ( rule__XCatchClause__Group__0 ) ) + // InternalExpression.g:2444:3: ( rule__XCatchClause__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + before(grammarAccess.getXCatchClauseAccess().getGroup()); } - // InternalExpression.g:2485:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) - // InternalExpression.g:2485:3: rule__SwitchExpression__DefaultExprAssignment_6 + // InternalExpression.g:2445:3: ( rule__XCatchClause__Group__0 ) + // InternalExpression.g:2445:4: rule__XCatchClause__Group__0 { pushFollow(FOLLOW_2); - rule__SwitchExpression__DefaultExprAssignment_6(); + rule__XCatchClause__Group__0(); state._fsp--; if (state.failed) return ; @@ -8641,7 +8254,7 @@ public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + after(grammarAccess.getXCatchClauseAccess().getGroup()); } } @@ -8661,24 +8274,28 @@ public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__6__Impl" - + // $ANTLR end "ruleXCatchClause" - // $ANTLR start "rule__SwitchExpression__Group__7" - // InternalExpression.g:2493:1: rule__SwitchExpression__Group__7 : rule__SwitchExpression__Group__7__Impl ; - public final void rule__SwitchExpression__Group__7() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedName" + // InternalExpression.g:2454:1: entryRuleQualifiedName : ruleQualifiedName EOF ; + public final void entryRuleQualifiedName() throws RecognitionException { try { - // InternalExpression.g:2497:1: ( rule__SwitchExpression__Group__7__Impl ) - // InternalExpression.g:2498:2: rule__SwitchExpression__Group__7__Impl + // InternalExpression.g:2455:1: ( ruleQualifiedName EOF ) + // InternalExpression.g:2456:1: ruleQualifiedName EOF { - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__7__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedName(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8688,34 +8305,41 @@ public final void rule__SwitchExpression__Group__7() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group__7" + // $ANTLR end "entryRuleQualifiedName" - // $ANTLR start "rule__SwitchExpression__Group__7__Impl" - // InternalExpression.g:2504:1: rule__SwitchExpression__Group__7__Impl : ( '}' ) ; - public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedName" + // InternalExpression.g:2463:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; + public final void ruleQualifiedName() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2508:1: ( ( '}' ) ) - // InternalExpression.g:2509:1: ( '}' ) + // InternalExpression.g:2467:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) + // InternalExpression.g:2468:2: ( ( rule__QualifiedName__Group__0 ) ) { - // InternalExpression.g:2509:1: ( '}' ) - // InternalExpression.g:2510:2: '}' + // InternalExpression.g:2468:2: ( ( rule__QualifiedName__Group__0 ) ) + // InternalExpression.g:2469:3: ( rule__QualifiedName__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getQualifiedNameAccess().getGroup()); + } + // InternalExpression.g:2470:3: ( rule__QualifiedName__Group__0 ) + // InternalExpression.g:2470:4: rule__QualifiedName__Group__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,49,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); + after(grammarAccess.getQualifiedNameAccess().getGroup()); } } @@ -8735,29 +8359,31 @@ public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__7__Impl" + // $ANTLR end "ruleQualifiedName" - // $ANTLR start "rule__SwitchExpression__Group_1__0" - // InternalExpression.g:2520:1: rule__SwitchExpression__Group_1__0 : rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ; - public final void rule__SwitchExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "entryRuleNumber" + // InternalExpression.g:2479:1: entryRuleNumber : ruleNumber EOF ; + public final void entryRuleNumber() throws RecognitionException { + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); - int stackSize = keepStackSize(); - try { - // InternalExpression.g:2524:1: ( rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ) - // InternalExpression.g:2525:2: rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 + // InternalExpression.g:2483:1: ( ruleNumber EOF ) + // InternalExpression.g:2484:1: ruleNumber EOF { - pushFollow(FOLLOW_17); - rule__SwitchExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_1); + ruleNumber(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8768,33 +8394,44 @@ public final void rule__SwitchExpression__Group_1__0() throws RecognitionExcepti } finally { - restoreStackSize(stackSize); + myHiddenTokenState.restore(); } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__0" + // $ANTLR end "entryRuleNumber" - // $ANTLR start "rule__SwitchExpression__Group_1__0__Impl" - // InternalExpression.g:2532:1: rule__SwitchExpression__Group_1__0__Impl : ( '(' ) ; - public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleNumber" + // InternalExpression.g:2494:1: ruleNumber : ( ( rule__Number__Alternatives ) ) ; + public final void ruleNumber() throws RecognitionException { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); int stackSize = keepStackSize(); try { - // InternalExpression.g:2536:1: ( ( '(' ) ) - // InternalExpression.g:2537:1: ( '(' ) + // InternalExpression.g:2499:2: ( ( ( rule__Number__Alternatives ) ) ) + // InternalExpression.g:2500:2: ( ( rule__Number__Alternatives ) ) { - // InternalExpression.g:2537:1: ( '(' ) - // InternalExpression.g:2538:2: '(' + // InternalExpression.g:2500:2: ( ( rule__Number__Alternatives ) ) + // InternalExpression.g:2501:3: ( rule__Number__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); + before(grammarAccess.getNumberAccess().getAlternatives()); + } + // InternalExpression.g:2502:3: ( rule__Number__Alternatives ) + // InternalExpression.g:2502:4: rule__Number__Alternatives + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); + after(grammarAccess.getNumberAccess().getAlternatives()); } } @@ -8810,33 +8447,33 @@ public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionE finally { restoreStackSize(stackSize); + myHiddenTokenState.restore(); } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__0__Impl" + // $ANTLR end "ruleNumber" - // $ANTLR start "rule__SwitchExpression__Group_1__1" - // InternalExpression.g:2547:1: rule__SwitchExpression__Group_1__1 : rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ; - public final void rule__SwitchExpression__Group_1__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmTypeReference" + // InternalExpression.g:2512:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ; + public final void entryRuleJvmTypeReference() throws RecognitionException { try { - // InternalExpression.g:2551:1: ( rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ) - // InternalExpression.g:2552:2: rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 + // InternalExpression.g:2513:1: ( ruleJvmTypeReference EOF ) + // InternalExpression.g:2514:1: ruleJvmTypeReference EOF { - pushFollow(FOLLOW_8); - rule__SwitchExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8846,36 +8483,33 @@ public final void rule__SwitchExpression__Group_1__1() throws RecognitionExcepti recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__1" + // $ANTLR end "entryRuleJvmTypeReference" - // $ANTLR start "rule__SwitchExpression__Group_1__1__Impl" - // InternalExpression.g:2559:1: rule__SwitchExpression__Group_1__1__Impl : ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ; - public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmTypeReference" + // InternalExpression.g:2521:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ; + public final void ruleJvmTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2563:1: ( ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ) - // InternalExpression.g:2564:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) + // InternalExpression.g:2525:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) ) + // InternalExpression.g:2526:2: ( ( rule__JvmTypeReference__Alternatives ) ) { - // InternalExpression.g:2564:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) - // InternalExpression.g:2565:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) + // InternalExpression.g:2526:2: ( ( rule__JvmTypeReference__Alternatives ) ) + // InternalExpression.g:2527:3: ( rule__JvmTypeReference__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); + before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } - // InternalExpression.g:2566:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) - // InternalExpression.g:2566:3: rule__SwitchExpression__SwitchExprAssignment_1_1 + // InternalExpression.g:2528:3: ( rule__JvmTypeReference__Alternatives ) + // InternalExpression.g:2528:4: rule__JvmTypeReference__Alternatives { pushFollow(FOLLOW_2); - rule__SwitchExpression__SwitchExprAssignment_1_1(); + rule__JvmTypeReference__Alternatives(); state._fsp--; if (state.failed) return ; @@ -8883,7 +8517,7 @@ public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionE } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); + after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } } @@ -8903,24 +8537,28 @@ public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__1__Impl" + // $ANTLR end "ruleJvmTypeReference" - // $ANTLR start "rule__SwitchExpression__Group_1__2" - // InternalExpression.g:2574:1: rule__SwitchExpression__Group_1__2 : rule__SwitchExpression__Group_1__2__Impl ; - public final void rule__SwitchExpression__Group_1__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleArrayBrackets" + // InternalExpression.g:2537:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ; + public final void entryRuleArrayBrackets() throws RecognitionException { try { - // InternalExpression.g:2578:1: ( rule__SwitchExpression__Group_1__2__Impl ) - // InternalExpression.g:2579:2: rule__SwitchExpression__Group_1__2__Impl + // InternalExpression.g:2538:1: ( ruleArrayBrackets EOF ) + // InternalExpression.g:2539:1: ruleArrayBrackets EOF { - pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + ruleArrayBrackets(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8930,34 +8568,41 @@ public final void rule__SwitchExpression__Group_1__2() throws RecognitionExcepti recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__2" + // $ANTLR end "entryRuleArrayBrackets" - // $ANTLR start "rule__SwitchExpression__Group_1__2__Impl" - // InternalExpression.g:2585:1: rule__SwitchExpression__Group_1__2__Impl : ( ')' ) ; - public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleArrayBrackets" + // InternalExpression.g:2546:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ; + public final void ruleArrayBrackets() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2589:1: ( ( ')' ) ) - // InternalExpression.g:2590:1: ( ')' ) + // InternalExpression.g:2550:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) ) + // InternalExpression.g:2551:2: ( ( rule__ArrayBrackets__Group__0 ) ) { - // InternalExpression.g:2590:1: ( ')' ) - // InternalExpression.g:2591:2: ')' + // InternalExpression.g:2551:2: ( ( rule__ArrayBrackets__Group__0 ) ) + // InternalExpression.g:2552:3: ( rule__ArrayBrackets__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); + before(grammarAccess.getArrayBracketsAccess().getGroup()); + } + // InternalExpression.g:2553:3: ( rule__ArrayBrackets__Group__0 ) + // InternalExpression.g:2553:4: rule__ArrayBrackets__Group__0 + { + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); + after(grammarAccess.getArrayBracketsAccess().getGroup()); } } @@ -8977,29 +8622,28 @@ public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__2__Impl" + // $ANTLR end "ruleArrayBrackets" - // $ANTLR start "rule__Case__Group__0" - // InternalExpression.g:2601:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; - public final void rule__Case__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalExpression.g:2562:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ; + public final void entryRuleXFunctionTypeRef() throws RecognitionException { try { - // InternalExpression.g:2605:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) - // InternalExpression.g:2606:2: rule__Case__Group__0__Impl rule__Case__Group__1 + // InternalExpression.g:2563:1: ( ruleXFunctionTypeRef EOF ) + // InternalExpression.g:2564:1: ruleXFunctionTypeRef EOF { - pushFollow(FOLLOW_17); - rule__Case__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Case__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + ruleXFunctionTypeRef(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9009,34 +8653,41 @@ public final void rule__Case__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Case__Group__0" + // $ANTLR end "entryRuleXFunctionTypeRef" - // $ANTLR start "rule__Case__Group__0__Impl" - // InternalExpression.g:2613:1: rule__Case__Group__0__Impl : ( 'case' ) ; - public final void rule__Case__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXFunctionTypeRef" + // InternalExpression.g:2571:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ; + public final void ruleXFunctionTypeRef() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2617:1: ( ( 'case' ) ) - // InternalExpression.g:2618:1: ( 'case' ) + // InternalExpression.g:2575:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) ) + // InternalExpression.g:2576:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) { - // InternalExpression.g:2618:1: ( 'case' ) - // InternalExpression.g:2619:2: 'case' + // InternalExpression.g:2576:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) + // InternalExpression.g:2577:3: ( rule__XFunctionTypeRef__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getCaseKeyword_0()); + before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } - match(input,50,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:2578:3: ( rule__XFunctionTypeRef__Group__0 ) + // InternalExpression.g:2578:4: rule__XFunctionTypeRef__Group__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getCaseKeyword_0()); + after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } } @@ -9056,29 +8707,28 @@ public final void rule__Case__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__0__Impl" - + // $ANTLR end "ruleXFunctionTypeRef" - // $ANTLR start "rule__Case__Group__1" - // InternalExpression.g:2628:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; - public final void rule__Case__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalExpression.g:2587:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ; + public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException { try { - // InternalExpression.g:2632:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) - // InternalExpression.g:2633:2: rule__Case__Group__1__Impl rule__Case__Group__2 + // InternalExpression.g:2588:1: ( ruleJvmParameterizedTypeReference EOF ) + // InternalExpression.g:2589:1: ruleJvmParameterizedTypeReference EOF { - pushFollow(FOLLOW_6); - rule__Case__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Case__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmParameterizedTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9088,36 +8738,33 @@ public final void rule__Case__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Case__Group__1" + // $ANTLR end "entryRuleJvmParameterizedTypeReference" - // $ANTLR start "rule__Case__Group__1__Impl" - // InternalExpression.g:2640:1: rule__Case__Group__1__Impl : ( ( rule__Case__ConditionAssignment_1 ) ) ; - public final void rule__Case__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalExpression.g:2596:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ; + public final void ruleJvmParameterizedTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2644:1: ( ( ( rule__Case__ConditionAssignment_1 ) ) ) - // InternalExpression.g:2645:1: ( ( rule__Case__ConditionAssignment_1 ) ) + // InternalExpression.g:2600:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ) + // InternalExpression.g:2601:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) { - // InternalExpression.g:2645:1: ( ( rule__Case__ConditionAssignment_1 ) ) - // InternalExpression.g:2646:2: ( rule__Case__ConditionAssignment_1 ) + // InternalExpression.g:2601:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) + // InternalExpression.g:2602:3: ( rule__JvmParameterizedTypeReference__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getConditionAssignment_1()); + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } - // InternalExpression.g:2647:2: ( rule__Case__ConditionAssignment_1 ) - // InternalExpression.g:2647:3: rule__Case__ConditionAssignment_1 + // InternalExpression.g:2603:3: ( rule__JvmParameterizedTypeReference__Group__0 ) + // InternalExpression.g:2603:4: rule__JvmParameterizedTypeReference__Group__0 { pushFollow(FOLLOW_2); - rule__Case__ConditionAssignment_1(); + rule__JvmParameterizedTypeReference__Group__0(); state._fsp--; if (state.failed) return ; @@ -9125,7 +8772,7 @@ public final void rule__Case__Group__1__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getConditionAssignment_1()); + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } } @@ -9145,29 +8792,28 @@ public final void rule__Case__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__1__Impl" - + // $ANTLR end "ruleJvmParameterizedTypeReference" - // $ANTLR start "rule__Case__Group__2" - // InternalExpression.g:2655:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ; - public final void rule__Case__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalExpression.g:2612:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ; + public final void entryRuleJvmArgumentTypeReference() throws RecognitionException { try { - // InternalExpression.g:2659:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 ) - // InternalExpression.g:2660:2: rule__Case__Group__2__Impl rule__Case__Group__3 + // InternalExpression.g:2613:1: ( ruleJvmArgumentTypeReference EOF ) + // InternalExpression.g:2614:1: ruleJvmArgumentTypeReference EOF { - pushFollow(FOLLOW_17); - rule__Case__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Case__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmArgumentTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9177,34 +8823,41 @@ public final void rule__Case__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Case__Group__2" + // $ANTLR end "entryRuleJvmArgumentTypeReference" - // $ANTLR start "rule__Case__Group__2__Impl" - // InternalExpression.g:2667:1: rule__Case__Group__2__Impl : ( ':' ) ; - public final void rule__Case__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalExpression.g:2621:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ; + public final void ruleJvmArgumentTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2671:1: ( ( ':' ) ) - // InternalExpression.g:2672:1: ( ':' ) + // InternalExpression.g:2625:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ) + // InternalExpression.g:2626:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) { - // InternalExpression.g:2672:1: ( ':' ) - // InternalExpression.g:2673:2: ':' + // InternalExpression.g:2626:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) + // InternalExpression.g:2627:3: ( rule__JvmArgumentTypeReference__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getColonKeyword_2()); + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); + } + // InternalExpression.g:2628:3: ( rule__JvmArgumentTypeReference__Alternatives ) + // InternalExpression.g:2628:4: rule__JvmArgumentTypeReference__Alternatives + { + pushFollow(FOLLOW_2); + rule__JvmArgumentTypeReference__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getColonKeyword_2()); + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } } @@ -9224,24 +8877,28 @@ public final void rule__Case__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__2__Impl" - + // $ANTLR end "ruleJvmArgumentTypeReference" - // $ANTLR start "rule__Case__Group__3" - // InternalExpression.g:2682:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ; - public final void rule__Case__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalExpression.g:2637:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ; + public final void entryRuleJvmWildcardTypeReference() throws RecognitionException { try { - // InternalExpression.g:2686:1: ( rule__Case__Group__3__Impl ) - // InternalExpression.g:2687:2: rule__Case__Group__3__Impl + // InternalExpression.g:2638:1: ( ruleJvmWildcardTypeReference EOF ) + // InternalExpression.g:2639:1: ruleJvmWildcardTypeReference EOF { - pushFollow(FOLLOW_2); - rule__Case__Group__3__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmWildcardTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9251,36 +8908,33 @@ public final void rule__Case__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Case__Group__3" + // $ANTLR end "entryRuleJvmWildcardTypeReference" - // $ANTLR start "rule__Case__Group__3__Impl" - // InternalExpression.g:2693:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenParAssignment_3 ) ) ; - public final void rule__Case__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalExpression.g:2646:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ; + public final void ruleJvmWildcardTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2697:1: ( ( ( rule__Case__ThenParAssignment_3 ) ) ) - // InternalExpression.g:2698:1: ( ( rule__Case__ThenParAssignment_3 ) ) + // InternalExpression.g:2650:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ) + // InternalExpression.g:2651:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) { - // InternalExpression.g:2698:1: ( ( rule__Case__ThenParAssignment_3 ) ) - // InternalExpression.g:2699:2: ( rule__Case__ThenParAssignment_3 ) + // InternalExpression.g:2651:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) + // InternalExpression.g:2652:3: ( rule__JvmWildcardTypeReference__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getThenParAssignment_3()); + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } - // InternalExpression.g:2700:2: ( rule__Case__ThenParAssignment_3 ) - // InternalExpression.g:2700:3: rule__Case__ThenParAssignment_3 + // InternalExpression.g:2653:3: ( rule__JvmWildcardTypeReference__Group__0 ) + // InternalExpression.g:2653:4: rule__JvmWildcardTypeReference__Group__0 { pushFollow(FOLLOW_2); - rule__Case__ThenParAssignment_3(); + rule__JvmWildcardTypeReference__Group__0(); state._fsp--; if (state.failed) return ; @@ -9288,7 +8942,7 @@ public final void rule__Case__Group__3__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getThenParAssignment_3()); + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } } @@ -9308,29 +8962,28 @@ public final void rule__Case__Group__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__3__Impl" + // $ANTLR end "ruleJvmWildcardTypeReference" - // $ANTLR start "rule__OrExpression__Group__0" - // InternalExpression.g:2709:1: rule__OrExpression__Group__0 : rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ; - public final void rule__OrExpression__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmUpperBound" + // InternalExpression.g:2662:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ; + public final void entryRuleJvmUpperBound() throws RecognitionException { try { - // InternalExpression.g:2713:1: ( rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ) - // InternalExpression.g:2714:2: rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 + // InternalExpression.g:2663:1: ( ruleJvmUpperBound EOF ) + // InternalExpression.g:2664:1: ruleJvmUpperBound EOF { - pushFollow(FOLLOW_19); - rule__OrExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__OrExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + ruleJvmUpperBound(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9340,38 +8993,41 @@ public final void rule__OrExpression__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__OrExpression__Group__0" + // $ANTLR end "entryRuleJvmUpperBound" - // $ANTLR start "rule__OrExpression__Group__0__Impl" - // InternalExpression.g:2721:1: rule__OrExpression__Group__0__Impl : ( ruleAndExpression ) ; - public final void rule__OrExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmUpperBound" + // InternalExpression.g:2671:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ; + public final void ruleJvmUpperBound() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2725:1: ( ( ruleAndExpression ) ) - // InternalExpression.g:2726:1: ( ruleAndExpression ) + // InternalExpression.g:2675:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) ) + // InternalExpression.g:2676:2: ( ( rule__JvmUpperBound__Group__0 ) ) { - // InternalExpression.g:2726:1: ( ruleAndExpression ) - // InternalExpression.g:2727:2: ruleAndExpression + // InternalExpression.g:2676:2: ( ( rule__JvmUpperBound__Group__0 ) ) + // InternalExpression.g:2677:3: ( rule__JvmUpperBound__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); + before(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + // InternalExpression.g:2678:3: ( rule__JvmUpperBound__Group__0 ) + // InternalExpression.g:2678:4: rule__JvmUpperBound__Group__0 + { pushFollow(FOLLOW_2); - ruleAndExpression(); + rule__JvmUpperBound__Group__0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); + after(grammarAccess.getJvmUpperBoundAccess().getGroup()); } } @@ -9391,24 +9047,28 @@ public final void rule__OrExpression__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__OrExpression__Group__0__Impl" + // $ANTLR end "ruleJvmUpperBound" - // $ANTLR start "rule__OrExpression__Group__1" - // InternalExpression.g:2736:1: rule__OrExpression__Group__1 : rule__OrExpression__Group__1__Impl ; - public final void rule__OrExpression__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalExpression.g:2687:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ; + public final void entryRuleJvmUpperBoundAnded() throws RecognitionException { try { - // InternalExpression.g:2740:1: ( rule__OrExpression__Group__1__Impl ) - // InternalExpression.g:2741:2: rule__OrExpression__Group__1__Impl + // InternalExpression.g:2688:1: ( ruleJvmUpperBoundAnded EOF ) + // InternalExpression.g:2689:1: ruleJvmUpperBoundAnded EOF { - pushFollow(FOLLOW_2); - rule__OrExpression__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + ruleJvmUpperBoundAnded(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9418,62 +9078,41 @@ public final void rule__OrExpression__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__OrExpression__Group__1" + // $ANTLR end "entryRuleJvmUpperBoundAnded" - // $ANTLR start "rule__OrExpression__Group__1__Impl" - // InternalExpression.g:2747:1: rule__OrExpression__Group__1__Impl : ( ( rule__OrExpression__Group_1__0 )* ) ; - public final void rule__OrExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalExpression.g:2696:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ; + public final void ruleJvmUpperBoundAnded() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2751:1: ( ( ( rule__OrExpression__Group_1__0 )* ) ) - // InternalExpression.g:2752:1: ( ( rule__OrExpression__Group_1__0 )* ) + // InternalExpression.g:2700:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ) + // InternalExpression.g:2701:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) { - // InternalExpression.g:2752:1: ( ( rule__OrExpression__Group_1__0 )* ) - // InternalExpression.g:2753:2: ( rule__OrExpression__Group_1__0 )* + // InternalExpression.g:2701:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) + // InternalExpression.g:2702:3: ( rule__JvmUpperBoundAnded__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getGroup_1()); + before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } - // InternalExpression.g:2754:2: ( rule__OrExpression__Group_1__0 )* - loop22: - do { - int alt22=2; - int LA22_0 = input.LA(1); - - if ( (LA22_0==59) ) { - alt22=1; - } - - - switch (alt22) { - case 1 : - // InternalExpression.g:2754:3: rule__OrExpression__Group_1__0 - { - pushFollow(FOLLOW_20); - rule__OrExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:2703:3: ( rule__JvmUpperBoundAnded__Group__0 ) + // InternalExpression.g:2703:4: rule__JvmUpperBoundAnded__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop22; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getGroup_1()); + after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } } @@ -9493,29 +9132,28 @@ public final void rule__OrExpression__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__OrExpression__Group__1__Impl" - + // $ANTLR end "ruleJvmUpperBoundAnded" - // $ANTLR start "rule__OrExpression__Group_1__0" - // InternalExpression.g:2763:1: rule__OrExpression__Group_1__0 : rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ; - public final void rule__OrExpression__Group_1__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmLowerBound" + // InternalExpression.g:2712:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ; + public final void entryRuleJvmLowerBound() throws RecognitionException { try { - // InternalExpression.g:2767:1: ( rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ) - // InternalExpression.g:2768:2: rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 + // InternalExpression.g:2713:1: ( ruleJvmLowerBound EOF ) + // InternalExpression.g:2714:1: ruleJvmLowerBound EOF { - pushFollow(FOLLOW_19); - rule__OrExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + ruleJvmLowerBound(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9525,38 +9163,41 @@ public final void rule__OrExpression__Group_1__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__OrExpression__Group_1__0" + // $ANTLR end "entryRuleJvmLowerBound" - // $ANTLR start "rule__OrExpression__Group_1__0__Impl" - // InternalExpression.g:2775:1: rule__OrExpression__Group_1__0__Impl : ( () ) ; - public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmLowerBound" + // InternalExpression.g:2721:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ; + public final void ruleJvmLowerBound() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2779:1: ( ( () ) ) - // InternalExpression.g:2780:1: ( () ) + // InternalExpression.g:2725:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) ) + // InternalExpression.g:2726:2: ( ( rule__JvmLowerBound__Group__0 ) ) { - // InternalExpression.g:2780:1: ( () ) - // InternalExpression.g:2781:2: () + // InternalExpression.g:2726:2: ( ( rule__JvmLowerBound__Group__0 ) ) + // InternalExpression.g:2727:3: ( rule__JvmLowerBound__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getJvmLowerBoundAccess().getGroup()); } - // InternalExpression.g:2782:2: () - // InternalExpression.g:2782:3: + // InternalExpression.g:2728:3: ( rule__JvmLowerBound__Group__0 ) + // InternalExpression.g:2728:4: rule__JvmLowerBound__Group__0 { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__0(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getJvmLowerBoundAccess().getGroup()); } } @@ -9565,6 +9206,10 @@ public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionExcep } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -9572,29 +9217,28 @@ public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__0__Impl" - + // $ANTLR end "ruleJvmLowerBound" - // $ANTLR start "rule__OrExpression__Group_1__1" - // InternalExpression.g:2790:1: rule__OrExpression__Group_1__1 : rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ; - public final void rule__OrExpression__Group_1__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalExpression.g:2737:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ; + public final void entryRuleJvmLowerBoundAnded() throws RecognitionException { try { - // InternalExpression.g:2794:1: ( rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ) - // InternalExpression.g:2795:2: rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 + // InternalExpression.g:2738:1: ( ruleJvmLowerBoundAnded EOF ) + // InternalExpression.g:2739:1: ruleJvmLowerBoundAnded EOF { - pushFollow(FOLLOW_17); - rule__OrExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + ruleJvmLowerBoundAnded(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9604,36 +9248,33 @@ public final void rule__OrExpression__Group_1__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__OrExpression__Group_1__1" + // $ANTLR end "entryRuleJvmLowerBoundAnded" - // $ANTLR start "rule__OrExpression__Group_1__1__Impl" - // InternalExpression.g:2802:1: rule__OrExpression__Group_1__1__Impl : ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalExpression.g:2746:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ; + public final void ruleJvmLowerBoundAnded() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2806:1: ( ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ) - // InternalExpression.g:2807:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) + // InternalExpression.g:2750:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ) + // InternalExpression.g:2751:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) { - // InternalExpression.g:2807:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) - // InternalExpression.g:2808:2: ( rule__OrExpression__OperatorAssignment_1_1 ) + // InternalExpression.g:2751:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) + // InternalExpression.g:2752:3: ( rule__JvmLowerBoundAnded__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } - // InternalExpression.g:2809:2: ( rule__OrExpression__OperatorAssignment_1_1 ) - // InternalExpression.g:2809:3: rule__OrExpression__OperatorAssignment_1_1 + // InternalExpression.g:2753:3: ( rule__JvmLowerBoundAnded__Group__0 ) + // InternalExpression.g:2753:4: rule__JvmLowerBoundAnded__Group__0 { pushFollow(FOLLOW_2); - rule__OrExpression__OperatorAssignment_1_1(); + rule__JvmLowerBoundAnded__Group__0(); state._fsp--; if (state.failed) return ; @@ -9641,7 +9282,7 @@ public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } } @@ -9661,24 +9302,28 @@ public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__1__Impl" + // $ANTLR end "ruleJvmLowerBoundAnded" - // $ANTLR start "rule__OrExpression__Group_1__2" - // InternalExpression.g:2817:1: rule__OrExpression__Group_1__2 : rule__OrExpression__Group_1__2__Impl ; - public final void rule__OrExpression__Group_1__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalExpression.g:2762:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ; + public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException { try { - // InternalExpression.g:2821:1: ( rule__OrExpression__Group_1__2__Impl ) - // InternalExpression.g:2822:2: rule__OrExpression__Group_1__2__Impl + // InternalExpression.g:2763:1: ( ruleQualifiedNameWithWildcard EOF ) + // InternalExpression.g:2764:1: ruleQualifiedNameWithWildcard EOF { - pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedNameWithWildcard(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9688,36 +9333,33 @@ public final void rule__OrExpression__Group_1__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__OrExpression__Group_1__2" + // $ANTLR end "entryRuleQualifiedNameWithWildcard" - // $ANTLR start "rule__OrExpression__Group_1__2__Impl" - // InternalExpression.g:2828:1: rule__OrExpression__Group_1__2__Impl : ( ( rule__OrExpression__RightAssignment_1_2 ) ) ; - public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalExpression.g:2771:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ; + public final void ruleQualifiedNameWithWildcard() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2832:1: ( ( ( rule__OrExpression__RightAssignment_1_2 ) ) ) - // InternalExpression.g:2833:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) + // InternalExpression.g:2775:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ) + // InternalExpression.g:2776:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) { - // InternalExpression.g:2833:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) - // InternalExpression.g:2834:2: ( rule__OrExpression__RightAssignment_1_2 ) + // InternalExpression.g:2776:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) + // InternalExpression.g:2777:3: ( rule__QualifiedNameWithWildcard__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } - // InternalExpression.g:2835:2: ( rule__OrExpression__RightAssignment_1_2 ) - // InternalExpression.g:2835:3: rule__OrExpression__RightAssignment_1_2 + // InternalExpression.g:2778:3: ( rule__QualifiedNameWithWildcard__Group__0 ) + // InternalExpression.g:2778:4: rule__QualifiedNameWithWildcard__Group__0 { pushFollow(FOLLOW_2); - rule__OrExpression__RightAssignment_1_2(); + rule__QualifiedNameWithWildcard__Group__0(); state._fsp--; if (state.failed) return ; @@ -9725,7 +9367,7 @@ public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } } @@ -9745,29 +9387,28 @@ public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__2__Impl" - + // $ANTLR end "ruleQualifiedNameWithWildcard" - // $ANTLR start "rule__AndExpression__Group__0" - // InternalExpression.g:2844:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ; - public final void rule__AndExpression__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleValidID" + // InternalExpression.g:2787:1: entryRuleValidID : ruleValidID EOF ; + public final void entryRuleValidID() throws RecognitionException { try { - // InternalExpression.g:2848:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ) - // InternalExpression.g:2849:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 + // InternalExpression.g:2788:1: ( ruleValidID EOF ) + // InternalExpression.g:2789:1: ruleValidID EOF { - pushFollow(FOLLOW_21); - rule__AndExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__AndExpression__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + ruleValidID(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getValidIDRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9777,38 +9418,31 @@ public final void rule__AndExpression__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__AndExpression__Group__0" + // $ANTLR end "entryRuleValidID" - // $ANTLR start "rule__AndExpression__Group__0__Impl" - // InternalExpression.g:2856:1: rule__AndExpression__Group__0__Impl : ( ruleImpliesExpression ) ; - public final void rule__AndExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleValidID" + // InternalExpression.g:2796:1: ruleValidID : ( RULE_ID ) ; + public final void ruleValidID() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2860:1: ( ( ruleImpliesExpression ) ) - // InternalExpression.g:2861:1: ( ruleImpliesExpression ) + // InternalExpression.g:2800:2: ( ( RULE_ID ) ) + // InternalExpression.g:2801:2: ( RULE_ID ) { - // InternalExpression.g:2861:1: ( ruleImpliesExpression ) - // InternalExpression.g:2862:2: ruleImpliesExpression + // InternalExpression.g:2801:2: ( RULE_ID ) + // InternalExpression.g:2802:3: RULE_ID { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); + before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } - pushFollow(FOLLOW_2); - ruleImpliesExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); + after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } } @@ -9828,24 +9462,28 @@ public final void rule__AndExpression__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__AndExpression__Group__0__Impl" - + // $ANTLR end "ruleValidID" - // $ANTLR start "rule__AndExpression__Group__1" - // InternalExpression.g:2871:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ; - public final void rule__AndExpression__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXImportDeclaration" + // InternalExpression.g:2812:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ; + public final void entryRuleXImportDeclaration() throws RecognitionException { try { - // InternalExpression.g:2875:1: ( rule__AndExpression__Group__1__Impl ) - // InternalExpression.g:2876:2: rule__AndExpression__Group__1__Impl + // InternalExpression.g:2813:1: ( ruleXImportDeclaration EOF ) + // InternalExpression.g:2814:1: ruleXImportDeclaration EOF { - pushFollow(FOLLOW_2); - rule__AndExpression__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXImportDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9855,62 +9493,41 @@ public final void rule__AndExpression__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__AndExpression__Group__1" + // $ANTLR end "entryRuleXImportDeclaration" - // $ANTLR start "rule__AndExpression__Group__1__Impl" - // InternalExpression.g:2882:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ; - public final void rule__AndExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXImportDeclaration" + // InternalExpression.g:2821:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ; + public final void ruleXImportDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2886:1: ( ( ( rule__AndExpression__Group_1__0 )* ) ) - // InternalExpression.g:2887:1: ( ( rule__AndExpression__Group_1__0 )* ) + // InternalExpression.g:2825:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) ) + // InternalExpression.g:2826:2: ( ( rule__XImportDeclaration__Group__0 ) ) { - // InternalExpression.g:2887:1: ( ( rule__AndExpression__Group_1__0 )* ) - // InternalExpression.g:2888:2: ( rule__AndExpression__Group_1__0 )* + // InternalExpression.g:2826:2: ( ( rule__XImportDeclaration__Group__0 ) ) + // InternalExpression.g:2827:3: ( rule__XImportDeclaration__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getGroup_1()); + before(grammarAccess.getXImportDeclarationAccess().getGroup()); } - // InternalExpression.g:2889:2: ( rule__AndExpression__Group_1__0 )* - loop23: - do { - int alt23=2; - int LA23_0 = input.LA(1); - - if ( (LA23_0==60) ) { - alt23=1; - } - - - switch (alt23) { - case 1 : - // InternalExpression.g:2889:3: rule__AndExpression__Group_1__0 - { - pushFollow(FOLLOW_22); - rule__AndExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:2828:3: ( rule__XImportDeclaration__Group__0 ) + // InternalExpression.g:2828:4: rule__XImportDeclaration__Group__0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop23; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getGroup_1()); + after(grammarAccess.getXImportDeclarationAccess().getGroup()); } } @@ -9930,29 +9547,28 @@ public final void rule__AndExpression__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__AndExpression__Group__1__Impl" + // $ANTLR end "ruleXImportDeclaration" - // $ANTLR start "rule__AndExpression__Group_1__0" - // InternalExpression.g:2898:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ; - public final void rule__AndExpression__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalExpression.g:2837:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ; + public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException { try { - // InternalExpression.g:2902:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ) - // InternalExpression.g:2903:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 + // InternalExpression.g:2838:1: ( ruleQualifiedNameInStaticImport EOF ) + // InternalExpression.g:2839:1: ruleQualifiedNameInStaticImport EOF { - pushFollow(FOLLOW_21); - rule__AndExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedNameInStaticImport(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9962,124 +9578,95 @@ public final void rule__AndExpression__Group_1__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__AndExpression__Group_1__0" + // $ANTLR end "entryRuleQualifiedNameInStaticImport" - // $ANTLR start "rule__AndExpression__Group_1__0__Impl" - // InternalExpression.g:2910:1: rule__AndExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalExpression.g:2846:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ; + public final void ruleQualifiedNameInStaticImport() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2914:1: ( ( () ) ) - // InternalExpression.g:2915:1: ( () ) + // InternalExpression.g:2850:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ) + // InternalExpression.g:2851:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + { + // InternalExpression.g:2851:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + // InternalExpression.g:2852:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) { - // InternalExpression.g:2915:1: ( () ) - // InternalExpression.g:2916:2: () + // InternalExpression.g:2852:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) + // InternalExpression.g:2853:4: ( rule__QualifiedNameInStaticImport__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } - // InternalExpression.g:2917:2: () - // InternalExpression.g:2917:3: + // InternalExpression.g:2854:4: ( rule__QualifiedNameInStaticImport__Group__0 ) + // InternalExpression.g:2854:5: rule__QualifiedNameInStaticImport__Group__0 { + pushFollow(FOLLOW_3); + rule__QualifiedNameInStaticImport__Group__0(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } } - + // InternalExpression.g:2857:3: ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) + // InternalExpression.g:2858:4: ( rule__QualifiedNameInStaticImport__Group__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + // InternalExpression.g:2859:4: ( rule__QualifiedNameInStaticImport__Group__0 )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__AndExpression__Group_1__0__Impl" - - - // $ANTLR start "rule__AndExpression__Group_1__1" - // InternalExpression.g:2925:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ; - public final void rule__AndExpression__Group_1__1() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:2929:1: ( rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ) - // InternalExpression.g:2930:2: rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 - { - pushFollow(FOLLOW_17); - rule__AndExpression__Group_1__1__Impl(); + if ( (LA1_0==RULE_ID) ) { + int LA1_2 = input.LA(2); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__2(); + if ( (LA1_2==58) ) { + alt1=1; + } - state._fsp--; - if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + switch (alt1) { + case 1 : + // InternalExpression.g:2859:5: rule__QualifiedNameInStaticImport__Group__0 + { + pushFollow(FOLLOW_3); + rule__QualifiedNameInStaticImport__Group__0(); - } - return ; - } - // $ANTLR end "rule__AndExpression__Group_1__1" + state._fsp--; + if (state.failed) return ; + } + break; - // $ANTLR start "rule__AndExpression__Group_1__1__Impl" - // InternalExpression.g:2937:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException { + default : + break loop1; + } + } while (true); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:2941:1: ( ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ) - // InternalExpression.g:2942:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) - { - // InternalExpression.g:2942:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) - // InternalExpression.g:2943:2: ( rule__AndExpression__OperatorAssignment_1_1 ) - { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } - // InternalExpression.g:2944:2: ( rule__AndExpression__OperatorAssignment_1_1 ) - // InternalExpression.g:2944:3: rule__AndExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__AndExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; } - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); - } } @@ -10098,78 +9685,97 @@ public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__1__Impl" + // $ANTLR end "ruleQualifiedNameInStaticImport" - // $ANTLR start "rule__AndExpression__Group_1__2" - // InternalExpression.g:2952:1: rule__AndExpression__Group_1__2 : rule__AndExpression__Group_1__2__Impl ; - public final void rule__AndExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__Expression__Alternatives" + // InternalExpression.g:2868:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ); + public final void rule__Expression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2956:1: ( rule__AndExpression__Group_1__2__Impl ) - // InternalExpression.g:2957:2: rule__AndExpression__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__2__Impl(); - - state._fsp--; - if (state.failed) return ; - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + // InternalExpression.g:2872:1: ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ) + int alt2=3; + alt2 = dfa2.predict(input); + switch (alt2) { + case 1 : + // InternalExpression.g:2873:2: ( ruleLetExpression ) + { + // InternalExpression.g:2873:2: ( ruleLetExpression ) + // InternalExpression.g:2874:3: ruleLetExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleLetExpression(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__AndExpression__Group_1__2" + } - // $ANTLR start "rule__AndExpression__Group_1__2__Impl" - // InternalExpression.g:2963:1: rule__AndExpression__Group_1__2__Impl : ( ( rule__AndExpression__RightAssignment_1_2 ) ) ; - public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:2879:2: ( ( ruleCastedExpression ) ) + { + // InternalExpression.g:2879:2: ( ( ruleCastedExpression ) ) + // InternalExpression.g:2880:3: ( ruleCastedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } + // InternalExpression.g:2881:3: ( ruleCastedExpression ) + // InternalExpression.g:2881:4: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:2967:1: ( ( ( rule__AndExpression__RightAssignment_1_2 ) ) ) - // InternalExpression.g:2968:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) - { - // InternalExpression.g:2968:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) - // InternalExpression.g:2969:2: ( rule__AndExpression__RightAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); - } - // InternalExpression.g:2970:2: ( rule__AndExpression__RightAssignment_1_2 ) - // InternalExpression.g:2970:3: rule__AndExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__AndExpression__RightAssignment_1_2(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); - } + } - } + } + break; + case 3 : + // InternalExpression.g:2885:2: ( ruleChainExpression ) + { + // InternalExpression.g:2885:2: ( ruleChainExpression ) + // InternalExpression.g:2886:3: ruleChainExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleChainExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -10182,77 +9788,138 @@ public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__2__Impl" + // $ANTLR end "rule__Expression__Alternatives" - // $ANTLR start "rule__ImpliesExpression__Group__0" - // InternalExpression.g:2979:1: rule__ImpliesExpression__Group__0 : rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ; - public final void rule__ImpliesExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ChainedExpression__Alternatives" + // InternalExpression.g:2895:1: rule__ChainedExpression__Alternatives : ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ); + public final void rule__ChainedExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:2983:1: ( rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ) - // InternalExpression.g:2984:2: rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 - { - pushFollow(FOLLOW_23); - rule__ImpliesExpression__Group__0__Impl(); + // InternalExpression.g:2899:1: ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ) + int alt3=3; + switch ( input.LA(1) ) { + case 70: + { + alt3=1; + } + break; + case RULE_ID: + case RULE_INT: + case RULE_REAL: + case RULE_STRING: + case 24: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + case 40: + case 67: + case 74: + case 80: + case 81: + case 92: + case 102: + { + alt3=2; + } + break; + case 73: + { + alt3=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group__1(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt3) { + case 1 : + // InternalExpression.g:2900:2: ( ruleIfExpressionKw ) + { + // InternalExpression.g:2900:2: ( ruleIfExpressionKw ) + // InternalExpression.g:2901:3: ruleIfExpressionKw + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleIfExpressionKw(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ImpliesExpression__Group__0" + } + break; + case 2 : + // InternalExpression.g:2906:2: ( ruleIfExpressionTri ) + { + // InternalExpression.g:2906:2: ( ruleIfExpressionTri ) + // InternalExpression.g:2907:3: ruleIfExpressionTri + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleIfExpressionTri(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); + } - // $ANTLR start "rule__ImpliesExpression__Group__0__Impl" - // InternalExpression.g:2991:1: rule__ImpliesExpression__Group__0__Impl : ( ruleRelationalExpression ) ; - public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:2995:1: ( ( ruleRelationalExpression ) ) - // InternalExpression.g:2996:1: ( ruleRelationalExpression ) - { - // InternalExpression.g:2996:1: ( ruleRelationalExpression ) - // InternalExpression.g:2997:2: ruleRelationalExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleRelationalExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); - } + } + break; + case 3 : + // InternalExpression.g:2912:2: ( ruleSwitchExpression ) + { + // InternalExpression.g:2912:2: ( ruleSwitchExpression ) + // InternalExpression.g:2913:3: ruleSwitchExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleSwitchExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); + } + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -10265,96 +9932,174 @@ public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__0__Impl" + // $ANTLR end "rule__ChainedExpression__Alternatives" - // $ANTLR start "rule__ImpliesExpression__Group__1" - // InternalExpression.g:3006:1: rule__ImpliesExpression__Group__1 : rule__ImpliesExpression__Group__1__Impl ; - public final void rule__ImpliesExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // InternalExpression.g:2922:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ); + public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3010:1: ( rule__ImpliesExpression__Group__1__Impl ) - // InternalExpression.g:3011:2: rule__ImpliesExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:2926:1: ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ) + int alt4=6; + switch ( input.LA(1) ) { + case 17: + { + alt4=1; + } + break; + case 18: + { + alt4=2; + } + break; + case 19: + { + alt4=3; + } + break; + case 20: + { + alt4=4; + } + break; + case 21: + { + alt4=5; + } + break; + case 22: + { + alt4=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt4) { + case 1 : + // InternalExpression.g:2927:2: ( '==' ) + { + // InternalExpression.g:2927:2: ( '==' ) + // InternalExpression.g:2928:3: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); + } + match(input,17,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ImpliesExpression__Group__1" + } + break; + case 2 : + // InternalExpression.g:2933:2: ( '!=' ) + { + // InternalExpression.g:2933:2: ( '!=' ) + // InternalExpression.g:2934:3: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + } + match(input,18,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + } + + } - // $ANTLR start "rule__ImpliesExpression__Group__1__Impl" - // InternalExpression.g:3017:1: rule__ImpliesExpression__Group__1__Impl : ( ( rule__ImpliesExpression__Group_1__0 )* ) ; - public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3021:1: ( ( ( rule__ImpliesExpression__Group_1__0 )* ) ) - // InternalExpression.g:3022:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) - { - // InternalExpression.g:3022:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) - // InternalExpression.g:3023:2: ( rule__ImpliesExpression__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); - } - // InternalExpression.g:3024:2: ( rule__ImpliesExpression__Group_1__0 )* - loop24: - do { - int alt24=2; - int LA24_0 = input.LA(1); + } + break; + case 3 : + // InternalExpression.g:2939:2: ( '>=' ) + { + // InternalExpression.g:2939:2: ( '>=' ) + // InternalExpression.g:2940:3: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); + } - if ( (LA24_0==61) ) { - alt24=1; - } + } - switch (alt24) { - case 1 : - // InternalExpression.g:3024:3: rule__ImpliesExpression__Group_1__0 - { - pushFollow(FOLLOW_24); - rule__ImpliesExpression__Group_1__0(); + } + break; + case 4 : + // InternalExpression.g:2945:2: ( '<=' ) + { + // InternalExpression.g:2945:2: ( '<=' ) + // InternalExpression.g:2946:3: '<=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + } + match(input,20,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + } - state._fsp--; - if (state.failed) return ; + } - } - break; - default : - break loop24; - } - } while (true); + } + break; + case 5 : + // InternalExpression.g:2951:2: ( '>' ) + { + // InternalExpression.g:2951:2: ( '>' ) + // InternalExpression.g:2952:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); - } + } - } + + } + break; + case 6 : + // InternalExpression.g:2957:2: ( '<' ) + { + // InternalExpression.g:2957:2: ( '<' ) + // InternalExpression.g:2958:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); + } + + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -10367,32 +10112,74 @@ public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__1__Impl" + // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // $ANTLR start "rule__ImpliesExpression__Group_1__0" - // InternalExpression.g:3033:1: rule__ImpliesExpression__Group_1__0 : rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ; - public final void rule__ImpliesExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__NameAlternatives_1_1_0" + // InternalExpression.g:2967:1: rule__AdditiveExpression__NameAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) ); + public final void rule__AdditiveExpression__NameAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3037:1: ( rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ) - // InternalExpression.g:3038:2: rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 - { - pushFollow(FOLLOW_23); - rule__ImpliesExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__1(); + // InternalExpression.g:2971:1: ( ( '+' ) | ( '-' ) ) + int alt5=2; + int LA5_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA5_0==23) ) { + alt5=1; + } + else if ( (LA5_0==24) ) { + alt5=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + throw nvae; } + switch (alt5) { + case 1 : + // InternalExpression.g:2972:2: ( '+' ) + { + // InternalExpression.g:2972:2: ( '+' ) + // InternalExpression.g:2973:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:2978:2: ( '-' ) + { + // InternalExpression.g:2978:2: ( '-' ) + // InternalExpression.g:2979:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -10405,73 +10192,74 @@ public final void rule__ImpliesExpression__Group_1__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__0" + // $ANTLR end "rule__AdditiveExpression__NameAlternatives_1_1_0" - // $ANTLR start "rule__ImpliesExpression__Group_1__0__Impl" - // InternalExpression.g:3045:1: rule__ImpliesExpression__Group_1__0__Impl : ( () ) ; - public final void rule__ImpliesExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__NameAlternatives_1_1_0" + // InternalExpression.g:2988:1: rule__MultiplicativeExpression__NameAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) ); + public final void rule__MultiplicativeExpression__NameAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3049:1: ( ( () ) ) - // InternalExpression.g:3050:1: ( () ) - { - // InternalExpression.g:3050:1: ( () ) - // InternalExpression.g:3051:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); - } - // InternalExpression.g:3052:2: () - // InternalExpression.g:3052:3: - { - } + // InternalExpression.g:2992:1: ( ( '*' ) | ( '/' ) ) + int alt6=2; + int LA6_0 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + if ( (LA6_0==25) ) { + alt6=1; } - + else if ( (LA6_0==26) ) { + alt6=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); - + throw nvae; } + switch (alt6) { + case 1 : + // InternalExpression.g:2993:2: ( '*' ) + { + // InternalExpression.g:2993:2: ( '*' ) + // InternalExpression.g:2994:3: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); + } - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__ImpliesExpression__Group_1__0__Impl" + } - // $ANTLR start "rule__ImpliesExpression__Group_1__1" - // InternalExpression.g:3060:1: rule__ImpliesExpression__Group_1__1 : rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ; - public final void rule__ImpliesExpression__Group_1__1() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:2999:2: ( '/' ) + { + // InternalExpression.g:2999:2: ( '/' ) + // InternalExpression.g:3000:3: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); + } + match(input,26,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3064:1: ( rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ) - // InternalExpression.g:3065:2: rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 - { - pushFollow(FOLLOW_17); - rule__ImpliesExpression__Group_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__2(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -10484,45 +10272,82 @@ public final void rule__ImpliesExpression__Group_1__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__1" + // $ANTLR end "rule__MultiplicativeExpression__NameAlternatives_1_1_0" - // $ANTLR start "rule__ImpliesExpression__Group_1__1__Impl" - // InternalExpression.g:3072:1: rule__ImpliesExpression__Group_1__1__Impl : ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__ImpliesExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__UnaryOrInfixExpression__Alternatives" + // InternalExpression.g:3009:1: rule__UnaryOrInfixExpression__Alternatives : ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ); + public final void rule__UnaryOrInfixExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3076:1: ( ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ) - // InternalExpression.g:3077:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) - { - // InternalExpression.g:3077:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) - // InternalExpression.g:3078:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalExpression.g:3079:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) - // InternalExpression.g:3079:3: rule__ImpliesExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3013:1: ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ) + int alt7=2; + int LA7_0 = input.LA(1); + if ( (LA7_0==24||LA7_0==27) ) { + alt7=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); + else if ( (LA7_0==RULE_ID||LA7_0==RULE_INT||(LA7_0>=RULE_REAL && LA7_0<=RULE_STRING)||(LA7_0>=28 && LA7_0<=40)||LA7_0==67||LA7_0==74||(LA7_0>=80 && LA7_0<=81)||LA7_0==92||LA7_0==102) ) { + alt7=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); + throw nvae; } + switch (alt7) { + case 1 : + // InternalExpression.g:3014:2: ( ruleUnaryExpression ) + { + // InternalExpression.g:3014:2: ( ruleUnaryExpression ) + // InternalExpression.g:3015:3: ruleUnaryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleUnaryExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); + } + + } - } + } + break; + case 2 : + // InternalExpression.g:3020:2: ( ruleInfixExpression ) + { + // InternalExpression.g:3020:2: ( ruleInfixExpression ) + // InternalExpression.g:3021:3: ruleInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -10535,27 +10360,74 @@ public final void rule__ImpliesExpression__Group_1__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__1__Impl" + // $ANTLR end "rule__UnaryOrInfixExpression__Alternatives" - // $ANTLR start "rule__ImpliesExpression__Group_1__2" - // InternalExpression.g:3087:1: rule__ImpliesExpression__Group_1__2 : rule__ImpliesExpression__Group_1__2__Impl ; - public final void rule__ImpliesExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__NameAlternatives_0_0" + // InternalExpression.g:3030:1: rule__UnaryExpression__NameAlternatives_0_0 : ( ( '!' ) | ( '-' ) ); + public final void rule__UnaryExpression__NameAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3091:1: ( rule__ImpliesExpression__Group_1__2__Impl ) - // InternalExpression.g:3092:2: rule__ImpliesExpression__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__2__Impl(); + // InternalExpression.g:3034:1: ( ( '!' ) | ( '-' ) ) + int alt8=2; + int LA8_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA8_0==27) ) { + alt8=1; + } + else if ( (LA8_0==24) ) { + alt8=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + throw nvae; } + switch (alt8) { + case 1 : + // InternalExpression.g:3035:2: ( '!' ) + { + // InternalExpression.g:3035:2: ( '!' ) + // InternalExpression.g:3036:3: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); + } + match(input,27,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:3041:2: ( '-' ) + { + // InternalExpression.g:3041:2: ( '-' ) + // InternalExpression.g:3042:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -10568,128 +10440,200 @@ public final void rule__ImpliesExpression__Group_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__2" + // $ANTLR end "rule__UnaryExpression__NameAlternatives_0_0" - // $ANTLR start "rule__ImpliesExpression__Group_1__2__Impl" - // InternalExpression.g:3098:1: rule__ImpliesExpression__Group_1__2__Impl : ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ; - public final void rule__ImpliesExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Alternatives_1" + // InternalExpression.g:3051:1: rule__InfixExpression__Alternatives_1 : ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ); + public final void rule__InfixExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3102:1: ( ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ) - // InternalExpression.g:3103:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) - { - // InternalExpression.g:3103:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) - // InternalExpression.g:3104:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); - } - // InternalExpression.g:3105:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) - // InternalExpression.g:3105:3: rule__ImpliesExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__RightAssignment_1_2(); + // InternalExpression.g:3055:1: ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ) + int alt9=4; + int LA9_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA9_0==58) ) { + switch ( input.LA(2) ) { + case 38: + case 39: + case 40: + { + alt9=2; + } + break; + case RULE_ID: + { + int LA9_3 = input.LA(3); - } + if ( (LA9_3==67) ) { + alt9=1; + } + else if ( (LA9_3==EOF||(LA9_3>=15 && LA9_3<=26)||LA9_3==48||LA9_3==58||LA9_3==66||(LA9_3>=68 && LA9_3<=69)||(LA9_3>=71 && LA9_3<=72)||(LA9_3>=75 && LA9_3<=78)||LA9_3==84||LA9_3==101) ) { + alt9=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 3, input); + + throw nvae; + } + } + break; + case 102: + { + alt9=3; + } + break; + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + { + alt9=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 1, input); + + throw nvae; + } - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + throw nvae; } + switch (alt9) { + case 1 : + // InternalExpression.g:3056:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:3056:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) + // InternalExpression.g:3057:3: ( rule__InfixExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:3058:3: ( rule__InfixExpression__Group_1_0__0 ) + // InternalExpression.g:3058:4: rule__InfixExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ImpliesExpression__Group_1__2__Impl" + } + break; + case 2 : + // InternalExpression.g:3062:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) + { + // InternalExpression.g:3062:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) + // InternalExpression.g:3063:3: ( rule__InfixExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); + } + // InternalExpression.g:3064:3: ( rule__InfixExpression__Group_1_1__0 ) + // InternalExpression.g:3064:4: rule__InfixExpression__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__0(); - // $ANTLR start "rule__RelationalExpression__Group__0" - // InternalExpression.g:3114:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ; - public final void rule__RelationalExpression__Group__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3118:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) - // InternalExpression.g:3119:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 - { - pushFollow(FOLLOW_25); - rule__RelationalExpression__Group__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__RelationalExpression__Group__1(); + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); + } - state._fsp--; - if (state.failed) return ; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 3 : + // InternalExpression.g:3068:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) + { + // InternalExpression.g:3068:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) + // InternalExpression.g:3069:3: ( rule__InfixExpression__Group_1_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); + } + // InternalExpression.g:3070:3: ( rule__InfixExpression__Group_1_2__0 ) + // InternalExpression.g:3070:4: rule__InfixExpression__Group_1_2__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group__0" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); + } - // $ANTLR start "rule__RelationalExpression__Group__0__Impl" - // InternalExpression.g:3126:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3130:1: ( ( ruleAdditiveExpression ) ) - // InternalExpression.g:3131:1: ( ruleAdditiveExpression ) - { - // InternalExpression.g:3131:1: ( ruleAdditiveExpression ) - // InternalExpression.g:3132:2: ruleAdditiveExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleAdditiveExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); - } + } + break; + case 4 : + // InternalExpression.g:3074:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) + { + // InternalExpression.g:3074:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) + // InternalExpression.g:3075:3: ( rule__InfixExpression__Group_1_3__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); + } + // InternalExpression.g:3076:3: ( rule__InfixExpression__Group_1_3__0 ) + // InternalExpression.g:3076:4: rule__InfixExpression__Group_1_3__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__0(); - } + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); + } + + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -10702,96 +10646,222 @@ public final void rule__RelationalExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0__Impl" + // $ANTLR end "rule__InfixExpression__Alternatives_1" - // $ANTLR start "rule__RelationalExpression__Group__1" - // InternalExpression.g:3141:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; - public final void rule__RelationalExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__NameAlternatives_1_3_2_0" + // InternalExpression.g:3084:1: rule__InfixExpression__NameAlternatives_1_3_2_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); + public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3145:1: ( rule__RelationalExpression__Group__1__Impl ) - // InternalExpression.g:3146:2: rule__RelationalExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3088:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) + int alt10=8; + switch ( input.LA(1) ) { + case 28: + { + alt10=1; + } + break; + case 29: + { + alt10=2; + } + break; + case 30: + { + alt10=3; + } + break; + case 31: + { + alt10=4; + } + break; + case 32: + { + alt10=5; + } + break; + case 33: + { + alt10=6; + } + break; + case 34: + { + alt10=7; + } + break; + case 35: + { + alt10=8; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 10, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt10) { + case 1 : + // InternalExpression.g:3089:2: ( 'collect' ) + { + // InternalExpression.g:3089:2: ( 'collect' ) + // InternalExpression.g:3090:3: 'collect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); + } + match(input,28,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group__1" + } + break; + case 2 : + // InternalExpression.g:3095:2: ( 'select' ) + { + // InternalExpression.g:3095:2: ( 'select' ) + // InternalExpression.g:3096:3: 'select' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); + } + match(input,29,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); + } - // $ANTLR start "rule__RelationalExpression__Group__1__Impl" - // InternalExpression.g:3152:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )* ) ; - public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3156:1: ( ( ( rule__RelationalExpression__Group_1__0 )* ) ) - // InternalExpression.g:3157:1: ( ( rule__RelationalExpression__Group_1__0 )* ) - { - // InternalExpression.g:3157:1: ( ( rule__RelationalExpression__Group_1__0 )* ) - // InternalExpression.g:3158:2: ( rule__RelationalExpression__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); - } - // InternalExpression.g:3159:2: ( rule__RelationalExpression__Group_1__0 )* - loop25: - do { - int alt25=2; - int LA25_0 = input.LA(1); - if ( ((LA25_0>=12 && LA25_0<=17)) ) { - alt25=1; - } + } + break; + case 3 : + // InternalExpression.g:3101:2: ( 'selectFirst' ) + { + // InternalExpression.g:3101:2: ( 'selectFirst' ) + // InternalExpression.g:3102:3: 'selectFirst' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); + } + match(input,30,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); + } + } - switch (alt25) { - case 1 : - // InternalExpression.g:3159:3: rule__RelationalExpression__Group_1__0 - { - pushFollow(FOLLOW_26); - rule__RelationalExpression__Group_1__0(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalExpression.g:3107:2: ( 'reject' ) + { + // InternalExpression.g:3107:2: ( 'reject' ) + // InternalExpression.g:3108:3: 'reject' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); + } + match(input,31,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); + } - } - break; + } - default : - break loop25; - } - } while (true); - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); - } + } + break; + case 5 : + // InternalExpression.g:3113:2: ( 'exists' ) + { + // InternalExpression.g:3113:2: ( 'exists' ) + // InternalExpression.g:3114:3: 'exists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); + } + match(input,32,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); + } - } + } - } + } + break; + case 6 : + // InternalExpression.g:3119:2: ( 'notExists' ) + { + // InternalExpression.g:3119:2: ( 'notExists' ) + // InternalExpression.g:3120:3: 'notExists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); + } + match(input,33,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); + } + + } + + + } + break; + case 7 : + // InternalExpression.g:3125:2: ( 'sortBy' ) + { + // InternalExpression.g:3125:2: ( 'sortBy' ) + // InternalExpression.g:3126:3: 'sortBy' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); + } + match(input,34,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); + } + + } + + } + break; + case 8 : + // InternalExpression.g:3131:2: ( 'forAll' ) + { + // InternalExpression.g:3131:2: ( 'forAll' ) + // InternalExpression.g:3132:3: 'forAll' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); + } + match(input,35,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -10804,162 +10874,215 @@ public final void rule__RelationalExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1__Impl" + // $ANTLR end "rule__InfixExpression__NameAlternatives_1_3_2_0" - // $ANTLR start "rule__RelationalExpression__Group_1__0" - // InternalExpression.g:3168: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__PrimaryExpression__Alternatives" + // InternalExpression.g:3141:1: rule__PrimaryExpression__Alternatives : ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ); + public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3172:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) - // InternalExpression.g:3173:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 - { - pushFollow(FOLLOW_25); - rule__RelationalExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__1(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3145:1: ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ) + int alt11=6; + switch ( input.LA(1) ) { + case RULE_INT: + case RULE_REAL: + case RULE_STRING: + case 36: + case 37: + case 92: + { + alt11=1; + } + break; + case RULE_ID: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 38: + case 39: + case 40: + case 102: + { + alt11=2; + } + break; + case 74: + { + alt11=3; + } + break; + case 81: + { + alt11=4; + } + break; + case 80: + { + alt11=5; + } + break; + case 67: + { + alt11=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); - - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group_1__0" - - - // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" - // InternalExpression.g:3180:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; - public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { - - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3184:1: ( ( () ) ) - // InternalExpression.g:3185:1: ( () ) - { - // InternalExpression.g:3185:1: ( () ) - // InternalExpression.g:3186:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); - } - // InternalExpression.g:3187:2: () - // InternalExpression.g:3187:3: - { - } + switch (alt11) { + case 1 : + // InternalExpression.g:3146:2: ( ruleLiteral ) + { + // InternalExpression.g:3146:2: ( ruleLiteral ) + // InternalExpression.g:3147:3: ruleLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleLiteral(); - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); + } - } + } - } + } + break; + case 2 : + // InternalExpression.g:3152:2: ( ruleFeatureCall ) + { + // InternalExpression.g:3152:2: ( ruleFeatureCall ) + // InternalExpression.g:3153:3: ruleFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCall(); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" + } + break; + case 3 : + // InternalExpression.g:3158:2: ( ruleListLiteral ) + { + // InternalExpression.g:3158:2: ( ruleListLiteral ) + // InternalExpression.g:3159:3: ruleListLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleListLiteral(); - // $ANTLR start "rule__RelationalExpression__Group_1__1" - // InternalExpression.g:3195: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 { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3199:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) - // InternalExpression.g:3200:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 - { - pushFollow(FOLLOW_17); - rule__RelationalExpression__Group_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__2(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalExpression.g:3164:2: ( ruleConstructorCallExpression ) + { + // InternalExpression.g:3164:2: ( ruleConstructorCallExpression ) + // InternalExpression.g:3165:3: ruleConstructorCallExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleConstructorCallExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group_1__1" + } + break; + case 5 : + // InternalExpression.g:3170:2: ( ruleGlobalVarExpression ) + { + // InternalExpression.g:3170:2: ( ruleGlobalVarExpression ) + // InternalExpression.g:3171:3: ruleGlobalVarExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleGlobalVarExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); + } - // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" - // InternalExpression.g:3207:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__RelationalExpression__Group_1__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3211:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) - // InternalExpression.g:3212:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) - { - // InternalExpression.g:3212:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) - // InternalExpression.g:3213:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalExpression.g:3214:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) - // InternalExpression.g:3214:3: rule__RelationalExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__OperatorAssignment_1_1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 6 : + // InternalExpression.g:3176:2: ( ruleParanthesizedExpression ) + { + // InternalExpression.g:3176:2: ( ruleParanthesizedExpression ) + // InternalExpression.g:3177:3: ruleParanthesizedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleParanthesizedExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -10972,116 +11095,171 @@ public final void rule__RelationalExpression__Group_1__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" + // $ANTLR end "rule__PrimaryExpression__Alternatives" - // $ANTLR start "rule__RelationalExpression__Group_1__2" - // InternalExpression.g:3222: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__Literal__Alternatives" + // InternalExpression.g:3186:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ); + public final void rule__Literal__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3226:1: ( rule__RelationalExpression__Group_1__2__Impl ) - // InternalExpression.g:3227:2: rule__RelationalExpression__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__2__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3190:1: ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ) + int alt12=5; + switch ( input.LA(1) ) { + case 36: + case 37: + { + alt12=1; + } + break; + case RULE_INT: + { + alt12=2; + } + break; + case 92: + { + alt12=3; + } + break; + case RULE_REAL: + { + alt12=4; + } + break; + case RULE_STRING: + { + alt12=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 12, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt12) { + case 1 : + // InternalExpression.g:3191:2: ( ruleBooleanLiteral ) + { + // InternalExpression.g:3191:2: ( ruleBooleanLiteral ) + // InternalExpression.g:3192:3: ruleBooleanLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleBooleanLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group_1__2" + } - // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" - // InternalExpression.g:3233:1: rule__RelationalExpression__Group_1__2__Impl : ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ; - public final void rule__RelationalExpression__Group_1__2__Impl() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:3197:2: ( ruleIntegerLiteral ) + { + // InternalExpression.g:3197:2: ( ruleIntegerLiteral ) + // InternalExpression.g:3198:3: ruleIntegerLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleIntegerLiteral(); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3237:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) - // InternalExpression.g:3238:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) - { - // InternalExpression.g:3238:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) - // InternalExpression.g:3239:2: ( rule__RelationalExpression__RightAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); - } - // InternalExpression.g:3240:2: ( rule__RelationalExpression__RightAssignment_1_2 ) - // InternalExpression.g:3240:3: rule__RelationalExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__RightAssignment_1_2(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); + } - state._fsp--; - if (state.failed) return ; + } - } - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); - } + } + break; + case 3 : + // InternalExpression.g:3203:2: ( ruleNullLiteral ) + { + // InternalExpression.g:3203:2: ( ruleNullLiteral ) + // InternalExpression.g:3204:3: ruleNullLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleNullLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 4 : + // InternalExpression.g:3209:2: ( ruleRealLiteral ) + { + // InternalExpression.g:3209:2: ( ruleRealLiteral ) + // InternalExpression.g:3210:3: ruleRealLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleRealLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); + } - } - return ; - } - // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" + } - // $ANTLR start "rule__AdditiveExpression__Group__0" - // InternalExpression.g:3249:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; - public final void rule__AdditiveExpression__Group__0() throws RecognitionException { + } + break; + case 5 : + // InternalExpression.g:3215:2: ( ruleStringLiteral ) + { + // InternalExpression.g:3215:2: ( ruleStringLiteral ) + // InternalExpression.g:3216:3: ruleStringLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleStringLiteral(); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3253:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) - // InternalExpression.g:3254:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 - { - pushFollow(FOLLOW_27); - rule__AdditiveExpression__Group__0__Impl(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -11094,72 +11272,74 @@ public final void rule__AdditiveExpression__Group__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0" + // $ANTLR end "rule__Literal__Alternatives" - // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" - // InternalExpression.g:3261:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__BooleanLiteral__ValAlternatives_0" + // InternalExpression.g:3225:1: rule__BooleanLiteral__ValAlternatives_0 : ( ( 'true' ) | ( 'false' ) ); + public final void rule__BooleanLiteral__ValAlternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3265:1: ( ( ruleMultiplicativeExpression ) ) - // InternalExpression.g:3266:1: ( ruleMultiplicativeExpression ) - { - // InternalExpression.g:3266:1: ( ruleMultiplicativeExpression ) - // InternalExpression.g:3267:2: ruleMultiplicativeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleMultiplicativeExpression(); + // InternalExpression.g:3229:1: ( ( 'true' ) | ( 'false' ) ) + int alt13=2; + int LA13_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + if ( (LA13_0==36) ) { + alt13=1; } - + else if ( (LA13_0==37) ) { + alt13=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); - + throw nvae; } + switch (alt13) { + case 1 : + // InternalExpression.g:3230:2: ( 'true' ) + { + // InternalExpression.g:3230:2: ( 'true' ) + // InternalExpression.g:3231:3: 'true' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); + } + match(input,36,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" + } + break; + case 2 : + // InternalExpression.g:3236:2: ( 'false' ) + { + // InternalExpression.g:3236:2: ( 'false' ) + // InternalExpression.g:3237:3: 'false' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); + } + match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); + } - // $ANTLR start "rule__AdditiveExpression__Group__1" - // InternalExpression.g:3276:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; - public final void rule__AdditiveExpression__Group__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3280:1: ( rule__AdditiveExpression__Group__1__Impl ) - // InternalExpression.g:3281:2: rule__AdditiveExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group__1__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -11172,101 +11352,171 @@ public final void rule__AdditiveExpression__Group__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1" + // $ANTLR end "rule__BooleanLiteral__ValAlternatives_0" - // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" - // InternalExpression.g:3287:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; - public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__FeatureCall__Alternatives" + // InternalExpression.g:3246:1: rule__FeatureCall__Alternatives : ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ); + public final void rule__FeatureCall__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3291:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) - // InternalExpression.g:3292:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) - { - // InternalExpression.g:3292:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) - // InternalExpression.g:3293:2: ( rule__AdditiveExpression__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); - } - // InternalExpression.g:3294:2: ( rule__AdditiveExpression__Group_1__0 )* - loop26: - do { - int alt26=2; - int LA26_0 = input.LA(1); + // InternalExpression.g:3250:1: ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ) + int alt14=4; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA14_1 = input.LA(2); - if ( ((LA26_0>=18 && LA26_0<=19)) ) { - alt26=1; + if ( (LA14_1==67) ) { + alt14=1; } - - - switch (alt26) { - case 1 : - // InternalExpression.g:3294:3: rule__AdditiveExpression__Group_1__0 - { - pushFollow(FOLLOW_28); - rule__AdditiveExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop26; + else if ( (LA14_1==EOF||(LA14_1>=15 && LA14_1<=26)||LA14_1==48||LA14_1==58||LA14_1==66||(LA14_1>=68 && LA14_1<=69)||(LA14_1>=71 && LA14_1<=72)||(LA14_1>=75 && LA14_1<=78)||LA14_1==84||LA14_1==101) ) { + alt14=2; } - } while (true); + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 14, 1, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); - } + throw nvae; + } + } + break; + case 38: + case 39: + case 40: + { + alt14=2; + } + break; + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + { + alt14=3; + } + break; + case 102: + { + alt14=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); + throw nvae; } + switch (alt14) { + case 1 : + // InternalExpression.g:3251:2: ( ruleOperationCall ) + { + // InternalExpression.g:3251:2: ( ruleOperationCall ) + // InternalExpression.g:3252:3: ruleOperationCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleOperationCall(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" + } + break; + case 2 : + // InternalExpression.g:3257:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) + { + // InternalExpression.g:3257:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) + // InternalExpression.g:3258:3: ( rule__FeatureCall__TypeAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); + } + // InternalExpression.g:3259:3: ( rule__FeatureCall__TypeAssignment_1 ) + // InternalExpression.g:3259:4: rule__FeatureCall__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__FeatureCall__TypeAssignment_1(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__AdditiveExpression__Group_1__0" - // InternalExpression.g:3303: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 { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3307:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) - // InternalExpression.g:3308:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 - { - pushFollow(FOLLOW_27); - rule__AdditiveExpression__Group_1__0__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 3 : + // InternalExpression.g:3263:2: ( ruleCollectionExpression ) + { + // InternalExpression.g:3263:2: ( ruleCollectionExpression ) + // InternalExpression.g:3264:3: ruleCollectionExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleCollectionExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); + } + + } + + + } + break; + case 4 : + // InternalExpression.g:3269:2: ( ruleTypeSelectExpression ) + { + // InternalExpression.g:3269:2: ( ruleTypeSelectExpression ) + // InternalExpression.g:3270:3: ruleTypeSelectExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleTypeSelectExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -11279,124 +11529,222 @@ public final void rule__AdditiveExpression__Group_1__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0" + // $ANTLR end "rule__FeatureCall__Alternatives" - // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" - // InternalExpression.g:3315:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__CollectionExpression__NameAlternatives_0_0" + // InternalExpression.g:3279:1: rule__CollectionExpression__NameAlternatives_0_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); + public final void rule__CollectionExpression__NameAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3319:1: ( ( () ) ) - // InternalExpression.g:3320:1: ( () ) - { - // InternalExpression.g:3320:1: ( () ) - // InternalExpression.g:3321:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); - } - // InternalExpression.g:3322:2: () - // InternalExpression.g:3322:3: - { - } + // InternalExpression.g:3283:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) + int alt15=8; + switch ( input.LA(1) ) { + case 28: + { + alt15=1; + } + break; + case 29: + { + alt15=2; + } + break; + case 30: + { + alt15=3; + } + break; + case 31: + { + alt15=4; + } + break; + case 32: + { + alt15=5; + } + break; + case 33: + { + alt15=6; + } + break; + case 34: + { + alt15=7; + } + break; + case 35: + { + alt15=8; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); + throw nvae; } - } + switch (alt15) { + case 1 : + // InternalExpression.g:3284:2: ( 'collect' ) + { + // InternalExpression.g:3284:2: ( 'collect' ) + // InternalExpression.g:3285:3: 'collect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); + } + match(input,28,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); + } + } - } - } - finally { + } + break; + case 2 : + // InternalExpression.g:3290:2: ( 'select' ) + { + // InternalExpression.g:3290:2: ( 'select' ) + // InternalExpression.g:3291:3: 'select' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); + } + match(input,29,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" + } + break; + case 3 : + // InternalExpression.g:3296:2: ( 'selectFirst' ) + { + // InternalExpression.g:3296:2: ( 'selectFirst' ) + // InternalExpression.g:3297:3: 'selectFirst' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); + } + match(input,30,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); + } - // $ANTLR start "rule__AdditiveExpression__Group_1__1" - // InternalExpression.g:3330: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 { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3334:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) - // InternalExpression.g:3335:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 - { - pushFollow(FOLLOW_17); - rule__AdditiveExpression__Group_1__1__Impl(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__2(); + } + break; + case 4 : + // InternalExpression.g:3302:2: ( 'reject' ) + { + // InternalExpression.g:3302:2: ( 'reject' ) + // InternalExpression.g:3303:3: 'reject' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); + } + match(input,31,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); + } - state._fsp--; - if (state.failed) return ; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 5 : + // InternalExpression.g:3308:2: ( 'exists' ) + { + // InternalExpression.g:3308:2: ( 'exists' ) + // InternalExpression.g:3309:3: 'exists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); + } + match(input,32,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__AdditiveExpression__Group_1__1" + } + break; + case 6 : + // InternalExpression.g:3314:2: ( 'notExists' ) + { + // InternalExpression.g:3314:2: ( 'notExists' ) + // InternalExpression.g:3315:3: 'notExists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); + } + match(input,33,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); + } - // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" - // InternalExpression.g:3342:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ; - public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3346:1: ( ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ) - // InternalExpression.g:3347:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) - { - // InternalExpression.g:3347:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) - // InternalExpression.g:3348:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); - } - // InternalExpression.g:3349:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) - // InternalExpression.g:3349:3: rule__AdditiveExpression__NameAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__NameAssignment_1_1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 7 : + // InternalExpression.g:3320:2: ( 'sortBy' ) + { + // InternalExpression.g:3320:2: ( 'sortBy' ) + // InternalExpression.g:3321:3: 'sortBy' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); + } + match(input,34,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); - } - } + } + break; + case 8 : + // InternalExpression.g:3326:2: ( 'forAll' ) + { + // InternalExpression.g:3326:2: ( 'forAll' ) + // InternalExpression.g:3327:3: 'forAll' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); + } + match(input,35,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); + } + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -11409,27 +11757,82 @@ public final void rule__AdditiveExpression__Group_1__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" + // $ANTLR end "rule__CollectionExpression__NameAlternatives_0_0" - // $ANTLR start "rule__AdditiveExpression__Group_1__2" - // InternalExpression.g:3357: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__Type__Alternatives" + // InternalExpression.g:3336:1: rule__Type__Alternatives : ( ( ruleCollectionType ) | ( ruleSimpleType ) ); + public final void rule__Type__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3361:1: ( rule__AdditiveExpression__Group_1__2__Impl ) - // InternalExpression.g:3362:2: rule__AdditiveExpression__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__2__Impl(); + // InternalExpression.g:3340:1: ( ( ruleCollectionType ) | ( ruleSimpleType ) ) + int alt16=2; + int LA16_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( ((LA16_0>=38 && LA16_0<=40)) ) { + alt16=1; + } + else if ( (LA16_0==RULE_ID) ) { + alt16=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); + throw nvae; } + switch (alt16) { + case 1 : + // InternalExpression.g:3341:2: ( ruleCollectionType ) + { + // InternalExpression.g:3341:2: ( ruleCollectionType ) + // InternalExpression.g:3342:3: ruleCollectionType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleCollectionType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:3347:2: ( ruleSimpleType ) + { + // InternalExpression.g:3347:2: ( ruleSimpleType ) + // InternalExpression.g:3348:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -11442,45 +11845,102 @@ public final void rule__AdditiveExpression__Group_1__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2" + // $ANTLR end "rule__Type__Alternatives" - // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" - // InternalExpression.g:3368:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ; - public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__CollectionType__ClAlternatives_0_0" + // InternalExpression.g:3357:1: rule__CollectionType__ClAlternatives_0_0 : ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ); + public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3372:1: ( ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ) - // InternalExpression.g:3373:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) - { - // InternalExpression.g:3373:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) - // InternalExpression.g:3374:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); + // InternalExpression.g:3361:1: ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ) + int alt17=3; + switch ( input.LA(1) ) { + case 38: + { + alt17=1; + } + break; + case 39: + { + alt17=2; + } + break; + case 40: + { + alt17=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; } - // InternalExpression.g:3375:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) - // InternalExpression.g:3375:3: rule__AdditiveExpression__ParamsAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__ParamsAssignment_1_2(); - state._fsp--; - if (state.failed) return ; + switch (alt17) { + case 1 : + // InternalExpression.g:3362:2: ( 'Collection' ) + { + // InternalExpression.g:3362:2: ( 'Collection' ) + // InternalExpression.g:3363:3: 'Collection' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); + } + match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); - } - } + } + break; + case 2 : + // InternalExpression.g:3368:2: ( 'List' ) + { + // InternalExpression.g:3368:2: ( 'List' ) + // InternalExpression.g:3369:3: 'List' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); + } + match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); + } + + } - } + } + break; + case 3 : + // InternalExpression.g:3374:2: ( 'Set' ) + { + // InternalExpression.g:3374:2: ( 'Set' ) + // InternalExpression.g:3375:3: 'Set' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); + } + match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -11493,110 +11953,214 @@ public final void rule__AdditiveExpression__Group_1__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" + // $ANTLR end "rule__CollectionType__ClAlternatives_0_0" - // $ANTLR start "rule__MultiplicativeExpression__Group__0" - // InternalExpression.g:3384: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__XAssignment__Alternatives" + // InternalExpression.g:3384:1: rule__XAssignment__Alternatives : ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ); + public final void rule__XAssignment__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3388:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) - // InternalExpression.g:3389:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 - { - pushFollow(FOLLOW_29); - rule__MultiplicativeExpression__Group__0__Impl(); + // InternalExpression.g:3388:1: ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ) + int alt18=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA18_1 = input.LA(2); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group__1(); + if ( (LA18_1==EOF||(LA18_1>=RULE_ID && LA18_1<=RULE_DECIMAL)||LA18_1==RULE_STRING||(LA18_1>=15 && LA18_1<=19)||(LA18_1>=21 && LA18_1<=27)||(LA18_1>=36 && LA18_1<=37)||(LA18_1>=41 && LA18_1<=64)||(LA18_1>=66 && LA18_1<=68)||LA18_1==70||(LA18_1>=72 && LA18_1<=78)||(LA18_1>=81 && LA18_1<=99)||(LA18_1>=103 && LA18_1<=104)) ) { + alt18=2; + } + else if ( (LA18_1==14) ) { + alt18=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 1, input); - state._fsp--; - if (state.failed) return ; + throw nvae; + } + } + break; + case 60: + { + int LA18_2 = input.LA(2); - } + if ( (LA18_2==14) ) { + alt18=1; + } + else if ( (LA18_2==EOF||(LA18_2>=RULE_ID && LA18_2<=RULE_DECIMAL)||LA18_2==RULE_STRING||(LA18_2>=15 && LA18_2<=19)||(LA18_2>=21 && LA18_2<=27)||(LA18_2>=36 && LA18_2<=37)||(LA18_2>=41 && LA18_2<=64)||(LA18_2>=66 && LA18_2<=68)||LA18_2==70||(LA18_2>=72 && LA18_2<=78)||(LA18_2>=81 && LA18_2<=99)||(LA18_2>=103 && LA18_2<=104)) ) { + alt18=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 2, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + throw nvae; + } + } + break; + case 61: + { + int LA18_3 = input.LA(2); - restoreStackSize(stackSize); + if ( (LA18_3==EOF||(LA18_3>=RULE_ID && LA18_3<=RULE_DECIMAL)||LA18_3==RULE_STRING||(LA18_3>=15 && LA18_3<=19)||(LA18_3>=21 && LA18_3<=27)||(LA18_3>=36 && LA18_3<=37)||(LA18_3>=41 && LA18_3<=64)||(LA18_3>=66 && LA18_3<=68)||LA18_3==70||(LA18_3>=72 && LA18_3<=78)||(LA18_3>=81 && LA18_3<=99)||(LA18_3>=103 && LA18_3<=104)) ) { + alt18=2; + } + else if ( (LA18_3==14) ) { + alt18=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 3, input); - } - return ; - } - // $ANTLR end "rule__MultiplicativeExpression__Group__0" + throw nvae; + } + } + break; + case 62: + { + int LA18_4 = input.LA(2); + if ( (LA18_4==14) ) { + alt18=1; + } + else if ( (LA18_4==EOF||(LA18_4>=RULE_ID && LA18_4<=RULE_DECIMAL)||LA18_4==RULE_STRING||(LA18_4>=15 && LA18_4<=19)||(LA18_4>=21 && LA18_4<=27)||(LA18_4>=36 && LA18_4<=37)||(LA18_4>=41 && LA18_4<=64)||(LA18_4>=66 && LA18_4<=68)||LA18_4==70||(LA18_4>=72 && LA18_4<=78)||(LA18_4>=81 && LA18_4<=99)||(LA18_4>=103 && LA18_4<=104)) ) { + alt18=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 4, input); - // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" - // InternalExpression.g:3396:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleUnaryOrInfixExpression ) ; - public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { + throw nvae; + } + } + break; + case 63: + { + int LA18_5 = input.LA(2); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3400:1: ( ( ruleUnaryOrInfixExpression ) ) - // InternalExpression.g:3401:1: ( ruleUnaryOrInfixExpression ) - { - // InternalExpression.g:3401:1: ( ruleUnaryOrInfixExpression ) - // InternalExpression.g:3402:2: ruleUnaryOrInfixExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleUnaryOrInfixExpression(); + if ( (LA18_5==EOF||(LA18_5>=RULE_ID && LA18_5<=RULE_DECIMAL)||LA18_5==RULE_STRING||(LA18_5>=15 && LA18_5<=19)||(LA18_5>=21 && LA18_5<=27)||(LA18_5>=36 && LA18_5<=37)||(LA18_5>=41 && LA18_5<=64)||(LA18_5>=66 && LA18_5<=68)||LA18_5==70||(LA18_5>=72 && LA18_5<=78)||(LA18_5>=81 && LA18_5<=99)||(LA18_5>=103 && LA18_5<=104)) ) { + alt18=2; + } + else if ( (LA18_5==14) ) { + alt18=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 5, input); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); - } + throw nvae; + } + } + break; + case RULE_HEX: + case RULE_INT: + case RULE_DECIMAL: + case RULE_STRING: + case 22: + case 23: + case 24: + case 27: + case 36: + case 37: + case 64: + case 67: + case 70: + case 73: + case 74: + case 81: + case 82: + case 87: + case 89: + case 90: + case 91: + case 92: + case 93: + case 94: + case 95: + case 96: + case 98: + { + alt18=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); + throw nvae; } + switch (alt18) { + case 1 : + // InternalExpression.g:3389:2: ( ( rule__XAssignment__Group_0__0 ) ) + { + // InternalExpression.g:3389:2: ( ( rule__XAssignment__Group_0__0 ) ) + // InternalExpression.g:3390:3: ( rule__XAssignment__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_0()); + } + // InternalExpression.g:3391:3: ( rule__XAssignment__Group_0__0 ) + // InternalExpression.g:3391:4: rule__XAssignment__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__0(); - } + state._fsp--; + if (state.failed) return ; - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_0()); + } - } - return ; - } - // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" + } - // $ANTLR start "rule__MultiplicativeExpression__Group__1" - // InternalExpression.g:3411:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; - public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:3395:2: ( ( rule__XAssignment__Group_1__0 ) ) + { + // InternalExpression.g:3395:2: ( ( rule__XAssignment__Group_1__0 ) ) + // InternalExpression.g:3396:3: ( rule__XAssignment__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1()); + } + // InternalExpression.g:3397:3: ( rule__XAssignment__Group_1__0 ) + // InternalExpression.g:3397:4: rule__XAssignment__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__0(); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3415:1: ( rule__MultiplicativeExpression__Group__1__Impl ) - // InternalExpression.g:3416:2: rule__MultiplicativeExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group__1__Impl(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -11609,101 +12173,218 @@ public final void rule__MultiplicativeExpression__Group__1() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1" + // $ANTLR end "rule__XAssignment__Alternatives" - // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" - // InternalExpression.g:3422:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; - public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__OpMultiAssign__Alternatives" + // InternalExpression.g:3405:1: rule__OpMultiAssign__Alternatives : ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ); + public final void rule__OpMultiAssign__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3426:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) - // InternalExpression.g:3427:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) - { - // InternalExpression.g:3427:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) - // InternalExpression.g:3428:2: ( rule__MultiplicativeExpression__Group_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + // InternalExpression.g:3409:1: ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ) + int alt19=7; + switch ( input.LA(1) ) { + case 41: + { + alt19=1; + } + break; + case 42: + { + alt19=2; + } + break; + case 43: + { + alt19=3; + } + break; + case 44: + { + alt19=4; + } + break; + case 45: + { + alt19=5; + } + break; + case 22: + { + alt19=6; + } + break; + case 21: + { + alt19=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); + + throw nvae; } - // InternalExpression.g:3429:2: ( rule__MultiplicativeExpression__Group_1__0 )* - loop27: - do { - int alt27=2; - int LA27_0 = input.LA(1); - if ( ((LA27_0>=20 && LA27_0<=21)) ) { - alt27=1; - } + switch (alt19) { + case 1 : + // InternalExpression.g:3410:2: ( '+=' ) + { + // InternalExpression.g:3410:2: ( '+=' ) + // InternalExpression.g:3411:3: '+=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + match(input,41,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + } - switch (alt27) { - case 1 : - // InternalExpression.g:3429:3: rule__MultiplicativeExpression__Group_1__0 - { - pushFollow(FOLLOW_30); - rule__MultiplicativeExpression__Group_1__0(); - state._fsp--; - if (state.failed) return ; + } + break; + case 2 : + // InternalExpression.g:3416:2: ( '-=' ) + { + // InternalExpression.g:3416:2: ( '-=' ) + // InternalExpression.g:3417:3: '-=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + match(input,42,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } - } - break; + } - default : - break loop27; - } - } while (true); - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); - } + } + break; + case 3 : + // InternalExpression.g:3422:2: ( '*=' ) + { + // InternalExpression.g:3422:2: ( '*=' ) + // InternalExpression.g:3423:3: '*=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + match(input,43,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } - } + } - } + } + break; + case 4 : + // InternalExpression.g:3428:2: ( '/=' ) + { + // InternalExpression.g:3428:2: ( '/=' ) + // InternalExpression.g:3429:3: '/=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + match(input,44,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" + } + break; + case 5 : + // InternalExpression.g:3434:2: ( '%=' ) + { + // InternalExpression.g:3434:2: ( '%=' ) + // InternalExpression.g:3435:3: '%=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + } - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" - // InternalExpression.g:3438: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 { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3442:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) - // InternalExpression.g:3443:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 - { - pushFollow(FOLLOW_29); - rule__MultiplicativeExpression__Group_1__0__Impl(); + } + break; + case 6 : + // InternalExpression.g:3440:2: ( ( rule__OpMultiAssign__Group_5__0 ) ) + { + // InternalExpression.g:3440:2: ( ( rule__OpMultiAssign__Group_5__0 ) ) + // InternalExpression.g:3441:3: ( rule__OpMultiAssign__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + // InternalExpression.g:3442:3: ( rule__OpMultiAssign__Group_5__0 ) + // InternalExpression.g:3442:4: rule__OpMultiAssign__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + } + + + } + break; + case 7 : + // InternalExpression.g:3446:2: ( ( rule__OpMultiAssign__Group_6__0 ) ) + { + // InternalExpression.g:3446:2: ( ( rule__OpMultiAssign__Group_6__0 ) ) + // InternalExpression.g:3447:3: ( rule__OpMultiAssign__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } + // InternalExpression.g:3448:3: ( rule__OpMultiAssign__Group_6__0 ) + // InternalExpression.g:3448:4: rule__OpMultiAssign__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -11716,73 +12397,126 @@ public final void rule__MultiplicativeExpression__Group_1__0() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" + // $ANTLR end "rule__OpMultiAssign__Alternatives" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" - // InternalExpression.g:3450:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; - public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpEquality__Alternatives" + // InternalExpression.g:3456:1: rule__OpEquality__Alternatives : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ); + public final void rule__OpEquality__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3454:1: ( ( () ) ) - // InternalExpression.g:3455:1: ( () ) - { - // InternalExpression.g:3455:1: ( () ) - // InternalExpression.g:3456:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); - } - // InternalExpression.g:3457:2: () - // InternalExpression.g:3457:3: - { - } + // InternalExpression.g:3460:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ) + int alt20=4; + switch ( input.LA(1) ) { + case 17: + { + alt20=1; + } + break; + case 18: + { + alt20=2; + } + break; + case 46: + { + alt20=3; + } + break; + case 47: + { + alt20=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 20, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + throw nvae; } - } + switch (alt20) { + case 1 : + // InternalExpression.g:3461:2: ( '==' ) + { + // InternalExpression.g:3461:2: ( '==' ) + // InternalExpression.g:3462:3: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + match(input,17,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + } - } - } - finally { + } + break; + case 2 : + // InternalExpression.g:3467:2: ( '!=' ) + { + // InternalExpression.g:3467:2: ( '!=' ) + // InternalExpression.g:3468:3: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + match(input,18,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" + } + break; + case 3 : + // InternalExpression.g:3473:2: ( '===' ) + { + // InternalExpression.g:3473:2: ( '===' ) + // InternalExpression.g:3474:3: '===' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + + } - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" - // InternalExpression.g:3465: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 { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3469:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) - // InternalExpression.g:3470:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 - { - pushFollow(FOLLOW_17); - rule__MultiplicativeExpression__Group_1__1__Impl(); + } + break; + case 4 : + // InternalExpression.g:3479:2: ( '!==' ) + { + // InternalExpression.g:3479:2: ( '!==' ) + // InternalExpression.g:3480:3: '!==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -11795,78 +12529,94 @@ public final void rule__MultiplicativeExpression__Group_1__1() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" + // $ANTLR end "rule__OpEquality__Alternatives" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" - // InternalExpression.g:3477:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XRelationalExpression__Alternatives_1" + // InternalExpression.g:3489:1: rule__XRelationalExpression__Alternatives_1 : ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ); + public final void rule__XRelationalExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3481:1: ( ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ) - // InternalExpression.g:3482:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) - { - // InternalExpression.g:3482:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) - // InternalExpression.g:3483:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); - } - // InternalExpression.g:3484:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) - // InternalExpression.g:3484:3: rule__MultiplicativeExpression__NameAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__NameAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3493:1: ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ) + int alt21=2; + int LA21_0 = input.LA(1); + if ( (LA21_0==85) ) { + alt21=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + else if ( (LA21_0==19||(LA21_0>=21 && LA21_0<=22)) ) { + alt21=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 0, input); + throw nvae; } + switch (alt21) { + case 1 : + // InternalExpression.g:3494:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:3494:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + // InternalExpression.g:3495:3: ( rule__XRelationalExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:3496:3: ( rule__XRelationalExpression__Group_1_0__0 ) + // InternalExpression.g:3496:4: rule__XRelationalExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" + } + break; + case 2 : + // InternalExpression.g:3500:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + { + // InternalExpression.g:3500:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + // InternalExpression.g:3501:3: ( rule__XRelationalExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } + // InternalExpression.g:3502:3: ( rule__XRelationalExpression__Group_1_1__0 ) + // InternalExpression.g:3502:4: rule__XRelationalExpression__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__0(); - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" - // InternalExpression.g:3492:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; - public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3496:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) - // InternalExpression.g:3497:2: rule__MultiplicativeExpression__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2__Impl(); + } - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -11879,83 +12629,145 @@ public final void rule__MultiplicativeExpression__Group_1__2() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" + // $ANTLR end "rule__XRelationalExpression__Alternatives_1" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" - // InternalExpression.g:3503:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__OpCompare__Alternatives" + // InternalExpression.g:3510:1: rule__OpCompare__Alternatives : ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ); + public final void rule__OpCompare__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3507:1: ( ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ) - // InternalExpression.g:3508:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) - { - // InternalExpression.g:3508:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) - // InternalExpression.g:3509:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); - } - // InternalExpression.g:3510:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) - // InternalExpression.g:3510:3: rule__MultiplicativeExpression__ParamsAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__ParamsAssignment_1_2(); + // InternalExpression.g:3514:1: ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ) + int alt22=4; + switch ( input.LA(1) ) { + case 19: + { + alt22=1; + } + break; + case 22: + { + int LA22_2 = input.LA(2); - state._fsp--; - if (state.failed) return ; + if ( (LA22_2==EOF||(LA22_2>=RULE_ID && LA22_2<=RULE_DECIMAL)||LA22_2==RULE_STRING||(LA22_2>=22 && LA22_2<=24)||LA22_2==27||(LA22_2>=36 && LA22_2<=37)||(LA22_2>=60 && LA22_2<=64)||LA22_2==67||LA22_2==70||(LA22_2>=73 && LA22_2<=74)||(LA22_2>=81 && LA22_2<=82)||LA22_2==87||(LA22_2>=89 && LA22_2<=96)||LA22_2==98) ) { + alt22=4; + } + else if ( (LA22_2==14) ) { + alt22=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 22, 2, input); - } + throw nvae; + } + } + break; + case 21: + { + alt22=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); + throw nvae; } - } + switch (alt22) { + case 1 : + // InternalExpression.g:3515:2: ( '>=' ) + { + // InternalExpression.g:3515:2: ( '>=' ) + // InternalExpression.g:3516:3: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 2 : + // InternalExpression.g:3521:2: ( ( rule__OpCompare__Group_1__0 ) ) + { + // InternalExpression.g:3521:2: ( ( rule__OpCompare__Group_1__0 ) ) + // InternalExpression.g:3522:3: ( rule__OpCompare__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGroup_1()); + } + // InternalExpression.g:3523:3: ( rule__OpCompare__Group_1__0 ) + // InternalExpression.g:3523:4: rule__OpCompare__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGroup_1()); + } - // $ANTLR start "rule__UnaryExpression__Group__0" - // InternalExpression.g:3519:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ; - public final void rule__UnaryExpression__Group__0() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3523:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ) - // InternalExpression.g:3524:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 - { - pushFollow(FOLLOW_17); - rule__UnaryExpression__Group__0__Impl(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__UnaryExpression__Group__1(); + } + break; + case 3 : + // InternalExpression.g:3527:2: ( '>' ) + { + // InternalExpression.g:3527:2: ( '>' ) + // InternalExpression.g:3528:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + case 4 : + // InternalExpression.g:3533:2: ( '<' ) + { + // InternalExpression.g:3533:2: ( '<' ) + // InternalExpression.g:3534:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -11968,167 +12780,223 @@ public final void rule__UnaryExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__UnaryExpression__Group__0" + // $ANTLR end "rule__OpCompare__Alternatives" - // $ANTLR start "rule__UnaryExpression__Group__0__Impl" - // InternalExpression.g:3531:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__NameAssignment_0 ) ) ; - public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives" + // InternalExpression.g:3543:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ); + public final void rule__OpOther__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3535:1: ( ( ( rule__UnaryExpression__NameAssignment_0 ) ) ) - // InternalExpression.g:3536:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) - { - // InternalExpression.g:3536:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) - // InternalExpression.g:3537:2: ( rule__UnaryExpression__NameAssignment_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); - } - // InternalExpression.g:3538:2: ( rule__UnaryExpression__NameAssignment_0 ) - // InternalExpression.g:3538:3: rule__UnaryExpression__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__UnaryExpression__NameAssignment_0(); + // InternalExpression.g:3547:1: ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ) + int alt23=9; + alt23 = dfa23.predict(input); + switch (alt23) { + case 1 : + // InternalExpression.g:3548:2: ( '->' ) + { + // InternalExpression.g:3548:2: ( '->' ) + // InternalExpression.g:3549:3: '->' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + match(input,48,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } - state._fsp--; - if (state.failed) return ; + } - } - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); - } + } + break; + case 2 : + // InternalExpression.g:3554:2: ( '..<' ) + { + // InternalExpression.g:3554:2: ( '..<' ) + // InternalExpression.g:3555:3: '..<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + match(input,49,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } - } + } - } + } + break; + case 3 : + // InternalExpression.g:3560:2: ( ( rule__OpOther__Group_2__0 ) ) + { + // InternalExpression.g:3560:2: ( ( rule__OpOther__Group_2__0 ) ) + // InternalExpression.g:3561:3: ( rule__OpOther__Group_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_2()); + } + // InternalExpression.g:3562:3: ( rule__OpOther__Group_2__0 ) + // InternalExpression.g:3562:4: rule__OpOther__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__UnaryExpression__Group__0__Impl" + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_2()); + } + } - // $ANTLR start "rule__UnaryExpression__Group__1" - // InternalExpression.g:3546:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ; - public final void rule__UnaryExpression__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3550:1: ( rule__UnaryExpression__Group__1__Impl ) - // InternalExpression.g:3551:2: rule__UnaryExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__UnaryExpression__Group__1__Impl(); + } + break; + case 4 : + // InternalExpression.g:3566:2: ( '..' ) + { + // InternalExpression.g:3566:2: ( '..' ) + // InternalExpression.g:3567:3: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + match(input,50,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } - state._fsp--; - if (state.failed) return ; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 5 : + // InternalExpression.g:3572:2: ( '=>' ) + { + // InternalExpression.g:3572:2: ( '=>' ) + // InternalExpression.g:3573:3: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__UnaryExpression__Group__1" + } + break; + case 6 : + // InternalExpression.g:3578:2: ( ( rule__OpOther__Group_5__0 ) ) + { + // InternalExpression.g:3578:2: ( ( rule__OpOther__Group_5__0 ) ) + // InternalExpression.g:3579:3: ( rule__OpOther__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5()); + } + // InternalExpression.g:3580:3: ( rule__OpOther__Group_5__0 ) + // InternalExpression.g:3580:4: rule__OpOther__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__0(); - // $ANTLR start "rule__UnaryExpression__Group__1__Impl" - // InternalExpression.g:3557:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ; - public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3561:1: ( ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ) - // InternalExpression.g:3562:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) - { - // InternalExpression.g:3562:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) - // InternalExpression.g:3563:2: ( rule__UnaryExpression__ParamsAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); - } - // InternalExpression.g:3564:2: ( rule__UnaryExpression__ParamsAssignment_1 ) - // InternalExpression.g:3564:3: rule__UnaryExpression__ParamsAssignment_1 - { - pushFollow(FOLLOW_2); - rule__UnaryExpression__ParamsAssignment_1(); + } - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); - } - } + } + break; + case 7 : + // InternalExpression.g:3584:2: ( ( rule__OpOther__Group_6__0 ) ) + { + // InternalExpression.g:3584:2: ( ( rule__OpOther__Group_6__0 ) ) + // InternalExpression.g:3585:3: ( rule__OpOther__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6()); + } + // InternalExpression.g:3586:3: ( rule__OpOther__Group_6__0 ) + // InternalExpression.g:3586:4: rule__OpOther__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__UnaryExpression__Group__1__Impl" + } + break; + case 8 : + // InternalExpression.g:3590:2: ( '<>' ) + { + // InternalExpression.g:3590:2: ( '<>' ) + // InternalExpression.g:3591:3: '<>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } - // $ANTLR start "rule__InfixExpression__Group__0" - // InternalExpression.g:3573:1: rule__InfixExpression__Group__0 : rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ; - public final void rule__InfixExpression__Group__0() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3577:1: ( rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ) - // InternalExpression.g:3578:2: rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 - { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group__0__Impl(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group__1(); + } + break; + case 9 : + // InternalExpression.g:3596:2: ( '?:' ) + { + // InternalExpression.g:3596:2: ( '?:' ) + // InternalExpression.g:3597:3: '?:' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + match(input,53,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12141,72 +13009,95 @@ public final void rule__InfixExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__InfixExpression__Group__0" + // $ANTLR end "rule__OpOther__Alternatives" - // $ANTLR start "rule__InfixExpression__Group__0__Impl" - // InternalExpression.g:3585:1: rule__InfixExpression__Group__0__Impl : ( rulePrimaryExpression ) ; - public final void rule__InfixExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives_5_1" + // InternalExpression.g:3606:1: rule__OpOther__Alternatives_5_1 : ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ); + public final void rule__OpOther__Alternatives_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3589:1: ( ( rulePrimaryExpression ) ) - // InternalExpression.g:3590:1: ( rulePrimaryExpression ) - { - // InternalExpression.g:3590:1: ( rulePrimaryExpression ) - // InternalExpression.g:3591:2: rulePrimaryExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - rulePrimaryExpression(); + // InternalExpression.g:3610:1: ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ) + int alt24=2; + int LA24_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + if ( (LA24_0==21) ) { + int LA24_1 = input.LA(2); + + if ( (LA24_1==EOF||(LA24_1>=RULE_ID && LA24_1<=RULE_DECIMAL)||LA24_1==RULE_STRING||(LA24_1>=22 && LA24_1<=24)||LA24_1==27||(LA24_1>=36 && LA24_1<=37)||(LA24_1>=60 && LA24_1<=64)||LA24_1==67||LA24_1==70||(LA24_1>=73 && LA24_1<=74)||(LA24_1>=81 && LA24_1<=82)||LA24_1==87||(LA24_1>=89 && LA24_1<=96)||LA24_1==98) ) { + alt24=2; + } + else if ( (LA24_1==21) ) { + alt24=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 24, 1, input); + + throw nvae; + } } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 24, 0, input); + throw nvae; } + switch (alt24) { + case 1 : + // InternalExpression.g:3611:2: ( ( rule__OpOther__Group_5_1_0__0 ) ) + { + // InternalExpression.g:3611:2: ( ( rule__OpOther__Group_5_1_0__0 ) ) + // InternalExpression.g:3612:3: ( rule__OpOther__Group_5_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } + // InternalExpression.g:3613:3: ( rule__OpOther__Group_5_1_0__0 ) + // InternalExpression.g:3613:4: rule__OpOther__Group_5_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group__0__Impl" + } + break; + case 2 : + // InternalExpression.g:3617:2: ( '>' ) + { + // InternalExpression.g:3617:2: ( '>' ) + // InternalExpression.g:3618:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } - // $ANTLR start "rule__InfixExpression__Group__1" - // InternalExpression.g:3600:1: rule__InfixExpression__Group__1 : rule__InfixExpression__Group__1__Impl ; - public final void rule__InfixExpression__Group__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3604:1: ( rule__InfixExpression__Group__1__Impl ) - // InternalExpression.g:3605:2: rule__InfixExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group__1__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12219,63 +13110,117 @@ public final void rule__InfixExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__InfixExpression__Group__1" + // $ANTLR end "rule__OpOther__Alternatives_5_1" - // $ANTLR start "rule__InfixExpression__Group__1__Impl" - // InternalExpression.g:3611:1: rule__InfixExpression__Group__1__Impl : ( ( rule__InfixExpression__Alternatives_1 )* ) ; - public final void rule__InfixExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives_6_1" + // InternalExpression.g:3627:1: rule__OpOther__Alternatives_6_1 : ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ); + public final void rule__OpOther__Alternatives_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3615:1: ( ( ( rule__InfixExpression__Alternatives_1 )* ) ) - // InternalExpression.g:3616:1: ( ( rule__InfixExpression__Alternatives_1 )* ) - { - // InternalExpression.g:3616:1: ( ( rule__InfixExpression__Alternatives_1 )* ) - // InternalExpression.g:3617:2: ( rule__InfixExpression__Alternatives_1 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); - } - // InternalExpression.g:3618:2: ( rule__InfixExpression__Alternatives_1 )* - loop28: - do { - int alt28=2; - int LA28_0 = input.LA(1); + // InternalExpression.g:3631:1: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ) + int alt25=3; + int LA25_0 = input.LA(1); + + if ( (LA25_0==22) ) { + int LA25_1 = input.LA(2); - if ( (LA28_0==51) ) { - alt28=1; + if ( (synpred71_InternalExpression()) ) { + alt25=1; + } + else if ( (synpred72_InternalExpression()) ) { + alt25=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 25, 1, input); + throw nvae; + } + } + else if ( (LA25_0==51) ) { + alt25=3; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); - switch (alt28) { - case 1 : - // InternalExpression.g:3618:3: rule__InfixExpression__Alternatives_1 - { - pushFollow(FOLLOW_32); - rule__InfixExpression__Alternatives_1(); + throw nvae; + } + switch (alt25) { + case 1 : + // InternalExpression.g:3632:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // InternalExpression.g:3632:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // InternalExpression.g:3633:3: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // InternalExpression.g:3634:3: ( rule__OpOther__Group_6_1_0__0 ) + // InternalExpression.g:3634:4: rule__OpOther__Group_6_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } - default : - break loop28; - } - } while (true); + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); - } + } - } + } + break; + case 2 : + // InternalExpression.g:3638:2: ( '<' ) + { + // InternalExpression.g:3638:2: ( '<' ) + // InternalExpression.g:3639:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + + } - } + } + break; + case 3 : + // InternalExpression.g:3644:2: ( '=>' ) + { + // InternalExpression.g:3644:2: ( '=>' ) + // InternalExpression.g:3645:3: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12288,32 +13233,74 @@ public final void rule__InfixExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group__1__Impl" + // $ANTLR end "rule__OpOther__Alternatives_6_1" - // $ANTLR start "rule__InfixExpression__Group_1_0__0" - // InternalExpression.g:3627:1: rule__InfixExpression__Group_1_0__0 : rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ; - public final void rule__InfixExpression__Group_1_0__0() throws RecognitionException { + // $ANTLR start "rule__OpAdd__Alternatives" + // InternalExpression.g:3654:1: rule__OpAdd__Alternatives : ( ( '+' ) | ( '-' ) ); + public final void rule__OpAdd__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3631:1: ( rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ) - // InternalExpression.g:3632:2: rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 - { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__1(); + // InternalExpression.g:3658:1: ( ( '+' ) | ( '-' ) ) + int alt26=2; + int LA26_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA26_0==23) ) { + alt26=1; + } + else if ( (LA26_0==24) ) { + alt26=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 26, 0, input); + throw nvae; } + switch (alt26) { + case 1 : + // InternalExpression.g:3659:2: ( '+' ) + { + // InternalExpression.g:3659:2: ( '+' ) + // InternalExpression.g:3660:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:3665:2: ( '-' ) + { + // InternalExpression.g:3665:2: ( '-' ) + // InternalExpression.g:3666:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12326,73 +13313,126 @@ public final void rule__InfixExpression__Group_1_0__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__0" + // $ANTLR end "rule__OpAdd__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_0__0__Impl" - // InternalExpression.g:3639:1: rule__InfixExpression__Group_1_0__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpMulti__Alternatives" + // InternalExpression.g:3675:1: rule__OpMulti__Alternatives : ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ); + public final void rule__OpMulti__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3643:1: ( ( () ) ) - // InternalExpression.g:3644:1: ( () ) - { - // InternalExpression.g:3644:1: ( () ) - // InternalExpression.g:3645:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); - } - // InternalExpression.g:3646:2: () - // InternalExpression.g:3646:3: - { - } + // InternalExpression.g:3679:1: ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ) + int alt27=4; + switch ( input.LA(1) ) { + case 25: + { + alt27=1; + } + break; + case 54: + { + alt27=2; + } + break; + case 26: + { + alt27=3; + } + break; + case 55: + { + alt27=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 27, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + throw nvae; } - } + switch (alt27) { + case 1 : + // InternalExpression.g:3680:2: ( '*' ) + { + // InternalExpression.g:3680:2: ( '*' ) + // InternalExpression.g:3681:3: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + } - } - } - finally { + } + break; + case 2 : + // InternalExpression.g:3686:2: ( '**' ) + { + // InternalExpression.g:3686:2: ( '**' ) + // InternalExpression.g:3687:3: '**' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + match(input,54,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0__0__Impl" + } + break; + case 3 : + // InternalExpression.g:3692:2: ( '/' ) + { + // InternalExpression.g:3692:2: ( '/' ) + // InternalExpression.g:3693:3: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + match(input,26,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + + } - // $ANTLR start "rule__InfixExpression__Group_1_0__1" - // InternalExpression.g:3654:1: rule__InfixExpression__Group_1_0__1 : rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ; - public final void rule__InfixExpression__Group_1_0__1() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3658:1: ( rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ) - // InternalExpression.g:3659:2: rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 - { - pushFollow(FOLLOW_3); - rule__InfixExpression__Group_1_0__1__Impl(); + } + break; + case 4 : + // InternalExpression.g:3698:2: ( '%' ) + { + // InternalExpression.g:3698:2: ( '%' ) + // InternalExpression.g:3699:3: '%' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + match(input,55,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__2(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12405,73 +13445,88 @@ public final void rule__InfixExpression__Group_1_0__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__1" + // $ANTLR end "rule__OpMulti__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_0__1__Impl" - // InternalExpression.g:3666:1: rule__InfixExpression__Group_1_0__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XUnaryOperation__Alternatives" + // InternalExpression.g:3708:1: rule__XUnaryOperation__Alternatives : ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ); + public final void rule__XUnaryOperation__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3670:1: ( ( '.' ) ) - // InternalExpression.g:3671:1: ( '.' ) - { - // InternalExpression.g:3671:1: ( '.' ) - // InternalExpression.g:3672:2: '.' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + // InternalExpression.g:3712:1: ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ) + int alt28=2; + int LA28_0 = input.LA(1); + + if ( ((LA28_0>=23 && LA28_0<=24)||LA28_0==27) ) { + alt28=1; } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + else if ( ((LA28_0>=RULE_ID && LA28_0<=RULE_DECIMAL)||LA28_0==RULE_STRING||LA28_0==22||(LA28_0>=36 && LA28_0<=37)||(LA28_0>=60 && LA28_0<=64)||LA28_0==67||LA28_0==70||(LA28_0>=73 && LA28_0<=74)||(LA28_0>=81 && LA28_0<=82)||LA28_0==87||(LA28_0>=89 && LA28_0<=96)||LA28_0==98) ) { + alt28=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 0, input); + throw nvae; } + switch (alt28) { + case 1 : + // InternalExpression.g:3713:2: ( ( rule__XUnaryOperation__Group_0__0 ) ) + { + // InternalExpression.g:3713:2: ( ( rule__XUnaryOperation__Group_0__0 ) ) + // InternalExpression.g:3714:3: ( rule__XUnaryOperation__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } + // InternalExpression.g:3715:3: ( rule__XUnaryOperation__Group_0__0 ) + // InternalExpression.g:3715:4: rule__XUnaryOperation__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0__1__Impl" + } + break; + case 2 : + // InternalExpression.g:3719:2: ( ruleXCastedExpression ) + { + // InternalExpression.g:3719:2: ( ruleXCastedExpression ) + // InternalExpression.g:3720:3: ruleXCastedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXCastedExpression(); - // $ANTLR start "rule__InfixExpression__Group_1_0__2" - // InternalExpression.g:3681:1: rule__InfixExpression__Group_1_0__2 : rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ; - public final void rule__InfixExpression__Group_1_0__2() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3685:1: ( rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ) - // InternalExpression.g:3686:2: rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 - { - pushFollow(FOLLOW_33); - rule__InfixExpression__Group_1_0__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__3(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12484,83 +13539,102 @@ public final void rule__InfixExpression__Group_1_0__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__2" + // $ANTLR end "rule__XUnaryOperation__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_0__2__Impl" - // InternalExpression.g:3693:1: rule__InfixExpression__Group_1_0__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ; - public final void rule__InfixExpression__Group_1_0__2__Impl() throws RecognitionException { + // $ANTLR start "rule__OpUnary__Alternatives" + // InternalExpression.g:3729:1: rule__OpUnary__Alternatives : ( ( '!' ) | ( '-' ) | ( '+' ) ); + public final void rule__OpUnary__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3697:1: ( ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ) - // InternalExpression.g:3698:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) - { - // InternalExpression.g:3698:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) - // InternalExpression.g:3699:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); - } - // InternalExpression.g:3700:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) - // InternalExpression.g:3700:3: rule__InfixExpression__NameAssignment_1_0_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_0_2(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); - } + // InternalExpression.g:3733:1: ( ( '!' ) | ( '-' ) | ( '+' ) ) + int alt29=3; + switch ( input.LA(1) ) { + case 27: + { + alt29=1; + } + break; + case 24: + { + alt29=2; + } + break; + case 23: + { + alt29=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 29, 0, input); + throw nvae; } + switch (alt29) { + case 1 : + // InternalExpression.g:3734:2: ( '!' ) + { + // InternalExpression.g:3734:2: ( '!' ) + // InternalExpression.g:3735:3: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + match(input,27,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExpression.g:3740:2: ( '-' ) + { + // InternalExpression.g:3740:2: ( '-' ) + // InternalExpression.g:3741:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0__2__Impl" + } - // $ANTLR start "rule__InfixExpression__Group_1_0__3" - // InternalExpression.g:3708:1: rule__InfixExpression__Group_1_0__3 : rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ; - public final void rule__InfixExpression__Group_1_0__3() throws RecognitionException { + } + break; + case 3 : + // InternalExpression.g:3746:2: ( '+' ) + { + // InternalExpression.g:3746:2: ( '+' ) + // InternalExpression.g:3747:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3712:1: ( rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ) - // InternalExpression.g:3713:2: rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 - { - pushFollow(FOLLOW_34); - rule__InfixExpression__Group_1_0__3__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__4(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12573,35 +13647,74 @@ public final void rule__InfixExpression__Group_1_0__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__3" + // $ANTLR end "rule__OpUnary__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_0__3__Impl" - // InternalExpression.g:3720:1: rule__InfixExpression__Group_1_0__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_0__3__Impl() throws RecognitionException { + // $ANTLR start "rule__OpPostfix__Alternatives" + // InternalExpression.g:3756:1: rule__OpPostfix__Alternatives : ( ( '++' ) | ( '--' ) ); + public final void rule__OpPostfix__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3724:1: ( ( '(' ) ) - // InternalExpression.g:3725:1: ( '(' ) - { - // InternalExpression.g:3725:1: ( '(' ) - // InternalExpression.g:3726:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + // InternalExpression.g:3760:1: ( ( '++' ) | ( '--' ) ) + int alt30=2; + int LA30_0 = input.LA(1); + + if ( (LA30_0==56) ) { + alt30=1; } - match(input,39,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + else if ( (LA30_0==57) ) { + alt30=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 30, 0, input); + throw nvae; } + switch (alt30) { + case 1 : + // InternalExpression.g:3761:2: ( '++' ) + { + // InternalExpression.g:3761:2: ( '++' ) + // InternalExpression.g:3762:3: '++' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + match(input,56,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + } - } + } + break; + case 2 : + // InternalExpression.g:3767:2: ( '--' ) + { + // InternalExpression.g:3767:2: ( '--' ) + // InternalExpression.g:3768:3: '--' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + match(input,57,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12614,32 +13727,80 @@ public final void rule__InfixExpression__Group_1_0__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__3__Impl" + // $ANTLR end "rule__OpPostfix__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_0__4" - // InternalExpression.g:3735:1: rule__InfixExpression__Group_1_0__4 : rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ; - public final void rule__InfixExpression__Group_1_0__4() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1" + // InternalExpression.g:3777:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3739:1: ( rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ) - // InternalExpression.g:3740:2: rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 - { - pushFollow(FOLLOW_34); - rule__InfixExpression__Group_1_0__4__Impl(); + // InternalExpression.g:3781:1: ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) ) + int alt31=2; + alt31 = dfa31.predict(input); + switch (alt31) { + case 1 : + // InternalExpression.g:3782:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) + { + // InternalExpression.g:3782:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) + // InternalExpression.g:3783:3: ( rule__XMemberFeatureCall__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); + } + // InternalExpression.g:3784:3: ( rule__XMemberFeatureCall__Group_1_0__0 ) + // InternalExpression.g:3784:4: rule__XMemberFeatureCall__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__5(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:3788:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) + { + // InternalExpression.g:3788:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) + // InternalExpression.g:3789:3: ( rule__XMemberFeatureCall__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); + } + // InternalExpression.g:3790:3: ( rule__XMemberFeatureCall__Group_1_1__0 ) + // InternalExpression.g:3790:4: rule__XMemberFeatureCall__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12652,56 +13813,84 @@ public final void rule__InfixExpression__Group_1_0__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__4" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1" - // $ANTLR start "rule__InfixExpression__Group_1_0__4__Impl" - // InternalExpression.g:3747:1: rule__InfixExpression__Group_1_0__4__Impl : ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ; - public final void rule__InfixExpression__Group_1_0__4__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1" + // InternalExpression.g:3798:1: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_0_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3751:1: ( ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ) - // InternalExpression.g:3752:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) - { - // InternalExpression.g:3752:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) - // InternalExpression.g:3753:2: ( rule__InfixExpression__Group_1_0_4__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + // InternalExpression.g:3802:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) ) + int alt32=2; + int LA32_0 = input.LA(1); + + if ( (LA32_0==58) ) { + alt32=1; + } + else if ( (LA32_0==84) ) { + alt32=2; } - // InternalExpression.g:3754:2: ( rule__InfixExpression__Group_1_0_4__0 )? - int alt29=2; - int LA29_0 = input.LA(1); + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 32, 0, input); - if ( ((LA29_0>=RULE_ID && LA29_0<=RULE_STRING)||LA29_0==19||(LA29_0>=22 && LA29_0<=36)||LA29_0==39||LA29_0==43||(LA29_0>=46 && LA29_0<=47)||(LA29_0>=54 && LA29_0<=55)||(LA29_0>=62 && LA29_0<=63)) ) { - alt29=1; + throw nvae; } - switch (alt29) { + switch (alt32) { case 1 : - // InternalExpression.g:3754:3: rule__InfixExpression__Group_1_0_4__0 + // InternalExpression.g:3803:2: ( '.' ) + { + // InternalExpression.g:3803:2: ( '.' ) + // InternalExpression.g:3804:3: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:3809:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) + { + // InternalExpression.g:3809:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) + // InternalExpression.g:3810:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); + } + // InternalExpression.g:3811:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) + // InternalExpression.g:3811:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 { pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__0(); + rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1(); state._fsp--; if (state.failed) return ; } - break; - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12714,68 +13903,122 @@ public final void rule__InfixExpression__Group_1_0__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__4__Impl" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1" - // $ANTLR start "rule__InfixExpression__Group_1_0__5" - // InternalExpression.g:3762:1: rule__InfixExpression__Group_1_0__5 : rule__InfixExpression__Group_1_0__5__Impl ; - public final void rule__InfixExpression__Group_1_0__5() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1" + // InternalExpression.g:3819:1: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_1_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3766:1: ( rule__InfixExpression__Group_1_0__5__Impl ) - // InternalExpression.g:3767:2: rule__InfixExpression__Group_1_0__5__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__5__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3823:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) ) + int alt33=3; + switch ( input.LA(1) ) { + case 58: + { + alt33=1; + } + break; + case 103: + { + alt33=2; + } + break; + case 84: + { + alt33=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 33, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt33) { + case 1 : + // InternalExpression.g:3824:2: ( '.' ) + { + // InternalExpression.g:3824:2: ( '.' ) + // InternalExpression.g:3825:3: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0__5" + } + break; + case 2 : + // InternalExpression.g:3830:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) + { + // InternalExpression.g:3830:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) + // InternalExpression.g:3831:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); + } + // InternalExpression.g:3832:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) + // InternalExpression.g:3832:4: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1(); - // $ANTLR start "rule__InfixExpression__Group_1_0__5__Impl" - // InternalExpression.g:3773:1: rule__InfixExpression__Group_1_0__5__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_0__5__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3777:1: ( ( ')' ) ) - // InternalExpression.g:3778:1: ( ')' ) - { - // InternalExpression.g:3778:1: ( ')' ) - // InternalExpression.g:3779:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); - } - match(input,40,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); + } + + } - } + } + break; + case 3 : + // InternalExpression.g:3836:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) + { + // InternalExpression.g:3836:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) + // InternalExpression.g:3837:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); + } + // InternalExpression.g:3838:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) + // InternalExpression.g:3838:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2(); + + state._fsp--; + if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12788,83 +14031,80 @@ public final void rule__InfixExpression__Group_1_0__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__5__Impl" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__0" - // InternalExpression.g:3789:1: rule__InfixExpression__Group_1_0_4__0 : rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ; - public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_3_1" + // InternalExpression.g:3846:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_1_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3793:1: ( rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ) - // InternalExpression.g:3794:2: rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 - { - pushFollow(FOLLOW_35); - rule__InfixExpression__Group_1_0_4__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__1(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:3850:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) ) + int alt34=2; + alt34 = dfa34.predict(input); + switch (alt34) { + case 1 : + // InternalExpression.g:3851:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + { + // InternalExpression.g:3851:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + // InternalExpression.g:3852:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + // InternalExpression.g:3853:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + // InternalExpression.g:3853:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0(); - } + state._fsp--; + if (state.failed) return ; - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__0" + } - // $ANTLR start "rule__InfixExpression__Group_1_0_4__0__Impl" - // InternalExpression.g:3801:1: rule__InfixExpression__Group_1_0_4__0__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ; - public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:3857:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) + { + // InternalExpression.g:3857:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) + // InternalExpression.g:3858:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); + } + // InternalExpression.g:3859:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) + // InternalExpression.g:3859:4: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__0(); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3805:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ) - // InternalExpression.g:3806:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) - { - // InternalExpression.g:3806:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) - // InternalExpression.g:3807:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); - } - // InternalExpression.g:3808:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) - // InternalExpression.g:3808:3: rule__InfixExpression__ParamsAssignment_1_0_4_0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__ParamsAssignment_1_0_4_0(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12877,297 +14117,379 @@ public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__0__Impl" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_3_1" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__1" - // InternalExpression.g:3816:1: rule__InfixExpression__Group_1_0_4__1 : rule__InfixExpression__Group_1_0_4__1__Impl ; - public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionException { + // $ANTLR start "rule__XPrimaryExpression__Alternatives" + // InternalExpression.g:3867:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) ); + public final void rule__XPrimaryExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3820:1: ( rule__InfixExpression__Group_1_0_4__1__Impl ) - // InternalExpression.g:3821:2: rule__InfixExpression__Group_1_0_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__1__Impl(); + // InternalExpression.g:3871:1: ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) ) + int alt35=15; + alt35 = dfa35.predict(input); + switch (alt35) { + case 1 : + // InternalExpression.g:3872:2: ( ruleXConstructorCall ) + { + // InternalExpression.g:3872:2: ( ruleXConstructorCall ) + // InternalExpression.g:3873:3: ruleXConstructorCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXConstructorCall(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExpression.g:3878:2: ( ruleXBlockExpression ) + { + // InternalExpression.g:3878:2: ( ruleXBlockExpression ) + // InternalExpression.g:3879:3: ruleXBlockExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXBlockExpression(); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__1" + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + } - // $ANTLR start "rule__InfixExpression__Group_1_0_4__1__Impl" - // InternalExpression.g:3827:1: rule__InfixExpression__Group_1_0_4__1__Impl : ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ; - public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3831:1: ( ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ) - // InternalExpression.g:3832:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) - { - // InternalExpression.g:3832:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) - // InternalExpression.g:3833:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); - } - // InternalExpression.g:3834:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* - loop30: - do { - int alt30=2; - int LA30_0 = input.LA(1); + } + break; + case 3 : + // InternalExpression.g:3884:2: ( ruleXSwitchExpression ) + { + // InternalExpression.g:3884:2: ( ruleXSwitchExpression ) + // InternalExpression.g:3885:3: ruleXSwitchExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleXSwitchExpression(); - if ( (LA30_0==52) ) { - alt30=1; - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + } - switch (alt30) { - case 1 : - // InternalExpression.g:3834:3: rule__InfixExpression__Group_1_0_4_1__0 - { - pushFollow(FOLLOW_36); - rule__InfixExpression__Group_1_0_4_1__0(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalExpression.g:3890:2: ( ( ruleXSynchronizedExpression ) ) + { + // InternalExpression.g:3890:2: ( ( ruleXSynchronizedExpression ) ) + // InternalExpression.g:3891:3: ( ruleXSynchronizedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + // InternalExpression.g:3892:3: ( ruleXSynchronizedExpression ) + // InternalExpression.g:3892:4: ruleXSynchronizedExpression + { + pushFollow(FOLLOW_2); + ruleXSynchronizedExpression(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop30; - } - } while (true); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } - } + } - } + } + break; + case 5 : + // InternalExpression.g:3896:2: ( ruleXFeatureCall ) + { + // InternalExpression.g:3896:2: ( ruleXFeatureCall ) + // InternalExpression.g:3897:3: ruleXFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleXFeatureCall(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__1__Impl" + } + break; + case 6 : + // InternalExpression.g:3902:2: ( ruleXLiteral ) + { + // InternalExpression.g:3902:2: ( ruleXLiteral ) + // InternalExpression.g:3903:3: ruleXLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleXLiteral(); - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0" - // InternalExpression.g:3843:1: rule__InfixExpression__Group_1_0_4_1__0 : rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ; - public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3847:1: ( rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ) - // InternalExpression.g:3848:2: rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 - { - pushFollow(FOLLOW_5); - rule__InfixExpression__Group_1_0_4_1__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4_1__1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 7 : + // InternalExpression.g:3908:2: ( ruleXIfExpression ) + { + // InternalExpression.g:3908:2: ( ruleXIfExpression ) + // InternalExpression.g:3909:3: ruleXIfExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } + pushFollow(FOLLOW_2); + ruleXIfExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0" + } + break; + case 8 : + // InternalExpression.g:3914:2: ( ( ruleXForLoopExpression ) ) + { + // InternalExpression.g:3914:2: ( ( ruleXForLoopExpression ) ) + // InternalExpression.g:3915:3: ( ruleXForLoopExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + // InternalExpression.g:3916:3: ( ruleXForLoopExpression ) + // InternalExpression.g:3916:4: ruleXForLoopExpression + { + pushFollow(FOLLOW_2); + ruleXForLoopExpression(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0__Impl" - // InternalExpression.g:3855:1: rule__InfixExpression__Group_1_0_4_1__0__Impl : ( ',' ) ; - public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3859:1: ( ( ',' ) ) - // InternalExpression.g:3860:1: ( ',' ) - { - // InternalExpression.g:3860:1: ( ',' ) - // InternalExpression.g:3861:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); - } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } - } + } - } + } + break; + case 9 : + // InternalExpression.g:3920:2: ( ruleXBasicForLoopExpression ) + { + // InternalExpression.g:3920:2: ( ruleXBasicForLoopExpression ) + // InternalExpression.g:3921:3: ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + pushFollow(FOLLOW_2); + ruleXBasicForLoopExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0__Impl" + } + break; + case 10 : + // InternalExpression.g:3926:2: ( ruleXWhileExpression ) + { + // InternalExpression.g:3926:2: ( ruleXWhileExpression ) + // InternalExpression.g:3927:3: ruleXWhileExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } + pushFollow(FOLLOW_2); + ruleXWhileExpression(); - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1" - // InternalExpression.g:3870:1: rule__InfixExpression__Group_1_0_4_1__1 : rule__InfixExpression__Group_1_0_4_1__1__Impl ; - public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3874:1: ( rule__InfixExpression__Group_1_0_4_1__1__Impl ) - // InternalExpression.g:3875:2: rule__InfixExpression__Group_1_0_4_1__1__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 11 : + // InternalExpression.g:3932:2: ( ruleXDoWhileExpression ) + { + // InternalExpression.g:3932:2: ( ruleXDoWhileExpression ) + // InternalExpression.g:3933:3: ruleXDoWhileExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } + pushFollow(FOLLOW_2); + ruleXDoWhileExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1" + } + break; + case 12 : + // InternalExpression.g:3938:2: ( ruleXThrowExpression ) + { + // InternalExpression.g:3938:2: ( ruleXThrowExpression ) + // InternalExpression.g:3939:3: ruleXThrowExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } + pushFollow(FOLLOW_2); + ruleXThrowExpression(); - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1__Impl" - // InternalExpression.g:3881:1: rule__InfixExpression__Group_1_0_4_1__1__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ; - public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3885:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ) - // InternalExpression.g:3886:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) - { - // InternalExpression.g:3886:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) - // InternalExpression.g:3887:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); - } - // InternalExpression.g:3888:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) - // InternalExpression.g:3888:3: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__ParamsAssignment_1_0_4_1_1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 13 : + // InternalExpression.g:3944:2: ( ruleXReturnExpression ) + { + // InternalExpression.g:3944:2: ( ruleXReturnExpression ) + // InternalExpression.g:3945:3: ruleXReturnExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + pushFollow(FOLLOW_2); + ruleXReturnExpression(); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } - } + } - } + } + break; + case 14 : + // InternalExpression.g:3950:2: ( ruleXTryCatchFinallyExpression ) + { + // InternalExpression.g:3950:2: ( ruleXTryCatchFinallyExpression ) + // InternalExpression.g:3951:3: ruleXTryCatchFinallyExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + pushFollow(FOLLOW_2); + ruleXTryCatchFinallyExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1__Impl" + } + break; + case 15 : + // InternalExpression.g:3956:2: ( ruleXParenthesizedExpression ) + { + // InternalExpression.g:3956:2: ( ruleXParenthesizedExpression ) + // InternalExpression.g:3957:3: ruleXParenthesizedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + pushFollow(FOLLOW_2); + ruleXParenthesizedExpression(); - // $ANTLR start "rule__InfixExpression__Group_1_1__0" - // InternalExpression.g:3897:1: rule__InfixExpression__Group_1_1__0 : rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ; - public final void rule__InfixExpression__Group_1_1__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3901:1: ( rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ) - // InternalExpression.g:3902:2: rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 - { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_1__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13180,147 +14502,235 @@ public final void rule__InfixExpression__Group_1_1__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__0" + // $ANTLR end "rule__XPrimaryExpression__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_1__0__Impl" - // InternalExpression.g:3909:1: rule__InfixExpression__Group_1_1__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XLiteral__Alternatives" + // InternalExpression.g:3966:1: rule__XLiteral__Alternatives : ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) ); + public final void rule__XLiteral__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3913:1: ( ( () ) ) - // InternalExpression.g:3914:1: ( () ) - { - // InternalExpression.g:3914:1: ( () ) - // InternalExpression.g:3915:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); - } - // InternalExpression.g:3916:2: () - // InternalExpression.g:3916:3: - { - } + // InternalExpression.g:3970:1: ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) ) + int alt36=7; + switch ( input.LA(1) ) { + case 87: + { + alt36=1; + } + break; + case 82: + { + alt36=2; + } + break; + case 36: + case 37: + { + alt36=3; + } + break; + case RULE_HEX: + case RULE_INT: + case RULE_DECIMAL: + { + alt36=4; + } + break; + case 92: + { + alt36=5; + } + break; + case RULE_STRING: + { + alt36=6; + } + break; + case 93: + { + alt36=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 36, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + throw nvae; } - } + switch (alt36) { + case 1 : + // InternalExpression.g:3971:2: ( ruleXCollectionLiteral ) + { + // InternalExpression.g:3971:2: ( ruleXCollectionLiteral ) + // InternalExpression.g:3972:3: ruleXCollectionLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXCollectionLiteral(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } - } + } - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExpression.g:3977:2: ( ( ruleXClosure ) ) + { + // InternalExpression.g:3977:2: ( ( ruleXClosure ) ) + // InternalExpression.g:3978:3: ( ruleXClosure ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } + // InternalExpression.g:3979:3: ( ruleXClosure ) + // InternalExpression.g:3979:4: ruleXClosure + { + pushFollow(FOLLOW_2); + ruleXClosure(); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_1__0__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__InfixExpression__Group_1_1__1" - // InternalExpression.g:3924:1: rule__InfixExpression__Group_1_1__1 : rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ; - public final void rule__InfixExpression__Group_1_1__1() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3928:1: ( rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ) - // InternalExpression.g:3929:2: rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 - { - pushFollow(FOLLOW_7); - rule__InfixExpression__Group_1_1__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__2(); - state._fsp--; - if (state.failed) return ; + } + break; + case 3 : + // InternalExpression.g:3983:2: ( ruleXBooleanLiteral ) + { + // InternalExpression.g:3983:2: ( ruleXBooleanLiteral ) + // InternalExpression.g:3984:3: ruleXBooleanLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleXBooleanLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_1__1" + } + break; + case 4 : + // InternalExpression.g:3989:2: ( ruleXNumberLiteral ) + { + // InternalExpression.g:3989:2: ( ruleXNumberLiteral ) + // InternalExpression.g:3990:3: ruleXNumberLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleXNumberLiteral(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } - // $ANTLR start "rule__InfixExpression__Group_1_1__1__Impl" - // InternalExpression.g:3936:1: rule__InfixExpression__Group_1_1__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_1__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3940:1: ( ( '.' ) ) - // InternalExpression.g:3941:1: ( '.' ) - { - // InternalExpression.g:3941:1: ( '.' ) - // InternalExpression.g:3942:2: '.' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); - } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); - } - } + } + break; + case 5 : + // InternalExpression.g:3995:2: ( ruleXNullLiteral ) + { + // InternalExpression.g:3995:2: ( ruleXNullLiteral ) + // InternalExpression.g:3996:3: ruleXNullLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleXNullLiteral(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 6 : + // InternalExpression.g:4001:2: ( ruleXStringLiteral ) + { + // InternalExpression.g:4001:2: ( ruleXStringLiteral ) + // InternalExpression.g:4002:3: ruleXStringLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleXStringLiteral(); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_1__1__Impl" + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + } - // $ANTLR start "rule__InfixExpression__Group_1_1__2" - // InternalExpression.g:3951:1: rule__InfixExpression__Group_1_1__2 : rule__InfixExpression__Group_1_1__2__Impl ; - public final void rule__InfixExpression__Group_1_1__2() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3955:1: ( rule__InfixExpression__Group_1_1__2__Impl ) - // InternalExpression.g:3956:2: rule__InfixExpression__Group_1_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__2__Impl(); + } + break; + case 7 : + // InternalExpression.g:4007:2: ( ruleXTypeLiteral ) + { + // InternalExpression.g:4007:2: ( ruleXTypeLiteral ) + // InternalExpression.g:4008:3: ruleXTypeLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + pushFollow(FOLLOW_2); + ruleXTypeLiteral(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13333,83 +14743,93 @@ public final void rule__InfixExpression__Group_1_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__2" + // $ANTLR end "rule__XLiteral__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_1__2__Impl" - // InternalExpression.g:3962:1: rule__InfixExpression__Group_1_1__2__Impl : ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ; - public final void rule__InfixExpression__Group_1_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XCollectionLiteral__Alternatives" + // InternalExpression.g:4017:1: rule__XCollectionLiteral__Alternatives : ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) ); + public final void rule__XCollectionLiteral__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3966:1: ( ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ) - // InternalExpression.g:3967:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) - { - // InternalExpression.g:3967:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) - // InternalExpression.g:3968:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); - } - // InternalExpression.g:3969:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) - // InternalExpression.g:3969:3: rule__InfixExpression__TypeAssignment_1_1_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__TypeAssignment_1_1_2(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:4021:1: ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) ) + int alt37=2; + int LA37_0 = input.LA(1); - } + if ( (LA37_0==87) ) { + int LA37_1 = input.LA(2); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); - } + if ( (LA37_1==74) ) { + alt37=1; + } + else if ( (LA37_1==82) ) { + alt37=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 37, 1, input); + throw nvae; + } } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 37, 0, input); - + throw nvae; } + switch (alt37) { + case 1 : + // InternalExpression.g:4022:2: ( ruleXSetLiteral ) + { + // InternalExpression.g:4022:2: ( ruleXSetLiteral ) + // InternalExpression.g:4023:3: ruleXSetLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXSetLiteral(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_1__2__Impl" + } + break; + case 2 : + // InternalExpression.g:4028:2: ( ruleXListLiteral ) + { + // InternalExpression.g:4028:2: ( ruleXListLiteral ) + // InternalExpression.g:4029:3: ruleXListLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXListLiteral(); - // $ANTLR start "rule__InfixExpression__Group_1_2__0" - // InternalExpression.g:3978:1: rule__InfixExpression__Group_1_2__0 : rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ; - public final void rule__InfixExpression__Group_1_2__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:3982:1: ( rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ) - // InternalExpression.g:3983:2: rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 - { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_2__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13422,73 +14842,80 @@ public final void rule__InfixExpression__Group_1_2__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__0" + // $ANTLR end "rule__XCollectionLiteral__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_2__0__Impl" - // InternalExpression.g:3990:1: rule__InfixExpression__Group_1_2__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XSwitchExpression__Alternatives_2" + // InternalExpression.g:4038:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) ); + public final void rule__XSwitchExpression__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:3994:1: ( ( () ) ) - // InternalExpression.g:3995:1: ( () ) - { - // InternalExpression.g:3995:1: ( () ) - // InternalExpression.g:3996:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); - } - // InternalExpression.g:3997:2: () - // InternalExpression.g:3997:3: - { - } + // InternalExpression.g:4042:1: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) ) + int alt38=2; + alt38 = dfa38.predict(input); + switch (alt38) { + case 1 : + // InternalExpression.g:4043:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + { + // InternalExpression.g:4043:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + // InternalExpression.g:4044:3: ( rule__XSwitchExpression__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + // InternalExpression.g:4045:3: ( rule__XSwitchExpression__Group_2_0__0 ) + // InternalExpression.g:4045:4: rule__XSwitchExpression__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } - } + } - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExpression.g:4049:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) ) + { + // InternalExpression.g:4049:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) ) + // InternalExpression.g:4050:3: ( rule__XSwitchExpression__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); + } + // InternalExpression.g:4051:3: ( rule__XSwitchExpression__Group_2_1__0 ) + // InternalExpression.g:4051:4: rule__XSwitchExpression__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__0(); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_2__0__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__InfixExpression__Group_1_2__1" - // InternalExpression.g:4005:1: rule__InfixExpression__Group_1_2__1 : rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ; - public final void rule__InfixExpression__Group_1_2__1() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4009:1: ( rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ) - // InternalExpression.g:4010:2: rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 - { - pushFollow(FOLLOW_37); - rule__InfixExpression__Group_1_2__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__2(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13501,73 +14928,94 @@ public final void rule__InfixExpression__Group_1_2__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__1" + // $ANTLR end "rule__XSwitchExpression__Alternatives_2" - // $ANTLR start "rule__InfixExpression__Group_1_2__1__Impl" - // InternalExpression.g:4017:1: rule__InfixExpression__Group_1_2__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XCasePart__Alternatives_3" + // InternalExpression.g:4059:1: rule__XCasePart__Alternatives_3 : ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) ); + public final void rule__XCasePart__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4021:1: ( ( '.' ) ) - // InternalExpression.g:4022:1: ( '.' ) - { - // InternalExpression.g:4022:1: ( '.' ) - // InternalExpression.g:4023:2: '.' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + // InternalExpression.g:4063:1: ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) ) + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==66) ) { + alt39=1; } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + else if ( (LA39_0==78) ) { + alt39=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 39, 0, input); + throw nvae; } + switch (alt39) { + case 1 : + // InternalExpression.g:4064:2: ( ( rule__XCasePart__Group_3_0__0 ) ) + { + // InternalExpression.g:4064:2: ( ( rule__XCasePart__Group_3_0__0 ) ) + // InternalExpression.g:4065:3: ( rule__XCasePart__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup_3_0()); + } + // InternalExpression.g:4066:3: ( rule__XCasePart__Group_3_0__0 ) + // InternalExpression.g:4066:4: rule__XCasePart__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getGroup_3_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_2__1__Impl" + } + break; + case 2 : + // InternalExpression.g:4070:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) + { + // InternalExpression.g:4070:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) + // InternalExpression.g:4071:3: ( rule__XCasePart__FallThroughAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); + } + // InternalExpression.g:4072:3: ( rule__XCasePart__FallThroughAssignment_3_1 ) + // InternalExpression.g:4072:4: rule__XCasePart__FallThroughAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__FallThroughAssignment_3_1(); - // $ANTLR start "rule__InfixExpression__Group_1_2__2" - // InternalExpression.g:4032:1: rule__InfixExpression__Group_1_2__2 : rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ; - public final void rule__InfixExpression__Group_1_2__2() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4036:1: ( rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ) - // InternalExpression.g:4037:2: rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 - { - pushFollow(FOLLOW_33); - rule__InfixExpression__Group_1_2__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__3(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -13580,83 +15028,82 @@ public final void rule__InfixExpression__Group_1_2__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__2" + // $ANTLR end "rule__XCasePart__Alternatives_3" - // $ANTLR start "rule__InfixExpression__Group_1_2__2__Impl" - // InternalExpression.g:4044:1: rule__InfixExpression__Group_1_2__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ; - public final void rule__InfixExpression__Group_1_2__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XExpressionOrVarDeclaration__Alternatives" + // InternalExpression.g:4080:1: rule__XExpressionOrVarDeclaration__Alternatives : ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) ); + public final void rule__XExpressionOrVarDeclaration__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4048:1: ( ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ) - // InternalExpression.g:4049:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) - { - // InternalExpression.g:4049:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) - // InternalExpression.g:4050:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); - } - // InternalExpression.g:4051:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) - // InternalExpression.g:4051:3: rule__InfixExpression__NameAssignment_1_2_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_2_2(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExpression.g:4084:1: ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) ) + int alt40=2; + int LA40_0 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + if ( (LA40_0==59||LA40_0==104) ) { + alt40=1; } - + else if ( ((LA40_0>=RULE_ID && LA40_0<=RULE_DECIMAL)||LA40_0==RULE_STRING||(LA40_0>=22 && LA40_0<=24)||LA40_0==27||(LA40_0>=36 && LA40_0<=37)||(LA40_0>=60 && LA40_0<=64)||LA40_0==67||LA40_0==70||(LA40_0>=73 && LA40_0<=74)||(LA40_0>=81 && LA40_0<=82)||LA40_0==87||(LA40_0>=89 && LA40_0<=96)||LA40_0==98) ) { + alt40=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); - + throw nvae; } + switch (alt40) { + case 1 : + // InternalExpression.g:4085:2: ( ruleXVariableDeclaration ) + { + // InternalExpression.g:4085:2: ( ruleXVariableDeclaration ) + // InternalExpression.g:4086:3: ruleXVariableDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXVariableDeclaration(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_2__2__Impl" + } + break; + case 2 : + // InternalExpression.g:4091:2: ( ruleXExpression ) + { + // InternalExpression.g:4091:2: ( ruleXExpression ) + // InternalExpression.g:4092:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); - // $ANTLR start "rule__InfixExpression__Group_1_2__3" - // InternalExpression.g:4059:1: rule__InfixExpression__Group_1_2__3 : rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ; - public final void rule__InfixExpression__Group_1_2__3() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4063:1: ( rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ) - // InternalExpression.g:4064:2: rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 - { - pushFollow(FOLLOW_7); - rule__InfixExpression__Group_1_2__3__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__4(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13669,73 +15116,84 @@ public final void rule__InfixExpression__Group_1_2__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__3" + // $ANTLR end "rule__XExpressionOrVarDeclaration__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_2__3__Impl" - // InternalExpression.g:4071:1: rule__InfixExpression__Group_1_2__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_2__3__Impl() throws RecognitionException { + // $ANTLR start "rule__XVariableDeclaration__Alternatives_1" + // InternalExpression.g:4101:1: rule__XVariableDeclaration__Alternatives_1 : ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) ); + public final void rule__XVariableDeclaration__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4075:1: ( ( '(' ) ) - // InternalExpression.g:4076:1: ( '(' ) - { - // InternalExpression.g:4076:1: ( '(' ) - // InternalExpression.g:4077:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + // InternalExpression.g:4105:1: ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) ) + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==104) ) { + alt41=1; } - match(input,39,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + else if ( (LA41_0==59) ) { + alt41=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 41, 0, input); + throw nvae; } + switch (alt41) { + case 1 : + // InternalExpression.g:4106:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) + { + // InternalExpression.g:4106:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) + // InternalExpression.g:4107:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); + } + // InternalExpression.g:4108:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) + // InternalExpression.g:4108:4: rule__XVariableDeclaration__WriteableAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__WriteableAssignment_1_0(); + state._fsp--; + if (state.failed) return ; - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_2__3__Impl" + } - // $ANTLR start "rule__InfixExpression__Group_1_2__4" - // InternalExpression.g:4086:1: rule__InfixExpression__Group_1_2__4 : rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ; - public final void rule__InfixExpression__Group_1_2__4() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:4112:2: ( 'val' ) + { + // InternalExpression.g:4112:2: ( 'val' ) + // InternalExpression.g:4113:3: 'val' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + match(input,59,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4090:1: ( rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ) - // InternalExpression.g:4091:2: rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 - { - pushFollow(FOLLOW_8); - rule__InfixExpression__Group_1_2__4__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__5(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13748,78 +15206,108 @@ public final void rule__InfixExpression__Group_1_2__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__4" + // $ANTLR end "rule__XVariableDeclaration__Alternatives_1" - // $ANTLR start "rule__InfixExpression__Group_1_2__4__Impl" - // InternalExpression.g:4098:1: rule__InfixExpression__Group_1_2__4__Impl : ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ; - public final void rule__InfixExpression__Group_1_2__4__Impl() throws RecognitionException { + // $ANTLR start "rule__XVariableDeclaration__Alternatives_2" + // InternalExpression.g:4122:1: rule__XVariableDeclaration__Alternatives_2 : ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) ); + public final void rule__XVariableDeclaration__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4102:1: ( ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ) - // InternalExpression.g:4103:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) - { - // InternalExpression.g:4103:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) - // InternalExpression.g:4104:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); - } - // InternalExpression.g:4105:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) - // InternalExpression.g:4105:3: rule__InfixExpression__TypeAssignment_1_2_4 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__TypeAssignment_1_2_4(); + // InternalExpression.g:4126:1: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) ) + int alt42=2; + int LA42_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA42_0==RULE_ID) ) { + int LA42_1 = input.LA(2); - } + if ( (synpred111_InternalExpression()) ) { + alt42=1; + } + else if ( (true) ) { + alt42=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 42, 1, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + throw nvae; + } } + else if ( (LA42_0==51||LA42_0==67) ) { + alt42=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 42, 0, input); + throw nvae; } + switch (alt42) { + case 1 : + // InternalExpression.g:4127:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + { + // InternalExpression.g:4127:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + // InternalExpression.g:4128:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + // InternalExpression.g:4129:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + // InternalExpression.g:4129:4: rule__XVariableDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_2__4__Impl" + } + break; + case 2 : + // InternalExpression.g:4133:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) + { + // InternalExpression.g:4133:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) + // InternalExpression.g:4134:3: ( rule__XVariableDeclaration__NameAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); + } + // InternalExpression.g:4135:3: ( rule__XVariableDeclaration__NameAssignment_2_1 ) + // InternalExpression.g:4135:4: rule__XVariableDeclaration__NameAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__NameAssignment_2_1(); - // $ANTLR start "rule__InfixExpression__Group_1_2__5" - // InternalExpression.g:4113:1: rule__InfixExpression__Group_1_2__5 : rule__InfixExpression__Group_1_2__5__Impl ; - public final void rule__InfixExpression__Group_1_2__5() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4117:1: ( rule__InfixExpression__Group_1_2__5__Impl ) - // InternalExpression.g:4118:2: rule__InfixExpression__Group_1_2__5__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__5__Impl(); + } - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13832,73 +15320,80 @@ public final void rule__InfixExpression__Group_1_2__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__5" + // $ANTLR end "rule__XVariableDeclaration__Alternatives_2" - // $ANTLR start "rule__InfixExpression__Group_1_2__5__Impl" - // InternalExpression.g:4124:1: rule__InfixExpression__Group_1_2__5__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_2__5__Impl() throws RecognitionException { + // $ANTLR start "rule__XFeatureCall__Alternatives_3_1" + // InternalExpression.g:4143:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) ); + public final void rule__XFeatureCall__Alternatives_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4128:1: ( ( ')' ) ) - // InternalExpression.g:4129:1: ( ')' ) - { - // InternalExpression.g:4129:1: ( ')' ) - // InternalExpression.g:4130:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); - } - match(input,40,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); - } + // InternalExpression.g:4147:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) ) + int alt43=2; + alt43 = dfa43.predict(input); + switch (alt43) { + case 1 : + // InternalExpression.g:4148:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + { + // InternalExpression.g:4148:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + // InternalExpression.g:4149:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + // InternalExpression.g:4150:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + // InternalExpression.g:4150:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0(); - } + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_2__5__Impl" + } + break; + case 2 : + // InternalExpression.g:4154:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) + { + // InternalExpression.g:4154:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) + // InternalExpression.g:4155:3: ( rule__XFeatureCall__Group_3_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); + } + // InternalExpression.g:4156:3: ( rule__XFeatureCall__Group_3_1_1__0 ) + // InternalExpression.g:4156:4: rule__XFeatureCall__Group_3_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__0(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__InfixExpression__Group_1_3__0" - // InternalExpression.g:4140:1: rule__InfixExpression__Group_1_3__0 : rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ; - public final void rule__InfixExpression__Group_1_3__0() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4144:1: ( rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ) - // InternalExpression.g:4145:2: rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 - { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_3__0__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13911,73 +15406,154 @@ public final void rule__InfixExpression__Group_1_3__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__0" + // $ANTLR end "rule__XFeatureCall__Alternatives_3_1" - // $ANTLR start "rule__InfixExpression__Group_1_3__0__Impl" - // InternalExpression.g:4152:1: rule__InfixExpression__Group_1_3__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__FeatureCallID__Alternatives" + // InternalExpression.g:4164:1: rule__FeatureCallID__Alternatives : ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) ); + public final void rule__FeatureCallID__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4156:1: ( ( () ) ) - // InternalExpression.g:4157:1: ( () ) - { - // InternalExpression.g:4157:1: ( () ) - // InternalExpression.g:4158:2: () - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); - } - // InternalExpression.g:4159:2: () - // InternalExpression.g:4159:3: - { - } + // InternalExpression.g:4168:1: ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) ) + int alt44=5; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt44=1; + } + break; + case 60: + { + alt44=2; + } + break; + case 61: + { + alt44=3; + } + break; + case 62: + { + alt44=4; + } + break; + case 63: + { + alt44=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 44, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + throw nvae; } - } + switch (alt44) { + case 1 : + // InternalExpression.g:4169:2: ( ruleValidID ) + { + // InternalExpression.g:4169:2: ( ruleValidID ) + // InternalExpression.g:4170:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + } - } - } - finally { + } + break; + case 2 : + // InternalExpression.g:4175:2: ( 'extends' ) + { + // InternalExpression.g:4175:2: ( 'extends' ) + // InternalExpression.g:4176:3: 'extends' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + match(input,60,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_3__0__Impl" + } + break; + case 3 : + // InternalExpression.g:4181:2: ( 'static' ) + { + // InternalExpression.g:4181:2: ( 'static' ) + // InternalExpression.g:4182:3: 'static' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + match(input,61,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } - // $ANTLR start "rule__InfixExpression__Group_1_3__1" - // InternalExpression.g:4167:1: rule__InfixExpression__Group_1_3__1 : rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ; - public final void rule__InfixExpression__Group_1_3__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4171:1: ( rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ) - // InternalExpression.g:4172:2: rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 - { - pushFollow(FOLLOW_38); - rule__InfixExpression__Group_1_3__1__Impl(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__2(); + } + break; + case 4 : + // InternalExpression.g:4187:2: ( 'import' ) + { + // InternalExpression.g:4187:2: ( 'import' ) + // InternalExpression.g:4188:3: 'import' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + match(input,62,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } - state._fsp--; - if (state.failed) return ; + } - } + } + break; + case 5 : + // InternalExpression.g:4193:2: ( 'extension' ) + { + // InternalExpression.g:4193:2: ( 'extension' ) + // InternalExpression.g:4194:3: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -13990,73 +15566,78 @@ public final void rule__InfixExpression__Group_1_3__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__1" + // $ANTLR end "rule__FeatureCallID__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_3__1__Impl" - // InternalExpression.g:4179:1: rule__InfixExpression__Group_1_3__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IdOrSuper__Alternatives" + // InternalExpression.g:4203:1: rule__IdOrSuper__Alternatives : ( ( ruleFeatureCallID ) | ( 'super' ) ); + public final void rule__IdOrSuper__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4183:1: ( ( '.' ) ) - // InternalExpression.g:4184:1: ( '.' ) - { - // InternalExpression.g:4184:1: ( '.' ) - // InternalExpression.g:4185:2: '.' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); - } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); - } + // InternalExpression.g:4207:1: ( ( ruleFeatureCallID ) | ( 'super' ) ) + int alt45=2; + int LA45_0 = input.LA(1); + if ( (LA45_0==RULE_ID||(LA45_0>=60 && LA45_0<=63)) ) { + alt45=1; } - - + else if ( (LA45_0==64) ) { + alt45=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 45, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + throw nvae; + } + switch (alt45) { + case 1 : + // InternalExpression.g:4208:2: ( ruleFeatureCallID ) + { + // InternalExpression.g:4208:2: ( ruleFeatureCallID ) + // InternalExpression.g:4209:3: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_3__1__Impl" + } - // $ANTLR start "rule__InfixExpression__Group_1_3__2" - // InternalExpression.g:4194:1: rule__InfixExpression__Group_1_3__2 : rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ; - public final void rule__InfixExpression__Group_1_3__2() throws RecognitionException { + } + break; + case 2 : + // InternalExpression.g:4214:2: ( 'super' ) + { + // InternalExpression.g:4214:2: ( 'super' ) + // InternalExpression.g:4215:3: 'super' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + match(input,64,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4198:1: ( rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ) - // InternalExpression.g:4199:2: rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 - { - pushFollow(FOLLOW_33); - rule__InfixExpression__Group_1_3__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__3(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14069,83 +15650,80 @@ public final void rule__InfixExpression__Group_1_3__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__2" + // $ANTLR end "rule__IdOrSuper__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_3__2__Impl" - // InternalExpression.g:4206:1: rule__InfixExpression__Group_1_3__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ; - public final void rule__InfixExpression__Group_1_3__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XConstructorCall__Alternatives_4_1" + // InternalExpression.g:4224:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) ); + public final void rule__XConstructorCall__Alternatives_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4210:1: ( ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ) - // InternalExpression.g:4211:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) - { - // InternalExpression.g:4211:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) - // InternalExpression.g:4212:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); - } - // InternalExpression.g:4213:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) - // InternalExpression.g:4213:3: rule__InfixExpression__NameAssignment_1_3_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_3_2(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalExpression.g:4228:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) ) + int alt46=2; + alt46 = dfa46.predict(input); + switch (alt46) { + case 1 : + // InternalExpression.g:4229:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + { + // InternalExpression.g:4229:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + // InternalExpression.g:4230:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + // InternalExpression.g:4231:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + // InternalExpression.g:4231:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExpression.g:4235:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) + { + // InternalExpression.g:4235:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) + // InternalExpression.g:4236:3: ( rule__XConstructorCall__Group_4_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); + } + // InternalExpression.g:4237:3: ( rule__XConstructorCall__Group_4_1_1__0 ) + // InternalExpression.g:4237:4: rule__XConstructorCall__Group_4_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__0(); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_3__2__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__InfixExpression__Group_1_3__3" - // InternalExpression.g:4221:1: rule__InfixExpression__Group_1_3__3 : rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ; - public final void rule__InfixExpression__Group_1_3__3() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4225:1: ( rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ) - // InternalExpression.g:4226:2: rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 - { - pushFollow(FOLLOW_5); - rule__InfixExpression__Group_1_3__3__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__4(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14158,73 +15736,84 @@ public final void rule__InfixExpression__Group_1_3__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__3" + // $ANTLR end "rule__XConstructorCall__Alternatives_4_1" - // $ANTLR start "rule__InfixExpression__Group_1_3__3__Impl" - // InternalExpression.g:4233:1: rule__InfixExpression__Group_1_3__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_3__3__Impl() throws RecognitionException { + // $ANTLR start "rule__XBooleanLiteral__Alternatives_1" + // InternalExpression.g:4245:1: rule__XBooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) ); + public final void rule__XBooleanLiteral__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4237:1: ( ( '(' ) ) - // InternalExpression.g:4238:1: ( '(' ) - { - // InternalExpression.g:4238:1: ( '(' ) - // InternalExpression.g:4239:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + // InternalExpression.g:4249:1: ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) ) + int alt47=2; + int LA47_0 = input.LA(1); + + if ( (LA47_0==37) ) { + alt47=1; } - match(input,39,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + else if ( (LA47_0==36) ) { + alt47=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 47, 0, input); + throw nvae; } + switch (alt47) { + case 1 : + // InternalExpression.g:4250:2: ( 'false' ) + { + // InternalExpression.g:4250:2: ( 'false' ) + // InternalExpression.g:4251:3: 'false' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + } - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalExpression.g:4256:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) + { + // InternalExpression.g:4256:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) + // InternalExpression.g:4257:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); + } + // InternalExpression.g:4258:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) + // InternalExpression.g:4258:4: rule__XBooleanLiteral__IsTrueAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__IsTrueAssignment_1_1(); - } - return ; - } - // $ANTLR end "rule__InfixExpression__Group_1_3__3__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__InfixExpression__Group_1_3__4" - // InternalExpression.g:4248:1: rule__InfixExpression__Group_1_3__4 : rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ; - public final void rule__InfixExpression__Group_1_3__4() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:4252:1: ( rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ) - // InternalExpression.g:4253:2: rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 - { - pushFollow(FOLLOW_5); - rule__InfixExpression__Group_1_3__4__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__5(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14237,61 +15826,95 @@ public final void rule__InfixExpression__Group_1_3__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__4" + // $ANTLR end "rule__XBooleanLiteral__Alternatives_1" - // $ANTLR start "rule__InfixExpression__Group_1_3__4__Impl" - // InternalExpression.g:4260:1: rule__InfixExpression__Group_1_3__4__Impl : ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ; - public final void rule__InfixExpression__Group_1_3__4__Impl() throws RecognitionException { + // $ANTLR start "rule__XTryCatchFinallyExpression__Alternatives_3" + // InternalExpression.g:4266:1: rule__XTryCatchFinallyExpression__Alternatives_3 : ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) ); + public final void rule__XTryCatchFinallyExpression__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4264:1: ( ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ) - // InternalExpression.g:4265:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) - { - // InternalExpression.g:4265:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) - // InternalExpression.g:4266:2: ( rule__InfixExpression__Group_1_3_4__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); - } - // InternalExpression.g:4267:2: ( rule__InfixExpression__Group_1_3_4__0 )? - int alt31=2; - int LA31_0 = input.LA(1); + // InternalExpression.g:4270:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) ) + int alt48=2; + int LA48_0 = input.LA(1); - if ( (LA31_0==RULE_ID) ) { - int LA31_1 = input.LA(2); + if ( (LA48_0==99) ) { + alt48=1; + } + else if ( (LA48_0==97) ) { + alt48=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 48, 0, input); - if ( (LA31_1==53) ) { - alt31=1; - } + throw nvae; } - switch (alt31) { + switch (alt48) { case 1 : - // InternalExpression.g:4267:3: rule__InfixExpression__Group_1_3_4__0 + // InternalExpression.g:4271:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) + { + // InternalExpression.g:4271:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) + // InternalExpression.g:4272:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); + } + // InternalExpression.g:4273:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) + // InternalExpression.g:4273:4: rule__XTryCatchFinallyExpression__Group_3_0__0 { pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__0(); + rule__XTryCatchFinallyExpression__Group_3_0__0(); state._fsp--; if (state.failed) return ; } - break; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); - } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); + } + } - } - } + } + break; + case 2 : + // InternalExpression.g:4277:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) + { + // InternalExpression.g:4277:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) + // InternalExpression.g:4278:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); + } + // InternalExpression.g:4279:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) + // InternalExpression.g:4279:4: rule__XTryCatchFinallyExpression__Group_3_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); + } + + } + + + } + break; + + } + } catch (RecognitionException re) { reportError(re); recover(input,re); @@ -14303,32 +15926,84 @@ public final void rule__InfixExpression__Group_1_3__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__4__Impl" + // $ANTLR end "rule__XTryCatchFinallyExpression__Alternatives_3" - // $ANTLR start "rule__InfixExpression__Group_1_3__5" - // InternalExpression.g:4275:1: rule__InfixExpression__Group_1_3__5 : rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ; - public final void rule__InfixExpression__Group_1_3__5() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives" + // InternalExpression.g:4287:1: rule__Number__Alternatives : ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) ); + public final void rule__Number__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4279:1: ( rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ) - // InternalExpression.g:4280:2: rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 - { - pushFollow(FOLLOW_8); - rule__InfixExpression__Group_1_3__5__Impl(); + // InternalExpression.g:4291:1: ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) ) + int alt49=2; + int LA49_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__6(); - - state._fsp--; - if (state.failed) return ; + if ( (LA49_0==RULE_HEX) ) { + alt49=1; + } + else if ( ((LA49_0>=RULE_INT && LA49_0<=RULE_DECIMAL)) ) { + alt49=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 49, 0, input); + throw nvae; } + switch (alt49) { + case 1 : + // InternalExpression.g:4292:2: ( RULE_HEX ) + { + // InternalExpression.g:4292:2: ( RULE_HEX ) + // InternalExpression.g:4293:3: RULE_HEX + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + match(input,RULE_HEX,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4298:2: ( ( rule__Number__Group_1__0 ) ) + { + // InternalExpression.g:4298:2: ( ( rule__Number__Group_1__0 ) ) + // InternalExpression.g:4299:3: ( rule__Number__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getGroup_1()); + } + // InternalExpression.g:4300:3: ( rule__Number__Group_1__0 ) + // InternalExpression.g:4300:4: rule__Number__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__Number__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getGroup_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14341,45 +16016,74 @@ public final void rule__InfixExpression__Group_1_3__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__5" + // $ANTLR end "rule__Number__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_3__5__Impl" - // InternalExpression.g:4287:1: rule__InfixExpression__Group_1_3__5__Impl : ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ; - public final void rule__InfixExpression__Group_1_3__5__Impl() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives_1_0" + // InternalExpression.g:4308:1: rule__Number__Alternatives_1_0 : ( ( RULE_INT ) | ( RULE_DECIMAL ) ); + public final void rule__Number__Alternatives_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4291:1: ( ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ) - // InternalExpression.g:4292:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) - { - // InternalExpression.g:4292:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) - // InternalExpression.g:4293:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); - } - // InternalExpression.g:4294:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) - // InternalExpression.g:4294:3: rule__InfixExpression__ExpAssignment_1_3_5 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__ExpAssignment_1_3_5(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:4312:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) ) + int alt50=2; + int LA50_0 = input.LA(1); + if ( (LA50_0==RULE_INT) ) { + alt50=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + else if ( (LA50_0==RULE_DECIMAL) ) { + alt50=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 50, 0, input); + throw nvae; } + switch (alt50) { + case 1 : + // InternalExpression.g:4313:2: ( RULE_INT ) + { + // InternalExpression.g:4313:2: ( RULE_INT ) + // InternalExpression.g:4314:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + } - } + } + break; + case 2 : + // InternalExpression.g:4319:2: ( RULE_DECIMAL ) + { + // InternalExpression.g:4319:2: ( RULE_DECIMAL ) + // InternalExpression.g:4320:3: RULE_DECIMAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14392,27 +16096,74 @@ public final void rule__InfixExpression__Group_1_3__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__5__Impl" + // $ANTLR end "rule__Number__Alternatives_1_0" - // $ANTLR start "rule__InfixExpression__Group_1_3__6" - // InternalExpression.g:4302:1: rule__InfixExpression__Group_1_3__6 : rule__InfixExpression__Group_1_3__6__Impl ; - public final void rule__InfixExpression__Group_1_3__6() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives_1_1_1" + // InternalExpression.g:4329:1: rule__Number__Alternatives_1_1_1 : ( ( RULE_INT ) | ( RULE_DECIMAL ) ); + public final void rule__Number__Alternatives_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4306:1: ( rule__InfixExpression__Group_1_3__6__Impl ) - // InternalExpression.g:4307:2: rule__InfixExpression__Group_1_3__6__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__6__Impl(); + // InternalExpression.g:4333:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) ) + int alt51=2; + int LA51_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA51_0==RULE_INT) ) { + alt51=1; + } + else if ( (LA51_0==RULE_DECIMAL) ) { + alt51=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 51, 0, input); + throw nvae; } + switch (alt51) { + case 1 : + // InternalExpression.g:4334:2: ( RULE_INT ) + { + // InternalExpression.g:4334:2: ( RULE_INT ) + // InternalExpression.g:4335:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4340:2: ( RULE_DECIMAL ) + { + // InternalExpression.g:4340:2: ( RULE_DECIMAL ) + // InternalExpression.g:4341:3: RULE_DECIMAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14425,35 +16176,88 @@ public final void rule__InfixExpression__Group_1_3__6() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__6" + // $ANTLR end "rule__Number__Alternatives_1_1_1" - // $ANTLR start "rule__InfixExpression__Group_1_3__6__Impl" - // InternalExpression.g:4313:1: rule__InfixExpression__Group_1_3__6__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_3__6__Impl() throws RecognitionException { + // $ANTLR start "rule__JvmTypeReference__Alternatives" + // InternalExpression.g:4350:1: rule__JvmTypeReference__Alternatives : ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ); + public final void rule__JvmTypeReference__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4317:1: ( ( ')' ) ) - // InternalExpression.g:4318:1: ( ')' ) - { - // InternalExpression.g:4318:1: ( ')' ) - // InternalExpression.g:4319:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + // InternalExpression.g:4354:1: ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ) + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==RULE_ID) ) { + alt52=1; } - match(input,40,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + else if ( (LA52_0==51||LA52_0==67) ) { + alt52=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 52, 0, input); + throw nvae; } + switch (alt52) { + case 1 : + // InternalExpression.g:4355:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) + { + // InternalExpression.g:4355:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) + // InternalExpression.g:4356:3: ( rule__JvmTypeReference__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); + } + // InternalExpression.g:4357:3: ( rule__JvmTypeReference__Group_0__0 ) + // InternalExpression.g:4357:4: rule__JvmTypeReference__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0__0(); + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4361:2: ( ruleXFunctionTypeRef ) + { + // InternalExpression.g:4361:2: ( ruleXFunctionTypeRef ) + // InternalExpression.g:4362:3: ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXFunctionTypeRef(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14466,32 +16270,82 @@ public final void rule__InfixExpression__Group_1_3__6__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__6__Impl" + // $ANTLR end "rule__JvmTypeReference__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__0" - // InternalExpression.g:4329:1: rule__InfixExpression__Group_1_3_4__0 : rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ; - public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionException { + // $ANTLR start "rule__JvmArgumentTypeReference__Alternatives" + // InternalExpression.g:4371:1: rule__JvmArgumentTypeReference__Alternatives : ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ); + public final void rule__JvmArgumentTypeReference__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4333:1: ( rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ) - // InternalExpression.g:4334:2: rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 - { - pushFollow(FOLLOW_39); - rule__InfixExpression__Group_1_3_4__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__1(); + // InternalExpression.g:4375:1: ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ) + int alt53=2; + int LA53_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA53_0==RULE_ID||LA53_0==51||LA53_0==67) ) { + alt53=1; + } + else if ( (LA53_0==69) ) { + alt53=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 53, 0, input); + throw nvae; } + switch (alt53) { + case 1 : + // InternalExpression.g:4376:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:4376:2: ( ruleJvmTypeReference ) + // InternalExpression.g:4377:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4382:2: ( ruleJvmWildcardTypeReference ) + { + // InternalExpression.g:4382:2: ( ruleJvmWildcardTypeReference ) + // InternalExpression.g:4383:3: ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14504,45 +16358,94 @@ public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__0" + // $ANTLR end "rule__JvmArgumentTypeReference__Alternatives" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__0__Impl" - // InternalExpression.g:4341:1: rule__InfixExpression__Group_1_3_4__0__Impl : ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ; - public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__JvmWildcardTypeReference__Alternatives_2" + // InternalExpression.g:4392:1: rule__JvmWildcardTypeReference__Alternatives_2 : ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ); + public final void rule__JvmWildcardTypeReference__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4345:1: ( ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ) - // InternalExpression.g:4346:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) - { - // InternalExpression.g:4346:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) - // InternalExpression.g:4347:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); - } - // InternalExpression.g:4348:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) - // InternalExpression.g:4348:3: rule__InfixExpression__VarAssignment_1_3_4_0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__VarAssignment_1_3_4_0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:4396:1: ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ) + int alt54=2; + int LA54_0 = input.LA(1); + if ( (LA54_0==60) ) { + alt54=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + else if ( (LA54_0==64) ) { + alt54=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 54, 0, input); + throw nvae; } + switch (alt54) { + case 1 : + // InternalExpression.g:4397:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) + { + // InternalExpression.g:4397:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) + // InternalExpression.g:4398:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); + } + // InternalExpression.g:4399:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) + // InternalExpression.g:4399:4: rule__JvmWildcardTypeReference__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4403:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) + { + // InternalExpression.g:4403:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) + // InternalExpression.g:4404:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); + } + // InternalExpression.g:4405:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) + // InternalExpression.g:4405:4: rule__JvmWildcardTypeReference__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14555,27 +16458,109 @@ public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__0__Impl" + // $ANTLR end "rule__JvmWildcardTypeReference__Alternatives_2" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__1" - // InternalExpression.g:4356:1: rule__InfixExpression__Group_1_3_4__1 : rule__InfixExpression__Group_1_3_4__1__Impl ; - public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionException { + // $ANTLR start "rule__XImportDeclaration__Alternatives_1" + // InternalExpression.g:4413:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ); + public final void rule__XImportDeclaration__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4360:1: ( rule__InfixExpression__Group_1_3_4__1__Impl ) - // InternalExpression.g:4361:2: rule__InfixExpression__Group_1_3_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__1__Impl(); + // InternalExpression.g:4417:1: ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ) + int alt55=3; + alt55 = dfa55.predict(input); + switch (alt55) { + case 1 : + // InternalExpression.g:4418:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) + { + // InternalExpression.g:4418:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) + // InternalExpression.g:4419:3: ( rule__XImportDeclaration__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); + } + // InternalExpression.g:4420:3: ( rule__XImportDeclaration__Group_1_0__0 ) + // InternalExpression.g:4420:4: rule__XImportDeclaration__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4424:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) + { + // InternalExpression.g:4424:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) + // InternalExpression.g:4425:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); + } + // InternalExpression.g:4426:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) + // InternalExpression.g:4426:4: rule__XImportDeclaration__ImportedTypeAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedTypeAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); + } + + } + + + } + break; + case 3 : + // InternalExpression.g:4430:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) + { + // InternalExpression.g:4430:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) + // InternalExpression.g:4431:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); + } + // InternalExpression.g:4432:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) + // InternalExpression.g:4432:4: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedNamespaceAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14588,35 +16573,94 @@ public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__1" + // $ANTLR end "rule__XImportDeclaration__Alternatives_1" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__1__Impl" - // InternalExpression.g:4367:1: rule__InfixExpression__Group_1_3_4__1__Impl : ( '|' ) ; - public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XImportDeclaration__Alternatives_1_0_3" + // InternalExpression.g:4440:1: rule__XImportDeclaration__Alternatives_1_0_3 : ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ); + public final void rule__XImportDeclaration__Alternatives_1_0_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4371:1: ( ( '|' ) ) - // InternalExpression.g:4372:1: ( '|' ) - { - // InternalExpression.g:4372:1: ( '|' ) - // InternalExpression.g:4373:2: '|' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + // InternalExpression.g:4444:1: ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ) + int alt56=2; + int LA56_0 = input.LA(1); + + if ( (LA56_0==25) ) { + alt56=1; } - match(input,53,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + else if ( (LA56_0==RULE_ID) ) { + alt56=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 56, 0, input); + throw nvae; } + switch (alt56) { + case 1 : + // InternalExpression.g:4445:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) + { + // InternalExpression.g:4445:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) + // InternalExpression.g:4446:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); + } + // InternalExpression.g:4447:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) + // InternalExpression.g:4447:4: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__WildcardAssignment_1_0_3_0(); + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); + } + + } + + + } + break; + case 2 : + // InternalExpression.g:4451:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) + { + // InternalExpression.g:4451:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) + // InternalExpression.g:4452:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); + } + // InternalExpression.g:4453:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) + // InternalExpression.g:4453:4: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__MemberNameAssignment_1_0_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14629,26 +16673,26 @@ public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__1__Impl" + // $ANTLR end "rule__XImportDeclaration__Alternatives_1_0_3" - // $ANTLR start "rule__ParanthesizedExpression__Group__0" - // InternalExpression.g:4383:1: rule__ParanthesizedExpression__Group__0 : rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ; - public final void rule__ParanthesizedExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__0" + // InternalExpression.g:4461:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ; + public final void rule__LetExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4387:1: ( rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ) - // InternalExpression.g:4388:2: rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 + // InternalExpression.g:4465:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ) + // InternalExpression.g:4466:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 { - pushFollow(FOLLOW_5); - rule__ParanthesizedExpression__Group__0__Impl(); + pushFollow(FOLLOW_4); + rule__LetExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__1(); + rule__LetExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -14667,28 +16711,28 @@ public final void rule__ParanthesizedExpression__Group__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__0" + // $ANTLR end "rule__LetExpression__Group__0" - // $ANTLR start "rule__ParanthesizedExpression__Group__0__Impl" - // InternalExpression.g:4395:1: rule__ParanthesizedExpression__Group__0__Impl : ( '(' ) ; - public final void rule__ParanthesizedExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__0__Impl" + // InternalExpression.g:4473:1: rule__LetExpression__Group__0__Impl : ( 'let' ) ; + public final void rule__LetExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4399:1: ( ( '(' ) ) - // InternalExpression.g:4400:1: ( '(' ) + // InternalExpression.g:4477:1: ( ( 'let' ) ) + // InternalExpression.g:4478:1: ( 'let' ) { - // InternalExpression.g:4400:1: ( '(' ) - // InternalExpression.g:4401:2: '(' + // InternalExpression.g:4478:1: ( 'let' ) + // InternalExpression.g:4479:2: 'let' { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } - match(input,39,FOLLOW_2); if (state.failed) return ; + match(input,65,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } } @@ -14708,26 +16752,26 @@ public final void rule__ParanthesizedExpression__Group__0__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__0__Impl" + // $ANTLR end "rule__LetExpression__Group__0__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__1" - // InternalExpression.g:4410:1: rule__ParanthesizedExpression__Group__1 : rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ; - public final void rule__ParanthesizedExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__1" + // InternalExpression.g:4488:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ; + public final void rule__LetExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4414:1: ( rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ) - // InternalExpression.g:4415:2: rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 + // InternalExpression.g:4492:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ) + // InternalExpression.g:4493:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 { - pushFollow(FOLLOW_8); - rule__ParanthesizedExpression__Group__1__Impl(); + pushFollow(FOLLOW_5); + rule__LetExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__2(); + rule__LetExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -14746,37 +16790,43 @@ public final void rule__ParanthesizedExpression__Group__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__1" + // $ANTLR end "rule__LetExpression__Group__1" - // $ANTLR start "rule__ParanthesizedExpression__Group__1__Impl" - // InternalExpression.g:4422:1: rule__ParanthesizedExpression__Group__1__Impl : ( ruleExpression ) ; - public final void rule__ParanthesizedExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__1__Impl" + // InternalExpression.g:4500:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ; + public final void rule__LetExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4426:1: ( ( ruleExpression ) ) - // InternalExpression.g:4427:1: ( ruleExpression ) + // InternalExpression.g:4504:1: ( ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ) + // InternalExpression.g:4505:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) { - // InternalExpression.g:4427:1: ( ruleExpression ) - // InternalExpression.g:4428:2: ruleExpression + // InternalExpression.g:4505:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) + // InternalExpression.g:4506:2: ( rule__LetExpression__IdentifierAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + // InternalExpression.g:4507:2: ( rule__LetExpression__IdentifierAssignment_1 ) + // InternalExpression.g:4507:3: rule__LetExpression__IdentifierAssignment_1 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__LetExpression__IdentifierAssignment_1(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); - } } - + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); + } + + } + + } } @@ -14791,21 +16841,26 @@ public final void rule__ParanthesizedExpression__Group__1__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__1__Impl" + // $ANTLR end "rule__LetExpression__Group__1__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__2" - // InternalExpression.g:4437:1: rule__ParanthesizedExpression__Group__2 : rule__ParanthesizedExpression__Group__2__Impl ; - public final void rule__ParanthesizedExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__2" + // InternalExpression.g:4515:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ; + public final void rule__LetExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4441:1: ( rule__ParanthesizedExpression__Group__2__Impl ) - // InternalExpression.g:4442:2: rule__ParanthesizedExpression__Group__2__Impl + // InternalExpression.g:4519:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ) + // InternalExpression.g:4520:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 { + pushFollow(FOLLOW_6); + rule__LetExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__2__Impl(); + rule__LetExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -14824,28 +16879,28 @@ public final void rule__ParanthesizedExpression__Group__2() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__2" + // $ANTLR end "rule__LetExpression__Group__2" - // $ANTLR start "rule__ParanthesizedExpression__Group__2__Impl" - // InternalExpression.g:4448:1: rule__ParanthesizedExpression__Group__2__Impl : ( ')' ) ; - public final void rule__ParanthesizedExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__2__Impl" + // InternalExpression.g:4527:1: rule__LetExpression__Group__2__Impl : ( '=' ) ; + public final void rule__LetExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4452:1: ( ( ')' ) ) - // InternalExpression.g:4453:1: ( ')' ) + // InternalExpression.g:4531:1: ( ( '=' ) ) + // InternalExpression.g:4532:1: ( '=' ) { - // InternalExpression.g:4453:1: ( ')' ) - // InternalExpression.g:4454:2: ')' + // InternalExpression.g:4532:1: ( '=' ) + // InternalExpression.g:4533:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } - match(input,40,FOLLOW_2); if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } } @@ -14865,26 +16920,26 @@ public final void rule__ParanthesizedExpression__Group__2__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__2__Impl" + // $ANTLR end "rule__LetExpression__Group__2__Impl" - // $ANTLR start "rule__GlobalVarExpression__Group__0" - // InternalExpression.g:4464:1: rule__GlobalVarExpression__Group__0 : rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ; - public final void rule__GlobalVarExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__3" + // InternalExpression.g:4542:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ; + public final void rule__LetExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4468:1: ( rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ) - // InternalExpression.g:4469:2: rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 + // InternalExpression.g:4546:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ) + // InternalExpression.g:4547:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 { - pushFollow(FOLLOW_3); - rule__GlobalVarExpression__Group__0__Impl(); + pushFollow(FOLLOW_7); + rule__LetExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalVarExpression__Group__1(); + rule__LetExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -14903,28 +16958,38 @@ public final void rule__GlobalVarExpression__Group__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__0" + // $ANTLR end "rule__LetExpression__Group__3" - // $ANTLR start "rule__GlobalVarExpression__Group__0__Impl" - // InternalExpression.g:4476:1: rule__GlobalVarExpression__Group__0__Impl : ( 'GLOBALVAR' ) ; - public final void rule__GlobalVarExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__3__Impl" + // InternalExpression.g:4554:1: rule__LetExpression__Group__3__Impl : ( ( rule__LetExpression__VarExprAssignment_3 ) ) ; + public final void rule__LetExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4480:1: ( ( 'GLOBALVAR' ) ) - // InternalExpression.g:4481:1: ( 'GLOBALVAR' ) + // InternalExpression.g:4558:1: ( ( ( rule__LetExpression__VarExprAssignment_3 ) ) ) + // InternalExpression.g:4559:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) { - // InternalExpression.g:4481:1: ( 'GLOBALVAR' ) - // InternalExpression.g:4482:2: 'GLOBALVAR' + // InternalExpression.g:4559:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) + // InternalExpression.g:4560:2: ( rule__LetExpression__VarExprAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); + } + // InternalExpression.g:4561:2: ( rule__LetExpression__VarExprAssignment_3 ) + // InternalExpression.g:4561:3: rule__LetExpression__VarExprAssignment_3 + { + pushFollow(FOLLOW_2); + rule__LetExpression__VarExprAssignment_3(); + + state._fsp--; + if (state.failed) return ; + } - match(input,54,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } } @@ -14944,21 +17009,26 @@ public final void rule__GlobalVarExpression__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__0__Impl" + // $ANTLR end "rule__LetExpression__Group__3__Impl" - // $ANTLR start "rule__GlobalVarExpression__Group__1" - // InternalExpression.g:4491:1: rule__GlobalVarExpression__Group__1 : rule__GlobalVarExpression__Group__1__Impl ; - public final void rule__GlobalVarExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__4" + // InternalExpression.g:4569:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ; + public final void rule__LetExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4495:1: ( rule__GlobalVarExpression__Group__1__Impl ) - // InternalExpression.g:4496:2: rule__GlobalVarExpression__Group__1__Impl + // InternalExpression.g:4573:1: ( rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ) + // InternalExpression.g:4574:2: rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 { + pushFollow(FOLLOW_6); + rule__LetExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalVarExpression__Group__1__Impl(); + rule__LetExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -14977,38 +17047,28 @@ public final void rule__GlobalVarExpression__Group__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__1" + // $ANTLR end "rule__LetExpression__Group__4" - // $ANTLR start "rule__GlobalVarExpression__Group__1__Impl" - // InternalExpression.g:4502:1: rule__GlobalVarExpression__Group__1__Impl : ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ; - public final void rule__GlobalVarExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__4__Impl" + // InternalExpression.g:4581:1: rule__LetExpression__Group__4__Impl : ( ':' ) ; + public final void rule__LetExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4506:1: ( ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ) - // InternalExpression.g:4507:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + // InternalExpression.g:4585:1: ( ( ':' ) ) + // InternalExpression.g:4586:1: ( ':' ) { - // InternalExpression.g:4507:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) - // InternalExpression.g:4508:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + // InternalExpression.g:4586:1: ( ':' ) + // InternalExpression.g:4587:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); - } - // InternalExpression.g:4509:2: ( rule__GlobalVarExpression__NameAssignment_1 ) - // InternalExpression.g:4509:3: rule__GlobalVarExpression__NameAssignment_1 - { - pushFollow(FOLLOW_2); - rule__GlobalVarExpression__NameAssignment_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } - + match(input,66,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } } @@ -15028,26 +17088,21 @@ public final void rule__GlobalVarExpression__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__1__Impl" + // $ANTLR end "rule__LetExpression__Group__4__Impl" - // $ANTLR start "rule__OperationCall__Group__0" - // InternalExpression.g:4518:1: rule__OperationCall__Group__0 : rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ; - public final void rule__OperationCall__Group__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__5" + // InternalExpression.g:4596:1: rule__LetExpression__Group__5 : rule__LetExpression__Group__5__Impl ; + public final void rule__LetExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4522:1: ( rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ) - // InternalExpression.g:4523:2: rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 + // InternalExpression.g:4600:1: ( rule__LetExpression__Group__5__Impl ) + // InternalExpression.g:4601:2: rule__LetExpression__Group__5__Impl { - pushFollow(FOLLOW_33); - rule__OperationCall__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__1(); + rule__LetExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -15066,30 +17121,30 @@ public final void rule__OperationCall__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__0" + // $ANTLR end "rule__LetExpression__Group__5" - // $ANTLR start "rule__OperationCall__Group__0__Impl" - // InternalExpression.g:4530:1: rule__OperationCall__Group__0__Impl : ( ( rule__OperationCall__NameAssignment_0 ) ) ; - public final void rule__OperationCall__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__5__Impl" + // InternalExpression.g:4607:1: rule__LetExpression__Group__5__Impl : ( ( rule__LetExpression__TargetAssignment_5 ) ) ; + public final void rule__LetExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4534:1: ( ( ( rule__OperationCall__NameAssignment_0 ) ) ) - // InternalExpression.g:4535:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + // InternalExpression.g:4611:1: ( ( ( rule__LetExpression__TargetAssignment_5 ) ) ) + // InternalExpression.g:4612:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) { - // InternalExpression.g:4535:1: ( ( rule__OperationCall__NameAssignment_0 ) ) - // InternalExpression.g:4536:2: ( rule__OperationCall__NameAssignment_0 ) + // InternalExpression.g:4612:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) + // InternalExpression.g:4613:2: ( rule__LetExpression__TargetAssignment_5 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } - // InternalExpression.g:4537:2: ( rule__OperationCall__NameAssignment_0 ) - // InternalExpression.g:4537:3: rule__OperationCall__NameAssignment_0 + // InternalExpression.g:4614:2: ( rule__LetExpression__TargetAssignment_5 ) + // InternalExpression.g:4614:3: rule__LetExpression__TargetAssignment_5 { pushFollow(FOLLOW_2); - rule__OperationCall__NameAssignment_0(); + rule__LetExpression__TargetAssignment_5(); state._fsp--; if (state.failed) return ; @@ -15097,7 +17152,7 @@ public final void rule__OperationCall__Group__0__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } } @@ -15117,26 +17172,26 @@ public final void rule__OperationCall__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__0__Impl" + // $ANTLR end "rule__LetExpression__Group__5__Impl" - // $ANTLR start "rule__OperationCall__Group__1" - // InternalExpression.g:4545:1: rule__OperationCall__Group__1 : rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ; - public final void rule__OperationCall__Group__1() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__0" + // InternalExpression.g:4623:1: rule__CastedExpression__Group__0 : rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ; + public final void rule__CastedExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4549:1: ( rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ) - // InternalExpression.g:4550:2: rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 + // InternalExpression.g:4627:1: ( rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ) + // InternalExpression.g:4628:2: rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 { - pushFollow(FOLLOW_34); - rule__OperationCall__Group__1__Impl(); + pushFollow(FOLLOW_8); + rule__CastedExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__2(); + rule__CastedExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -15155,28 +17210,28 @@ public final void rule__OperationCall__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__1" + // $ANTLR end "rule__CastedExpression__Group__0" - // $ANTLR start "rule__OperationCall__Group__1__Impl" - // InternalExpression.g:4557:1: rule__OperationCall__Group__1__Impl : ( '(' ) ; - public final void rule__OperationCall__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__0__Impl" + // InternalExpression.g:4635:1: rule__CastedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__CastedExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4561:1: ( ( '(' ) ) - // InternalExpression.g:4562:1: ( '(' ) + // InternalExpression.g:4639:1: ( ( '(' ) ) + // InternalExpression.g:4640:1: ( '(' ) { - // InternalExpression.g:4562:1: ( '(' ) - // InternalExpression.g:4563:2: '(' + // InternalExpression.g:4640:1: ( '(' ) + // InternalExpression.g:4641:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } - match(input,39,FOLLOW_2); if (state.failed) return ; + match(input,67,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } } @@ -15196,26 +17251,26 @@ public final void rule__OperationCall__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__1__Impl" + // $ANTLR end "rule__CastedExpression__Group__0__Impl" - // $ANTLR start "rule__OperationCall__Group__2" - // InternalExpression.g:4572:1: rule__OperationCall__Group__2 : rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ; - public final void rule__OperationCall__Group__2() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__1" + // InternalExpression.g:4650:1: rule__CastedExpression__Group__1 : rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ; + public final void rule__CastedExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4576:1: ( rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ) - // InternalExpression.g:4577:2: rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 + // InternalExpression.g:4654:1: ( rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ) + // InternalExpression.g:4655:2: rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 { - pushFollow(FOLLOW_34); - rule__OperationCall__Group__2__Impl(); + pushFollow(FOLLOW_9); + rule__CastedExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__3(); + rule__CastedExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -15234,49 +17289,117 @@ public final void rule__OperationCall__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__2" + // $ANTLR end "rule__CastedExpression__Group__1" - // $ANTLR start "rule__OperationCall__Group__2__Impl" - // InternalExpression.g:4584:1: rule__OperationCall__Group__2__Impl : ( ( rule__OperationCall__Group_2__0 )? ) ; - public final void rule__OperationCall__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__1__Impl" + // InternalExpression.g:4662:1: rule__CastedExpression__Group__1__Impl : ( ( rule__CastedExpression__TypeAssignment_1 ) ) ; + public final void rule__CastedExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4588:1: ( ( ( rule__OperationCall__Group_2__0 )? ) ) - // InternalExpression.g:4589:1: ( ( rule__OperationCall__Group_2__0 )? ) + // InternalExpression.g:4666:1: ( ( ( rule__CastedExpression__TypeAssignment_1 ) ) ) + // InternalExpression.g:4667:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) { - // InternalExpression.g:4589:1: ( ( rule__OperationCall__Group_2__0 )? ) - // InternalExpression.g:4590:2: ( rule__OperationCall__Group_2__0 )? + // InternalExpression.g:4667:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) + // InternalExpression.g:4668:2: ( rule__CastedExpression__TypeAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getGroup_2()); + before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } - // InternalExpression.g:4591:2: ( rule__OperationCall__Group_2__0 )? - int alt32=2; - int LA32_0 = input.LA(1); + // InternalExpression.g:4669:2: ( rule__CastedExpression__TypeAssignment_1 ) + // InternalExpression.g:4669:3: rule__CastedExpression__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__CastedExpression__TypeAssignment_1(); + + state._fsp--; + if (state.failed) return ; - if ( ((LA32_0>=RULE_ID && LA32_0<=RULE_STRING)||LA32_0==19||(LA32_0>=22 && LA32_0<=36)||LA32_0==39||LA32_0==43||(LA32_0>=46 && LA32_0<=47)||(LA32_0>=54 && LA32_0<=55)||(LA32_0>=62 && LA32_0<=63)) ) { - alt32=1; } - switch (alt32) { - case 1 : - // InternalExpression.g:4591:3: rule__OperationCall__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__0(); - state._fsp--; - if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); + } - } - break; + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__Group__1__Impl" + + + // $ANTLR start "rule__CastedExpression__Group__2" + // InternalExpression.g:4677:1: rule__CastedExpression__Group__2 : rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ; + public final void rule__CastedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:4681:1: ( rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ) + // InternalExpression.g:4682:2: rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 + { + pushFollow(FOLLOW_6); + rule__CastedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CastedExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__Group__2" + + + // $ANTLR start "rule__CastedExpression__Group__2__Impl" + // InternalExpression.g:4689:1: rule__CastedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__CastedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:4693:1: ( ( ')' ) ) + // InternalExpression.g:4694:1: ( ')' ) + { + // InternalExpression.g:4694:1: ( ')' ) + // InternalExpression.g:4695:2: ')' + { if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getGroup_2()); + before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } } @@ -15296,21 +17419,21 @@ public final void rule__OperationCall__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__2__Impl" + // $ANTLR end "rule__CastedExpression__Group__2__Impl" - // $ANTLR start "rule__OperationCall__Group__3" - // InternalExpression.g:4599:1: rule__OperationCall__Group__3 : rule__OperationCall__Group__3__Impl ; - public final void rule__OperationCall__Group__3() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__3" + // InternalExpression.g:4704:1: rule__CastedExpression__Group__3 : rule__CastedExpression__Group__3__Impl ; + public final void rule__CastedExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4603:1: ( rule__OperationCall__Group__3__Impl ) - // InternalExpression.g:4604:2: rule__OperationCall__Group__3__Impl + // InternalExpression.g:4708:1: ( rule__CastedExpression__Group__3__Impl ) + // InternalExpression.g:4709:2: rule__CastedExpression__Group__3__Impl { pushFollow(FOLLOW_2); - rule__OperationCall__Group__3__Impl(); + rule__CastedExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -15329,28 +17452,38 @@ public final void rule__OperationCall__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__3" + // $ANTLR end "rule__CastedExpression__Group__3" - // $ANTLR start "rule__OperationCall__Group__3__Impl" - // InternalExpression.g:4610:1: rule__OperationCall__Group__3__Impl : ( ')' ) ; - public final void rule__OperationCall__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__3__Impl" + // InternalExpression.g:4715:1: rule__CastedExpression__Group__3__Impl : ( ( rule__CastedExpression__TargetAssignment_3 ) ) ; + public final void rule__CastedExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4614:1: ( ( ')' ) ) - // InternalExpression.g:4615:1: ( ')' ) + // InternalExpression.g:4719:1: ( ( ( rule__CastedExpression__TargetAssignment_3 ) ) ) + // InternalExpression.g:4720:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) { - // InternalExpression.g:4615:1: ( ')' ) - // InternalExpression.g:4616:2: ')' + // InternalExpression.g:4720:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) + // InternalExpression.g:4721:2: ( rule__CastedExpression__TargetAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); + } + // InternalExpression.g:4722:2: ( rule__CastedExpression__TargetAssignment_3 ) + // InternalExpression.g:4722:3: rule__CastedExpression__TargetAssignment_3 + { + pushFollow(FOLLOW_2); + rule__CastedExpression__TargetAssignment_3(); + + state._fsp--; + if (state.failed) return ; + } - match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } } @@ -15370,26 +17503,26 @@ public final void rule__OperationCall__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__3__Impl" + // $ANTLR end "rule__CastedExpression__Group__3__Impl" - // $ANTLR start "rule__OperationCall__Group_2__0" - // InternalExpression.g:4626:1: rule__OperationCall__Group_2__0 : rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ; - public final void rule__OperationCall__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__0" + // InternalExpression.g:4731:1: rule__ChainExpression__Group__0 : rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ; + public final void rule__ChainExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4630:1: ( rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ) - // InternalExpression.g:4631:2: rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 + // InternalExpression.g:4735:1: ( rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ) + // InternalExpression.g:4736:2: rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 { - pushFollow(FOLLOW_35); - rule__OperationCall__Group_2__0__Impl(); + pushFollow(FOLLOW_10); + rule__ChainExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__1(); + rule__ChainExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -15408,38 +17541,32 @@ public final void rule__OperationCall__Group_2__0() throws RecognitionException } return ; } - // $ANTLR end "rule__OperationCall__Group_2__0" + // $ANTLR end "rule__ChainExpression__Group__0" - // $ANTLR start "rule__OperationCall__Group_2__0__Impl" - // InternalExpression.g:4638:1: rule__OperationCall__Group_2__0__Impl : ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ; - public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__0__Impl" + // InternalExpression.g:4743:1: rule__ChainExpression__Group__0__Impl : ( ruleChainedExpression ) ; + public final void rule__ChainExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4642:1: ( ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ) - // InternalExpression.g:4643:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + // InternalExpression.g:4747:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:4748:1: ( ruleChainedExpression ) { - // InternalExpression.g:4643:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) - // InternalExpression.g:4644:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + // InternalExpression.g:4748:1: ( ruleChainedExpression ) + // InternalExpression.g:4749:2: ruleChainedExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } - // InternalExpression.g:4645:2: ( rule__OperationCall__ParamsAssignment_2_0 ) - // InternalExpression.g:4645:3: rule__OperationCall__ParamsAssignment_2_0 - { pushFollow(FOLLOW_2); - rule__OperationCall__ParamsAssignment_2_0(); + ruleChainedExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } } @@ -15459,21 +17586,21 @@ public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__Group_2__0__Impl" + // $ANTLR end "rule__ChainExpression__Group__0__Impl" - // $ANTLR start "rule__OperationCall__Group_2__1" - // InternalExpression.g:4653:1: rule__OperationCall__Group_2__1 : rule__OperationCall__Group_2__1__Impl ; - public final void rule__OperationCall__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__1" + // InternalExpression.g:4758:1: rule__ChainExpression__Group__1 : rule__ChainExpression__Group__1__Impl ; + public final void rule__ChainExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4657:1: ( rule__OperationCall__Group_2__1__Impl ) - // InternalExpression.g:4658:2: rule__OperationCall__Group_2__1__Impl + // InternalExpression.g:4762:1: ( rule__ChainExpression__Group__1__Impl ) + // InternalExpression.g:4763:2: rule__ChainExpression__Group__1__Impl { pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__1__Impl(); + rule__ChainExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -15492,42 +17619,42 @@ public final void rule__OperationCall__Group_2__1() throws RecognitionException } return ; } - // $ANTLR end "rule__OperationCall__Group_2__1" + // $ANTLR end "rule__ChainExpression__Group__1" - // $ANTLR start "rule__OperationCall__Group_2__1__Impl" - // InternalExpression.g:4664:1: rule__OperationCall__Group_2__1__Impl : ( ( rule__OperationCall__Group_2_1__0 )* ) ; - public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__1__Impl" + // InternalExpression.g:4769:1: rule__ChainExpression__Group__1__Impl : ( ( rule__ChainExpression__Group_1__0 )* ) ; + public final void rule__ChainExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4668:1: ( ( ( rule__OperationCall__Group_2_1__0 )* ) ) - // InternalExpression.g:4669:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + // InternalExpression.g:4773:1: ( ( ( rule__ChainExpression__Group_1__0 )* ) ) + // InternalExpression.g:4774:1: ( ( rule__ChainExpression__Group_1__0 )* ) { - // InternalExpression.g:4669:1: ( ( rule__OperationCall__Group_2_1__0 )* ) - // InternalExpression.g:4670:2: ( rule__OperationCall__Group_2_1__0 )* + // InternalExpression.g:4774:1: ( ( rule__ChainExpression__Group_1__0 )* ) + // InternalExpression.g:4775:2: ( rule__ChainExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getGroup_2_1()); + before(grammarAccess.getChainExpressionAccess().getGroup_1()); } - // InternalExpression.g:4671:2: ( rule__OperationCall__Group_2_1__0 )* - loop33: + // InternalExpression.g:4776:2: ( rule__ChainExpression__Group_1__0 )* + loop57: do { - int alt33=2; - int LA33_0 = input.LA(1); + int alt57=2; + int LA57_0 = input.LA(1); - if ( (LA33_0==52) ) { - alt33=1; + if ( (LA57_0==48) ) { + alt57=1; } - switch (alt33) { + switch (alt57) { case 1 : - // InternalExpression.g:4671:3: rule__OperationCall__Group_2_1__0 + // InternalExpression.g:4776:3: rule__ChainExpression__Group_1__0 { - pushFollow(FOLLOW_36); - rule__OperationCall__Group_2_1__0(); + pushFollow(FOLLOW_11); + rule__ChainExpression__Group_1__0(); state._fsp--; if (state.failed) return ; @@ -15536,12 +17663,12 @@ public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionExce break; default : - break loop33; + break loop57; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getGroup_2_1()); + after(grammarAccess.getChainExpressionAccess().getGroup_1()); } } @@ -15561,26 +17688,26 @@ public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__Group_2__1__Impl" + // $ANTLR end "rule__ChainExpression__Group__1__Impl" - // $ANTLR start "rule__OperationCall__Group_2_1__0" - // InternalExpression.g:4680:1: rule__OperationCall__Group_2_1__0 : rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ; - public final void rule__OperationCall__Group_2_1__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__0" + // InternalExpression.g:4785:1: rule__ChainExpression__Group_1__0 : rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ; + public final void rule__ChainExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4684:1: ( rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ) - // InternalExpression.g:4685:2: rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 + // InternalExpression.g:4789:1: ( rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ) + // InternalExpression.g:4790:2: rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 { - pushFollow(FOLLOW_5); - rule__OperationCall__Group_2_1__0__Impl(); + pushFollow(FOLLOW_10); + rule__ChainExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2_1__1(); + rule__ChainExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -15599,28 +17726,32 @@ public final void rule__OperationCall__Group_2_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__0" + // $ANTLR end "rule__ChainExpression__Group_1__0" - // $ANTLR start "rule__OperationCall__Group_2_1__0__Impl" - // InternalExpression.g:4692:1: rule__OperationCall__Group_2_1__0__Impl : ( ',' ) ; - public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__0__Impl" + // InternalExpression.g:4797:1: rule__ChainExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4696:1: ( ( ',' ) ) - // InternalExpression.g:4697:1: ( ',' ) + // InternalExpression.g:4801:1: ( ( () ) ) + // InternalExpression.g:4802:1: ( () ) { - // InternalExpression.g:4697:1: ( ',' ) - // InternalExpression.g:4698:2: ',' + // InternalExpression.g:4802:1: ( () ) + // InternalExpression.g:4803:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); + } + // InternalExpression.g:4804:2: () + // InternalExpression.g:4804:3: + { } - match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } } @@ -15629,10 +17760,6 @@ public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionEx } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -15640,21 +17767,26 @@ public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__0__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__0__Impl" - // $ANTLR start "rule__OperationCall__Group_2_1__1" - // InternalExpression.g:4707:1: rule__OperationCall__Group_2_1__1 : rule__OperationCall__Group_2_1__1__Impl ; - public final void rule__OperationCall__Group_2_1__1() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__1" + // InternalExpression.g:4812:1: rule__ChainExpression__Group_1__1 : rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ; + public final void rule__ChainExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4711:1: ( rule__OperationCall__Group_2_1__1__Impl ) - // InternalExpression.g:4712:2: rule__OperationCall__Group_2_1__1__Impl + // InternalExpression.g:4816:1: ( rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ) + // InternalExpression.g:4817:2: rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 { + pushFollow(FOLLOW_6); + rule__ChainExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2_1__1__Impl(); + rule__ChainExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -15673,38 +17805,28 @@ public final void rule__OperationCall__Group_2_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__1" + // $ANTLR end "rule__ChainExpression__Group_1__1" - // $ANTLR start "rule__OperationCall__Group_2_1__1__Impl" - // InternalExpression.g:4718:1: rule__OperationCall__Group_2_1__1__Impl : ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ; - public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__1__Impl" + // InternalExpression.g:4824:1: rule__ChainExpression__Group_1__1__Impl : ( '->' ) ; + public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4722:1: ( ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ) - // InternalExpression.g:4723:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + // InternalExpression.g:4828:1: ( ( '->' ) ) + // InternalExpression.g:4829:1: ( '->' ) { - // InternalExpression.g:4723:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) - // InternalExpression.g:4724:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + // InternalExpression.g:4829:1: ( '->' ) + // InternalExpression.g:4830:2: '->' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); - } - // InternalExpression.g:4725:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) - // InternalExpression.g:4725:3: rule__OperationCall__ParamsAssignment_2_1_1 - { - pushFollow(FOLLOW_2); - rule__OperationCall__ParamsAssignment_2_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } - + match(input,48,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } } @@ -15724,26 +17846,21 @@ public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__1__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__1__Impl" - // $ANTLR start "rule__ListLiteral__Group__0" - // InternalExpression.g:4734:1: rule__ListLiteral__Group__0 : rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ; - public final void rule__ListLiteral__Group__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__2" + // InternalExpression.g:4839:1: rule__ChainExpression__Group_1__2 : rule__ChainExpression__Group_1__2__Impl ; + public final void rule__ChainExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4738:1: ( rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ) - // InternalExpression.g:4739:2: rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 + // InternalExpression.g:4843:1: ( rule__ChainExpression__Group_1__2__Impl ) + // InternalExpression.g:4844:2: rule__ChainExpression__Group_1__2__Impl { - pushFollow(FOLLOW_40); - rule__ListLiteral__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__1(); + rule__ChainExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -15762,32 +17879,38 @@ public final void rule__ListLiteral__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__0" + // $ANTLR end "rule__ChainExpression__Group_1__2" - // $ANTLR start "rule__ListLiteral__Group__0__Impl" - // InternalExpression.g:4746:1: rule__ListLiteral__Group__0__Impl : ( () ) ; - public final void rule__ListLiteral__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__2__Impl" + // InternalExpression.g:4850:1: rule__ChainExpression__Group_1__2__Impl : ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ; + public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4750:1: ( ( () ) ) - // InternalExpression.g:4751:1: ( () ) + // InternalExpression.g:4854:1: ( ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ) + // InternalExpression.g:4855:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) { - // InternalExpression.g:4751:1: ( () ) - // InternalExpression.g:4752:2: () + // InternalExpression.g:4855:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) + // InternalExpression.g:4856:2: ( rule__ChainExpression__NextAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } - // InternalExpression.g:4753:2: () - // InternalExpression.g:4753:3: + // InternalExpression.g:4857:2: ( rule__ChainExpression__NextAssignment_1_2 ) + // InternalExpression.g:4857:3: rule__ChainExpression__NextAssignment_1_2 { + pushFollow(FOLLOW_2); + rule__ChainExpression__NextAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } } @@ -15796,6 +17919,10 @@ public final void rule__ListLiteral__Group__0__Impl() throws RecognitionExceptio } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -15803,26 +17930,26 @@ public final void rule__ListLiteral__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__0__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__2__Impl" - // $ANTLR start "rule__ListLiteral__Group__1" - // InternalExpression.g:4761:1: rule__ListLiteral__Group__1 : rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ; - public final void rule__ListLiteral__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__0" + // InternalExpression.g:4866:1: rule__IfExpressionTri__Group__0 : rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ; + public final void rule__IfExpressionTri__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4765:1: ( rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ) - // InternalExpression.g:4766:2: rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 + // InternalExpression.g:4870:1: ( rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ) + // InternalExpression.g:4871:2: rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 { - pushFollow(FOLLOW_41); - rule__ListLiteral__Group__1__Impl(); + pushFollow(FOLLOW_12); + rule__IfExpressionTri__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__2(); + rule__IfExpressionTri__Group__1(); state._fsp--; if (state.failed) return ; @@ -15841,28 +17968,32 @@ public final void rule__ListLiteral__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__1" + // $ANTLR end "rule__IfExpressionTri__Group__0" - // $ANTLR start "rule__ListLiteral__Group__1__Impl" - // InternalExpression.g:4773:1: rule__ListLiteral__Group__1__Impl : ( '{' ) ; - public final void rule__ListLiteral__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__0__Impl" + // InternalExpression.g:4878:1: rule__IfExpressionTri__Group__0__Impl : ( ruleOrExpression ) ; + public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4777:1: ( ( '{' ) ) - // InternalExpression.g:4778:1: ( '{' ) + // InternalExpression.g:4882:1: ( ( ruleOrExpression ) ) + // InternalExpression.g:4883:1: ( ruleOrExpression ) { - // InternalExpression.g:4778:1: ( '{' ) - // InternalExpression.g:4779:2: '{' + // InternalExpression.g:4883:1: ( ruleOrExpression ) + // InternalExpression.g:4884:2: ruleOrExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } - match(input,47,FOLLOW_2); if (state.failed) return ; + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } } @@ -15882,26 +18013,21 @@ public final void rule__ListLiteral__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group__0__Impl" - // $ANTLR start "rule__ListLiteral__Group__2" - // InternalExpression.g:4788:1: rule__ListLiteral__Group__2 : rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ; - public final void rule__ListLiteral__Group__2() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__1" + // InternalExpression.g:4893:1: rule__IfExpressionTri__Group__1 : rule__IfExpressionTri__Group__1__Impl ; + public final void rule__IfExpressionTri__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4792:1: ( rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ) - // InternalExpression.g:4793:2: rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 + // InternalExpression.g:4897:1: ( rule__IfExpressionTri__Group__1__Impl ) + // InternalExpression.g:4898:2: rule__IfExpressionTri__Group__1__Impl { - pushFollow(FOLLOW_41); - rule__ListLiteral__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__3(); + rule__IfExpressionTri__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -15920,38 +18046,38 @@ public final void rule__ListLiteral__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__2" + // $ANTLR end "rule__IfExpressionTri__Group__1" - // $ANTLR start "rule__ListLiteral__Group__2__Impl" - // InternalExpression.g:4800:1: rule__ListLiteral__Group__2__Impl : ( ( rule__ListLiteral__Group_2__0 )? ) ; - public final void rule__ListLiteral__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__1__Impl" + // InternalExpression.g:4904:1: rule__IfExpressionTri__Group__1__Impl : ( ( rule__IfExpressionTri__Group_1__0 )? ) ; + public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4804:1: ( ( ( rule__ListLiteral__Group_2__0 )? ) ) - // InternalExpression.g:4805:1: ( ( rule__ListLiteral__Group_2__0 )? ) + // InternalExpression.g:4908:1: ( ( ( rule__IfExpressionTri__Group_1__0 )? ) ) + // InternalExpression.g:4909:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) { - // InternalExpression.g:4805:1: ( ( rule__ListLiteral__Group_2__0 )? ) - // InternalExpression.g:4806:2: ( rule__ListLiteral__Group_2__0 )? + // InternalExpression.g:4909:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) + // InternalExpression.g:4910:2: ( rule__IfExpressionTri__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getGroup_2()); + before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } - // InternalExpression.g:4807:2: ( rule__ListLiteral__Group_2__0 )? - int alt34=2; - int LA34_0 = input.LA(1); + // InternalExpression.g:4911:2: ( rule__IfExpressionTri__Group_1__0 )? + int alt58=2; + int LA58_0 = input.LA(1); - if ( ((LA34_0>=RULE_ID && LA34_0<=RULE_STRING)||LA34_0==19||(LA34_0>=22 && LA34_0<=36)||LA34_0==39||LA34_0==43||(LA34_0>=46 && LA34_0<=47)||(LA34_0>=54 && LA34_0<=55)||(LA34_0>=62 && LA34_0<=63)) ) { - alt34=1; + if ( (LA58_0==69) ) { + alt58=1; } - switch (alt34) { + switch (alt58) { case 1 : - // InternalExpression.g:4807:3: rule__ListLiteral__Group_2__0 + // InternalExpression.g:4911:3: rule__IfExpressionTri__Group_1__0 { pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__0(); + rule__IfExpressionTri__Group_1__0(); state._fsp--; if (state.failed) return ; @@ -15962,7 +18088,7 @@ public final void rule__ListLiteral__Group__2__Impl() throws RecognitionExceptio } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getGroup_2()); + after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } } @@ -15982,21 +18108,26 @@ public final void rule__ListLiteral__Group__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__2__Impl" + // $ANTLR end "rule__IfExpressionTri__Group__1__Impl" - // $ANTLR start "rule__ListLiteral__Group__3" - // InternalExpression.g:4815:1: rule__ListLiteral__Group__3 : rule__ListLiteral__Group__3__Impl ; - public final void rule__ListLiteral__Group__3() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__0" + // InternalExpression.g:4920:1: rule__IfExpressionTri__Group_1__0 : rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ; + public final void rule__IfExpressionTri__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4819:1: ( rule__ListLiteral__Group__3__Impl ) - // InternalExpression.g:4820:2: rule__ListLiteral__Group__3__Impl + // InternalExpression.g:4924:1: ( rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ) + // InternalExpression.g:4925:2: rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 { + pushFollow(FOLLOW_12); + rule__IfExpressionTri__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__3__Impl(); + rule__IfExpressionTri__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -16015,28 +18146,32 @@ public final void rule__ListLiteral__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__3" + // $ANTLR end "rule__IfExpressionTri__Group_1__0" - // $ANTLR start "rule__ListLiteral__Group__3__Impl" - // InternalExpression.g:4826:1: rule__ListLiteral__Group__3__Impl : ( '}' ) ; - public final void rule__ListLiteral__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__0__Impl" + // InternalExpression.g:4932:1: rule__IfExpressionTri__Group_1__0__Impl : ( () ) ; + public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4830:1: ( ( '}' ) ) - // InternalExpression.g:4831:1: ( '}' ) + // InternalExpression.g:4936:1: ( ( () ) ) + // InternalExpression.g:4937:1: ( () ) { - // InternalExpression.g:4831:1: ( '}' ) - // InternalExpression.g:4832:2: '}' + // InternalExpression.g:4937:1: ( () ) + // InternalExpression.g:4938:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } - match(input,49,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:4939:2: () + // InternalExpression.g:4939:3: + { + } + if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } } @@ -16045,10 +18180,6 @@ public final void rule__ListLiteral__Group__3__Impl() throws RecognitionExceptio } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -16056,26 +18187,26 @@ public final void rule__ListLiteral__Group__3__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__3__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__0__Impl" - // $ANTLR start "rule__ListLiteral__Group_2__0" - // InternalExpression.g:4842:1: rule__ListLiteral__Group_2__0 : rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ; - public final void rule__ListLiteral__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__1" + // InternalExpression.g:4947:1: rule__IfExpressionTri__Group_1__1 : rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ; + public final void rule__IfExpressionTri__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4846:1: ( rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ) - // InternalExpression.g:4847:2: rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 + // InternalExpression.g:4951:1: ( rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ) + // InternalExpression.g:4952:2: rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 { - pushFollow(FOLLOW_35); - rule__ListLiteral__Group_2__0__Impl(); + pushFollow(FOLLOW_6); + rule__IfExpressionTri__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__1(); + rule__IfExpressionTri__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -16094,38 +18225,28 @@ public final void rule__ListLiteral__Group_2__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__0" + // $ANTLR end "rule__IfExpressionTri__Group_1__1" - // $ANTLR start "rule__ListLiteral__Group_2__0__Impl" - // InternalExpression.g:4854:1: rule__ListLiteral__Group_2__0__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ; - public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__1__Impl" + // InternalExpression.g:4959:1: rule__IfExpressionTri__Group_1__1__Impl : ( '?' ) ; + public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4858:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ) - // InternalExpression.g:4859:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + // InternalExpression.g:4963:1: ( ( '?' ) ) + // InternalExpression.g:4964:1: ( '?' ) { - // InternalExpression.g:4859:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) - // InternalExpression.g:4860:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + // InternalExpression.g:4964:1: ( '?' ) + // InternalExpression.g:4965:2: '?' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); - } - // InternalExpression.g:4861:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) - // InternalExpression.g:4861:3: rule__ListLiteral__ElementsAssignment_2_0 - { - pushFollow(FOLLOW_2); - rule__ListLiteral__ElementsAssignment_2_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } - + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } } @@ -16145,21 +18266,26 @@ public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__0__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__1__Impl" - // $ANTLR start "rule__ListLiteral__Group_2__1" - // InternalExpression.g:4869:1: rule__ListLiteral__Group_2__1 : rule__ListLiteral__Group_2__1__Impl ; - public final void rule__ListLiteral__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__2" + // InternalExpression.g:4974:1: rule__IfExpressionTri__Group_1__2 : rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ; + public final void rule__IfExpressionTri__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4873:1: ( rule__ListLiteral__Group_2__1__Impl ) - // InternalExpression.g:4874:2: rule__ListLiteral__Group_2__1__Impl + // InternalExpression.g:4978:1: ( rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ) + // InternalExpression.g:4979:2: rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 { + pushFollow(FOLLOW_7); + rule__IfExpressionTri__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__1__Impl(); + rule__IfExpressionTri__Group_1__3(); state._fsp--; if (state.failed) return ; @@ -16178,56 +18304,38 @@ public final void rule__ListLiteral__Group_2__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__1" + // $ANTLR end "rule__IfExpressionTri__Group_1__2" - // $ANTLR start "rule__ListLiteral__Group_2__1__Impl" - // InternalExpression.g:4880:1: rule__ListLiteral__Group_2__1__Impl : ( ( rule__ListLiteral__Group_2_1__0 )* ) ; - public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__2__Impl" + // InternalExpression.g:4986:1: rule__IfExpressionTri__Group_1__2__Impl : ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ; + public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4884:1: ( ( ( rule__ListLiteral__Group_2_1__0 )* ) ) - // InternalExpression.g:4885:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + // InternalExpression.g:4990:1: ( ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ) + // InternalExpression.g:4991:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) { - // InternalExpression.g:4885:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) - // InternalExpression.g:4886:2: ( rule__ListLiteral__Group_2_1__0 )* + // InternalExpression.g:4991:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) + // InternalExpression.g:4992:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getGroup_2_1()); + before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } - // InternalExpression.g:4887:2: ( rule__ListLiteral__Group_2_1__0 )* - loop35: - do { - int alt35=2; - int LA35_0 = input.LA(1); - - if ( (LA35_0==52) ) { - alt35=1; - } - - - switch (alt35) { - case 1 : - // InternalExpression.g:4887:3: rule__ListLiteral__Group_2_1__0 - { - pushFollow(FOLLOW_36); - rule__ListLiteral__Group_2_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalExpression.g:4993:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) + // InternalExpression.g:4993:3: rule__IfExpressionTri__ThenPartAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__IfExpressionTri__ThenPartAssignment_1_2(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop35; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getGroup_2_1()); + after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } } @@ -16247,26 +18355,26 @@ public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__2__Impl" - // $ANTLR start "rule__ListLiteral__Group_2_1__0" - // InternalExpression.g:4896:1: rule__ListLiteral__Group_2_1__0 : rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ; - public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__3" + // InternalExpression.g:5001:1: rule__IfExpressionTri__Group_1__3 : rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ; + public final void rule__IfExpressionTri__Group_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4900:1: ( rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ) - // InternalExpression.g:4901:2: rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 + // InternalExpression.g:5005:1: ( rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ) + // InternalExpression.g:5006:2: rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 { - pushFollow(FOLLOW_5); - rule__ListLiteral__Group_2_1__0__Impl(); + pushFollow(FOLLOW_6); + rule__IfExpressionTri__Group_1__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2_1__1(); + rule__IfExpressionTri__Group_1__4(); state._fsp--; if (state.failed) return ; @@ -16285,28 +18393,28 @@ public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__0" + // $ANTLR end "rule__IfExpressionTri__Group_1__3" - // $ANTLR start "rule__ListLiteral__Group_2_1__0__Impl" - // InternalExpression.g:4908:1: rule__ListLiteral__Group_2_1__0__Impl : ( ',' ) ; - public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__3__Impl" + // InternalExpression.g:5013:1: rule__IfExpressionTri__Group_1__3__Impl : ( ':' ) ; + public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4912:1: ( ( ',' ) ) - // InternalExpression.g:4913:1: ( ',' ) + // InternalExpression.g:5017:1: ( ( ':' ) ) + // InternalExpression.g:5018:1: ( ':' ) { - // InternalExpression.g:4913:1: ( ',' ) - // InternalExpression.g:4914:2: ',' + // InternalExpression.g:5018:1: ( ':' ) + // InternalExpression.g:5019:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,66,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } } @@ -16326,21 +18434,21 @@ public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__0__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__3__Impl" - // $ANTLR start "rule__ListLiteral__Group_2_1__1" - // InternalExpression.g:4923:1: rule__ListLiteral__Group_2_1__1 : rule__ListLiteral__Group_2_1__1__Impl ; - public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__4" + // InternalExpression.g:5028:1: rule__IfExpressionTri__Group_1__4 : rule__IfExpressionTri__Group_1__4__Impl ; + public final void rule__IfExpressionTri__Group_1__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4927:1: ( rule__ListLiteral__Group_2_1__1__Impl ) - // InternalExpression.g:4928:2: rule__ListLiteral__Group_2_1__1__Impl + // InternalExpression.g:5032:1: ( rule__IfExpressionTri__Group_1__4__Impl ) + // InternalExpression.g:5033:2: rule__IfExpressionTri__Group_1__4__Impl { pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2_1__1__Impl(); + rule__IfExpressionTri__Group_1__4__Impl(); state._fsp--; if (state.failed) return ; @@ -16359,30 +18467,30 @@ public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__1" + // $ANTLR end "rule__IfExpressionTri__Group_1__4" - // $ANTLR start "rule__ListLiteral__Group_2_1__1__Impl" - // InternalExpression.g:4934:1: rule__ListLiteral__Group_2_1__1__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ; - public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__4__Impl" + // InternalExpression.g:5039:1: rule__IfExpressionTri__Group_1__4__Impl : ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ; + public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4938:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ) - // InternalExpression.g:4939:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + // InternalExpression.g:5043:1: ( ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ) + // InternalExpression.g:5044:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) { - // InternalExpression.g:4939:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) - // InternalExpression.g:4940:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + // InternalExpression.g:5044:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) + // InternalExpression.g:5045:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } - // InternalExpression.g:4941:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) - // InternalExpression.g:4941:3: rule__ListLiteral__ElementsAssignment_2_1_1 + // InternalExpression.g:5046:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) + // InternalExpression.g:5046:3: rule__IfExpressionTri__ElsePartAssignment_1_4 { pushFollow(FOLLOW_2); - rule__ListLiteral__ElementsAssignment_2_1_1(); + rule__IfExpressionTri__ElsePartAssignment_1_4(); state._fsp--; if (state.failed) return ; @@ -16390,7 +18498,7 @@ public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } } @@ -16410,26 +18518,26 @@ public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__4__Impl" - // $ANTLR start "rule__ConstructorCallExpression__Group__0" - // InternalExpression.g:4950:1: rule__ConstructorCallExpression__Group__0 : rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ; - public final void rule__ConstructorCallExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__0" + // InternalExpression.g:5055:1: rule__IfExpressionKw__Group__0 : rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ; + public final void rule__IfExpressionKw__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4954:1: ( rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ) - // InternalExpression.g:4955:2: rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 + // InternalExpression.g:5059:1: ( rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ) + // InternalExpression.g:5060:2: rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 { - pushFollow(FOLLOW_7); - rule__ConstructorCallExpression__Group__0__Impl(); + pushFollow(FOLLOW_6); + rule__IfExpressionKw__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__Group__1(); + rule__IfExpressionKw__Group__1(); state._fsp--; if (state.failed) return ; @@ -16448,28 +18556,28 @@ public final void rule__ConstructorCallExpression__Group__0() throws Recognition } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__0" + // $ANTLR end "rule__IfExpressionKw__Group__0" - // $ANTLR start "rule__ConstructorCallExpression__Group__0__Impl" - // InternalExpression.g:4962:1: rule__ConstructorCallExpression__Group__0__Impl : ( 'new' ) ; - public final void rule__ConstructorCallExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__0__Impl" + // InternalExpression.g:5067:1: rule__IfExpressionKw__Group__0__Impl : ( 'if' ) ; + public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4966:1: ( ( 'new' ) ) - // InternalExpression.g:4967:1: ( 'new' ) + // InternalExpression.g:5071:1: ( ( 'if' ) ) + // InternalExpression.g:5072:1: ( 'if' ) { - // InternalExpression.g:4967:1: ( 'new' ) - // InternalExpression.g:4968:2: 'new' + // InternalExpression.g:5072:1: ( 'if' ) + // InternalExpression.g:5073:2: 'if' { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } - match(input,55,FOLLOW_2); if (state.failed) return ; + match(input,70,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } } @@ -16489,21 +18597,26 @@ public final void rule__ConstructorCallExpression__Group__0__Impl() throws Recog } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__0__Impl" - // $ANTLR start "rule__ConstructorCallExpression__Group__1" - // InternalExpression.g:4977:1: rule__ConstructorCallExpression__Group__1 : rule__ConstructorCallExpression__Group__1__Impl ; - public final void rule__ConstructorCallExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__1" + // InternalExpression.g:5082:1: rule__IfExpressionKw__Group__1 : rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ; + public final void rule__IfExpressionKw__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4981:1: ( rule__ConstructorCallExpression__Group__1__Impl ) - // InternalExpression.g:4982:2: rule__ConstructorCallExpression__Group__1__Impl + // InternalExpression.g:5086:1: ( rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ) + // InternalExpression.g:5087:2: rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 { + pushFollow(FOLLOW_13); + rule__IfExpressionKw__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__Group__1__Impl(); + rule__IfExpressionKw__Group__2(); state._fsp--; if (state.failed) return ; @@ -16522,30 +18635,30 @@ public final void rule__ConstructorCallExpression__Group__1() throws Recognition } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__1" + // $ANTLR end "rule__IfExpressionKw__Group__1" - // $ANTLR start "rule__ConstructorCallExpression__Group__1__Impl" - // InternalExpression.g:4988:1: rule__ConstructorCallExpression__Group__1__Impl : ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ; - public final void rule__ConstructorCallExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__1__Impl" + // InternalExpression.g:5094:1: rule__IfExpressionKw__Group__1__Impl : ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ; + public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:4992:1: ( ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ) - // InternalExpression.g:4993:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + // InternalExpression.g:5098:1: ( ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ) + // InternalExpression.g:5099:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) { - // InternalExpression.g:4993:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) - // InternalExpression.g:4994:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + // InternalExpression.g:5099:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) + // InternalExpression.g:5100:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } - // InternalExpression.g:4995:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) - // InternalExpression.g:4995:3: rule__ConstructorCallExpression__TypeAssignment_1 + // InternalExpression.g:5101:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) + // InternalExpression.g:5101:3: rule__IfExpressionKw__ConditionAssignment_1 { pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__TypeAssignment_1(); + rule__IfExpressionKw__ConditionAssignment_1(); state._fsp--; if (state.failed) return ; @@ -16553,7 +18666,7 @@ public final void rule__ConstructorCallExpression__Group__1__Impl() throws Recog } if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } } @@ -16573,26 +18686,26 @@ public final void rule__ConstructorCallExpression__Group__1__Impl() throws Recog } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__1__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__0" - // InternalExpression.g:5004:1: rule__TypeSelectExpression__Group__0 : rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ; - public final void rule__TypeSelectExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__2" + // InternalExpression.g:5109:1: rule__IfExpressionKw__Group__2 : rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ; + public final void rule__IfExpressionKw__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5008:1: ( rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ) - // InternalExpression.g:5009:2: rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 + // InternalExpression.g:5113:1: ( rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ) + // InternalExpression.g:5114:2: rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 { - pushFollow(FOLLOW_33); - rule__TypeSelectExpression__Group__0__Impl(); + pushFollow(FOLLOW_6); + rule__IfExpressionKw__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__1(); + rule__IfExpressionKw__Group__3(); state._fsp--; if (state.failed) return ; @@ -16611,38 +18724,28 @@ public final void rule__TypeSelectExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__0" + // $ANTLR end "rule__IfExpressionKw__Group__2" - // $ANTLR start "rule__TypeSelectExpression__Group__0__Impl" - // InternalExpression.g:5016:1: rule__TypeSelectExpression__Group__0__Impl : ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ; - public final void rule__TypeSelectExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__2__Impl" + // InternalExpression.g:5121:1: rule__IfExpressionKw__Group__2__Impl : ( 'then' ) ; + public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5020:1: ( ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ) - // InternalExpression.g:5021:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + // InternalExpression.g:5125:1: ( ( 'then' ) ) + // InternalExpression.g:5126:1: ( 'then' ) { - // InternalExpression.g:5021:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) - // InternalExpression.g:5022:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + // InternalExpression.g:5126:1: ( 'then' ) + // InternalExpression.g:5127:2: 'then' { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); - } - // InternalExpression.g:5023:2: ( rule__TypeSelectExpression__NameAssignment_0 ) - // InternalExpression.g:5023:3: rule__TypeSelectExpression__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__TypeSelectExpression__NameAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } - + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } } @@ -16662,26 +18765,26 @@ public final void rule__TypeSelectExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__2__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__1" - // InternalExpression.g:5031:1: rule__TypeSelectExpression__Group__1 : rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ; - public final void rule__TypeSelectExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__3" + // InternalExpression.g:5136:1: rule__IfExpressionKw__Group__3 : rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ; + public final void rule__IfExpressionKw__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5035:1: ( rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ) - // InternalExpression.g:5036:2: rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 + // InternalExpression.g:5140:1: ( rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ) + // InternalExpression.g:5141:2: rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 { - pushFollow(FOLLOW_7); - rule__TypeSelectExpression__Group__1__Impl(); + pushFollow(FOLLOW_14); + rule__IfExpressionKw__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__2(); + rule__IfExpressionKw__Group__4(); state._fsp--; if (state.failed) return ; @@ -16700,28 +18803,38 @@ public final void rule__TypeSelectExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__1" + // $ANTLR end "rule__IfExpressionKw__Group__3" - // $ANTLR start "rule__TypeSelectExpression__Group__1__Impl" - // InternalExpression.g:5043:1: rule__TypeSelectExpression__Group__1__Impl : ( '(' ) ; - public final void rule__TypeSelectExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__3__Impl" + // InternalExpression.g:5148:1: rule__IfExpressionKw__Group__3__Impl : ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ; + public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5047:1: ( ( '(' ) ) - // InternalExpression.g:5048:1: ( '(' ) + // InternalExpression.g:5152:1: ( ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ) + // InternalExpression.g:5153:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) { - // InternalExpression.g:5048:1: ( '(' ) - // InternalExpression.g:5049:2: '(' + // InternalExpression.g:5153:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) + // InternalExpression.g:5154:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); + } + // InternalExpression.g:5155:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) + // InternalExpression.g:5155:3: rule__IfExpressionKw__ThenPartAssignment_3 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__ThenPartAssignment_3(); + + state._fsp--; + if (state.failed) return ; + } - match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } } @@ -16741,26 +18854,21 @@ public final void rule__TypeSelectExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__3__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__2" - // InternalExpression.g:5058:1: rule__TypeSelectExpression__Group__2 : rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ; - public final void rule__TypeSelectExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__4" + // InternalExpression.g:5163:1: rule__IfExpressionKw__Group__4 : rule__IfExpressionKw__Group__4__Impl ; + public final void rule__IfExpressionKw__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5062:1: ( rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ) - // InternalExpression.g:5063:2: rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 + // InternalExpression.g:5167:1: ( rule__IfExpressionKw__Group__4__Impl ) + // InternalExpression.g:5168:2: rule__IfExpressionKw__Group__4__Impl { - pushFollow(FOLLOW_8); - rule__TypeSelectExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__3(); + rule__IfExpressionKw__Group__4__Impl(); state._fsp--; if (state.failed) return ; @@ -16779,38 +18887,53 @@ public final void rule__TypeSelectExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__2" + // $ANTLR end "rule__IfExpressionKw__Group__4" - // $ANTLR start "rule__TypeSelectExpression__Group__2__Impl" - // InternalExpression.g:5070:1: rule__TypeSelectExpression__Group__2__Impl : ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ; - public final void rule__TypeSelectExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__4__Impl" + // InternalExpression.g:5174:1: rule__IfExpressionKw__Group__4__Impl : ( ( rule__IfExpressionKw__Group_4__0 )? ) ; + public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5074:1: ( ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ) - // InternalExpression.g:5075:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + // InternalExpression.g:5178:1: ( ( ( rule__IfExpressionKw__Group_4__0 )? ) ) + // InternalExpression.g:5179:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) { - // InternalExpression.g:5075:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) - // InternalExpression.g:5076:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + // InternalExpression.g:5179:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) + // InternalExpression.g:5180:2: ( rule__IfExpressionKw__Group_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } - // InternalExpression.g:5077:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) - // InternalExpression.g:5077:3: rule__TypeSelectExpression__TypeAssignment_2 - { - pushFollow(FOLLOW_2); - rule__TypeSelectExpression__TypeAssignment_2(); + // InternalExpression.g:5181:2: ( rule__IfExpressionKw__Group_4__0 )? + int alt59=2; + int LA59_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA59_0==72) ) { + int LA59_1 = input.LA(2); + + if ( (synpred132_InternalExpression()) ) { + alt59=1; + } + } + switch (alt59) { + case 1 : + // InternalExpression.g:5181:3: rule__IfExpressionKw__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } } @@ -16830,21 +18953,21 @@ public final void rule__TypeSelectExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__2__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__4__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__3" - // InternalExpression.g:5085:1: rule__TypeSelectExpression__Group__3 : rule__TypeSelectExpression__Group__3__Impl ; - public final void rule__TypeSelectExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4__0" + // InternalExpression.g:5190:1: rule__IfExpressionKw__Group_4__0 : rule__IfExpressionKw__Group_4__0__Impl ; + public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5089:1: ( rule__TypeSelectExpression__Group__3__Impl ) - // InternalExpression.g:5090:2: rule__TypeSelectExpression__Group__3__Impl + // InternalExpression.g:5194:1: ( rule__IfExpressionKw__Group_4__0__Impl ) + // InternalExpression.g:5195:2: rule__IfExpressionKw__Group_4__0__Impl { pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__3__Impl(); + rule__IfExpressionKw__Group_4__0__Impl(); state._fsp--; if (state.failed) return ; @@ -16863,28 +18986,38 @@ public final void rule__TypeSelectExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__3" + // $ANTLR end "rule__IfExpressionKw__Group_4__0" - // $ANTLR start "rule__TypeSelectExpression__Group__3__Impl" - // InternalExpression.g:5096:1: rule__TypeSelectExpression__Group__3__Impl : ( ')' ) ; - public final void rule__TypeSelectExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4__0__Impl" + // InternalExpression.g:5201:1: rule__IfExpressionKw__Group_4__0__Impl : ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ; + public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5100:1: ( ( ')' ) ) - // InternalExpression.g:5101:1: ( ')' ) + // InternalExpression.g:5205:1: ( ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ) + // InternalExpression.g:5206:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) { - // InternalExpression.g:5101:1: ( ')' ) - // InternalExpression.g:5102:2: ')' + // InternalExpression.g:5206:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) + // InternalExpression.g:5207:2: ( rule__IfExpressionKw__Group_4_0__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + } + // InternalExpression.g:5208:2: ( rule__IfExpressionKw__Group_4_0__0 ) + // InternalExpression.g:5208:3: rule__IfExpressionKw__Group_4_0__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4_0__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } } @@ -16904,26 +19037,26 @@ public final void rule__TypeSelectExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__3__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4__0__Impl" - // $ANTLR start "rule__CollectionExpression__Group__0" - // InternalExpression.g:5112:1: rule__CollectionExpression__Group__0 : rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ; - public final void rule__CollectionExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__0" + // InternalExpression.g:5217:1: rule__IfExpressionKw__Group_4_0__0 : rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ; + public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5116:1: ( rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ) - // InternalExpression.g:5117:2: rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 + // InternalExpression.g:5221:1: ( rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ) + // InternalExpression.g:5222:2: rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 { - pushFollow(FOLLOW_33); - rule__CollectionExpression__Group__0__Impl(); + pushFollow(FOLLOW_6); + rule__IfExpressionKw__Group_4_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__1(); + rule__IfExpressionKw__Group_4_0__1(); state._fsp--; if (state.failed) return ; @@ -16942,38 +19075,28 @@ public final void rule__CollectionExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__0" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__0" - // $ANTLR start "rule__CollectionExpression__Group__0__Impl" - // InternalExpression.g:5124:1: rule__CollectionExpression__Group__0__Impl : ( ( rule__CollectionExpression__NameAssignment_0 ) ) ; - public final void rule__CollectionExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__0__Impl" + // InternalExpression.g:5229:1: rule__IfExpressionKw__Group_4_0__0__Impl : ( 'else' ) ; + public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5128:1: ( ( ( rule__CollectionExpression__NameAssignment_0 ) ) ) - // InternalExpression.g:5129:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + // InternalExpression.g:5233:1: ( ( 'else' ) ) + // InternalExpression.g:5234:1: ( 'else' ) { - // InternalExpression.g:5129:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) - // InternalExpression.g:5130:2: ( rule__CollectionExpression__NameAssignment_0 ) + // InternalExpression.g:5234:1: ( 'else' ) + // InternalExpression.g:5235:2: 'else' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); - } - // InternalExpression.g:5131:2: ( rule__CollectionExpression__NameAssignment_0 ) - // InternalExpression.g:5131:3: rule__CollectionExpression__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__NameAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } - + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } } @@ -16993,26 +19116,21 @@ public final void rule__CollectionExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__0__Impl" - // $ANTLR start "rule__CollectionExpression__Group__1" - // InternalExpression.g:5139:1: rule__CollectionExpression__Group__1 : rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ; - public final void rule__CollectionExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__1" + // InternalExpression.g:5244:1: rule__IfExpressionKw__Group_4_0__1 : rule__IfExpressionKw__Group_4_0__1__Impl ; + public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5143:1: ( rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ) - // InternalExpression.g:5144:2: rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 + // InternalExpression.g:5248:1: ( rule__IfExpressionKw__Group_4_0__1__Impl ) + // InternalExpression.g:5249:2: rule__IfExpressionKw__Group_4_0__1__Impl { - pushFollow(FOLLOW_5); - rule__CollectionExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__2(); + rule__IfExpressionKw__Group_4_0__1__Impl(); state._fsp--; if (state.failed) return ; @@ -17031,28 +19149,38 @@ public final void rule__CollectionExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__1" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__1" - // $ANTLR start "rule__CollectionExpression__Group__1__Impl" - // InternalExpression.g:5151:1: rule__CollectionExpression__Group__1__Impl : ( '(' ) ; - public final void rule__CollectionExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__1__Impl" + // InternalExpression.g:5255:1: rule__IfExpressionKw__Group_4_0__1__Impl : ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ; + public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5155:1: ( ( '(' ) ) - // InternalExpression.g:5156:1: ( '(' ) + // InternalExpression.g:5259:1: ( ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ) + // InternalExpression.g:5260:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) { - // InternalExpression.g:5156:1: ( '(' ) - // InternalExpression.g:5157:2: '(' + // InternalExpression.g:5260:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) + // InternalExpression.g:5261:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); + } + // InternalExpression.g:5262:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) + // InternalExpression.g:5262:3: rule__IfExpressionKw__ElsePartAssignment_4_0_1 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__ElsePartAssignment_4_0_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } } @@ -17072,26 +19200,26 @@ public final void rule__CollectionExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__1__Impl" - // $ANTLR start "rule__CollectionExpression__Group__2" - // InternalExpression.g:5166:1: rule__CollectionExpression__Group__2 : rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ; - public final void rule__CollectionExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__0" + // InternalExpression.g:5271:1: rule__SwitchExpression__Group__0 : rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ; + public final void rule__SwitchExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5170:1: ( rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ) - // InternalExpression.g:5171:2: rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 + // InternalExpression.g:5275:1: ( rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ) + // InternalExpression.g:5276:2: rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 { - pushFollow(FOLLOW_5); - rule__CollectionExpression__Group__2__Impl(); + pushFollow(FOLLOW_15); + rule__SwitchExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__3(); + rule__SwitchExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -17110,53 +19238,28 @@ public final void rule__CollectionExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__2" + // $ANTLR end "rule__SwitchExpression__Group__0" - // $ANTLR start "rule__CollectionExpression__Group__2__Impl" - // InternalExpression.g:5178:1: rule__CollectionExpression__Group__2__Impl : ( ( rule__CollectionExpression__Group_2__0 )? ) ; - public final void rule__CollectionExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__0__Impl" + // InternalExpression.g:5283:1: rule__SwitchExpression__Group__0__Impl : ( 'switch' ) ; + public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5182:1: ( ( ( rule__CollectionExpression__Group_2__0 )? ) ) - // InternalExpression.g:5183:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + // InternalExpression.g:5287:1: ( ( 'switch' ) ) + // InternalExpression.g:5288:1: ( 'switch' ) { - // InternalExpression.g:5183:1: ( ( rule__CollectionExpression__Group_2__0 )? ) - // InternalExpression.g:5184:2: ( rule__CollectionExpression__Group_2__0 )? + // InternalExpression.g:5288:1: ( 'switch' ) + // InternalExpression.g:5289:2: 'switch' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); - } - // InternalExpression.g:5185:2: ( rule__CollectionExpression__Group_2__0 )? - int alt36=2; - int LA36_0 = input.LA(1); - - if ( (LA36_0==RULE_ID) ) { - int LA36_1 = input.LA(2); - - if ( (LA36_1==53) ) { - alt36=1; - } - } - switch (alt36) { - case 1 : - // InternalExpression.g:5185:3: rule__CollectionExpression__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } - + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } } @@ -17176,26 +19279,26 @@ public final void rule__CollectionExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__2__Impl" + // $ANTLR end "rule__SwitchExpression__Group__0__Impl" - // $ANTLR start "rule__CollectionExpression__Group__3" - // InternalExpression.g:5193:1: rule__CollectionExpression__Group__3 : rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ; - public final void rule__CollectionExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__1" + // InternalExpression.g:5298:1: rule__SwitchExpression__Group__1 : rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ; + public final void rule__SwitchExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5197:1: ( rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ) - // InternalExpression.g:5198:2: rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 + // InternalExpression.g:5302:1: ( rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ) + // InternalExpression.g:5303:2: rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 { - pushFollow(FOLLOW_8); - rule__CollectionExpression__Group__3__Impl(); + pushFollow(FOLLOW_15); + rule__SwitchExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__4(); + rule__SwitchExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -17214,38 +19317,49 @@ public final void rule__CollectionExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__3" + // $ANTLR end "rule__SwitchExpression__Group__1" - // $ANTLR start "rule__CollectionExpression__Group__3__Impl" - // InternalExpression.g:5205:1: rule__CollectionExpression__Group__3__Impl : ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ; - public final void rule__CollectionExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__1__Impl" + // InternalExpression.g:5310:1: rule__SwitchExpression__Group__1__Impl : ( ( rule__SwitchExpression__Group_1__0 )? ) ; + public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5209:1: ( ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ) - // InternalExpression.g:5210:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + // InternalExpression.g:5314:1: ( ( ( rule__SwitchExpression__Group_1__0 )? ) ) + // InternalExpression.g:5315:1: ( ( rule__SwitchExpression__Group_1__0 )? ) { - // InternalExpression.g:5210:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) - // InternalExpression.g:5211:2: ( rule__CollectionExpression__ExpAssignment_3 ) + // InternalExpression.g:5315:1: ( ( rule__SwitchExpression__Group_1__0 )? ) + // InternalExpression.g:5316:2: ( rule__SwitchExpression__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } - // InternalExpression.g:5212:2: ( rule__CollectionExpression__ExpAssignment_3 ) - // InternalExpression.g:5212:3: rule__CollectionExpression__ExpAssignment_3 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__ExpAssignment_3(); + // InternalExpression.g:5317:2: ( rule__SwitchExpression__Group_1__0 )? + int alt60=2; + int LA60_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA60_0==67) ) { + alt60=1; + } + switch (alt60) { + case 1 : + // InternalExpression.g:5317:3: rule__SwitchExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } } @@ -17265,21 +19379,26 @@ public final void rule__CollectionExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__3__Impl" + // $ANTLR end "rule__SwitchExpression__Group__1__Impl" - // $ANTLR start "rule__CollectionExpression__Group__4" - // InternalExpression.g:5220:1: rule__CollectionExpression__Group__4 : rule__CollectionExpression__Group__4__Impl ; - public final void rule__CollectionExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__2" + // InternalExpression.g:5325:1: rule__SwitchExpression__Group__2 : rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ; + public final void rule__SwitchExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5224:1: ( rule__CollectionExpression__Group__4__Impl ) - // InternalExpression.g:5225:2: rule__CollectionExpression__Group__4__Impl + // InternalExpression.g:5329:1: ( rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ) + // InternalExpression.g:5330:2: rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 { + pushFollow(FOLLOW_16); + rule__SwitchExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__4__Impl(); + rule__SwitchExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -17298,28 +19417,28 @@ public final void rule__CollectionExpression__Group__4() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__4" + // $ANTLR end "rule__SwitchExpression__Group__2" - // $ANTLR start "rule__CollectionExpression__Group__4__Impl" - // InternalExpression.g:5231:1: rule__CollectionExpression__Group__4__Impl : ( ')' ) ; - public final void rule__CollectionExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__2__Impl" + // InternalExpression.g:5337:1: rule__SwitchExpression__Group__2__Impl : ( '{' ) ; + public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5235:1: ( ( ')' ) ) - // InternalExpression.g:5236:1: ( ')' ) + // InternalExpression.g:5341:1: ( ( '{' ) ) + // InternalExpression.g:5342:1: ( '{' ) { - // InternalExpression.g:5236:1: ( ')' ) - // InternalExpression.g:5237:2: ')' + // InternalExpression.g:5342:1: ( '{' ) + // InternalExpression.g:5343:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } - match(input,40,FOLLOW_2); if (state.failed) return ; + match(input,74,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } } @@ -17339,26 +19458,26 @@ public final void rule__CollectionExpression__Group__4__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__4__Impl" + // $ANTLR end "rule__SwitchExpression__Group__2__Impl" - // $ANTLR start "rule__CollectionExpression__Group_2__0" - // InternalExpression.g:5247:1: rule__CollectionExpression__Group_2__0 : rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ; - public final void rule__CollectionExpression__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__3" + // InternalExpression.g:5352:1: rule__SwitchExpression__Group__3 : rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ; + public final void rule__SwitchExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5251:1: ( rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ) - // InternalExpression.g:5252:2: rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 + // InternalExpression.g:5356:1: ( rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ) + // InternalExpression.g:5357:2: rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 { - pushFollow(FOLLOW_39); - rule__CollectionExpression__Group_2__0__Impl(); + pushFollow(FOLLOW_16); + rule__SwitchExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__1(); + rule__SwitchExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -17377,38 +19496,56 @@ public final void rule__CollectionExpression__Group_2__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__0" + // $ANTLR end "rule__SwitchExpression__Group__3" - // $ANTLR start "rule__CollectionExpression__Group_2__0__Impl" - // InternalExpression.g:5259:1: rule__CollectionExpression__Group_2__0__Impl : ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ; - public final void rule__CollectionExpression__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__3__Impl" + // InternalExpression.g:5364:1: rule__SwitchExpression__Group__3__Impl : ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ; + public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5263:1: ( ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ) - // InternalExpression.g:5264:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + // InternalExpression.g:5368:1: ( ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ) + // InternalExpression.g:5369:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) { - // InternalExpression.g:5264:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) - // InternalExpression.g:5265:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + // InternalExpression.g:5369:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) + // InternalExpression.g:5370:2: ( rule__SwitchExpression__CaseAssignment_3 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } - // InternalExpression.g:5266:2: ( rule__CollectionExpression__VarAssignment_2_0 ) - // InternalExpression.g:5266:3: rule__CollectionExpression__VarAssignment_2_0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__VarAssignment_2_0(); + // InternalExpression.g:5371:2: ( rule__SwitchExpression__CaseAssignment_3 )* + loop61: + do { + int alt61=2; + int LA61_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA61_0==77) ) { + alt61=1; + } - } + + switch (alt61) { + case 1 : + // InternalExpression.g:5371:3: rule__SwitchExpression__CaseAssignment_3 + { + pushFollow(FOLLOW_17); + rule__SwitchExpression__CaseAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop61; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } } @@ -17428,21 +19565,26 @@ public final void rule__CollectionExpression__Group_2__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group__3__Impl" - // $ANTLR start "rule__CollectionExpression__Group_2__1" - // InternalExpression.g:5274:1: rule__CollectionExpression__Group_2__1 : rule__CollectionExpression__Group_2__1__Impl ; - public final void rule__CollectionExpression__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__4" + // InternalExpression.g:5379:1: rule__SwitchExpression__Group__4 : rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ; + public final void rule__SwitchExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5278:1: ( rule__CollectionExpression__Group_2__1__Impl ) - // InternalExpression.g:5279:2: rule__CollectionExpression__Group_2__1__Impl + // InternalExpression.g:5383:1: ( rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ) + // InternalExpression.g:5384:2: rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 { + pushFollow(FOLLOW_7); + rule__SwitchExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__1__Impl(); + rule__SwitchExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -17461,28 +19603,28 @@ public final void rule__CollectionExpression__Group_2__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__1" + // $ANTLR end "rule__SwitchExpression__Group__4" - // $ANTLR start "rule__CollectionExpression__Group_2__1__Impl" - // InternalExpression.g:5285:1: rule__CollectionExpression__Group_2__1__Impl : ( '|' ) ; - public final void rule__CollectionExpression__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__4__Impl" + // InternalExpression.g:5391:1: rule__SwitchExpression__Group__4__Impl : ( 'default' ) ; + public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5289:1: ( ( '|' ) ) - // InternalExpression.g:5290:1: ( '|' ) + // InternalExpression.g:5395:1: ( ( 'default' ) ) + // InternalExpression.g:5396:1: ( 'default' ) { - // InternalExpression.g:5290:1: ( '|' ) - // InternalExpression.g:5291:2: '|' + // InternalExpression.g:5396:1: ( 'default' ) + // InternalExpression.g:5397:2: 'default' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - match(input,53,FOLLOW_2); if (state.failed) return ; + match(input,75,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } } @@ -17502,26 +19644,26 @@ public final void rule__CollectionExpression__Group_2__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__1__Impl" - + // $ANTLR end "rule__SwitchExpression__Group__4__Impl" - // $ANTLR start "rule__CollectionType__Group__0" - // InternalExpression.g:5301:1: rule__CollectionType__Group__0 : rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ; - public final void rule__CollectionType__Group__0() throws RecognitionException { + + // $ANTLR start "rule__SwitchExpression__Group__5" + // InternalExpression.g:5406:1: rule__SwitchExpression__Group__5 : rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ; + public final void rule__SwitchExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5305:1: ( rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ) - // InternalExpression.g:5306:2: rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 + // InternalExpression.g:5410:1: ( rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ) + // InternalExpression.g:5411:2: rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 { - pushFollow(FOLLOW_42); - rule__CollectionType__Group__0__Impl(); + pushFollow(FOLLOW_18); + rule__SwitchExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__1(); + rule__SwitchExpression__Group__6(); state._fsp--; if (state.failed) return ; @@ -17540,38 +19682,28 @@ public final void rule__CollectionType__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__0" + // $ANTLR end "rule__SwitchExpression__Group__5" - // $ANTLR start "rule__CollectionType__Group__0__Impl" - // InternalExpression.g:5313:1: rule__CollectionType__Group__0__Impl : ( ( rule__CollectionType__ClAssignment_0 ) ) ; - public final void rule__CollectionType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__5__Impl" + // InternalExpression.g:5418:1: rule__SwitchExpression__Group__5__Impl : ( ':' ) ; + public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5317:1: ( ( ( rule__CollectionType__ClAssignment_0 ) ) ) - // InternalExpression.g:5318:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + // InternalExpression.g:5422:1: ( ( ':' ) ) + // InternalExpression.g:5423:1: ( ':' ) { - // InternalExpression.g:5318:1: ( ( rule__CollectionType__ClAssignment_0 ) ) - // InternalExpression.g:5319:2: ( rule__CollectionType__ClAssignment_0 ) + // InternalExpression.g:5423:1: ( ':' ) + // InternalExpression.g:5424:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); - } - // InternalExpression.g:5320:2: ( rule__CollectionType__ClAssignment_0 ) - // InternalExpression.g:5320:3: rule__CollectionType__ClAssignment_0 - { - pushFollow(FOLLOW_2); - rule__CollectionType__ClAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } - + match(input,66,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } } @@ -17591,26 +19723,26 @@ public final void rule__CollectionType__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group__5__Impl" - // $ANTLR start "rule__CollectionType__Group__1" - // InternalExpression.g:5328:1: rule__CollectionType__Group__1 : rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ; - public final void rule__CollectionType__Group__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__6" + // InternalExpression.g:5433:1: rule__SwitchExpression__Group__6 : rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ; + public final void rule__SwitchExpression__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5332:1: ( rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ) - // InternalExpression.g:5333:2: rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 + // InternalExpression.g:5437:1: ( rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ) + // InternalExpression.g:5438:2: rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 { - pushFollow(FOLLOW_7); - rule__CollectionType__Group__1__Impl(); + pushFollow(FOLLOW_19); + rule__SwitchExpression__Group__6__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__2(); + rule__SwitchExpression__Group__7(); state._fsp--; if (state.failed) return ; @@ -17629,28 +19761,38 @@ public final void rule__CollectionType__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__1" + // $ANTLR end "rule__SwitchExpression__Group__6" - // $ANTLR start "rule__CollectionType__Group__1__Impl" - // InternalExpression.g:5340:1: rule__CollectionType__Group__1__Impl : ( '[' ) ; - public final void rule__CollectionType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__6__Impl" + // InternalExpression.g:5445:1: rule__SwitchExpression__Group__6__Impl : ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ; + public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5344:1: ( ( '[' ) ) - // InternalExpression.g:5345:1: ( '[' ) + // InternalExpression.g:5449:1: ( ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ) + // InternalExpression.g:5450:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) { - // InternalExpression.g:5345:1: ( '[' ) - // InternalExpression.g:5346:2: '[' + // InternalExpression.g:5450:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) + // InternalExpression.g:5451:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } - match(input,56,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:5452:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) + // InternalExpression.g:5452:3: rule__SwitchExpression__DefaultExprAssignment_6 + { + pushFollow(FOLLOW_2); + rule__SwitchExpression__DefaultExprAssignment_6(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } } @@ -17670,26 +19812,21 @@ public final void rule__CollectionType__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group__6__Impl" - // $ANTLR start "rule__CollectionType__Group__2" - // InternalExpression.g:5355:1: rule__CollectionType__Group__2 : rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ; - public final void rule__CollectionType__Group__2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__7" + // InternalExpression.g:5460:1: rule__SwitchExpression__Group__7 : rule__SwitchExpression__Group__7__Impl ; + public final void rule__SwitchExpression__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5359:1: ( rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ) - // InternalExpression.g:5360:2: rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 + // InternalExpression.g:5464:1: ( rule__SwitchExpression__Group__7__Impl ) + // InternalExpression.g:5465:2: rule__SwitchExpression__Group__7__Impl { - pushFollow(FOLLOW_43); - rule__CollectionType__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__3(); + rule__SwitchExpression__Group__7__Impl(); state._fsp--; if (state.failed) return ; @@ -17708,38 +19845,28 @@ public final void rule__CollectionType__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__2" + // $ANTLR end "rule__SwitchExpression__Group__7" - // $ANTLR start "rule__CollectionType__Group__2__Impl" - // InternalExpression.g:5367:1: rule__CollectionType__Group__2__Impl : ( ( rule__CollectionType__Id1Assignment_2 ) ) ; - public final void rule__CollectionType__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__7__Impl" + // InternalExpression.g:5471:1: rule__SwitchExpression__Group__7__Impl : ( '}' ) ; + public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5371:1: ( ( ( rule__CollectionType__Id1Assignment_2 ) ) ) - // InternalExpression.g:5372:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + // InternalExpression.g:5475:1: ( ( '}' ) ) + // InternalExpression.g:5476:1: ( '}' ) { - // InternalExpression.g:5372:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) - // InternalExpression.g:5373:2: ( rule__CollectionType__Id1Assignment_2 ) + // InternalExpression.g:5476:1: ( '}' ) + // InternalExpression.g:5477:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); - } - // InternalExpression.g:5374:2: ( rule__CollectionType__Id1Assignment_2 ) - // InternalExpression.g:5374:3: rule__CollectionType__Id1Assignment_2 - { - pushFollow(FOLLOW_2); - rule__CollectionType__Id1Assignment_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } - + match(input,76,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } } @@ -17759,21 +19886,26 @@ public final void rule__CollectionType__Group__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__2__Impl" + // $ANTLR end "rule__SwitchExpression__Group__7__Impl" - // $ANTLR start "rule__CollectionType__Group__3" - // InternalExpression.g:5382:1: rule__CollectionType__Group__3 : rule__CollectionType__Group__3__Impl ; - public final void rule__CollectionType__Group__3() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__0" + // InternalExpression.g:5487:1: rule__SwitchExpression__Group_1__0 : rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ; + public final void rule__SwitchExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5386:1: ( rule__CollectionType__Group__3__Impl ) - // InternalExpression.g:5387:2: rule__CollectionType__Group__3__Impl + // InternalExpression.g:5491:1: ( rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ) + // InternalExpression.g:5492:2: rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 { + pushFollow(FOLLOW_18); + rule__SwitchExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__3__Impl(); + rule__SwitchExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -17792,28 +19924,28 @@ public final void rule__CollectionType__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__3" + // $ANTLR end "rule__SwitchExpression__Group_1__0" - // $ANTLR start "rule__CollectionType__Group__3__Impl" - // InternalExpression.g:5393:1: rule__CollectionType__Group__3__Impl : ( ']' ) ; - public final void rule__CollectionType__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__0__Impl" + // InternalExpression.g:5499:1: rule__SwitchExpression__Group_1__0__Impl : ( '(' ) ; + public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5397:1: ( ( ']' ) ) - // InternalExpression.g:5398:1: ( ']' ) + // InternalExpression.g:5503:1: ( ( '(' ) ) + // InternalExpression.g:5504:1: ( '(' ) { - // InternalExpression.g:5398:1: ( ']' ) - // InternalExpression.g:5399:2: ']' + // InternalExpression.g:5504:1: ( '(' ) + // InternalExpression.g:5505:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } - match(input,57,FOLLOW_2); if (state.failed) return ; + match(input,67,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } } @@ -17833,26 +19965,26 @@ public final void rule__CollectionType__Group__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__3__Impl" + // $ANTLR end "rule__SwitchExpression__Group_1__0__Impl" - // $ANTLR start "rule__SimpleType__Group__0" - // InternalExpression.g:5409:1: rule__SimpleType__Group__0 : rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ; - public final void rule__SimpleType__Group__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__1" + // InternalExpression.g:5514:1: rule__SwitchExpression__Group_1__1 : rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ; + public final void rule__SwitchExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5413:1: ( rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ) - // InternalExpression.g:5414:2: rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 + // InternalExpression.g:5518:1: ( rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ) + // InternalExpression.g:5519:2: rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 { - pushFollow(FOLLOW_44); - rule__SimpleType__Group__0__Impl(); + pushFollow(FOLLOW_9); + rule__SwitchExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group__1(); + rule__SwitchExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -17871,30 +20003,30 @@ public final void rule__SimpleType__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group__0" + // $ANTLR end "rule__SwitchExpression__Group_1__1" - // $ANTLR start "rule__SimpleType__Group__0__Impl" - // InternalExpression.g:5421:1: rule__SimpleType__Group__0__Impl : ( ( rule__SimpleType__IdAssignment_0 ) ) ; - public final void rule__SimpleType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__1__Impl" + // InternalExpression.g:5526:1: rule__SwitchExpression__Group_1__1__Impl : ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ; + public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5425:1: ( ( ( rule__SimpleType__IdAssignment_0 ) ) ) - // InternalExpression.g:5426:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + // InternalExpression.g:5530:1: ( ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ) + // InternalExpression.g:5531:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) { - // InternalExpression.g:5426:1: ( ( rule__SimpleType__IdAssignment_0 ) ) - // InternalExpression.g:5427:2: ( rule__SimpleType__IdAssignment_0 ) + // InternalExpression.g:5531:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) + // InternalExpression.g:5532:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } - // InternalExpression.g:5428:2: ( rule__SimpleType__IdAssignment_0 ) - // InternalExpression.g:5428:3: rule__SimpleType__IdAssignment_0 + // InternalExpression.g:5533:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) + // InternalExpression.g:5533:3: rule__SwitchExpression__SwitchExprAssignment_1_1 { pushFollow(FOLLOW_2); - rule__SimpleType__IdAssignment_0(); + rule__SwitchExpression__SwitchExprAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -17902,7 +20034,7 @@ public final void rule__SimpleType__Group__0__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } } @@ -17922,21 +20054,21 @@ public final void rule__SimpleType__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__SimpleType__Group__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group_1__1__Impl" - // $ANTLR start "rule__SimpleType__Group__1" - // InternalExpression.g:5436:1: rule__SimpleType__Group__1 : rule__SimpleType__Group__1__Impl ; - public final void rule__SimpleType__Group__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__2" + // InternalExpression.g:5541:1: rule__SwitchExpression__Group_1__2 : rule__SwitchExpression__Group_1__2__Impl ; + public final void rule__SwitchExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5440:1: ( rule__SimpleType__Group__1__Impl ) - // InternalExpression.g:5441:2: rule__SimpleType__Group__1__Impl + // InternalExpression.g:5545:1: ( rule__SwitchExpression__Group_1__2__Impl ) + // InternalExpression.g:5546:2: rule__SwitchExpression__Group_1__2__Impl { pushFollow(FOLLOW_2); - rule__SimpleType__Group__1__Impl(); + rule__SwitchExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -17955,56 +20087,28 @@ public final void rule__SimpleType__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group__1" + // $ANTLR end "rule__SwitchExpression__Group_1__2" - // $ANTLR start "rule__SimpleType__Group__1__Impl" - // InternalExpression.g:5447:1: rule__SimpleType__Group__1__Impl : ( ( rule__SimpleType__Group_1__0 )* ) ; - public final void rule__SimpleType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__2__Impl" + // InternalExpression.g:5552:1: rule__SwitchExpression__Group_1__2__Impl : ( ')' ) ; + public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5451:1: ( ( ( rule__SimpleType__Group_1__0 )* ) ) - // InternalExpression.g:5452:1: ( ( rule__SimpleType__Group_1__0 )* ) + // InternalExpression.g:5556:1: ( ( ')' ) ) + // InternalExpression.g:5557:1: ( ')' ) { - // InternalExpression.g:5452:1: ( ( rule__SimpleType__Group_1__0 )* ) - // InternalExpression.g:5453:2: ( rule__SimpleType__Group_1__0 )* + // InternalExpression.g:5557:1: ( ')' ) + // InternalExpression.g:5558:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getGroup_1()); + before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } - // InternalExpression.g:5454:2: ( rule__SimpleType__Group_1__0 )* - loop37: - do { - int alt37=2; - int LA37_0 = input.LA(1); - - if ( (LA37_0==58) ) { - alt37=1; - } - - - switch (alt37) { - case 1 : - // InternalExpression.g:5454:3: rule__SimpleType__Group_1__0 - { - pushFollow(FOLLOW_45); - rule__SimpleType__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop37; - } - } while (true); - + match(input,68,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getGroup_1()); + after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } } @@ -18024,26 +20128,26 @@ public final void rule__SimpleType__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__SimpleType__Group__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group_1__2__Impl" - // $ANTLR start "rule__SimpleType__Group_1__0" - // InternalExpression.g:5463:1: rule__SimpleType__Group_1__0 : rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ; - public final void rule__SimpleType__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__Case__Group__0" + // InternalExpression.g:5568:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; + public final void rule__Case__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5467:1: ( rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ) - // InternalExpression.g:5468:2: rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 + // InternalExpression.g:5572:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) + // InternalExpression.g:5573:2: rule__Case__Group__0__Impl rule__Case__Group__1 { - pushFollow(FOLLOW_3); - rule__SimpleType__Group_1__0__Impl(); + pushFollow(FOLLOW_18); + rule__Case__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group_1__1(); + rule__Case__Group__1(); state._fsp--; if (state.failed) return ; @@ -18062,28 +20166,28 @@ public final void rule__SimpleType__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group_1__0" + // $ANTLR end "rule__Case__Group__0" - // $ANTLR start "rule__SimpleType__Group_1__0__Impl" - // InternalExpression.g:5475:1: rule__SimpleType__Group_1__0__Impl : ( '::' ) ; - public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Case__Group__0__Impl" + // InternalExpression.g:5580:1: rule__Case__Group__0__Impl : ( 'case' ) ; + public final void rule__Case__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5479:1: ( ( '::' ) ) - // InternalExpression.g:5480:1: ( '::' ) + // InternalExpression.g:5584:1: ( ( 'case' ) ) + // InternalExpression.g:5585:1: ( 'case' ) { - // InternalExpression.g:5480:1: ( '::' ) - // InternalExpression.g:5481:2: '::' + // InternalExpression.g:5585:1: ( 'case' ) + // InternalExpression.g:5586:2: 'case' { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } - match(input,58,FOLLOW_2); if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } } @@ -18103,21 +20207,26 @@ public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SimpleType__Group_1__0__Impl" + // $ANTLR end "rule__Case__Group__0__Impl" - // $ANTLR start "rule__SimpleType__Group_1__1" - // InternalExpression.g:5490:1: rule__SimpleType__Group_1__1 : rule__SimpleType__Group_1__1__Impl ; - public final void rule__SimpleType__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__1" + // InternalExpression.g:5595:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; + public final void rule__Case__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5494:1: ( rule__SimpleType__Group_1__1__Impl ) - // InternalExpression.g:5495:2: rule__SimpleType__Group_1__1__Impl + // InternalExpression.g:5599:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) + // InternalExpression.g:5600:2: rule__Case__Group__1__Impl rule__Case__Group__2 { + pushFollow(FOLLOW_7); + rule__Case__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group_1__1__Impl(); + rule__Case__Group__2(); state._fsp--; if (state.failed) return ; @@ -18136,30 +20245,30 @@ public final void rule__SimpleType__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group_1__1" + // $ANTLR end "rule__Case__Group__1" - // $ANTLR start "rule__SimpleType__Group_1__1__Impl" - // InternalExpression.g:5501:1: rule__SimpleType__Group_1__1__Impl : ( ( rule__SimpleType__IdAssignment_1_1 ) ) ; - public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Case__Group__1__Impl" + // InternalExpression.g:5607:1: rule__Case__Group__1__Impl : ( ( rule__Case__ConditionAssignment_1 ) ) ; + public final void rule__Case__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5505:1: ( ( ( rule__SimpleType__IdAssignment_1_1 ) ) ) - // InternalExpression.g:5506:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + // InternalExpression.g:5611:1: ( ( ( rule__Case__ConditionAssignment_1 ) ) ) + // InternalExpression.g:5612:1: ( ( rule__Case__ConditionAssignment_1 ) ) { - // InternalExpression.g:5506:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) - // InternalExpression.g:5507:2: ( rule__SimpleType__IdAssignment_1_1 ) + // InternalExpression.g:5612:1: ( ( rule__Case__ConditionAssignment_1 ) ) + // InternalExpression.g:5613:2: ( rule__Case__ConditionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } - // InternalExpression.g:5508:2: ( rule__SimpleType__IdAssignment_1_1 ) - // InternalExpression.g:5508:3: rule__SimpleType__IdAssignment_1_1 + // InternalExpression.g:5614:2: ( rule__Case__ConditionAssignment_1 ) + // InternalExpression.g:5614:3: rule__Case__ConditionAssignment_1 { pushFollow(FOLLOW_2); - rule__SimpleType__IdAssignment_1_1(); + rule__Case__ConditionAssignment_1(); state._fsp--; if (state.failed) return ; @@ -18167,7 +20276,7 @@ public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionExcepti } if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } } @@ -18187,36 +20296,29 @@ public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SimpleType__Group_1__1__Impl" + // $ANTLR end "rule__Case__Group__1__Impl" - // $ANTLR start "rule__LetExpression__IdentifierAssignment_1" - // InternalExpression.g:5517:1: rule__LetExpression__IdentifierAssignment_1 : ( ruleIdentifier ) ; - public final void rule__LetExpression__IdentifierAssignment_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__2" + // InternalExpression.g:5622:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ; + public final void rule__Case__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5521:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:5522:2: ( ruleIdentifier ) + // InternalExpression.g:5626:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 ) + // InternalExpression.g:5627:2: rule__Case__Group__2__Impl rule__Case__Group__3 { - // InternalExpression.g:5522:2: ( ruleIdentifier ) - // InternalExpression.g:5523:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_18); + rule__Case__Group__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__Case__Group__3(); + state._fsp--; + if (state.failed) return ; } @@ -18232,32 +20334,28 @@ public final void rule__LetExpression__IdentifierAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__LetExpression__IdentifierAssignment_1" + // $ANTLR end "rule__Case__Group__2" - // $ANTLR start "rule__LetExpression__VarExprAssignment_3" - // InternalExpression.g:5532:1: rule__LetExpression__VarExprAssignment_3 : ( ruleExpression ) ; - public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionException { + // $ANTLR start "rule__Case__Group__2__Impl" + // InternalExpression.g:5634:1: rule__Case__Group__2__Impl : ( ':' ) ; + public final void rule__Case__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5536:1: ( ( ruleExpression ) ) - // InternalExpression.g:5537:2: ( ruleExpression ) + // InternalExpression.g:5638:1: ( ( ':' ) ) + // InternalExpression.g:5639:1: ( ':' ) { - // InternalExpression.g:5537:2: ( ruleExpression ) - // InternalExpression.g:5538:3: ruleExpression + // InternalExpression.g:5639:1: ( ':' ) + // InternalExpression.g:5640:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + before(grammarAccess.getCaseAccess().getColonKeyword_2()); } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,66,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + after(grammarAccess.getCaseAccess().getColonKeyword_2()); } } @@ -18277,36 +20375,24 @@ public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionE } return ; } - // $ANTLR end "rule__LetExpression__VarExprAssignment_3" + // $ANTLR end "rule__Case__Group__2__Impl" - // $ANTLR start "rule__LetExpression__TargetAssignment_5" - // InternalExpression.g:5547:1: rule__LetExpression__TargetAssignment_5 : ( ruleExpression ) ; - public final void rule__LetExpression__TargetAssignment_5() throws RecognitionException { + // $ANTLR start "rule__Case__Group__3" + // InternalExpression.g:5649:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ; + public final void rule__Case__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5551:1: ( ( ruleExpression ) ) - // InternalExpression.g:5552:2: ( ruleExpression ) + // InternalExpression.g:5653:1: ( rule__Case__Group__3__Impl ) + // InternalExpression.g:5654:2: rule__Case__Group__3__Impl { - // InternalExpression.g:5552:2: ( ruleExpression ) - // InternalExpression.g:5553:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__Case__Group__3__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); - } - - } - } @@ -18322,32 +20408,38 @@ public final void rule__LetExpression__TargetAssignment_5() throws RecognitionEx } return ; } - // $ANTLR end "rule__LetExpression__TargetAssignment_5" + // $ANTLR end "rule__Case__Group__3" - // $ANTLR start "rule__CastedExpression__TypeAssignment_1" - // InternalExpression.g:5562:1: rule__CastedExpression__TypeAssignment_1 : ( ruleType ) ; - public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__3__Impl" + // InternalExpression.g:5660:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenParAssignment_3 ) ) ; + public final void rule__Case__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5566:1: ( ( ruleType ) ) - // InternalExpression.g:5567:2: ( ruleType ) + // InternalExpression.g:5664:1: ( ( ( rule__Case__ThenParAssignment_3 ) ) ) + // InternalExpression.g:5665:1: ( ( rule__Case__ThenParAssignment_3 ) ) { - // InternalExpression.g:5567:2: ( ruleType ) - // InternalExpression.g:5568:3: ruleType + // InternalExpression.g:5665:1: ( ( rule__Case__ThenParAssignment_3 ) ) + // InternalExpression.g:5666:2: ( rule__Case__ThenParAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + // InternalExpression.g:5667:2: ( rule__Case__ThenParAssignment_3 ) + // InternalExpression.g:5667:3: rule__Case__ThenParAssignment_3 + { pushFollow(FOLLOW_2); - ruleType(); + rule__Case__ThenParAssignment_3(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } } @@ -18367,36 +20459,29 @@ public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionE } return ; } - // $ANTLR end "rule__CastedExpression__TypeAssignment_1" + // $ANTLR end "rule__Case__Group__3__Impl" - // $ANTLR start "rule__CastedExpression__TargetAssignment_3" - // InternalExpression.g:5577:1: rule__CastedExpression__TargetAssignment_3 : ( ruleExpression ) ; - public final void rule__CastedExpression__TargetAssignment_3() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__0" + // InternalExpression.g:5676:1: rule__OrExpression__Group__0 : rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ; + public final void rule__OrExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5581:1: ( ( ruleExpression ) ) - // InternalExpression.g:5582:2: ( ruleExpression ) + // InternalExpression.g:5680:1: ( rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ) + // InternalExpression.g:5681:2: rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 { - // InternalExpression.g:5582:2: ( ruleExpression ) - // InternalExpression.g:5583:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_20); + rule__OrExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -18412,32 +20497,32 @@ public final void rule__CastedExpression__TargetAssignment_3() throws Recognitio } return ; } - // $ANTLR end "rule__CastedExpression__TargetAssignment_3" + // $ANTLR end "rule__OrExpression__Group__0" - // $ANTLR start "rule__ChainExpression__NextAssignment_1_2" - // InternalExpression.g:5592:1: rule__ChainExpression__NextAssignment_1_2 : ( ruleChainedExpression ) ; - public final void rule__ChainExpression__NextAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__0__Impl" + // InternalExpression.g:5688:1: rule__OrExpression__Group__0__Impl : ( ruleAndExpression ) ; + public final void rule__OrExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5596:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:5597:2: ( ruleChainedExpression ) + // InternalExpression.g:5692:1: ( ( ruleAndExpression ) ) + // InternalExpression.g:5693:1: ( ruleAndExpression ) { - // InternalExpression.g:5597:2: ( ruleChainedExpression ) - // InternalExpression.g:5598:3: ruleChainedExpression + // InternalExpression.g:5693:1: ( ruleAndExpression ) + // InternalExpression.g:5694:2: ruleAndExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleChainedExpression(); + ruleAndExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } } @@ -18457,36 +20542,24 @@ public final void rule__ChainExpression__NextAssignment_1_2() throws Recognition } return ; } - // $ANTLR end "rule__ChainExpression__NextAssignment_1_2" + // $ANTLR end "rule__OrExpression__Group__0__Impl" - // $ANTLR start "rule__IfExpressionTri__ThenPartAssignment_1_2" - // InternalExpression.g:5607:1: rule__IfExpressionTri__ThenPartAssignment_1_2 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__1" + // InternalExpression.g:5703:1: rule__OrExpression__Group__1 : rule__OrExpression__Group__1__Impl ; + public final void rule__OrExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5611:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:5612:2: ( ruleChainedExpression ) + // InternalExpression.g:5707:1: ( rule__OrExpression__Group__1__Impl ) + // InternalExpression.g:5708:2: rule__OrExpression__Group__1__Impl { - // InternalExpression.g:5612:2: ( ruleChainedExpression ) - // InternalExpression.g:5613:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleChainedExpression(); + rule__OrExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -18502,32 +20575,56 @@ public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws Recogni } return ; } - // $ANTLR end "rule__IfExpressionTri__ThenPartAssignment_1_2" + // $ANTLR end "rule__OrExpression__Group__1" - // $ANTLR start "rule__IfExpressionTri__ElsePartAssignment_1_4" - // InternalExpression.g:5622:1: rule__IfExpressionTri__ElsePartAssignment_1_4 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__1__Impl" + // InternalExpression.g:5714:1: rule__OrExpression__Group__1__Impl : ( ( rule__OrExpression__Group_1__0 )* ) ; + public final void rule__OrExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5626:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:5627:2: ( ruleChainedExpression ) + // InternalExpression.g:5718:1: ( ( ( rule__OrExpression__Group_1__0 )* ) ) + // InternalExpression.g:5719:1: ( ( rule__OrExpression__Group_1__0 )* ) { - // InternalExpression.g:5627:2: ( ruleChainedExpression ) - // InternalExpression.g:5628:3: ruleChainedExpression + // InternalExpression.g:5719:1: ( ( rule__OrExpression__Group_1__0 )* ) + // InternalExpression.g:5720:2: ( rule__OrExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + before(grammarAccess.getOrExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + // InternalExpression.g:5721:2: ( rule__OrExpression__Group_1__0 )* + loop62: + do { + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==15) ) { + alt62=1; + } + + + switch (alt62) { + case 1 : + // InternalExpression.g:5721:3: rule__OrExpression__Group_1__0 + { + pushFollow(FOLLOW_21); + rule__OrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop62; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + after(grammarAccess.getOrExpressionAccess().getGroup_1()); } } @@ -18547,36 +20644,29 @@ public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws Recogni } return ; } - // $ANTLR end "rule__IfExpressionTri__ElsePartAssignment_1_4" + // $ANTLR end "rule__OrExpression__Group__1__Impl" - // $ANTLR start "rule__IfExpressionKw__ConditionAssignment_1" - // InternalExpression.g:5637:1: rule__IfExpressionKw__ConditionAssignment_1 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ConditionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__0" + // InternalExpression.g:5730:1: rule__OrExpression__Group_1__0 : rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ; + public final void rule__OrExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5641:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:5642:2: ( ruleChainedExpression ) + // InternalExpression.g:5734:1: ( rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ) + // InternalExpression.g:5735:2: rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 { - // InternalExpression.g:5642:2: ( ruleChainedExpression ) - // InternalExpression.g:5643:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + pushFollow(FOLLOW_20); + rule__OrExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -18592,32 +20682,32 @@ public final void rule__IfExpressionKw__ConditionAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__IfExpressionKw__ConditionAssignment_1" + // $ANTLR end "rule__OrExpression__Group_1__0" - // $ANTLR start "rule__IfExpressionKw__ThenPartAssignment_3" - // InternalExpression.g:5652:1: rule__IfExpressionKw__ThenPartAssignment_3 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ThenPartAssignment_3() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__0__Impl" + // InternalExpression.g:5742:1: rule__OrExpression__Group_1__0__Impl : ( () ) ; + public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5656:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:5657:2: ( ruleChainedExpression ) + // InternalExpression.g:5746:1: ( ( () ) ) + // InternalExpression.g:5747:1: ( () ) { - // InternalExpression.g:5657:2: ( ruleChainedExpression ) - // InternalExpression.g:5658:3: ruleChainedExpression + // InternalExpression.g:5747:1: ( () ) + // InternalExpression.g:5748:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + // InternalExpression.g:5749:2: () + // InternalExpression.g:5749:3: + { } - pushFollow(FOLLOW_2); - ruleChainedExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -18626,10 +20716,6 @@ public final void rule__IfExpressionKw__ThenPartAssignment_3() throws Recognitio } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -18637,36 +20723,29 @@ public final void rule__IfExpressionKw__ThenPartAssignment_3() throws Recognitio } return ; } - // $ANTLR end "rule__IfExpressionKw__ThenPartAssignment_3" + // $ANTLR end "rule__OrExpression__Group_1__0__Impl" - // $ANTLR start "rule__IfExpressionKw__ElsePartAssignment_4_0_1" - // InternalExpression.g:5667:1: rule__IfExpressionKw__ElsePartAssignment_4_0_1 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__1" + // InternalExpression.g:5757:1: rule__OrExpression__Group_1__1 : rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ; + public final void rule__OrExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5671:1: ( ( ruleChainedExpression ) ) - // InternalExpression.g:5672:2: ( ruleChainedExpression ) + // InternalExpression.g:5761:1: ( rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ) + // InternalExpression.g:5762:2: rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 { - // InternalExpression.g:5672:2: ( ruleChainedExpression ) - // InternalExpression.g:5673:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + pushFollow(FOLLOW_18); + rule__OrExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -18682,32 +20761,38 @@ public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws Recogn } return ; } - // $ANTLR end "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + // $ANTLR end "rule__OrExpression__Group_1__1" - // $ANTLR start "rule__SwitchExpression__SwitchExprAssignment_1_1" - // InternalExpression.g:5682:1: rule__SwitchExpression__SwitchExprAssignment_1_1 : ( ruleOrExpression ) ; - public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__1__Impl" + // InternalExpression.g:5769:1: rule__OrExpression__Group_1__1__Impl : ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5686:1: ( ( ruleOrExpression ) ) - // InternalExpression.g:5687:2: ( ruleOrExpression ) + // InternalExpression.g:5773:1: ( ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ) + // InternalExpression.g:5774:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) { - // InternalExpression.g:5687:2: ( ruleOrExpression ) - // InternalExpression.g:5688:3: ruleOrExpression + // InternalExpression.g:5774:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) + // InternalExpression.g:5775:2: ( rule__OrExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + // InternalExpression.g:5776:2: ( rule__OrExpression__OperatorAssignment_1_1 ) + // InternalExpression.g:5776:3: rule__OrExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__OrExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } } @@ -18727,36 +20812,24 @@ public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws Reco } return ; } - // $ANTLR end "rule__SwitchExpression__SwitchExprAssignment_1_1" + // $ANTLR end "rule__OrExpression__Group_1__1__Impl" - // $ANTLR start "rule__SwitchExpression__CaseAssignment_3" - // InternalExpression.g:5697:1: rule__SwitchExpression__CaseAssignment_3 : ( ruleCase ) ; - public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__2" + // InternalExpression.g:5784:1: rule__OrExpression__Group_1__2 : rule__OrExpression__Group_1__2__Impl ; + public final void rule__OrExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5701:1: ( ( ruleCase ) ) - // InternalExpression.g:5702:2: ( ruleCase ) - { - // InternalExpression.g:5702:2: ( ruleCase ) - // InternalExpression.g:5703:3: ruleCase + // InternalExpression.g:5788:1: ( rule__OrExpression__Group_1__2__Impl ) + // InternalExpression.g:5789:2: rule__OrExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); - } pushFollow(FOLLOW_2); - ruleCase(); + rule__OrExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); - } - - } - } @@ -18772,32 +20845,38 @@ public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__CaseAssignment_3" + // $ANTLR end "rule__OrExpression__Group_1__2" - // $ANTLR start "rule__SwitchExpression__DefaultExprAssignment_6" - // InternalExpression.g:5712:1: rule__SwitchExpression__DefaultExprAssignment_6 : ( ruleOrExpression ) ; - public final void rule__SwitchExpression__DefaultExprAssignment_6() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__2__Impl" + // InternalExpression.g:5795:1: rule__OrExpression__Group_1__2__Impl : ( ( rule__OrExpression__RightAssignment_1_2 ) ) ; + public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5716:1: ( ( ruleOrExpression ) ) - // InternalExpression.g:5717:2: ( ruleOrExpression ) + // InternalExpression.g:5799:1: ( ( ( rule__OrExpression__RightAssignment_1_2 ) ) ) + // InternalExpression.g:5800:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) { - // InternalExpression.g:5717:2: ( ruleOrExpression ) - // InternalExpression.g:5718:3: ruleOrExpression + // InternalExpression.g:5800:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) + // InternalExpression.g:5801:2: ( rule__OrExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + // InternalExpression.g:5802:2: ( rule__OrExpression__RightAssignment_1_2 ) + // InternalExpression.g:5802:3: rule__OrExpression__RightAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__OrExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } } @@ -18817,36 +20896,29 @@ public final void rule__SwitchExpression__DefaultExprAssignment_6() throws Recog } return ; } - // $ANTLR end "rule__SwitchExpression__DefaultExprAssignment_6" + // $ANTLR end "rule__OrExpression__Group_1__2__Impl" - // $ANTLR start "rule__Case__ConditionAssignment_1" - // InternalExpression.g:5727:1: rule__Case__ConditionAssignment_1 : ( ruleOrExpression ) ; - public final void rule__Case__ConditionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__0" + // InternalExpression.g:5811:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ; + public final void rule__AndExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5731:1: ( ( ruleOrExpression ) ) - // InternalExpression.g:5732:2: ( ruleOrExpression ) - { - // InternalExpression.g:5732:2: ( ruleOrExpression ) - // InternalExpression.g:5733:3: ruleOrExpression + // InternalExpression.g:5815:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ) + // InternalExpression.g:5816:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); - } + pushFollow(FOLLOW_22); + rule__AndExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__AndExpression__Group__1(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); - } - - } - } @@ -18862,32 +20934,32 @@ public final void rule__Case__ConditionAssignment_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Case__ConditionAssignment_1" + // $ANTLR end "rule__AndExpression__Group__0" - // $ANTLR start "rule__Case__ThenParAssignment_3" - // InternalExpression.g:5742:1: rule__Case__ThenParAssignment_3 : ( ruleOrExpression ) ; - public final void rule__Case__ThenParAssignment_3() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__0__Impl" + // InternalExpression.g:5823:1: rule__AndExpression__Group__0__Impl : ( ruleImpliesExpression ) ; + public final void rule__AndExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5746:1: ( ( ruleOrExpression ) ) - // InternalExpression.g:5747:2: ( ruleOrExpression ) + // InternalExpression.g:5827:1: ( ( ruleImpliesExpression ) ) + // InternalExpression.g:5828:1: ( ruleImpliesExpression ) { - // InternalExpression.g:5747:2: ( ruleOrExpression ) - // InternalExpression.g:5748:3: ruleOrExpression + // InternalExpression.g:5828:1: ( ruleImpliesExpression ) + // InternalExpression.g:5829:2: ruleImpliesExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleOrExpression(); + ruleImpliesExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } } @@ -18907,44 +20979,24 @@ public final void rule__Case__ThenParAssignment_3() throws RecognitionException } return ; } - // $ANTLR end "rule__Case__ThenParAssignment_3" + // $ANTLR end "rule__AndExpression__Group__0__Impl" - // $ANTLR start "rule__OrExpression__OperatorAssignment_1_1" - // InternalExpression.g:5757:1: rule__OrExpression__OperatorAssignment_1_1 : ( ( '||' ) ) ; - public final void rule__OrExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__1" + // InternalExpression.g:5838:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ; + public final void rule__AndExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5761:1: ( ( ( '||' ) ) ) - // InternalExpression.g:5762:2: ( ( '||' ) ) - { - // InternalExpression.g:5762:2: ( ( '||' ) ) - // InternalExpression.g:5763:3: ( '||' ) + // InternalExpression.g:5842:1: ( rule__AndExpression__Group__1__Impl ) + // InternalExpression.g:5843:2: rule__AndExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - // InternalExpression.g:5764:3: ( '||' ) - // InternalExpression.g:5765:4: '||' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - match(input,59,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group__1__Impl(); + state._fsp--; + if (state.failed) return ; } @@ -18960,85 +21012,56 @@ public final void rule__OrExpression__OperatorAssignment_1_1() throws Recognitio } return ; } - // $ANTLR end "rule__OrExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__AndExpression__Group__1" - // $ANTLR start "rule__OrExpression__RightAssignment_1_2" - // InternalExpression.g:5776:1: rule__OrExpression__RightAssignment_1_2 : ( ruleAndExpression ) ; - public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__1__Impl" + // InternalExpression.g:5849:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ; + public final void rule__AndExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5780:1: ( ( ruleAndExpression ) ) - // InternalExpression.g:5781:2: ( ruleAndExpression ) + // InternalExpression.g:5853:1: ( ( ( rule__AndExpression__Group_1__0 )* ) ) + // InternalExpression.g:5854:1: ( ( rule__AndExpression__Group_1__0 )* ) { - // InternalExpression.g:5781:2: ( ruleAndExpression ) - // InternalExpression.g:5782:3: ruleAndExpression + // InternalExpression.g:5854:1: ( ( rule__AndExpression__Group_1__0 )* ) + // InternalExpression.g:5855:2: ( rule__AndExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleAndExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); - } - - } - - + before(grammarAccess.getAndExpressionAccess().getGroup_1()); } + // InternalExpression.g:5856:2: ( rule__AndExpression__Group_1__0 )* + loop63: + do { + int alt63=2; + int LA63_0 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + if ( (LA63_0==16) ) { + alt63=1; + } - } - return ; - } - // $ANTLR end "rule__OrExpression__RightAssignment_1_2" + switch (alt63) { + case 1 : + // InternalExpression.g:5856:3: rule__AndExpression__Group_1__0 + { + pushFollow(FOLLOW_23); + rule__AndExpression__Group_1__0(); - // $ANTLR start "rule__AndExpression__OperatorAssignment_1_1" - // InternalExpression.g:5791:1: rule__AndExpression__OperatorAssignment_1_1 : ( ( '&&' ) ) ; - public final void rule__AndExpression__OperatorAssignment_1_1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:5795:1: ( ( ( '&&' ) ) ) - // InternalExpression.g:5796:2: ( ( '&&' ) ) - { - // InternalExpression.g:5796:2: ( ( '&&' ) ) - // InternalExpression.g:5797:3: ( '&&' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); - } - // InternalExpression.g:5798:3: ( '&&' ) - // InternalExpression.g:5799:4: '&&' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); - } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); - } + } + break; - } + default : + break loop63; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + after(grammarAccess.getAndExpressionAccess().getGroup_1()); } } @@ -19058,36 +21081,29 @@ public final void rule__AndExpression__OperatorAssignment_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__AndExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__AndExpression__Group__1__Impl" - // $ANTLR start "rule__AndExpression__RightAssignment_1_2" - // InternalExpression.g:5810:1: rule__AndExpression__RightAssignment_1_2 : ( ruleImpliesExpression ) ; - public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__0" + // InternalExpression.g:5865:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ; + public final void rule__AndExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5814:1: ( ( ruleImpliesExpression ) ) - // InternalExpression.g:5815:2: ( ruleImpliesExpression ) + // InternalExpression.g:5869:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ) + // InternalExpression.g:5870:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 { - // InternalExpression.g:5815:2: ( ruleImpliesExpression ) - // InternalExpression.g:5816:3: ruleImpliesExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleImpliesExpression(); + pushFollow(FOLLOW_22); + rule__AndExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -19103,40 +21119,32 @@ public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionE } return ; } - // $ANTLR end "rule__AndExpression__RightAssignment_1_2" + // $ANTLR end "rule__AndExpression__Group_1__0" - // $ANTLR start "rule__ImpliesExpression__OperatorAssignment_1_1" - // InternalExpression.g:5825:1: rule__ImpliesExpression__OperatorAssignment_1_1 : ( ( 'implies' ) ) ; - public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__0__Impl" + // InternalExpression.g:5877:1: rule__AndExpression__Group_1__0__Impl : ( () ) ; + public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5829:1: ( ( ( 'implies' ) ) ) - // InternalExpression.g:5830:2: ( ( 'implies' ) ) + // InternalExpression.g:5881:1: ( ( () ) ) + // InternalExpression.g:5882:1: ( () ) { - // InternalExpression.g:5830:2: ( ( 'implies' ) ) - // InternalExpression.g:5831:3: ( 'implies' ) + // InternalExpression.g:5882:1: ( () ) + // InternalExpression.g:5883:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } - // InternalExpression.g:5832:3: ( 'implies' ) - // InternalExpression.g:5833:4: 'implies' + // InternalExpression.g:5884:2: () + // InternalExpression.g:5884:3: { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } - match(input,61,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } - } if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -19145,10 +21153,6 @@ public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws Recog } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -19156,36 +21160,29 @@ public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws Recog } return ; } - // $ANTLR end "rule__ImpliesExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__AndExpression__Group_1__0__Impl" - // $ANTLR start "rule__ImpliesExpression__RightAssignment_1_2" - // InternalExpression.g:5844:1: rule__ImpliesExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; - public final void rule__ImpliesExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__1" + // InternalExpression.g:5892:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ; + public final void rule__AndExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5848:1: ( ( ruleRelationalExpression ) ) - // InternalExpression.g:5849:2: ( ruleRelationalExpression ) + // InternalExpression.g:5896:1: ( rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ) + // InternalExpression.g:5897:2: rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 { - // InternalExpression.g:5849:2: ( ruleRelationalExpression ) - // InternalExpression.g:5850:3: ruleRelationalExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleRelationalExpression(); + pushFollow(FOLLOW_18); + rule__AndExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -19201,30 +21198,30 @@ public final void rule__ImpliesExpression__RightAssignment_1_2() throws Recognit } return ; } - // $ANTLR end "rule__ImpliesExpression__RightAssignment_1_2" + // $ANTLR end "rule__AndExpression__Group_1__1" - // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" - // InternalExpression.g:5859: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__AndExpression__Group_1__1__Impl" + // InternalExpression.g:5904:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5863:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) - // InternalExpression.g:5864:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalExpression.g:5908:1: ( ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ) + // InternalExpression.g:5909:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) { - // InternalExpression.g:5864:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) - // InternalExpression.g:5865:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalExpression.g:5909:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) + // InternalExpression.g:5910:2: ( rule__AndExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } - // InternalExpression.g:5866:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) - // InternalExpression.g:5866:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 + // InternalExpression.g:5911:2: ( rule__AndExpression__OperatorAssignment_1_1 ) + // InternalExpression.g:5911:3: rule__AndExpression__OperatorAssignment_1_1 { pushFollow(FOLLOW_2); - rule__RelationalExpression__OperatorAlternatives_1_1_0(); + rule__AndExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -19232,7 +21229,7 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } } @@ -19252,36 +21249,24 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__AndExpression__Group_1__1__Impl" - // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" - // InternalExpression.g:5874:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__2" + // InternalExpression.g:5919:1: rule__AndExpression__Group_1__2 : rule__AndExpression__Group_1__2__Impl ; + public final void rule__AndExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5878:1: ( ( ruleAdditiveExpression ) ) - // InternalExpression.g:5879:2: ( ruleAdditiveExpression ) - { - // InternalExpression.g:5879:2: ( ruleAdditiveExpression ) - // InternalExpression.g:5880:3: ruleAdditiveExpression + // InternalExpression.g:5923:1: ( rule__AndExpression__Group_1__2__Impl ) + // InternalExpression.g:5924:2: rule__AndExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleAdditiveExpression(); + rule__AndExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -19297,30 +21282,30 @@ public final void rule__RelationalExpression__RightAssignment_1_2() throws Recog } return ; } - // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + // $ANTLR end "rule__AndExpression__Group_1__2" - // $ANTLR start "rule__AdditiveExpression__NameAssignment_1_1" - // InternalExpression.g:5889:1: rule__AdditiveExpression__NameAssignment_1_1 : ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ; - public final void rule__AdditiveExpression__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__2__Impl" + // InternalExpression.g:5930:1: rule__AndExpression__Group_1__2__Impl : ( ( rule__AndExpression__RightAssignment_1_2 ) ) ; + public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5893:1: ( ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ) - // InternalExpression.g:5894:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + // InternalExpression.g:5934:1: ( ( ( rule__AndExpression__RightAssignment_1_2 ) ) ) + // InternalExpression.g:5935:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) { - // InternalExpression.g:5894:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) - // InternalExpression.g:5895:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + // InternalExpression.g:5935:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) + // InternalExpression.g:5936:2: ( rule__AndExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } - // InternalExpression.g:5896:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) - // InternalExpression.g:5896:4: rule__AdditiveExpression__NameAlternatives_1_1_0 + // InternalExpression.g:5937:2: ( rule__AndExpression__RightAssignment_1_2 ) + // InternalExpression.g:5937:3: rule__AndExpression__RightAssignment_1_2 { pushFollow(FOLLOW_2); - rule__AdditiveExpression__NameAlternatives_1_1_0(); + rule__AndExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -19328,7 +21313,7 @@ public final void rule__AdditiveExpression__NameAssignment_1_1() throws Recognit } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } } @@ -19348,36 +21333,29 @@ public final void rule__AdditiveExpression__NameAssignment_1_1() throws Recognit } return ; } - // $ANTLR end "rule__AdditiveExpression__NameAssignment_1_1" + // $ANTLR end "rule__AndExpression__Group_1__2__Impl" - // $ANTLR start "rule__AdditiveExpression__ParamsAssignment_1_2" - // InternalExpression.g:5904:1: rule__AdditiveExpression__ParamsAssignment_1_2 : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__0" + // InternalExpression.g:5946:1: rule__ImpliesExpression__Group__0 : rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ; + public final void rule__ImpliesExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5908:1: ( ( ruleMultiplicativeExpression ) ) - // InternalExpression.g:5909:2: ( ruleMultiplicativeExpression ) - { - // InternalExpression.g:5909:2: ( ruleMultiplicativeExpression ) - // InternalExpression.g:5910:3: ruleMultiplicativeExpression + // InternalExpression.g:5950:1: ( rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ) + // InternalExpression.g:5951:2: rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleMultiplicativeExpression(); + pushFollow(FOLLOW_24); + rule__ImpliesExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -19393,38 +21371,32 @@ public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws Recogn } return ; } - // $ANTLR end "rule__AdditiveExpression__ParamsAssignment_1_2" + // $ANTLR end "rule__ImpliesExpression__Group__0" - // $ANTLR start "rule__MultiplicativeExpression__NameAssignment_1_1" - // InternalExpression.g:5919:1: rule__MultiplicativeExpression__NameAssignment_1_1 : ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ; - public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__0__Impl" + // InternalExpression.g:5958:1: rule__ImpliesExpression__Group__0__Impl : ( ruleRelationalExpression ) ; + public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5923:1: ( ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ) - // InternalExpression.g:5924:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + // InternalExpression.g:5962:1: ( ( ruleRelationalExpression ) ) + // InternalExpression.g:5963:1: ( ruleRelationalExpression ) { - // InternalExpression.g:5924:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) - // InternalExpression.g:5925:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + // InternalExpression.g:5963:1: ( ruleRelationalExpression ) + // InternalExpression.g:5964:2: ruleRelationalExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } - // InternalExpression.g:5926:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) - // InternalExpression.g:5926:4: rule__MultiplicativeExpression__NameAlternatives_1_1_0 - { pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__NameAlternatives_1_1_0(); + ruleRelationalExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } } @@ -19444,36 +21416,24 @@ public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__MultiplicativeExpression__NameAssignment_1_1" + // $ANTLR end "rule__ImpliesExpression__Group__0__Impl" - // $ANTLR start "rule__MultiplicativeExpression__ParamsAssignment_1_2" - // InternalExpression.g:5934:1: rule__MultiplicativeExpression__ParamsAssignment_1_2 : ( ruleUnaryOrInfixExpression ) ; - public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__1" + // InternalExpression.g:5973:1: rule__ImpliesExpression__Group__1 : rule__ImpliesExpression__Group__1__Impl ; + public final void rule__ImpliesExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5938:1: ( ( ruleUnaryOrInfixExpression ) ) - // InternalExpression.g:5939:2: ( ruleUnaryOrInfixExpression ) - { - // InternalExpression.g:5939:2: ( ruleUnaryOrInfixExpression ) - // InternalExpression.g:5940:3: ruleUnaryOrInfixExpression + // InternalExpression.g:5977:1: ( rule__ImpliesExpression__Group__1__Impl ) + // InternalExpression.g:5978:2: rule__ImpliesExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleUnaryOrInfixExpression(); + rule__ImpliesExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -19489,38 +21449,56 @@ public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws } return ; } - // $ANTLR end "rule__MultiplicativeExpression__ParamsAssignment_1_2" + // $ANTLR end "rule__ImpliesExpression__Group__1" - // $ANTLR start "rule__UnaryExpression__NameAssignment_0" - // InternalExpression.g:5949:1: rule__UnaryExpression__NameAssignment_0 : ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ; - public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__1__Impl" + // InternalExpression.g:5984:1: rule__ImpliesExpression__Group__1__Impl : ( ( rule__ImpliesExpression__Group_1__0 )* ) ; + public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5953:1: ( ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ) - // InternalExpression.g:5954:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + // InternalExpression.g:5988:1: ( ( ( rule__ImpliesExpression__Group_1__0 )* ) ) + // InternalExpression.g:5989:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) { - // InternalExpression.g:5954:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) - // InternalExpression.g:5955:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + // InternalExpression.g:5989:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) + // InternalExpression.g:5990:2: ( rule__ImpliesExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } - // InternalExpression.g:5956:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) - // InternalExpression.g:5956:4: rule__UnaryExpression__NameAlternatives_0_0 - { - pushFollow(FOLLOW_2); - rule__UnaryExpression__NameAlternatives_0_0(); + // InternalExpression.g:5991:2: ( rule__ImpliesExpression__Group_1__0 )* + loop64: + do { + int alt64=2; + int LA64_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA64_0==101) ) { + alt64=1; + } - } + + switch (alt64) { + case 1 : + // InternalExpression.g:5991:3: rule__ImpliesExpression__Group_1__0 + { + pushFollow(FOLLOW_25); + rule__ImpliesExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop64; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } } @@ -19540,36 +21518,29 @@ public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionEx } return ; } - // $ANTLR end "rule__UnaryExpression__NameAssignment_0" + // $ANTLR end "rule__ImpliesExpression__Group__1__Impl" - // $ANTLR start "rule__UnaryExpression__ParamsAssignment_1" - // InternalExpression.g:5964:1: rule__UnaryExpression__ParamsAssignment_1 : ( ruleInfixExpression ) ; - public final void rule__UnaryExpression__ParamsAssignment_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__0" + // InternalExpression.g:6000:1: rule__ImpliesExpression__Group_1__0 : rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ; + public final void rule__ImpliesExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5968:1: ( ( ruleInfixExpression ) ) - // InternalExpression.g:5969:2: ( ruleInfixExpression ) - { - // InternalExpression.g:5969:2: ( ruleInfixExpression ) - // InternalExpression.g:5970:3: ruleInfixExpression + // InternalExpression.g:6004:1: ( rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ) + // InternalExpression.g:6005:2: rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleInfixExpression(); + pushFollow(FOLLOW_24); + rule__ImpliesExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -19585,32 +21556,32 @@ public final void rule__UnaryExpression__ParamsAssignment_1() throws Recognition } return ; } - // $ANTLR end "rule__UnaryExpression__ParamsAssignment_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__0" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_0_2" - // InternalExpression.g:5979:1: rule__InfixExpression__NameAssignment_1_0_2 : ( ruleIdentifier ) ; - public final void rule__InfixExpression__NameAssignment_1_0_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__0__Impl" + // InternalExpression.g:6012:1: rule__ImpliesExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ImpliesExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5983:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:5984:2: ( ruleIdentifier ) + // InternalExpression.g:6016:1: ( ( () ) ) + // InternalExpression.g:6017:1: ( () ) { - // InternalExpression.g:5984:2: ( ruleIdentifier ) - // InternalExpression.g:5985:3: ruleIdentifier + // InternalExpression.g:6017:1: ( () ) + // InternalExpression.g:6018:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + // InternalExpression.g:6019:2: () + // InternalExpression.g:6019:3: + { } - pushFollow(FOLLOW_2); - ruleIdentifier(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -19619,10 +21590,6 @@ public final void rule__InfixExpression__NameAssignment_1_0_2() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -19630,36 +21597,29 @@ public final void rule__InfixExpression__NameAssignment_1_0_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_0_2" + // $ANTLR end "rule__ImpliesExpression__Group_1__0__Impl" - // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_0" - // InternalExpression.g:5994:1: rule__InfixExpression__ParamsAssignment_1_0_4_0 : ( ruleExpression ) ; - public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__1" + // InternalExpression.g:6027:1: rule__ImpliesExpression__Group_1__1 : rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ; + public final void rule__ImpliesExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:5998:1: ( ( ruleExpression ) ) - // InternalExpression.g:5999:2: ( ruleExpression ) - { - // InternalExpression.g:5999:2: ( ruleExpression ) - // InternalExpression.g:6000:3: ruleExpression + // InternalExpression.g:6031:1: ( rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ) + // InternalExpression.g:6032:2: rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_18); + rule__ImpliesExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -19675,32 +21635,38 @@ public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws Recog } return ; } - // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_0" + // $ANTLR end "rule__ImpliesExpression__Group_1__1" - // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" - // InternalExpression.g:6009:1: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 : ( ruleExpression ) ; - public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__1__Impl" + // InternalExpression.g:6039:1: rule__ImpliesExpression__Group_1__1__Impl : ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__ImpliesExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6013:1: ( ( ruleExpression ) ) - // InternalExpression.g:6014:2: ( ruleExpression ) + // InternalExpression.g:6043:1: ( ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ) + // InternalExpression.g:6044:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) { - // InternalExpression.g:6014:2: ( ruleExpression ) - // InternalExpression.g:6015:3: ruleExpression + // InternalExpression.g:6044:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) + // InternalExpression.g:6045:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + // InternalExpression.g:6046:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) + // InternalExpression.g:6046:3: rule__ImpliesExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__ImpliesExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } } @@ -19720,36 +21686,24 @@ public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws Rec } return ; } - // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__1__Impl" - // $ANTLR start "rule__InfixExpression__TypeAssignment_1_1_2" - // InternalExpression.g:6024:1: rule__InfixExpression__TypeAssignment_1_1_2 : ( ruleType ) ; - public final void rule__InfixExpression__TypeAssignment_1_1_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__2" + // InternalExpression.g:6054:1: rule__ImpliesExpression__Group_1__2 : rule__ImpliesExpression__Group_1__2__Impl ; + public final void rule__ImpliesExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6028:1: ( ( ruleType ) ) - // InternalExpression.g:6029:2: ( ruleType ) + // InternalExpression.g:6058:1: ( rule__ImpliesExpression__Group_1__2__Impl ) + // InternalExpression.g:6059:2: rule__ImpliesExpression__Group_1__2__Impl { - // InternalExpression.g:6029:2: ( ruleType ) - // InternalExpression.g:6030:3: ruleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); - } pushFollow(FOLLOW_2); - ruleType(); + rule__ImpliesExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); - } - - } - } @@ -19765,40 +21719,38 @@ public final void rule__InfixExpression__TypeAssignment_1_1_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__TypeAssignment_1_1_2" + // $ANTLR end "rule__ImpliesExpression__Group_1__2" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_2_2" - // InternalExpression.g:6039:1: rule__InfixExpression__NameAssignment_1_2_2 : ( ( 'typeSelect' ) ) ; - public final void rule__InfixExpression__NameAssignment_1_2_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__2__Impl" + // InternalExpression.g:6065:1: rule__ImpliesExpression__Group_1__2__Impl : ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ; + public final void rule__ImpliesExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6043:1: ( ( ( 'typeSelect' ) ) ) - // InternalExpression.g:6044:2: ( ( 'typeSelect' ) ) + // InternalExpression.g:6069:1: ( ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ) + // InternalExpression.g:6070:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) { - // InternalExpression.g:6044:2: ( ( 'typeSelect' ) ) - // InternalExpression.g:6045:3: ( 'typeSelect' ) + // InternalExpression.g:6070:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) + // InternalExpression.g:6071:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } - // InternalExpression.g:6046:3: ( 'typeSelect' ) - // InternalExpression.g:6047:4: 'typeSelect' + // InternalExpression.g:6072:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) + // InternalExpression.g:6072:3: rule__ImpliesExpression__RightAssignment_1_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } - match(input,62,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__RightAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } } @@ -19818,36 +21770,29 @@ public final void rule__InfixExpression__NameAssignment_1_2_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_2_2" + // $ANTLR end "rule__ImpliesExpression__Group_1__2__Impl" - // $ANTLR start "rule__InfixExpression__TypeAssignment_1_2_4" - // InternalExpression.g:6058:1: rule__InfixExpression__TypeAssignment_1_2_4 : ( ruleType ) ; - public final void rule__InfixExpression__TypeAssignment_1_2_4() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__0" + // InternalExpression.g:6081:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ; + public final void rule__RelationalExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6062:1: ( ( ruleType ) ) - // InternalExpression.g:6063:2: ( ruleType ) + // InternalExpression.g:6085:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) + // InternalExpression.g:6086:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 { - // InternalExpression.g:6063:2: ( ruleType ) - // InternalExpression.g:6064:3: ruleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); - } - pushFollow(FOLLOW_2); - ruleType(); + pushFollow(FOLLOW_26); + rule__RelationalExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -19863,38 +21808,32 @@ public final void rule__InfixExpression__TypeAssignment_1_2_4() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__TypeAssignment_1_2_4" + // $ANTLR end "rule__RelationalExpression__Group__0" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_3_2" - // InternalExpression.g:6073:1: rule__InfixExpression__NameAssignment_1_3_2 : ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ; - public final void rule__InfixExpression__NameAssignment_1_3_2() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__0__Impl" + // InternalExpression.g:6093:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; + public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6077:1: ( ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ) - // InternalExpression.g:6078:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + // InternalExpression.g:6097:1: ( ( ruleAdditiveExpression ) ) + // InternalExpression.g:6098:1: ( ruleAdditiveExpression ) { - // InternalExpression.g:6078:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) - // InternalExpression.g:6079:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + // InternalExpression.g:6098:1: ( ruleAdditiveExpression ) + // InternalExpression.g:6099:2: ruleAdditiveExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } - // InternalExpression.g:6080:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) - // InternalExpression.g:6080:4: rule__InfixExpression__NameAlternatives_1_3_2_0 - { pushFollow(FOLLOW_2); - rule__InfixExpression__NameAlternatives_1_3_2_0(); + ruleAdditiveExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } } @@ -19914,36 +21853,24 @@ public final void rule__InfixExpression__NameAssignment_1_3_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_3_2" + // $ANTLR end "rule__RelationalExpression__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__VarAssignment_1_3_4_0" - // InternalExpression.g:6088:1: rule__InfixExpression__VarAssignment_1_3_4_0 : ( ruleIdentifier ) ; - public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__1" + // InternalExpression.g:6108:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; + public final void rule__RelationalExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6092:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:6093:2: ( ruleIdentifier ) + // InternalExpression.g:6112:1: ( rule__RelationalExpression__Group__1__Impl ) + // InternalExpression.g:6113:2: rule__RelationalExpression__Group__1__Impl { - // InternalExpression.g:6093:2: ( ruleIdentifier ) - // InternalExpression.g:6094:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); - } pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__RelationalExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); - } - - } - } @@ -19959,41 +21886,65 @@ public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws Recognit } return ; } - // $ANTLR end "rule__InfixExpression__VarAssignment_1_3_4_0" + // $ANTLR end "rule__RelationalExpression__Group__1" - // $ANTLR start "rule__InfixExpression__ExpAssignment_1_3_5" - // InternalExpression.g:6103:1: rule__InfixExpression__ExpAssignment_1_3_5 : ( ruleExpression ) ; - public final void rule__InfixExpression__ExpAssignment_1_3_5() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__1__Impl" + // InternalExpression.g:6119:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )* ) ; + public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6107:1: ( ( ruleExpression ) ) - // InternalExpression.g:6108:2: ( ruleExpression ) + // InternalExpression.g:6123:1: ( ( ( rule__RelationalExpression__Group_1__0 )* ) ) + // InternalExpression.g:6124:1: ( ( rule__RelationalExpression__Group_1__0 )* ) { - // InternalExpression.g:6108:2: ( ruleExpression ) - // InternalExpression.g:6109:3: ruleExpression + // InternalExpression.g:6124:1: ( ( rule__RelationalExpression__Group_1__0 )* ) + // InternalExpression.g:6125:2: ( rule__RelationalExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleExpression(); + // InternalExpression.g:6126:2: ( rule__RelationalExpression__Group_1__0 )* + loop65: + do { + int alt65=2; + int LA65_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); - } + if ( ((LA65_0>=17 && LA65_0<=22)) ) { + alt65=1; + } - } + switch (alt65) { + case 1 : + // InternalExpression.g:6126:3: rule__RelationalExpression__Group_1__0 + { + pushFollow(FOLLOW_27); + rule__RelationalExpression__Group_1__0(); - } + state._fsp--; + if (state.failed) return ; - } - catch (RecognitionException re) { + } + break; + + default : + break loop65; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { reportError(re); recover(input,re); } @@ -20004,42 +21955,29 @@ public final void rule__InfixExpression__ExpAssignment_1_3_5() throws Recognitio } return ; } - // $ANTLR end "rule__InfixExpression__ExpAssignment_1_3_5" + // $ANTLR end "rule__RelationalExpression__Group__1__Impl" - // $ANTLR start "rule__BooleanLiteral__ValAssignment" - // InternalExpression.g:6118:1: rule__BooleanLiteral__ValAssignment : ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ; - public final void rule__BooleanLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__0" + // InternalExpression.g:6135: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 { int stackSize = keepStackSize(); try { - // InternalExpression.g:6122:1: ( ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ) - // InternalExpression.g:6123:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + // InternalExpression.g:6139:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) + // InternalExpression.g:6140:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 { - // InternalExpression.g:6123:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) - // InternalExpression.g:6124:3: ( rule__BooleanLiteral__ValAlternatives_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); - } - // InternalExpression.g:6125:3: ( rule__BooleanLiteral__ValAlternatives_0 ) - // InternalExpression.g:6125:4: rule__BooleanLiteral__ValAlternatives_0 - { - pushFollow(FOLLOW_2); - rule__BooleanLiteral__ValAlternatives_0(); + pushFollow(FOLLOW_26); + rule__RelationalExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__1(); - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); - } - - } - + state._fsp--; + if (state.failed) return ; } @@ -20055,32 +21993,70 @@ public final void rule__BooleanLiteral__ValAssignment() throws RecognitionExcept } return ; } - // $ANTLR end "rule__BooleanLiteral__ValAssignment" + // $ANTLR end "rule__RelationalExpression__Group_1__0" - // $ANTLR start "rule__IntegerLiteral__ValAssignment" - // InternalExpression.g:6133:1: rule__IntegerLiteral__ValAssignment : ( RULE_INT ) ; - public final void rule__IntegerLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" + // InternalExpression.g:6147:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; + public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6137:1: ( ( RULE_INT ) ) - // InternalExpression.g:6138:2: ( RULE_INT ) + // InternalExpression.g:6151:1: ( ( () ) ) + // InternalExpression.g:6152:1: ( () ) { - // InternalExpression.g:6138:2: ( RULE_INT ) - // InternalExpression.g:6139:3: RULE_INT + // InternalExpression.g:6152:1: ( () ) + // InternalExpression.g:6153:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } - match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:6154:2: () + // InternalExpression.g:6154:3: + { + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + } + } + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__RelationalExpression__Group_1__1" + // InternalExpression.g:6162: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 { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6166:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) + // InternalExpression.g:6167:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 + { + pushFollow(FOLLOW_18); + rule__RelationalExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__2(); + + state._fsp--; + if (state.failed) return ; } @@ -20096,44 +22072,75 @@ public final void rule__IntegerLiteral__ValAssignment() throws RecognitionExcept } return ; } - // $ANTLR end "rule__IntegerLiteral__ValAssignment" + // $ANTLR end "rule__RelationalExpression__Group_1__1" - // $ANTLR start "rule__NullLiteral__ValAssignment" - // InternalExpression.g:6148:1: rule__NullLiteral__ValAssignment : ( ( 'null' ) ) ; - public final void rule__NullLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" + // InternalExpression.g:6174:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__RelationalExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6152:1: ( ( ( 'null' ) ) ) - // InternalExpression.g:6153:2: ( ( 'null' ) ) + // InternalExpression.g:6178:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) + // InternalExpression.g:6179:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) { - // InternalExpression.g:6153:2: ( ( 'null' ) ) - // InternalExpression.g:6154:3: ( 'null' ) + // InternalExpression.g:6179:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) + // InternalExpression.g:6180:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } - // InternalExpression.g:6155:3: ( 'null' ) - // InternalExpression.g:6156:4: 'null' + // InternalExpression.g:6181:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) + // InternalExpression.g:6181:3: rule__RelationalExpression__OperatorAssignment_1_1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + pushFollow(FOLLOW_2); + rule__RelationalExpression__OperatorAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } } - if ( state.backtracking==0 ) { - after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__RelationalExpression__Group_1__2" + // InternalExpression.g:6189:1: rule__RelationalExpression__Group_1__2 : rule__RelationalExpression__Group_1__2__Impl ; + public final void rule__RelationalExpression__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6193:1: ( rule__RelationalExpression__Group_1__2__Impl ) + // InternalExpression.g:6194:2: rule__RelationalExpression__Group_1__2__Impl + { + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; } @@ -20149,28 +22156,38 @@ public final void rule__NullLiteral__ValAssignment() throws RecognitionException } return ; } - // $ANTLR end "rule__NullLiteral__ValAssignment" + // $ANTLR end "rule__RelationalExpression__Group_1__2" - // $ANTLR start "rule__RealLiteral__ValAssignment" - // InternalExpression.g:6167:1: rule__RealLiteral__ValAssignment : ( RULE_REAL ) ; - public final void rule__RealLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" + // InternalExpression.g:6200:1: rule__RelationalExpression__Group_1__2__Impl : ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ; + public final void rule__RelationalExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6171:1: ( ( RULE_REAL ) ) - // InternalExpression.g:6172:2: ( RULE_REAL ) + // InternalExpression.g:6204:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) + // InternalExpression.g:6205:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) { - // InternalExpression.g:6172:2: ( RULE_REAL ) - // InternalExpression.g:6173:3: RULE_REAL + // InternalExpression.g:6205:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) + // InternalExpression.g:6206:2: ( rule__RelationalExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - match(input,RULE_REAL,FOLLOW_2); if (state.failed) return ; + // InternalExpression.g:6207:2: ( rule__RelationalExpression__RightAssignment_1_2 ) + // InternalExpression.g:6207:3: rule__RelationalExpression__RightAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__RelationalExpression__RightAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } } @@ -20190,32 +22207,29 @@ public final void rule__RealLiteral__ValAssignment() throws RecognitionException } return ; } - // $ANTLR end "rule__RealLiteral__ValAssignment" + // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" - // $ANTLR start "rule__StringLiteral__ValAssignment" - // InternalExpression.g:6182:1: rule__StringLiteral__ValAssignment : ( RULE_STRING ) ; - public final void rule__StringLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__0" + // InternalExpression.g:6216:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; + public final void rule__AdditiveExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6186:1: ( ( RULE_STRING ) ) - // InternalExpression.g:6187:2: ( RULE_STRING ) - { - // InternalExpression.g:6187:2: ( RULE_STRING ) - // InternalExpression.g:6188:3: RULE_STRING + // InternalExpression.g:6220:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) + // InternalExpression.g:6221:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); - } - match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); - } + pushFollow(FOLLOW_28); + rule__AdditiveExpression__Group__0__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -20231,32 +22245,32 @@ public final void rule__StringLiteral__ValAssignment() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__StringLiteral__ValAssignment" + // $ANTLR end "rule__AdditiveExpression__Group__0" - // $ANTLR start "rule__GlobalVarExpression__NameAssignment_1" - // InternalExpression.g:6197:1: rule__GlobalVarExpression__NameAssignment_1 : ( ruleIdentifier ) ; - public final void rule__GlobalVarExpression__NameAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" + // InternalExpression.g:6228:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; + public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6201:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:6202:2: ( ruleIdentifier ) + // InternalExpression.g:6232:1: ( ( ruleMultiplicativeExpression ) ) + // InternalExpression.g:6233:1: ( ruleMultiplicativeExpression ) { - // InternalExpression.g:6202:2: ( ruleIdentifier ) - // InternalExpression.g:6203:3: ruleIdentifier + // InternalExpression.g:6233:1: ( ruleMultiplicativeExpression ) + // InternalExpression.g:6234:2: ruleMultiplicativeExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleIdentifier(); + ruleMultiplicativeExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } } @@ -20276,36 +22290,24 @@ public final void rule__GlobalVarExpression__NameAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalVarExpression__NameAssignment_1" + // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" - // $ANTLR start "rule__FeatureCall__TypeAssignment_1" - // InternalExpression.g:6212:1: rule__FeatureCall__TypeAssignment_1 : ( ruleType ) ; - public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__1" + // InternalExpression.g:6243:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; + public final void rule__AdditiveExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6216:1: ( ( ruleType ) ) - // InternalExpression.g:6217:2: ( ruleType ) - { - // InternalExpression.g:6217:2: ( ruleType ) - // InternalExpression.g:6218:3: ruleType + // InternalExpression.g:6247:1: ( rule__AdditiveExpression__Group__1__Impl ) + // InternalExpression.g:6248:2: rule__AdditiveExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); - } pushFollow(FOLLOW_2); - ruleType(); + rule__AdditiveExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); - } - - } - } @@ -20321,32 +22323,56 @@ public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__FeatureCall__TypeAssignment_1" + // $ANTLR end "rule__AdditiveExpression__Group__1" - // $ANTLR start "rule__OperationCall__NameAssignment_0" - // InternalExpression.g:6227:1: rule__OperationCall__NameAssignment_0 : ( ruleIdentifier ) ; - public final void rule__OperationCall__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" + // InternalExpression.g:6254:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; + public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6231:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:6232:2: ( ruleIdentifier ) + // InternalExpression.g:6258:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) + // InternalExpression.g:6259:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) { - // InternalExpression.g:6232:2: ( ruleIdentifier ) - // InternalExpression.g:6233:3: ruleIdentifier + // InternalExpression.g:6259:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) + // InternalExpression.g:6260:2: ( rule__AdditiveExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleIdentifier(); + // InternalExpression.g:6261:2: ( rule__AdditiveExpression__Group_1__0 )* + loop66: + do { + int alt66=2; + int LA66_0 = input.LA(1); + + if ( ((LA66_0>=23 && LA66_0<=24)) ) { + alt66=1; + } + + + switch (alt66) { + case 1 : + // InternalExpression.g:6261:3: rule__AdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_29); + rule__AdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop66; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } } @@ -20366,36 +22392,29 @@ public final void rule__OperationCall__NameAssignment_0() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__NameAssignment_0" + // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" - // $ANTLR start "rule__OperationCall__ParamsAssignment_2_0" - // InternalExpression.g:6242:1: rule__OperationCall__ParamsAssignment_2_0 : ( ruleExpression ) ; - public final void rule__OperationCall__ParamsAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__0" + // InternalExpression.g:6270: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 { int stackSize = keepStackSize(); try { - // InternalExpression.g:6246:1: ( ( ruleExpression ) ) - // InternalExpression.g:6247:2: ( ruleExpression ) - { - // InternalExpression.g:6247:2: ( ruleExpression ) - // InternalExpression.g:6248:3: ruleExpression + // InternalExpression.g:6274:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) + // InternalExpression.g:6275:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_28); + rule__AdditiveExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -20411,36 +22430,70 @@ public final void rule__OperationCall__ParamsAssignment_2_0() throws Recognition } return ; } - // $ANTLR end "rule__OperationCall__ParamsAssignment_2_0" + // $ANTLR end "rule__AdditiveExpression__Group_1__0" - // $ANTLR start "rule__OperationCall__ParamsAssignment_2_1_1" - // InternalExpression.g:6257:1: rule__OperationCall__ParamsAssignment_2_1_1 : ( ruleExpression ) ; - public final void rule__OperationCall__ParamsAssignment_2_1_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" + // InternalExpression.g:6282:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; + public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6261:1: ( ( ruleExpression ) ) - // InternalExpression.g:6262:2: ( ruleExpression ) + // InternalExpression.g:6286:1: ( ( () ) ) + // InternalExpression.g:6287:1: ( () ) { - // InternalExpression.g:6262:2: ( ruleExpression ) - // InternalExpression.g:6263:3: ruleExpression + // InternalExpression.g:6287:1: ( () ) + // InternalExpression.g:6288:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); + } + // InternalExpression.g:6289:2: () + // InternalExpression.g:6289:3: + { } - pushFollow(FOLLOW_2); - ruleExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); + } + } + } + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__AdditiveExpression__Group_1__1" + // InternalExpression.g:6297: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 { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6301:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) + // InternalExpression.g:6302:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 + { + pushFollow(FOLLOW_18); + rule__AdditiveExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group_1__2(); + + state._fsp--; + if (state.failed) return ; } @@ -20456,32 +22509,38 @@ public final void rule__OperationCall__ParamsAssignment_2_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__OperationCall__ParamsAssignment_2_1_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__1" - // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_0" - // InternalExpression.g:6272:1: rule__ListLiteral__ElementsAssignment_2_0 : ( ruleExpression ) ; - public final void rule__ListLiteral__ElementsAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" + // InternalExpression.g:6309:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ; + public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6276:1: ( ( ruleExpression ) ) - // InternalExpression.g:6277:2: ( ruleExpression ) + // InternalExpression.g:6313:1: ( ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ) + // InternalExpression.g:6314:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) { - // InternalExpression.g:6277:2: ( ruleExpression ) - // InternalExpression.g:6278:3: ruleExpression + // InternalExpression.g:6314:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) + // InternalExpression.g:6315:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + // InternalExpression.g:6316:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) + // InternalExpression.g:6316:3: rule__AdditiveExpression__NameAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__AdditiveExpression__NameAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } } @@ -20501,36 +22560,24 @@ public final void rule__ListLiteral__ElementsAssignment_2_0() throws Recognition } return ; } - // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_0" + // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" - // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_1_1" - // InternalExpression.g:6287:1: rule__ListLiteral__ElementsAssignment_2_1_1 : ( ruleExpression ) ; - public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__2" + // InternalExpression.g:6324:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ; + public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6291:1: ( ( ruleExpression ) ) - // InternalExpression.g:6292:2: ( ruleExpression ) + // InternalExpression.g:6328:1: ( rule__AdditiveExpression__Group_1__2__Impl ) + // InternalExpression.g:6329:2: rule__AdditiveExpression__Group_1__2__Impl { - // InternalExpression.g:6292:2: ( ruleExpression ) - // InternalExpression.g:6293:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__AdditiveExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); - } - - } - } @@ -20546,32 +22593,38 @@ public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_1_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__2" - // $ANTLR start "rule__ConstructorCallExpression__TypeAssignment_1" - // InternalExpression.g:6302:1: rule__ConstructorCallExpression__TypeAssignment_1 : ( ruleSimpleType ) ; - public final void rule__ConstructorCallExpression__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" + // InternalExpression.g:6335:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ; + public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6306:1: ( ( ruleSimpleType ) ) - // InternalExpression.g:6307:2: ( ruleSimpleType ) + // InternalExpression.g:6339:1: ( ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ) + // InternalExpression.g:6340:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) { - // InternalExpression.g:6307:2: ( ruleSimpleType ) - // InternalExpression.g:6308:3: ruleSimpleType + // InternalExpression.g:6340:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) + // InternalExpression.g:6341:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + // InternalExpression.g:6342:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) + // InternalExpression.g:6342:3: rule__AdditiveExpression__ParamsAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleSimpleType(); + rule__AdditiveExpression__ParamsAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } } @@ -20591,44 +22644,107 @@ public final void rule__ConstructorCallExpression__TypeAssignment_1() throws Rec } return ; } - // $ANTLR end "rule__ConstructorCallExpression__TypeAssignment_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" - // $ANTLR start "rule__TypeSelectExpression__NameAssignment_0" - // InternalExpression.g:6317:1: rule__TypeSelectExpression__NameAssignment_0 : ( ( 'typeSelect' ) ) ; - public final void rule__TypeSelectExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__0" + // InternalExpression.g:6351:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; + public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6321:1: ( ( ( 'typeSelect' ) ) ) - // InternalExpression.g:6322:2: ( ( 'typeSelect' ) ) + // InternalExpression.g:6355:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) + // InternalExpression.g:6356:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 { - // InternalExpression.g:6322:2: ( ( 'typeSelect' ) ) - // InternalExpression.g:6323:3: ( 'typeSelect' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + pushFollow(FOLLOW_30); + rule__MultiplicativeExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + } - // InternalExpression.g:6324:3: ( 'typeSelect' ) - // InternalExpression.g:6325:4: 'typeSelect' + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group__0" + + + // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" + // InternalExpression.g:6363:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleUnaryOrInfixExpression ) ; + public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6367:1: ( ( ruleUnaryOrInfixExpression ) ) + // InternalExpression.g:6368:1: ( ruleUnaryOrInfixExpression ) + { + // InternalExpression.g:6368:1: ( ruleUnaryOrInfixExpression ) + // InternalExpression.g:6369:2: ruleUnaryOrInfixExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } - match(input,62,FOLLOW_2); if (state.failed) return ; + pushFollow(FOLLOW_2); + ruleUnaryOrInfixExpression(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } } - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); - } } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" + + + // $ANTLR start "rule__MultiplicativeExpression__Group__1" + // InternalExpression.g:6378:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; + public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6382:1: ( rule__MultiplicativeExpression__Group__1__Impl ) + // InternalExpression.g:6383:2: rule__MultiplicativeExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; } @@ -20644,32 +22760,56 @@ public final void rule__TypeSelectExpression__NameAssignment_0() throws Recognit } return ; } - // $ANTLR end "rule__TypeSelectExpression__NameAssignment_0" + // $ANTLR end "rule__MultiplicativeExpression__Group__1" - // $ANTLR start "rule__TypeSelectExpression__TypeAssignment_2" - // InternalExpression.g:6336:1: rule__TypeSelectExpression__TypeAssignment_2 : ( ruleType ) ; - public final void rule__TypeSelectExpression__TypeAssignment_2() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" + // InternalExpression.g:6389:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; + public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalExpression.g:6340:1: ( ( ruleType ) ) - // InternalExpression.g:6341:2: ( ruleType ) + // InternalExpression.g:6393:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) + // InternalExpression.g:6394:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) { - // InternalExpression.g:6341:2: ( ruleType ) - // InternalExpression.g:6342:3: ruleType + // InternalExpression.g:6394:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) + // InternalExpression.g:6395:2: ( rule__MultiplicativeExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleType(); + // InternalExpression.g:6396:2: ( rule__MultiplicativeExpression__Group_1__0 )* + loop67: + do { + int alt67=2; + int LA67_0 = input.LA(1); + + if ( ((LA67_0>=25 && LA67_0<=26)) ) { + alt67=1; + } + + + switch (alt67) { + case 1 : + // InternalExpression.g:6396:3: rule__MultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_31); + rule__MultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop67; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } } @@ -20689,421 +22829,56695 @@ public final void rule__TypeSelectExpression__TypeAssignment_2() throws Recognit } return ; } - // $ANTLR end "rule__TypeSelectExpression__TypeAssignment_2" + // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" - // $ANTLR start "rule__CollectionExpression__NameAssignment_0" - // InternalExpression.g:6351:1: rule__CollectionExpression__NameAssignment_0 : ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ; - public final void rule__CollectionExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" + // InternalExpression.g:6405: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 { int stackSize = keepStackSize(); try { - // InternalExpression.g:6355:1: ( ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ) - // InternalExpression.g:6356:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) - { - // InternalExpression.g:6356:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) - // InternalExpression.g:6357:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); - } - // InternalExpression.g:6358:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) - // InternalExpression.g:6358:4: rule__CollectionExpression__NameAlternatives_0_0 + // InternalExpression.g:6409:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) + // InternalExpression.g:6410:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 { + pushFollow(FOLLOW_30); + rule__MultiplicativeExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__NameAlternatives_0_0(); + rule__MultiplicativeExpression__Group_1__1(); state._fsp--; if (state.failed) return ; - } + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" + + + // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" + // InternalExpression.g:6417:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; + public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6421:1: ( ( () ) ) + // InternalExpression.g:6422:1: ( () ) + { + // InternalExpression.g:6422:1: ( () ) + // InternalExpression.g:6423:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + } + // InternalExpression.g:6424:2: () + // InternalExpression.g:6424:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" + // InternalExpression.g:6432: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 { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6436:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) + // InternalExpression.g:6437:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 + { + pushFollow(FOLLOW_18); + rule__MultiplicativeExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" + + + // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" + // InternalExpression.g:6444:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ; + public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6448:1: ( ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ) + // InternalExpression.g:6449:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) + { + // InternalExpression.g:6449:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) + // InternalExpression.g:6450:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + } + // InternalExpression.g:6451:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) + // InternalExpression.g:6451:3: rule__MultiplicativeExpression__NameAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__NameAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" + // InternalExpression.g:6459:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; + public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6463:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) + // InternalExpression.g:6464:2: rule__MultiplicativeExpression__Group_1__2__Impl + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" + + + // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" + // InternalExpression.g:6470:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ; + public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6474:1: ( ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ) + // InternalExpression.g:6475:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) + { + // InternalExpression.g:6475:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) + // InternalExpression.g:6476:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); + } + // InternalExpression.g:6477:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) + // InternalExpression.g:6477:3: rule__MultiplicativeExpression__ParamsAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__ParamsAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" + + + // $ANTLR start "rule__UnaryExpression__Group__0" + // InternalExpression.g:6486:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ; + public final void rule__UnaryExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6490:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ) + // InternalExpression.g:6491:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 + { + pushFollow(FOLLOW_18); + rule__UnaryExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__UnaryExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__Group__0" + + + // $ANTLR start "rule__UnaryExpression__Group__0__Impl" + // InternalExpression.g:6498:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__NameAssignment_0 ) ) ; + public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6502:1: ( ( ( rule__UnaryExpression__NameAssignment_0 ) ) ) + // InternalExpression.g:6503:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) + { + // InternalExpression.g:6503:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) + // InternalExpression.g:6504:2: ( rule__UnaryExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); + } + // InternalExpression.g:6505:2: ( rule__UnaryExpression__NameAssignment_0 ) + // InternalExpression.g:6505:3: rule__UnaryExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__UnaryExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__Group__0__Impl" + + + // $ANTLR start "rule__UnaryExpression__Group__1" + // InternalExpression.g:6513:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ; + public final void rule__UnaryExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6517:1: ( rule__UnaryExpression__Group__1__Impl ) + // InternalExpression.g:6518:2: rule__UnaryExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__UnaryExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__Group__1" + + + // $ANTLR start "rule__UnaryExpression__Group__1__Impl" + // InternalExpression.g:6524:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ; + public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6528:1: ( ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ) + // InternalExpression.g:6529:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) + { + // InternalExpression.g:6529:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) + // InternalExpression.g:6530:2: ( rule__UnaryExpression__ParamsAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); + } + // InternalExpression.g:6531:2: ( rule__UnaryExpression__ParamsAssignment_1 ) + // InternalExpression.g:6531:3: rule__UnaryExpression__ParamsAssignment_1 + { + pushFollow(FOLLOW_2); + rule__UnaryExpression__ParamsAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__Group__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group__0" + // InternalExpression.g:6540:1: rule__InfixExpression__Group__0 : rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ; + public final void rule__InfixExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6544:1: ( rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ) + // InternalExpression.g:6545:2: rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 + { + pushFollow(FOLLOW_32); + rule__InfixExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group__0" + + + // $ANTLR start "rule__InfixExpression__Group__0__Impl" + // InternalExpression.g:6552:1: rule__InfixExpression__Group__0__Impl : ( rulePrimaryExpression ) ; + public final void rule__InfixExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6556:1: ( ( rulePrimaryExpression ) ) + // InternalExpression.g:6557:1: ( rulePrimaryExpression ) + { + // InternalExpression.g:6557:1: ( rulePrimaryExpression ) + // InternalExpression.g:6558:2: rulePrimaryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + rulePrimaryExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group__1" + // InternalExpression.g:6567:1: rule__InfixExpression__Group__1 : rule__InfixExpression__Group__1__Impl ; + public final void rule__InfixExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6571:1: ( rule__InfixExpression__Group__1__Impl ) + // InternalExpression.g:6572:2: rule__InfixExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group__1" + + + // $ANTLR start "rule__InfixExpression__Group__1__Impl" + // InternalExpression.g:6578:1: rule__InfixExpression__Group__1__Impl : ( ( rule__InfixExpression__Alternatives_1 )* ) ; + public final void rule__InfixExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6582:1: ( ( ( rule__InfixExpression__Alternatives_1 )* ) ) + // InternalExpression.g:6583:1: ( ( rule__InfixExpression__Alternatives_1 )* ) + { + // InternalExpression.g:6583:1: ( ( rule__InfixExpression__Alternatives_1 )* ) + // InternalExpression.g:6584:2: ( rule__InfixExpression__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + } + // InternalExpression.g:6585:2: ( rule__InfixExpression__Alternatives_1 )* + loop68: + do { + int alt68=2; + int LA68_0 = input.LA(1); + + if ( (LA68_0==58) ) { + alt68=1; + } + + + switch (alt68) { + case 1 : + // InternalExpression.g:6585:3: rule__InfixExpression__Alternatives_1 + { + pushFollow(FOLLOW_33); + rule__InfixExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop68; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__0" + // InternalExpression.g:6594:1: rule__InfixExpression__Group_1_0__0 : rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ; + public final void rule__InfixExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6598:1: ( rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ) + // InternalExpression.g:6599:2: rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 + { + pushFollow(FOLLOW_32); + rule__InfixExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__0__Impl" + // InternalExpression.g:6606:1: rule__InfixExpression__Group_1_0__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6610:1: ( ( () ) ) + // InternalExpression.g:6611:1: ( () ) + { + // InternalExpression.g:6611:1: ( () ) + // InternalExpression.g:6612:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + } + // InternalExpression.g:6613:2: () + // InternalExpression.g:6613:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__1" + // InternalExpression.g:6621:1: rule__InfixExpression__Group_1_0__1 : rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ; + public final void rule__InfixExpression__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6625:1: ( rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ) + // InternalExpression.g:6626:2: rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 + { + pushFollow(FOLLOW_4); + rule__InfixExpression__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__1__Impl" + // InternalExpression.g:6633:1: rule__InfixExpression__Group_1_0__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6637:1: ( ( '.' ) ) + // InternalExpression.g:6638:1: ( '.' ) + { + // InternalExpression.g:6638:1: ( '.' ) + // InternalExpression.g:6639:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__2" + // InternalExpression.g:6648:1: rule__InfixExpression__Group_1_0__2 : rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ; + public final void rule__InfixExpression__Group_1_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6652:1: ( rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ) + // InternalExpression.g:6653:2: rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 + { + pushFollow(FOLLOW_34); + rule__InfixExpression__Group_1_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__2__Impl" + // InternalExpression.g:6660:1: rule__InfixExpression__Group_1_0__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ; + public final void rule__InfixExpression__Group_1_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6664:1: ( ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ) + // InternalExpression.g:6665:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) + { + // InternalExpression.g:6665:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) + // InternalExpression.g:6666:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + } + // InternalExpression.g:6667:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) + // InternalExpression.g:6667:3: rule__InfixExpression__NameAssignment_1_0_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__3" + // InternalExpression.g:6675:1: rule__InfixExpression__Group_1_0__3 : rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ; + public final void rule__InfixExpression__Group_1_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6679:1: ( rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ) + // InternalExpression.g:6680:2: rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 + { + pushFollow(FOLLOW_35); + rule__InfixExpression__Group_1_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__3" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__3__Impl" + // InternalExpression.g:6687:1: rule__InfixExpression__Group_1_0__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6691:1: ( ( '(' ) ) + // InternalExpression.g:6692:1: ( '(' ) + { + // InternalExpression.g:6692:1: ( '(' ) + // InternalExpression.g:6693:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__3__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__4" + // InternalExpression.g:6702:1: rule__InfixExpression__Group_1_0__4 : rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ; + public final void rule__InfixExpression__Group_1_0__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6706:1: ( rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ) + // InternalExpression.g:6707:2: rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 + { + pushFollow(FOLLOW_35); + rule__InfixExpression__Group_1_0__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__4__Impl" + // InternalExpression.g:6714:1: rule__InfixExpression__Group_1_0__4__Impl : ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ; + public final void rule__InfixExpression__Group_1_0__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6718:1: ( ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ) + // InternalExpression.g:6719:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) + { + // InternalExpression.g:6719:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) + // InternalExpression.g:6720:2: ( rule__InfixExpression__Group_1_0_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + } + // InternalExpression.g:6721:2: ( rule__InfixExpression__Group_1_0_4__0 )? + int alt69=2; + int LA69_0 = input.LA(1); + + if ( (LA69_0==RULE_ID||LA69_0==RULE_INT||(LA69_0>=RULE_REAL && LA69_0<=RULE_STRING)||LA69_0==24||(LA69_0>=27 && LA69_0<=40)||LA69_0==65||LA69_0==67||LA69_0==70||(LA69_0>=73 && LA69_0<=74)||(LA69_0>=80 && LA69_0<=81)||LA69_0==92||LA69_0==102) ) { + alt69=1; + } + switch (alt69) { + case 1 : + // InternalExpression.g:6721:3: rule__InfixExpression__Group_1_0_4__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__4__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__5" + // InternalExpression.g:6729:1: rule__InfixExpression__Group_1_0__5 : rule__InfixExpression__Group_1_0__5__Impl ; + public final void rule__InfixExpression__Group_1_0__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6733:1: ( rule__InfixExpression__Group_1_0__5__Impl ) + // InternalExpression.g:6734:2: rule__InfixExpression__Group_1_0__5__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_0__5__Impl" + // InternalExpression.g:6740:1: rule__InfixExpression__Group_1_0__5__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_0__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6744:1: ( ( ')' ) ) + // InternalExpression.g:6745:1: ( ')' ) + { + // InternalExpression.g:6745:1: ( ')' ) + // InternalExpression.g:6746:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0__5__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__0" + // InternalExpression.g:6756:1: rule__InfixExpression__Group_1_0_4__0 : rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ; + public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6760:1: ( rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ) + // InternalExpression.g:6761:2: rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 + { + pushFollow(FOLLOW_36); + rule__InfixExpression__Group_1_0_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__0__Impl" + // InternalExpression.g:6768:1: rule__InfixExpression__Group_1_0_4__0__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ; + public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6772:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ) + // InternalExpression.g:6773:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) + { + // InternalExpression.g:6773:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) + // InternalExpression.g:6774:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); + } + // InternalExpression.g:6775:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) + // InternalExpression.g:6775:3: rule__InfixExpression__ParamsAssignment_1_0_4_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__ParamsAssignment_1_0_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__1" + // InternalExpression.g:6783:1: rule__InfixExpression__Group_1_0_4__1 : rule__InfixExpression__Group_1_0_4__1__Impl ; + public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6787:1: ( rule__InfixExpression__Group_1_0_4__1__Impl ) + // InternalExpression.g:6788:2: rule__InfixExpression__Group_1_0_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4__1__Impl" + // InternalExpression.g:6794:1: rule__InfixExpression__Group_1_0_4__1__Impl : ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ; + public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6798:1: ( ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ) + // InternalExpression.g:6799:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + { + // InternalExpression.g:6799:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + // InternalExpression.g:6800:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + } + // InternalExpression.g:6801:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + loop70: + do { + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==78) ) { + alt70=1; + } + + + switch (alt70) { + case 1 : + // InternalExpression.g:6801:3: rule__InfixExpression__Group_1_0_4_1__0 + { + pushFollow(FOLLOW_37); + rule__InfixExpression__Group_1_0_4_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop70; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0" + // InternalExpression.g:6810:1: rule__InfixExpression__Group_1_0_4_1__0 : rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ; + public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6814:1: ( rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ) + // InternalExpression.g:6815:2: rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 + { + pushFollow(FOLLOW_6); + rule__InfixExpression__Group_1_0_4_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0__Impl" + // InternalExpression.g:6822:1: rule__InfixExpression__Group_1_0_4_1__0__Impl : ( ',' ) ; + public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6826:1: ( ( ',' ) ) + // InternalExpression.g:6827:1: ( ',' ) + { + // InternalExpression.g:6827:1: ( ',' ) + // InternalExpression.g:6828:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1" + // InternalExpression.g:6837:1: rule__InfixExpression__Group_1_0_4_1__1 : rule__InfixExpression__Group_1_0_4_1__1__Impl ; + public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6841:1: ( rule__InfixExpression__Group_1_0_4_1__1__Impl ) + // InternalExpression.g:6842:2: rule__InfixExpression__Group_1_0_4_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1__Impl" + // InternalExpression.g:6848:1: rule__InfixExpression__Group_1_0_4_1__1__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ; + public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6852:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ) + // InternalExpression.g:6853:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + { + // InternalExpression.g:6853:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + // InternalExpression.g:6854:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + } + // InternalExpression.g:6855:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + // InternalExpression.g:6855:3: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__ParamsAssignment_1_0_4_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__0" + // InternalExpression.g:6864:1: rule__InfixExpression__Group_1_1__0 : rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ; + public final void rule__InfixExpression__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6868:1: ( rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ) + // InternalExpression.g:6869:2: rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 + { + pushFollow(FOLLOW_32); + rule__InfixExpression__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__0__Impl" + // InternalExpression.g:6876:1: rule__InfixExpression__Group_1_1__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6880:1: ( ( () ) ) + // InternalExpression.g:6881:1: ( () ) + { + // InternalExpression.g:6881:1: ( () ) + // InternalExpression.g:6882:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + } + // InternalExpression.g:6883:2: () + // InternalExpression.g:6883:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__1" + // InternalExpression.g:6891:1: rule__InfixExpression__Group_1_1__1 : rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ; + public final void rule__InfixExpression__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6895:1: ( rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ) + // InternalExpression.g:6896:2: rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 + { + pushFollow(FOLLOW_8); + rule__InfixExpression__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__1__Impl" + // InternalExpression.g:6903:1: rule__InfixExpression__Group_1_1__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6907:1: ( ( '.' ) ) + // InternalExpression.g:6908:1: ( '.' ) + { + // InternalExpression.g:6908:1: ( '.' ) + // InternalExpression.g:6909:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__2" + // InternalExpression.g:6918:1: rule__InfixExpression__Group_1_1__2 : rule__InfixExpression__Group_1_1__2__Impl ; + public final void rule__InfixExpression__Group_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6922:1: ( rule__InfixExpression__Group_1_1__2__Impl ) + // InternalExpression.g:6923:2: rule__InfixExpression__Group_1_1__2__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_1__2__Impl" + // InternalExpression.g:6929:1: rule__InfixExpression__Group_1_1__2__Impl : ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ; + public final void rule__InfixExpression__Group_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6933:1: ( ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ) + // InternalExpression.g:6934:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + { + // InternalExpression.g:6934:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + // InternalExpression.g:6935:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + } + // InternalExpression.g:6936:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + // InternalExpression.g:6936:3: rule__InfixExpression__TypeAssignment_1_1_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__TypeAssignment_1_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_1__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__0" + // InternalExpression.g:6945:1: rule__InfixExpression__Group_1_2__0 : rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ; + public final void rule__InfixExpression__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6949:1: ( rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ) + // InternalExpression.g:6950:2: rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 + { + pushFollow(FOLLOW_32); + rule__InfixExpression__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__0__Impl" + // InternalExpression.g:6957:1: rule__InfixExpression__Group_1_2__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6961:1: ( ( () ) ) + // InternalExpression.g:6962:1: ( () ) + { + // InternalExpression.g:6962:1: ( () ) + // InternalExpression.g:6963:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + } + // InternalExpression.g:6964:2: () + // InternalExpression.g:6964:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__1" + // InternalExpression.g:6972:1: rule__InfixExpression__Group_1_2__1 : rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ; + public final void rule__InfixExpression__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6976:1: ( rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ) + // InternalExpression.g:6977:2: rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 + { + pushFollow(FOLLOW_38); + rule__InfixExpression__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__1__Impl" + // InternalExpression.g:6984:1: rule__InfixExpression__Group_1_2__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:6988:1: ( ( '.' ) ) + // InternalExpression.g:6989:1: ( '.' ) + { + // InternalExpression.g:6989:1: ( '.' ) + // InternalExpression.g:6990:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__2" + // InternalExpression.g:6999:1: rule__InfixExpression__Group_1_2__2 : rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ; + public final void rule__InfixExpression__Group_1_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7003:1: ( rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ) + // InternalExpression.g:7004:2: rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 + { + pushFollow(FOLLOW_34); + rule__InfixExpression__Group_1_2__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__2__Impl" + // InternalExpression.g:7011:1: rule__InfixExpression__Group_1_2__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ; + public final void rule__InfixExpression__Group_1_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7015:1: ( ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ) + // InternalExpression.g:7016:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + { + // InternalExpression.g:7016:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + // InternalExpression.g:7017:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + } + // InternalExpression.g:7018:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + // InternalExpression.g:7018:3: rule__InfixExpression__NameAssignment_1_2_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_2_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__3" + // InternalExpression.g:7026:1: rule__InfixExpression__Group_1_2__3 : rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ; + public final void rule__InfixExpression__Group_1_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7030:1: ( rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ) + // InternalExpression.g:7031:2: rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 + { + pushFollow(FOLLOW_8); + rule__InfixExpression__Group_1_2__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__3" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__3__Impl" + // InternalExpression.g:7038:1: rule__InfixExpression__Group_1_2__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7042:1: ( ( '(' ) ) + // InternalExpression.g:7043:1: ( '(' ) + { + // InternalExpression.g:7043:1: ( '(' ) + // InternalExpression.g:7044:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__3__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__4" + // InternalExpression.g:7053:1: rule__InfixExpression__Group_1_2__4 : rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ; + public final void rule__InfixExpression__Group_1_2__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7057:1: ( rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ) + // InternalExpression.g:7058:2: rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 + { + pushFollow(FOLLOW_9); + rule__InfixExpression__Group_1_2__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__4__Impl" + // InternalExpression.g:7065:1: rule__InfixExpression__Group_1_2__4__Impl : ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ; + public final void rule__InfixExpression__Group_1_2__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7069:1: ( ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ) + // InternalExpression.g:7070:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + { + // InternalExpression.g:7070:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + // InternalExpression.g:7071:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + } + // InternalExpression.g:7072:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + // InternalExpression.g:7072:3: rule__InfixExpression__TypeAssignment_1_2_4 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__TypeAssignment_1_2_4(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__4__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__5" + // InternalExpression.g:7080:1: rule__InfixExpression__Group_1_2__5 : rule__InfixExpression__Group_1_2__5__Impl ; + public final void rule__InfixExpression__Group_1_2__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7084:1: ( rule__InfixExpression__Group_1_2__5__Impl ) + // InternalExpression.g:7085:2: rule__InfixExpression__Group_1_2__5__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_2__5__Impl" + // InternalExpression.g:7091:1: rule__InfixExpression__Group_1_2__5__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_2__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7095:1: ( ( ')' ) ) + // InternalExpression.g:7096:1: ( ')' ) + { + // InternalExpression.g:7096:1: ( ')' ) + // InternalExpression.g:7097:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_2__5__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__0" + // InternalExpression.g:7107:1: rule__InfixExpression__Group_1_3__0 : rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ; + public final void rule__InfixExpression__Group_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7111:1: ( rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ) + // InternalExpression.g:7112:2: rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 + { + pushFollow(FOLLOW_32); + rule__InfixExpression__Group_1_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__0__Impl" + // InternalExpression.g:7119:1: rule__InfixExpression__Group_1_3__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7123:1: ( ( () ) ) + // InternalExpression.g:7124:1: ( () ) + { + // InternalExpression.g:7124:1: ( () ) + // InternalExpression.g:7125:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + } + // InternalExpression.g:7126:2: () + // InternalExpression.g:7126:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__1" + // InternalExpression.g:7134:1: rule__InfixExpression__Group_1_3__1 : rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ; + public final void rule__InfixExpression__Group_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7138:1: ( rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ) + // InternalExpression.g:7139:2: rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 + { + pushFollow(FOLLOW_39); + rule__InfixExpression__Group_1_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__1__Impl" + // InternalExpression.g:7146:1: rule__InfixExpression__Group_1_3__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7150:1: ( ( '.' ) ) + // InternalExpression.g:7151:1: ( '.' ) + { + // InternalExpression.g:7151:1: ( '.' ) + // InternalExpression.g:7152:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__1__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__2" + // InternalExpression.g:7161:1: rule__InfixExpression__Group_1_3__2 : rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ; + public final void rule__InfixExpression__Group_1_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7165:1: ( rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ) + // InternalExpression.g:7166:2: rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 + { + pushFollow(FOLLOW_34); + rule__InfixExpression__Group_1_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__2" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__2__Impl" + // InternalExpression.g:7173:1: rule__InfixExpression__Group_1_3__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ; + public final void rule__InfixExpression__Group_1_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7177:1: ( ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ) + // InternalExpression.g:7178:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + { + // InternalExpression.g:7178:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + // InternalExpression.g:7179:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); + } + // InternalExpression.g:7180:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + // InternalExpression.g:7180:3: rule__InfixExpression__NameAssignment_1_3_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_3_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__2__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__3" + // InternalExpression.g:7188:1: rule__InfixExpression__Group_1_3__3 : rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ; + public final void rule__InfixExpression__Group_1_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7192:1: ( rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ) + // InternalExpression.g:7193:2: rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 + { + pushFollow(FOLLOW_6); + rule__InfixExpression__Group_1_3__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__3" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__3__Impl" + // InternalExpression.g:7200:1: rule__InfixExpression__Group_1_3__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7204:1: ( ( '(' ) ) + // InternalExpression.g:7205:1: ( '(' ) + { + // InternalExpression.g:7205:1: ( '(' ) + // InternalExpression.g:7206:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__3__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__4" + // InternalExpression.g:7215:1: rule__InfixExpression__Group_1_3__4 : rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ; + public final void rule__InfixExpression__Group_1_3__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7219:1: ( rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ) + // InternalExpression.g:7220:2: rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 + { + pushFollow(FOLLOW_6); + rule__InfixExpression__Group_1_3__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__4__Impl" + // InternalExpression.g:7227:1: rule__InfixExpression__Group_1_3__4__Impl : ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ; + public final void rule__InfixExpression__Group_1_3__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7231:1: ( ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ) + // InternalExpression.g:7232:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + { + // InternalExpression.g:7232:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + // InternalExpression.g:7233:2: ( rule__InfixExpression__Group_1_3_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + } + // InternalExpression.g:7234:2: ( rule__InfixExpression__Group_1_3_4__0 )? + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==RULE_ID) ) { + int LA71_1 = input.LA(2); + + if ( (LA71_1==79) ) { + alt71=1; + } + } + switch (alt71) { + case 1 : + // InternalExpression.g:7234:3: rule__InfixExpression__Group_1_3_4__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__4__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__5" + // InternalExpression.g:7242:1: rule__InfixExpression__Group_1_3__5 : rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ; + public final void rule__InfixExpression__Group_1_3__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7246:1: ( rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ) + // InternalExpression.g:7247:2: rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 + { + pushFollow(FOLLOW_9); + rule__InfixExpression__Group_1_3__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__5__Impl" + // InternalExpression.g:7254:1: rule__InfixExpression__Group_1_3__5__Impl : ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ; + public final void rule__InfixExpression__Group_1_3__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7258:1: ( ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ) + // InternalExpression.g:7259:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + { + // InternalExpression.g:7259:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + // InternalExpression.g:7260:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + } + // InternalExpression.g:7261:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + // InternalExpression.g:7261:3: rule__InfixExpression__ExpAssignment_1_3_5 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__ExpAssignment_1_3_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__5__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__6" + // InternalExpression.g:7269:1: rule__InfixExpression__Group_1_3__6 : rule__InfixExpression__Group_1_3__6__Impl ; + public final void rule__InfixExpression__Group_1_3__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7273:1: ( rule__InfixExpression__Group_1_3__6__Impl ) + // InternalExpression.g:7274:2: rule__InfixExpression__Group_1_3__6__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__6" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__6__Impl" + // InternalExpression.g:7280:1: rule__InfixExpression__Group_1_3__6__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_3__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7284:1: ( ( ')' ) ) + // InternalExpression.g:7285:1: ( ')' ) + { + // InternalExpression.g:7285:1: ( ')' ) + // InternalExpression.g:7286:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__6__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__0" + // InternalExpression.g:7296:1: rule__InfixExpression__Group_1_3_4__0 : rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ; + public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7300:1: ( rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ) + // InternalExpression.g:7301:2: rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 + { + pushFollow(FOLLOW_40); + rule__InfixExpression__Group_1_3_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__0__Impl" + // InternalExpression.g:7308:1: rule__InfixExpression__Group_1_3_4__0__Impl : ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ; + public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7312:1: ( ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ) + // InternalExpression.g:7313:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + { + // InternalExpression.g:7313:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + // InternalExpression.g:7314:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + } + // InternalExpression.g:7315:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + // InternalExpression.g:7315:3: rule__InfixExpression__VarAssignment_1_3_4_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__VarAssignment_1_3_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__1" + // InternalExpression.g:7323:1: rule__InfixExpression__Group_1_3_4__1 : rule__InfixExpression__Group_1_3_4__1__Impl ; + public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7327:1: ( rule__InfixExpression__Group_1_3_4__1__Impl ) + // InternalExpression.g:7328:2: rule__InfixExpression__Group_1_3_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__1__Impl" + // InternalExpression.g:7334:1: rule__InfixExpression__Group_1_3_4__1__Impl : ( '|' ) ; + public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7338:1: ( ( '|' ) ) + // InternalExpression.g:7339:1: ( '|' ) + { + // InternalExpression.g:7339:1: ( '|' ) + // InternalExpression.g:7340:2: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + } + match(input,79,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__1__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__0" + // InternalExpression.g:7350:1: rule__ParanthesizedExpression__Group__0 : rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ; + public final void rule__ParanthesizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7354:1: ( rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ) + // InternalExpression.g:7355:2: rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 + { + pushFollow(FOLLOW_6); + rule__ParanthesizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__0" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__0__Impl" + // InternalExpression.g:7362:1: rule__ParanthesizedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__ParanthesizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7366:1: ( ( '(' ) ) + // InternalExpression.g:7367:1: ( '(' ) + { + // InternalExpression.g:7367:1: ( '(' ) + // InternalExpression.g:7368:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__1" + // InternalExpression.g:7377:1: rule__ParanthesizedExpression__Group__1 : rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ; + public final void rule__ParanthesizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7381:1: ( rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ) + // InternalExpression.g:7382:2: rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 + { + pushFollow(FOLLOW_9); + rule__ParanthesizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__1" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__1__Impl" + // InternalExpression.g:7389:1: rule__ParanthesizedExpression__Group__1__Impl : ( ruleExpression ) ; + public final void rule__ParanthesizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7393:1: ( ( ruleExpression ) ) + // InternalExpression.g:7394:1: ( ruleExpression ) + { + // InternalExpression.g:7394:1: ( ruleExpression ) + // InternalExpression.g:7395:2: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__2" + // InternalExpression.g:7404:1: rule__ParanthesizedExpression__Group__2 : rule__ParanthesizedExpression__Group__2__Impl ; + public final void rule__ParanthesizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7408:1: ( rule__ParanthesizedExpression__Group__2__Impl ) + // InternalExpression.g:7409:2: rule__ParanthesizedExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__2" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__2__Impl" + // InternalExpression.g:7415:1: rule__ParanthesizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__ParanthesizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7419:1: ( ( ')' ) ) + // InternalExpression.g:7420:1: ( ')' ) + { + // InternalExpression.g:7420:1: ( ')' ) + // InternalExpression.g:7421:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__GlobalVarExpression__Group__0" + // InternalExpression.g:7431:1: rule__GlobalVarExpression__Group__0 : rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ; + public final void rule__GlobalVarExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7435:1: ( rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ) + // InternalExpression.g:7436:2: rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 + { + pushFollow(FOLLOW_4); + rule__GlobalVarExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__0" + + + // $ANTLR start "rule__GlobalVarExpression__Group__0__Impl" + // InternalExpression.g:7443:1: rule__GlobalVarExpression__Group__0__Impl : ( 'GLOBALVAR' ) ; + public final void rule__GlobalVarExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7447:1: ( ( 'GLOBALVAR' ) ) + // InternalExpression.g:7448:1: ( 'GLOBALVAR' ) + { + // InternalExpression.g:7448:1: ( 'GLOBALVAR' ) + // InternalExpression.g:7449:2: 'GLOBALVAR' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + } + match(input,80,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__0__Impl" + + + // $ANTLR start "rule__GlobalVarExpression__Group__1" + // InternalExpression.g:7458:1: rule__GlobalVarExpression__Group__1 : rule__GlobalVarExpression__Group__1__Impl ; + public final void rule__GlobalVarExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7462:1: ( rule__GlobalVarExpression__Group__1__Impl ) + // InternalExpression.g:7463:2: rule__GlobalVarExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__1" + + + // $ANTLR start "rule__GlobalVarExpression__Group__1__Impl" + // InternalExpression.g:7469:1: rule__GlobalVarExpression__Group__1__Impl : ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ; + public final void rule__GlobalVarExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7473:1: ( ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ) + // InternalExpression.g:7474:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + { + // InternalExpression.g:7474:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + // InternalExpression.g:7475:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + } + // InternalExpression.g:7476:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + // InternalExpression.g:7476:3: rule__GlobalVarExpression__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group__0" + // InternalExpression.g:7485:1: rule__OperationCall__Group__0 : rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ; + public final void rule__OperationCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7489:1: ( rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ) + // InternalExpression.g:7490:2: rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 + { + pushFollow(FOLLOW_34); + rule__OperationCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__0" + + + // $ANTLR start "rule__OperationCall__Group__0__Impl" + // InternalExpression.g:7497:1: rule__OperationCall__Group__0__Impl : ( ( rule__OperationCall__NameAssignment_0 ) ) ; + public final void rule__OperationCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7501:1: ( ( ( rule__OperationCall__NameAssignment_0 ) ) ) + // InternalExpression.g:7502:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + { + // InternalExpression.g:7502:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + // InternalExpression.g:7503:2: ( rule__OperationCall__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + } + // InternalExpression.g:7504:2: ( rule__OperationCall__NameAssignment_0 ) + // InternalExpression.g:7504:3: rule__OperationCall__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group__1" + // InternalExpression.g:7512:1: rule__OperationCall__Group__1 : rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ; + public final void rule__OperationCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7516:1: ( rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ) + // InternalExpression.g:7517:2: rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 + { + pushFollow(FOLLOW_35); + rule__OperationCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__1" + + + // $ANTLR start "rule__OperationCall__Group__1__Impl" + // InternalExpression.g:7524:1: rule__OperationCall__Group__1__Impl : ( '(' ) ; + public final void rule__OperationCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7528:1: ( ( '(' ) ) + // InternalExpression.g:7529:1: ( '(' ) + { + // InternalExpression.g:7529:1: ( '(' ) + // InternalExpression.g:7530:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group__2" + // InternalExpression.g:7539:1: rule__OperationCall__Group__2 : rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ; + public final void rule__OperationCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7543:1: ( rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ) + // InternalExpression.g:7544:2: rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 + { + pushFollow(FOLLOW_35); + rule__OperationCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__2" + + + // $ANTLR start "rule__OperationCall__Group__2__Impl" + // InternalExpression.g:7551:1: rule__OperationCall__Group__2__Impl : ( ( rule__OperationCall__Group_2__0 )? ) ; + public final void rule__OperationCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7555:1: ( ( ( rule__OperationCall__Group_2__0 )? ) ) + // InternalExpression.g:7556:1: ( ( rule__OperationCall__Group_2__0 )? ) + { + // InternalExpression.g:7556:1: ( ( rule__OperationCall__Group_2__0 )? ) + // InternalExpression.g:7557:2: ( rule__OperationCall__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getGroup_2()); + } + // InternalExpression.g:7558:2: ( rule__OperationCall__Group_2__0 )? + int alt72=2; + int LA72_0 = input.LA(1); + + if ( (LA72_0==RULE_ID||LA72_0==RULE_INT||(LA72_0>=RULE_REAL && LA72_0<=RULE_STRING)||LA72_0==24||(LA72_0>=27 && LA72_0<=40)||LA72_0==65||LA72_0==67||LA72_0==70||(LA72_0>=73 && LA72_0<=74)||(LA72_0>=80 && LA72_0<=81)||LA72_0==92||LA72_0==102) ) { + alt72=1; + } + switch (alt72) { + case 1 : + // InternalExpression.g:7558:3: rule__OperationCall__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__2__Impl" + + + // $ANTLR start "rule__OperationCall__Group__3" + // InternalExpression.g:7566:1: rule__OperationCall__Group__3 : rule__OperationCall__Group__3__Impl ; + public final void rule__OperationCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7570:1: ( rule__OperationCall__Group__3__Impl ) + // InternalExpression.g:7571:2: rule__OperationCall__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__3" + + + // $ANTLR start "rule__OperationCall__Group__3__Impl" + // InternalExpression.g:7577:1: rule__OperationCall__Group__3__Impl : ( ')' ) ; + public final void rule__OperationCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7581:1: ( ( ')' ) ) + // InternalExpression.g:7582:1: ( ')' ) + { + // InternalExpression.g:7582:1: ( ')' ) + // InternalExpression.g:7583:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__3__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2__0" + // InternalExpression.g:7593:1: rule__OperationCall__Group_2__0 : rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ; + public final void rule__OperationCall__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7597:1: ( rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ) + // InternalExpression.g:7598:2: rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 + { + pushFollow(FOLLOW_36); + rule__OperationCall__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__0" + + + // $ANTLR start "rule__OperationCall__Group_2__0__Impl" + // InternalExpression.g:7605:1: rule__OperationCall__Group_2__0__Impl : ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ; + public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7609:1: ( ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ) + // InternalExpression.g:7610:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + { + // InternalExpression.g:7610:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + // InternalExpression.g:7611:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + } + // InternalExpression.g:7612:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + // InternalExpression.g:7612:3: rule__OperationCall__ParamsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__ParamsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2__1" + // InternalExpression.g:7620:1: rule__OperationCall__Group_2__1 : rule__OperationCall__Group_2__1__Impl ; + public final void rule__OperationCall__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7624:1: ( rule__OperationCall__Group_2__1__Impl ) + // InternalExpression.g:7625:2: rule__OperationCall__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__1" + + + // $ANTLR start "rule__OperationCall__Group_2__1__Impl" + // InternalExpression.g:7631:1: rule__OperationCall__Group_2__1__Impl : ( ( rule__OperationCall__Group_2_1__0 )* ) ; + public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7635:1: ( ( ( rule__OperationCall__Group_2_1__0 )* ) ) + // InternalExpression.g:7636:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + { + // InternalExpression.g:7636:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + // InternalExpression.g:7637:2: ( rule__OperationCall__Group_2_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getGroup_2_1()); + } + // InternalExpression.g:7638:2: ( rule__OperationCall__Group_2_1__0 )* + loop73: + do { + int alt73=2; + int LA73_0 = input.LA(1); + + if ( (LA73_0==78) ) { + alt73=1; + } + + + switch (alt73) { + case 1 : + // InternalExpression.g:7638:3: rule__OperationCall__Group_2_1__0 + { + pushFollow(FOLLOW_37); + rule__OperationCall__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop73; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getGroup_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2_1__0" + // InternalExpression.g:7647:1: rule__OperationCall__Group_2_1__0 : rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ; + public final void rule__OperationCall__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7651:1: ( rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ) + // InternalExpression.g:7652:2: rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 + { + pushFollow(FOLLOW_6); + rule__OperationCall__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__0" + + + // $ANTLR start "rule__OperationCall__Group_2_1__0__Impl" + // InternalExpression.g:7659:1: rule__OperationCall__Group_2_1__0__Impl : ( ',' ) ; + public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7663:1: ( ( ',' ) ) + // InternalExpression.g:7664:1: ( ',' ) + { + // InternalExpression.g:7664:1: ( ',' ) + // InternalExpression.g:7665:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2_1__1" + // InternalExpression.g:7674:1: rule__OperationCall__Group_2_1__1 : rule__OperationCall__Group_2_1__1__Impl ; + public final void rule__OperationCall__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7678:1: ( rule__OperationCall__Group_2_1__1__Impl ) + // InternalExpression.g:7679:2: rule__OperationCall__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__1" + + + // $ANTLR start "rule__OperationCall__Group_2_1__1__Impl" + // InternalExpression.g:7685:1: rule__OperationCall__Group_2_1__1__Impl : ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ; + public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7689:1: ( ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ) + // InternalExpression.g:7690:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + { + // InternalExpression.g:7690:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + // InternalExpression.g:7691:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + } + // InternalExpression.g:7692:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + // InternalExpression.g:7692:3: rule__OperationCall__ParamsAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__OperationCall__ParamsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__0" + // InternalExpression.g:7701:1: rule__ListLiteral__Group__0 : rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ; + public final void rule__ListLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7705:1: ( rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ) + // InternalExpression.g:7706:2: rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 + { + pushFollow(FOLLOW_41); + rule__ListLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__0" + + + // $ANTLR start "rule__ListLiteral__Group__0__Impl" + // InternalExpression.g:7713:1: rule__ListLiteral__Group__0__Impl : ( () ) ; + public final void rule__ListLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7717:1: ( ( () ) ) + // InternalExpression.g:7718:1: ( () ) + { + // InternalExpression.g:7718:1: ( () ) + // InternalExpression.g:7719:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + } + // InternalExpression.g:7720:2: () + // InternalExpression.g:7720:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__1" + // InternalExpression.g:7728:1: rule__ListLiteral__Group__1 : rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ; + public final void rule__ListLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7732:1: ( rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ) + // InternalExpression.g:7733:2: rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 + { + pushFollow(FOLLOW_42); + rule__ListLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__1" + + + // $ANTLR start "rule__ListLiteral__Group__1__Impl" + // InternalExpression.g:7740:1: rule__ListLiteral__Group__1__Impl : ( '{' ) ; + public final void rule__ListLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7744:1: ( ( '{' ) ) + // InternalExpression.g:7745:1: ( '{' ) + { + // InternalExpression.g:7745:1: ( '{' ) + // InternalExpression.g:7746:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__2" + // InternalExpression.g:7755:1: rule__ListLiteral__Group__2 : rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ; + public final void rule__ListLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7759:1: ( rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ) + // InternalExpression.g:7760:2: rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 + { + pushFollow(FOLLOW_42); + rule__ListLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__2" + + + // $ANTLR start "rule__ListLiteral__Group__2__Impl" + // InternalExpression.g:7767:1: rule__ListLiteral__Group__2__Impl : ( ( rule__ListLiteral__Group_2__0 )? ) ; + public final void rule__ListLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7771:1: ( ( ( rule__ListLiteral__Group_2__0 )? ) ) + // InternalExpression.g:7772:1: ( ( rule__ListLiteral__Group_2__0 )? ) + { + // InternalExpression.g:7772:1: ( ( rule__ListLiteral__Group_2__0 )? ) + // InternalExpression.g:7773:2: ( rule__ListLiteral__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getGroup_2()); + } + // InternalExpression.g:7774:2: ( rule__ListLiteral__Group_2__0 )? + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==RULE_ID||LA74_0==RULE_INT||(LA74_0>=RULE_REAL && LA74_0<=RULE_STRING)||LA74_0==24||(LA74_0>=27 && LA74_0<=40)||LA74_0==65||LA74_0==67||LA74_0==70||(LA74_0>=73 && LA74_0<=74)||(LA74_0>=80 && LA74_0<=81)||LA74_0==92||LA74_0==102) ) { + alt74=1; + } + switch (alt74) { + case 1 : + // InternalExpression.g:7774:3: rule__ListLiteral__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__2__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__3" + // InternalExpression.g:7782:1: rule__ListLiteral__Group__3 : rule__ListLiteral__Group__3__Impl ; + public final void rule__ListLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7786:1: ( rule__ListLiteral__Group__3__Impl ) + // InternalExpression.g:7787:2: rule__ListLiteral__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__3" + + + // $ANTLR start "rule__ListLiteral__Group__3__Impl" + // InternalExpression.g:7793:1: rule__ListLiteral__Group__3__Impl : ( '}' ) ; + public final void rule__ListLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7797:1: ( ( '}' ) ) + // InternalExpression.g:7798:1: ( '}' ) + { + // InternalExpression.g:7798:1: ( '}' ) + // InternalExpression.g:7799:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + } + match(input,76,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__3__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2__0" + // InternalExpression.g:7809:1: rule__ListLiteral__Group_2__0 : rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ; + public final void rule__ListLiteral__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7813:1: ( rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ) + // InternalExpression.g:7814:2: rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 + { + pushFollow(FOLLOW_36); + rule__ListLiteral__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__0" + + + // $ANTLR start "rule__ListLiteral__Group_2__0__Impl" + // InternalExpression.g:7821:1: rule__ListLiteral__Group_2__0__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ; + public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7825:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ) + // InternalExpression.g:7826:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + { + // InternalExpression.g:7826:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + // InternalExpression.g:7827:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + } + // InternalExpression.g:7828:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + // InternalExpression.g:7828:3: rule__ListLiteral__ElementsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__ElementsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2__1" + // InternalExpression.g:7836:1: rule__ListLiteral__Group_2__1 : rule__ListLiteral__Group_2__1__Impl ; + public final void rule__ListLiteral__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7840:1: ( rule__ListLiteral__Group_2__1__Impl ) + // InternalExpression.g:7841:2: rule__ListLiteral__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__1" + + + // $ANTLR start "rule__ListLiteral__Group_2__1__Impl" + // InternalExpression.g:7847:1: rule__ListLiteral__Group_2__1__Impl : ( ( rule__ListLiteral__Group_2_1__0 )* ) ; + public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7851:1: ( ( ( rule__ListLiteral__Group_2_1__0 )* ) ) + // InternalExpression.g:7852:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + { + // InternalExpression.g:7852:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + // InternalExpression.g:7853:2: ( rule__ListLiteral__Group_2_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getGroup_2_1()); + } + // InternalExpression.g:7854:2: ( rule__ListLiteral__Group_2_1__0 )* + loop75: + do { + int alt75=2; + int LA75_0 = input.LA(1); + + if ( (LA75_0==78) ) { + alt75=1; + } + + + switch (alt75) { + case 1 : + // InternalExpression.g:7854:3: rule__ListLiteral__Group_2_1__0 + { + pushFollow(FOLLOW_37); + rule__ListLiteral__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop75; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getGroup_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__0" + // InternalExpression.g:7863:1: rule__ListLiteral__Group_2_1__0 : rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ; + public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7867:1: ( rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ) + // InternalExpression.g:7868:2: rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 + { + pushFollow(FOLLOW_6); + rule__ListLiteral__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__0" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__0__Impl" + // InternalExpression.g:7875:1: rule__ListLiteral__Group_2_1__0__Impl : ( ',' ) ; + public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7879:1: ( ( ',' ) ) + // InternalExpression.g:7880:1: ( ',' ) + { + // InternalExpression.g:7880:1: ( ',' ) + // InternalExpression.g:7881:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__1" + // InternalExpression.g:7890:1: rule__ListLiteral__Group_2_1__1 : rule__ListLiteral__Group_2_1__1__Impl ; + public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7894:1: ( rule__ListLiteral__Group_2_1__1__Impl ) + // InternalExpression.g:7895:2: rule__ListLiteral__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__1" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__1__Impl" + // InternalExpression.g:7901:1: rule__ListLiteral__Group_2_1__1__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ; + public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7905:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ) + // InternalExpression.g:7906:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + { + // InternalExpression.g:7906:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + // InternalExpression.g:7907:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + } + // InternalExpression.g:7908:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + // InternalExpression.g:7908:3: rule__ListLiteral__ElementsAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__ElementsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__1__Impl" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__0" + // InternalExpression.g:7917:1: rule__ConstructorCallExpression__Group__0 : rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ; + public final void rule__ConstructorCallExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7921:1: ( rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ) + // InternalExpression.g:7922:2: rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 + { + pushFollow(FOLLOW_8); + rule__ConstructorCallExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__0" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__0__Impl" + // InternalExpression.g:7929:1: rule__ConstructorCallExpression__Group__0__Impl : ( 'new' ) ; + public final void rule__ConstructorCallExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7933:1: ( ( 'new' ) ) + // InternalExpression.g:7934:1: ( 'new' ) + { + // InternalExpression.g:7934:1: ( 'new' ) + // InternalExpression.g:7935:2: 'new' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + } + match(input,81,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__0__Impl" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__1" + // InternalExpression.g:7944:1: rule__ConstructorCallExpression__Group__1 : rule__ConstructorCallExpression__Group__1__Impl ; + public final void rule__ConstructorCallExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7948:1: ( rule__ConstructorCallExpression__Group__1__Impl ) + // InternalExpression.g:7949:2: rule__ConstructorCallExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__1" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__1__Impl" + // InternalExpression.g:7955:1: rule__ConstructorCallExpression__Group__1__Impl : ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ; + public final void rule__ConstructorCallExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7959:1: ( ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ) + // InternalExpression.g:7960:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + { + // InternalExpression.g:7960:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + // InternalExpression.g:7961:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + } + // InternalExpression.g:7962:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + // InternalExpression.g:7962:3: rule__ConstructorCallExpression__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__TypeAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__1__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__0" + // InternalExpression.g:7971:1: rule__TypeSelectExpression__Group__0 : rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ; + public final void rule__TypeSelectExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7975:1: ( rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ) + // InternalExpression.g:7976:2: rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 + { + pushFollow(FOLLOW_34); + rule__TypeSelectExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__0" + + + // $ANTLR start "rule__TypeSelectExpression__Group__0__Impl" + // InternalExpression.g:7983:1: rule__TypeSelectExpression__Group__0__Impl : ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ; + public final void rule__TypeSelectExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:7987:1: ( ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ) + // InternalExpression.g:7988:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + { + // InternalExpression.g:7988:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + // InternalExpression.g:7989:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + } + // InternalExpression.g:7990:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + // InternalExpression.g:7990:3: rule__TypeSelectExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__0__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__1" + // InternalExpression.g:7998:1: rule__TypeSelectExpression__Group__1 : rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ; + public final void rule__TypeSelectExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8002:1: ( rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ) + // InternalExpression.g:8003:2: rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 + { + pushFollow(FOLLOW_8); + rule__TypeSelectExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__1" + + + // $ANTLR start "rule__TypeSelectExpression__Group__1__Impl" + // InternalExpression.g:8010:1: rule__TypeSelectExpression__Group__1__Impl : ( '(' ) ; + public final void rule__TypeSelectExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8014:1: ( ( '(' ) ) + // InternalExpression.g:8015:1: ( '(' ) + { + // InternalExpression.g:8015:1: ( '(' ) + // InternalExpression.g:8016:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__1__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__2" + // InternalExpression.g:8025:1: rule__TypeSelectExpression__Group__2 : rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ; + public final void rule__TypeSelectExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8029:1: ( rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ) + // InternalExpression.g:8030:2: rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 + { + pushFollow(FOLLOW_9); + rule__TypeSelectExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__2" + + + // $ANTLR start "rule__TypeSelectExpression__Group__2__Impl" + // InternalExpression.g:8037:1: rule__TypeSelectExpression__Group__2__Impl : ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ; + public final void rule__TypeSelectExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8041:1: ( ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ) + // InternalExpression.g:8042:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + { + // InternalExpression.g:8042:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + // InternalExpression.g:8043:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + } + // InternalExpression.g:8044:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + // InternalExpression.g:8044:3: rule__TypeSelectExpression__TypeAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__TypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__2__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__3" + // InternalExpression.g:8052:1: rule__TypeSelectExpression__Group__3 : rule__TypeSelectExpression__Group__3__Impl ; + public final void rule__TypeSelectExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8056:1: ( rule__TypeSelectExpression__Group__3__Impl ) + // InternalExpression.g:8057:2: rule__TypeSelectExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__3" + + + // $ANTLR start "rule__TypeSelectExpression__Group__3__Impl" + // InternalExpression.g:8063:1: rule__TypeSelectExpression__Group__3__Impl : ( ')' ) ; + public final void rule__TypeSelectExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8067:1: ( ( ')' ) ) + // InternalExpression.g:8068:1: ( ')' ) + { + // InternalExpression.g:8068:1: ( ')' ) + // InternalExpression.g:8069:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__3__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__0" + // InternalExpression.g:8079:1: rule__CollectionExpression__Group__0 : rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ; + public final void rule__CollectionExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8083:1: ( rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ) + // InternalExpression.g:8084:2: rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 + { + pushFollow(FOLLOW_34); + rule__CollectionExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__0" + + + // $ANTLR start "rule__CollectionExpression__Group__0__Impl" + // InternalExpression.g:8091:1: rule__CollectionExpression__Group__0__Impl : ( ( rule__CollectionExpression__NameAssignment_0 ) ) ; + public final void rule__CollectionExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8095:1: ( ( ( rule__CollectionExpression__NameAssignment_0 ) ) ) + // InternalExpression.g:8096:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + { + // InternalExpression.g:8096:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + // InternalExpression.g:8097:2: ( rule__CollectionExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + } + // InternalExpression.g:8098:2: ( rule__CollectionExpression__NameAssignment_0 ) + // InternalExpression.g:8098:3: rule__CollectionExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__0__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__1" + // InternalExpression.g:8106:1: rule__CollectionExpression__Group__1 : rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ; + public final void rule__CollectionExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8110:1: ( rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ) + // InternalExpression.g:8111:2: rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 + { + pushFollow(FOLLOW_6); + rule__CollectionExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__1" + + + // $ANTLR start "rule__CollectionExpression__Group__1__Impl" + // InternalExpression.g:8118:1: rule__CollectionExpression__Group__1__Impl : ( '(' ) ; + public final void rule__CollectionExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8122:1: ( ( '(' ) ) + // InternalExpression.g:8123:1: ( '(' ) + { + // InternalExpression.g:8123:1: ( '(' ) + // InternalExpression.g:8124:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__1__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__2" + // InternalExpression.g:8133:1: rule__CollectionExpression__Group__2 : rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ; + public final void rule__CollectionExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8137:1: ( rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ) + // InternalExpression.g:8138:2: rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 + { + pushFollow(FOLLOW_6); + rule__CollectionExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__2" + + + // $ANTLR start "rule__CollectionExpression__Group__2__Impl" + // InternalExpression.g:8145:1: rule__CollectionExpression__Group__2__Impl : ( ( rule__CollectionExpression__Group_2__0 )? ) ; + public final void rule__CollectionExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8149:1: ( ( ( rule__CollectionExpression__Group_2__0 )? ) ) + // InternalExpression.g:8150:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + { + // InternalExpression.g:8150:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + // InternalExpression.g:8151:2: ( rule__CollectionExpression__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + } + // InternalExpression.g:8152:2: ( rule__CollectionExpression__Group_2__0 )? + int alt76=2; + int LA76_0 = input.LA(1); + + if ( (LA76_0==RULE_ID) ) { + int LA76_1 = input.LA(2); + + if ( (LA76_1==79) ) { + alt76=1; + } + } + switch (alt76) { + case 1 : + // InternalExpression.g:8152:3: rule__CollectionExpression__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__2__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__3" + // InternalExpression.g:8160:1: rule__CollectionExpression__Group__3 : rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ; + public final void rule__CollectionExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8164:1: ( rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ) + // InternalExpression.g:8165:2: rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 + { + pushFollow(FOLLOW_9); + rule__CollectionExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__3" + + + // $ANTLR start "rule__CollectionExpression__Group__3__Impl" + // InternalExpression.g:8172:1: rule__CollectionExpression__Group__3__Impl : ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ; + public final void rule__CollectionExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8176:1: ( ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ) + // InternalExpression.g:8177:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + { + // InternalExpression.g:8177:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + // InternalExpression.g:8178:2: ( rule__CollectionExpression__ExpAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + } + // InternalExpression.g:8179:2: ( rule__CollectionExpression__ExpAssignment_3 ) + // InternalExpression.g:8179:3: rule__CollectionExpression__ExpAssignment_3 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__ExpAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__3__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__4" + // InternalExpression.g:8187:1: rule__CollectionExpression__Group__4 : rule__CollectionExpression__Group__4__Impl ; + public final void rule__CollectionExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8191:1: ( rule__CollectionExpression__Group__4__Impl ) + // InternalExpression.g:8192:2: rule__CollectionExpression__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__4" + + + // $ANTLR start "rule__CollectionExpression__Group__4__Impl" + // InternalExpression.g:8198:1: rule__CollectionExpression__Group__4__Impl : ( ')' ) ; + public final void rule__CollectionExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8202:1: ( ( ')' ) ) + // InternalExpression.g:8203:1: ( ')' ) + { + // InternalExpression.g:8203:1: ( ')' ) + // InternalExpression.g:8204:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__4__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group_2__0" + // InternalExpression.g:8214:1: rule__CollectionExpression__Group_2__0 : rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ; + public final void rule__CollectionExpression__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8218:1: ( rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ) + // InternalExpression.g:8219:2: rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 + { + pushFollow(FOLLOW_40); + rule__CollectionExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__0" + + + // $ANTLR start "rule__CollectionExpression__Group_2__0__Impl" + // InternalExpression.g:8226:1: rule__CollectionExpression__Group_2__0__Impl : ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ; + public final void rule__CollectionExpression__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8230:1: ( ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ) + // InternalExpression.g:8231:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + { + // InternalExpression.g:8231:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + // InternalExpression.g:8232:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + } + // InternalExpression.g:8233:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + // InternalExpression.g:8233:3: rule__CollectionExpression__VarAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__VarAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__0__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group_2__1" + // InternalExpression.g:8241:1: rule__CollectionExpression__Group_2__1 : rule__CollectionExpression__Group_2__1__Impl ; + public final void rule__CollectionExpression__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8245:1: ( rule__CollectionExpression__Group_2__1__Impl ) + // InternalExpression.g:8246:2: rule__CollectionExpression__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__1" + + + // $ANTLR start "rule__CollectionExpression__Group_2__1__Impl" + // InternalExpression.g:8252:1: rule__CollectionExpression__Group_2__1__Impl : ( '|' ) ; + public final void rule__CollectionExpression__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8256:1: ( ( '|' ) ) + // InternalExpression.g:8257:1: ( '|' ) + { + // InternalExpression.g:8257:1: ( '|' ) + // InternalExpression.g:8258:2: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + } + match(input,79,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__1__Impl" + + + // $ANTLR start "rule__CollectionType__Group__0" + // InternalExpression.g:8268:1: rule__CollectionType__Group__0 : rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ; + public final void rule__CollectionType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8272:1: ( rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ) + // InternalExpression.g:8273:2: rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 + { + pushFollow(FOLLOW_43); + rule__CollectionType__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__0" + + + // $ANTLR start "rule__CollectionType__Group__0__Impl" + // InternalExpression.g:8280:1: rule__CollectionType__Group__0__Impl : ( ( rule__CollectionType__ClAssignment_0 ) ) ; + public final void rule__CollectionType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8284:1: ( ( ( rule__CollectionType__ClAssignment_0 ) ) ) + // InternalExpression.g:8285:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + { + // InternalExpression.g:8285:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + // InternalExpression.g:8286:2: ( rule__CollectionType__ClAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + } + // InternalExpression.g:8287:2: ( rule__CollectionType__ClAssignment_0 ) + // InternalExpression.g:8287:3: rule__CollectionType__ClAssignment_0 + { + pushFollow(FOLLOW_2); + rule__CollectionType__ClAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__0__Impl" + + + // $ANTLR start "rule__CollectionType__Group__1" + // InternalExpression.g:8295:1: rule__CollectionType__Group__1 : rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ; + public final void rule__CollectionType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8299:1: ( rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ) + // InternalExpression.g:8300:2: rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 + { + pushFollow(FOLLOW_8); + rule__CollectionType__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__1" + + + // $ANTLR start "rule__CollectionType__Group__1__Impl" + // InternalExpression.g:8307:1: rule__CollectionType__Group__1__Impl : ( '[' ) ; + public final void rule__CollectionType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8311:1: ( ( '[' ) ) + // InternalExpression.g:8312:1: ( '[' ) + { + // InternalExpression.g:8312:1: ( '[' ) + // InternalExpression.g:8313:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__1__Impl" + + + // $ANTLR start "rule__CollectionType__Group__2" + // InternalExpression.g:8322:1: rule__CollectionType__Group__2 : rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ; + public final void rule__CollectionType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8326:1: ( rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ) + // InternalExpression.g:8327:2: rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 + { + pushFollow(FOLLOW_44); + rule__CollectionType__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__2" + + + // $ANTLR start "rule__CollectionType__Group__2__Impl" + // InternalExpression.g:8334:1: rule__CollectionType__Group__2__Impl : ( ( rule__CollectionType__Id1Assignment_2 ) ) ; + public final void rule__CollectionType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8338:1: ( ( ( rule__CollectionType__Id1Assignment_2 ) ) ) + // InternalExpression.g:8339:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + { + // InternalExpression.g:8339:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + // InternalExpression.g:8340:2: ( rule__CollectionType__Id1Assignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + } + // InternalExpression.g:8341:2: ( rule__CollectionType__Id1Assignment_2 ) + // InternalExpression.g:8341:3: rule__CollectionType__Id1Assignment_2 + { + pushFollow(FOLLOW_2); + rule__CollectionType__Id1Assignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__2__Impl" + + + // $ANTLR start "rule__CollectionType__Group__3" + // InternalExpression.g:8349:1: rule__CollectionType__Group__3 : rule__CollectionType__Group__3__Impl ; + public final void rule__CollectionType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8353:1: ( rule__CollectionType__Group__3__Impl ) + // InternalExpression.g:8354:2: rule__CollectionType__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionType__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__3" + + + // $ANTLR start "rule__CollectionType__Group__3__Impl" + // InternalExpression.g:8360:1: rule__CollectionType__Group__3__Impl : ( ']' ) ; + public final void rule__CollectionType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8364:1: ( ( ']' ) ) + // InternalExpression.g:8365:1: ( ']' ) + { + // InternalExpression.g:8365:1: ( ']' ) + // InternalExpression.g:8366:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__3__Impl" + + + // $ANTLR start "rule__SimpleType__Group__0" + // InternalExpression.g:8376:1: rule__SimpleType__Group__0 : rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ; + public final void rule__SimpleType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8380:1: ( rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ) + // InternalExpression.g:8381:2: rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 + { + pushFollow(FOLLOW_45); + rule__SimpleType__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SimpleType__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__0" + + + // $ANTLR start "rule__SimpleType__Group__0__Impl" + // InternalExpression.g:8388:1: rule__SimpleType__Group__0__Impl : ( ( rule__SimpleType__IdAssignment_0 ) ) ; + public final void rule__SimpleType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8392:1: ( ( ( rule__SimpleType__IdAssignment_0 ) ) ) + // InternalExpression.g:8393:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + { + // InternalExpression.g:8393:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + // InternalExpression.g:8394:2: ( rule__SimpleType__IdAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + } + // InternalExpression.g:8395:2: ( rule__SimpleType__IdAssignment_0 ) + // InternalExpression.g:8395:3: rule__SimpleType__IdAssignment_0 + { + pushFollow(FOLLOW_2); + rule__SimpleType__IdAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__0__Impl" + + + // $ANTLR start "rule__SimpleType__Group__1" + // InternalExpression.g:8403:1: rule__SimpleType__Group__1 : rule__SimpleType__Group__1__Impl ; + public final void rule__SimpleType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8407:1: ( rule__SimpleType__Group__1__Impl ) + // InternalExpression.g:8408:2: rule__SimpleType__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__SimpleType__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__1" + + + // $ANTLR start "rule__SimpleType__Group__1__Impl" + // InternalExpression.g:8414:1: rule__SimpleType__Group__1__Impl : ( ( rule__SimpleType__Group_1__0 )* ) ; + public final void rule__SimpleType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8418:1: ( ( ( rule__SimpleType__Group_1__0 )* ) ) + // InternalExpression.g:8419:1: ( ( rule__SimpleType__Group_1__0 )* ) + { + // InternalExpression.g:8419:1: ( ( rule__SimpleType__Group_1__0 )* ) + // InternalExpression.g:8420:2: ( rule__SimpleType__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getGroup_1()); + } + // InternalExpression.g:8421:2: ( rule__SimpleType__Group_1__0 )* + loop77: + do { + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==84) ) { + alt77=1; + } + + + switch (alt77) { + case 1 : + // InternalExpression.g:8421:3: rule__SimpleType__Group_1__0 + { + pushFollow(FOLLOW_46); + rule__SimpleType__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop77; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__1__Impl" + + + // $ANTLR start "rule__SimpleType__Group_1__0" + // InternalExpression.g:8430:1: rule__SimpleType__Group_1__0 : rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ; + public final void rule__SimpleType__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8434:1: ( rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ) + // InternalExpression.g:8435:2: rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 + { + pushFollow(FOLLOW_4); + rule__SimpleType__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SimpleType__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__0" + + + // $ANTLR start "rule__SimpleType__Group_1__0__Impl" + // InternalExpression.g:8442:1: rule__SimpleType__Group_1__0__Impl : ( '::' ) ; + public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8446:1: ( ( '::' ) ) + // InternalExpression.g:8447:1: ( '::' ) + { + // InternalExpression.g:8447:1: ( '::' ) + // InternalExpression.g:8448:2: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + } + match(input,84,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__0__Impl" + + + // $ANTLR start "rule__SimpleType__Group_1__1" + // InternalExpression.g:8457:1: rule__SimpleType__Group_1__1 : rule__SimpleType__Group_1__1__Impl ; + public final void rule__SimpleType__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8461:1: ( rule__SimpleType__Group_1__1__Impl ) + // InternalExpression.g:8462:2: rule__SimpleType__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__SimpleType__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__1" + + + // $ANTLR start "rule__SimpleType__Group_1__1__Impl" + // InternalExpression.g:8468:1: rule__SimpleType__Group_1__1__Impl : ( ( rule__SimpleType__IdAssignment_1_1 ) ) ; + public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8472:1: ( ( ( rule__SimpleType__IdAssignment_1_1 ) ) ) + // InternalExpression.g:8473:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + { + // InternalExpression.g:8473:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + // InternalExpression.g:8474:2: ( rule__SimpleType__IdAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + } + // InternalExpression.g:8475:2: ( rule__SimpleType__IdAssignment_1_1 ) + // InternalExpression.g:8475:3: rule__SimpleType__IdAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__SimpleType__IdAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__0" + // InternalExpression.g:8484:1: rule__XAssignment__Group_0__0 : rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ; + public final void rule__XAssignment__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8488:1: ( rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ) + // InternalExpression.g:8489:2: rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 + { + pushFollow(FOLLOW_47); + rule__XAssignment__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__0" + + + // $ANTLR start "rule__XAssignment__Group_0__0__Impl" + // InternalExpression.g:8496:1: rule__XAssignment__Group_0__0__Impl : ( () ) ; + public final void rule__XAssignment__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8500:1: ( ( () ) ) + // InternalExpression.g:8501:1: ( () ) + { + // InternalExpression.g:8501:1: ( () ) + // InternalExpression.g:8502:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); + } + // InternalExpression.g:8503:2: () + // InternalExpression.g:8503:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__1" + // InternalExpression.g:8511:1: rule__XAssignment__Group_0__1 : rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ; + public final void rule__XAssignment__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8515:1: ( rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ) + // InternalExpression.g:8516:2: rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 + { + pushFollow(FOLLOW_5); + rule__XAssignment__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__1" + + + // $ANTLR start "rule__XAssignment__Group_0__1__Impl" + // InternalExpression.g:8523:1: rule__XAssignment__Group_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ; + public final void rule__XAssignment__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8527:1: ( ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ) + // InternalExpression.g:8528:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) + { + // InternalExpression.g:8528:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) + // InternalExpression.g:8529:2: ( rule__XAssignment__FeatureAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); + } + // InternalExpression.g:8530:2: ( rule__XAssignment__FeatureAssignment_0_1 ) + // InternalExpression.g:8530:3: rule__XAssignment__FeatureAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__FeatureAssignment_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__2" + // InternalExpression.g:8538:1: rule__XAssignment__Group_0__2 : rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ; + public final void rule__XAssignment__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8542:1: ( rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ) + // InternalExpression.g:8543:2: rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 + { + pushFollow(FOLLOW_48); + rule__XAssignment__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__2" + + + // $ANTLR start "rule__XAssignment__Group_0__2__Impl" + // InternalExpression.g:8550:1: rule__XAssignment__Group_0__2__Impl : ( ruleOpSingleAssign ) ; + public final void rule__XAssignment__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8554:1: ( ( ruleOpSingleAssign ) ) + // InternalExpression.g:8555:1: ( ruleOpSingleAssign ) + { + // InternalExpression.g:8555:1: ( ruleOpSingleAssign ) + // InternalExpression.g:8556:2: ruleOpSingleAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__2__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__3" + // InternalExpression.g:8565:1: rule__XAssignment__Group_0__3 : rule__XAssignment__Group_0__3__Impl ; + public final void rule__XAssignment__Group_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8569:1: ( rule__XAssignment__Group_0__3__Impl ) + // InternalExpression.g:8570:2: rule__XAssignment__Group_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__3" + + + // $ANTLR start "rule__XAssignment__Group_0__3__Impl" + // InternalExpression.g:8576:1: rule__XAssignment__Group_0__3__Impl : ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ; + public final void rule__XAssignment__Group_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8580:1: ( ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ) + // InternalExpression.g:8581:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) ) + { + // InternalExpression.g:8581:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) ) + // InternalExpression.g:8582:2: ( rule__XAssignment__ValueAssignment_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); + } + // InternalExpression.g:8583:2: ( rule__XAssignment__ValueAssignment_0_3 ) + // InternalExpression.g:8583:3: rule__XAssignment__ValueAssignment_0_3 + { + pushFollow(FOLLOW_2); + rule__XAssignment__ValueAssignment_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__3__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1__0" + // InternalExpression.g:8592:1: rule__XAssignment__Group_1__0 : rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ; + public final void rule__XAssignment__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8596:1: ( rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ) + // InternalExpression.g:8597:2: rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 + { + pushFollow(FOLLOW_49); + rule__XAssignment__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__0" + + + // $ANTLR start "rule__XAssignment__Group_1__0__Impl" + // InternalExpression.g:8604:1: rule__XAssignment__Group_1__0__Impl : ( ruleXOrExpression ) ; + public final void rule__XAssignment__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8608:1: ( ( ruleXOrExpression ) ) + // InternalExpression.g:8609:1: ( ruleXOrExpression ) + { + // InternalExpression.g:8609:1: ( ruleXOrExpression ) + // InternalExpression.g:8610:2: ruleXOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1__1" + // InternalExpression.g:8619:1: rule__XAssignment__Group_1__1 : rule__XAssignment__Group_1__1__Impl ; + public final void rule__XAssignment__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8623:1: ( rule__XAssignment__Group_1__1__Impl ) + // InternalExpression.g:8624:2: rule__XAssignment__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__1" + + + // $ANTLR start "rule__XAssignment__Group_1__1__Impl" + // InternalExpression.g:8630:1: rule__XAssignment__Group_1__1__Impl : ( ( rule__XAssignment__Group_1_1__0 )? ) ; + public final void rule__XAssignment__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8634:1: ( ( ( rule__XAssignment__Group_1_1__0 )? ) ) + // InternalExpression.g:8635:1: ( ( rule__XAssignment__Group_1_1__0 )? ) + { + // InternalExpression.g:8635:1: ( ( rule__XAssignment__Group_1_1__0 )? ) + // InternalExpression.g:8636:2: ( rule__XAssignment__Group_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); + } + // InternalExpression.g:8637:2: ( rule__XAssignment__Group_1_1__0 )? + int alt78=2; + alt78 = dfa78.predict(input); + switch (alt78) { + case 1 : + // InternalExpression.g:8637:3: rule__XAssignment__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1__0" + // InternalExpression.g:8646:1: rule__XAssignment__Group_1_1__0 : rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ; + public final void rule__XAssignment__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8650:1: ( rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ) + // InternalExpression.g:8651:2: rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 + { + pushFollow(FOLLOW_48); + rule__XAssignment__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1__0__Impl" + // InternalExpression.g:8658:1: rule__XAssignment__Group_1_1__0__Impl : ( ( rule__XAssignment__Group_1_1_0__0 ) ) ; + public final void rule__XAssignment__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8662:1: ( ( ( rule__XAssignment__Group_1_1_0__0 ) ) ) + // InternalExpression.g:8663:1: ( ( rule__XAssignment__Group_1_1_0__0 ) ) + { + // InternalExpression.g:8663:1: ( ( rule__XAssignment__Group_1_1_0__0 ) ) + // InternalExpression.g:8664:2: ( rule__XAssignment__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); + } + // InternalExpression.g:8665:2: ( rule__XAssignment__Group_1_1_0__0 ) + // InternalExpression.g:8665:3: rule__XAssignment__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1__1" + // InternalExpression.g:8673:1: rule__XAssignment__Group_1_1__1 : rule__XAssignment__Group_1_1__1__Impl ; + public final void rule__XAssignment__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8677:1: ( rule__XAssignment__Group_1_1__1__Impl ) + // InternalExpression.g:8678:2: rule__XAssignment__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__1" + + + // $ANTLR start "rule__XAssignment__Group_1_1__1__Impl" + // InternalExpression.g:8684:1: rule__XAssignment__Group_1_1__1__Impl : ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ; + public final void rule__XAssignment__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8688:1: ( ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ) + // InternalExpression.g:8689:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) + { + // InternalExpression.g:8689:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) + // InternalExpression.g:8690:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); + } + // InternalExpression.g:8691:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 ) + // InternalExpression.g:8691:3: rule__XAssignment__RightOperandAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__RightOperandAssignment_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0__0" + // InternalExpression.g:8700:1: rule__XAssignment__Group_1_1_0__0 : rule__XAssignment__Group_1_1_0__0__Impl ; + public final void rule__XAssignment__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8704:1: ( rule__XAssignment__Group_1_1_0__0__Impl ) + // InternalExpression.g:8705:2: rule__XAssignment__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0__0__Impl" + // InternalExpression.g:8711:1: rule__XAssignment__Group_1_1_0__0__Impl : ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ; + public final void rule__XAssignment__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8715:1: ( ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ) + // InternalExpression.g:8716:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) + { + // InternalExpression.g:8716:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) + // InternalExpression.g:8717:2: ( rule__XAssignment__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); + } + // InternalExpression.g:8718:2: ( rule__XAssignment__Group_1_1_0_0__0 ) + // InternalExpression.g:8718:3: rule__XAssignment__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0" + // InternalExpression.g:8727:1: rule__XAssignment__Group_1_1_0_0__0 : rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ; + public final void rule__XAssignment__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8731:1: ( rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ) + // InternalExpression.g:8732:2: rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_49); + rule__XAssignment__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0__Impl" + // InternalExpression.g:8739:1: rule__XAssignment__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XAssignment__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8743:1: ( ( () ) ) + // InternalExpression.g:8744:1: ( () ) + { + // InternalExpression.g:8744:1: ( () ) + // InternalExpression.g:8745:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + // InternalExpression.g:8746:2: () + // InternalExpression.g:8746:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1" + // InternalExpression.g:8754:1: rule__XAssignment__Group_1_1_0_0__1 : rule__XAssignment__Group_1_1_0_0__1__Impl ; + public final void rule__XAssignment__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8758:1: ( rule__XAssignment__Group_1_1_0_0__1__Impl ) + // InternalExpression.g:8759:2: rule__XAssignment__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1__Impl" + // InternalExpression.g:8765:1: rule__XAssignment__Group_1_1_0_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ; + public final void rule__XAssignment__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8769:1: ( ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ) + // InternalExpression.g:8770:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) + { + // InternalExpression.g:8770:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) + // InternalExpression.g:8771:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); + } + // InternalExpression.g:8772:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) + // InternalExpression.g:8772:3: rule__XAssignment__FeatureAssignment_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__FeatureAssignment_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__0" + // InternalExpression.g:8781:1: rule__OpMultiAssign__Group_5__0 : rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ; + public final void rule__OpMultiAssign__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8785:1: ( rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ) + // InternalExpression.g:8786:2: rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 + { + pushFollow(FOLLOW_50); + rule__OpMultiAssign__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__0" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__0__Impl" + // InternalExpression.g:8793:1: rule__OpMultiAssign__Group_5__0__Impl : ( '<' ) ; + public final void rule__OpMultiAssign__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8797:1: ( ( '<' ) ) + // InternalExpression.g:8798:1: ( '<' ) + { + // InternalExpression.g:8798:1: ( '<' ) + // InternalExpression.g:8799:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__0__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__1" + // InternalExpression.g:8808:1: rule__OpMultiAssign__Group_5__1 : rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ; + public final void rule__OpMultiAssign__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8812:1: ( rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ) + // InternalExpression.g:8813:2: rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 + { + pushFollow(FOLLOW_5); + rule__OpMultiAssign__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__1" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__1__Impl" + // InternalExpression.g:8820:1: rule__OpMultiAssign__Group_5__1__Impl : ( '<' ) ; + public final void rule__OpMultiAssign__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8824:1: ( ( '<' ) ) + // InternalExpression.g:8825:1: ( '<' ) + { + // InternalExpression.g:8825:1: ( '<' ) + // InternalExpression.g:8826:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__2" + // InternalExpression.g:8835:1: rule__OpMultiAssign__Group_5__2 : rule__OpMultiAssign__Group_5__2__Impl ; + public final void rule__OpMultiAssign__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8839:1: ( rule__OpMultiAssign__Group_5__2__Impl ) + // InternalExpression.g:8840:2: rule__OpMultiAssign__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__2" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__2__Impl" + // InternalExpression.g:8846:1: rule__OpMultiAssign__Group_5__2__Impl : ( '=' ) ; + public final void rule__OpMultiAssign__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8850:1: ( ( '=' ) ) + // InternalExpression.g:8851:1: ( '=' ) + { + // InternalExpression.g:8851:1: ( '=' ) + // InternalExpression.g:8852:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__2__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__0" + // InternalExpression.g:8862:1: rule__OpMultiAssign__Group_6__0 : rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ; + public final void rule__OpMultiAssign__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8866:1: ( rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ) + // InternalExpression.g:8867:2: rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 + { + pushFollow(FOLLOW_51); + rule__OpMultiAssign__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__0" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__0__Impl" + // InternalExpression.g:8874:1: rule__OpMultiAssign__Group_6__0__Impl : ( '>' ) ; + public final void rule__OpMultiAssign__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8878:1: ( ( '>' ) ) + // InternalExpression.g:8879:1: ( '>' ) + { + // InternalExpression.g:8879:1: ( '>' ) + // InternalExpression.g:8880:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__0__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__1" + // InternalExpression.g:8889:1: rule__OpMultiAssign__Group_6__1 : rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ; + public final void rule__OpMultiAssign__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8893:1: ( rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ) + // InternalExpression.g:8894:2: rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 + { + pushFollow(FOLLOW_51); + rule__OpMultiAssign__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__1" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__1__Impl" + // InternalExpression.g:8901:1: rule__OpMultiAssign__Group_6__1__Impl : ( ( '>' )? ) ; + public final void rule__OpMultiAssign__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8905:1: ( ( ( '>' )? ) ) + // InternalExpression.g:8906:1: ( ( '>' )? ) + { + // InternalExpression.g:8906:1: ( ( '>' )? ) + // InternalExpression.g:8907:2: ( '>' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + // InternalExpression.g:8908:2: ( '>' )? + int alt79=2; + int LA79_0 = input.LA(1); + + if ( (LA79_0==21) ) { + alt79=1; + } + switch (alt79) { + case 1 : + // InternalExpression.g:8908:3: '>' + { + match(input,21,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__2" + // InternalExpression.g:8916:1: rule__OpMultiAssign__Group_6__2 : rule__OpMultiAssign__Group_6__2__Impl ; + public final void rule__OpMultiAssign__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8920:1: ( rule__OpMultiAssign__Group_6__2__Impl ) + // InternalExpression.g:8921:2: rule__OpMultiAssign__Group_6__2__Impl + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__2" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__2__Impl" + // InternalExpression.g:8927:1: rule__OpMultiAssign__Group_6__2__Impl : ( '>=' ) ; + public final void rule__OpMultiAssign__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8931:1: ( ( '>=' ) ) + // InternalExpression.g:8932:1: ( '>=' ) + { + // InternalExpression.g:8932:1: ( '>=' ) + // InternalExpression.g:8933:2: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__2__Impl" + + + // $ANTLR start "rule__XOrExpression__Group__0" + // InternalExpression.g:8943:1: rule__XOrExpression__Group__0 : rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ; + public final void rule__XOrExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8947:1: ( rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ) + // InternalExpression.g:8948:2: rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 + { + pushFollow(FOLLOW_20); + rule__XOrExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__0" + + + // $ANTLR start "rule__XOrExpression__Group__0__Impl" + // InternalExpression.g:8955:1: rule__XOrExpression__Group__0__Impl : ( ruleXAndExpression ) ; + public final void rule__XOrExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8959:1: ( ( ruleXAndExpression ) ) + // InternalExpression.g:8960:1: ( ruleXAndExpression ) + { + // InternalExpression.g:8960:1: ( ruleXAndExpression ) + // InternalExpression.g:8961:2: ruleXAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group__1" + // InternalExpression.g:8970:1: rule__XOrExpression__Group__1 : rule__XOrExpression__Group__1__Impl ; + public final void rule__XOrExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8974:1: ( rule__XOrExpression__Group__1__Impl ) + // InternalExpression.g:8975:2: rule__XOrExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__1" + + + // $ANTLR start "rule__XOrExpression__Group__1__Impl" + // InternalExpression.g:8981:1: rule__XOrExpression__Group__1__Impl : ( ( rule__XOrExpression__Group_1__0 )* ) ; + public final void rule__XOrExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:8985:1: ( ( ( rule__XOrExpression__Group_1__0 )* ) ) + // InternalExpression.g:8986:1: ( ( rule__XOrExpression__Group_1__0 )* ) + { + // InternalExpression.g:8986:1: ( ( rule__XOrExpression__Group_1__0 )* ) + // InternalExpression.g:8987:2: ( rule__XOrExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1()); + } + // InternalExpression.g:8988:2: ( rule__XOrExpression__Group_1__0 )* + loop80: + do { + int alt80=2; + int LA80_0 = input.LA(1); + + if ( (LA80_0==15) ) { + int LA80_2 = input.LA(2); + + if ( (synpred153_InternalExpression()) ) { + alt80=1; + } + + + } + + + switch (alt80) { + case 1 : + // InternalExpression.g:8988:3: rule__XOrExpression__Group_1__0 + { + pushFollow(FOLLOW_21); + rule__XOrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop80; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__1__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1__0" + // InternalExpression.g:8997:1: rule__XOrExpression__Group_1__0 : rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ; + public final void rule__XOrExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9001:1: ( rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ) + // InternalExpression.g:9002:2: rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 + { + pushFollow(FOLLOW_48); + rule__XOrExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__0" + + + // $ANTLR start "rule__XOrExpression__Group_1__0__Impl" + // InternalExpression.g:9009:1: rule__XOrExpression__Group_1__0__Impl : ( ( rule__XOrExpression__Group_1_0__0 ) ) ; + public final void rule__XOrExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9013:1: ( ( ( rule__XOrExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:9014:1: ( ( rule__XOrExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:9014:1: ( ( rule__XOrExpression__Group_1_0__0 ) ) + // InternalExpression.g:9015:2: ( rule__XOrExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:9016:2: ( rule__XOrExpression__Group_1_0__0 ) + // InternalExpression.g:9016:3: rule__XOrExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1__1" + // InternalExpression.g:9024:1: rule__XOrExpression__Group_1__1 : rule__XOrExpression__Group_1__1__Impl ; + public final void rule__XOrExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9028:1: ( rule__XOrExpression__Group_1__1__Impl ) + // InternalExpression.g:9029:2: rule__XOrExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__1" + + + // $ANTLR start "rule__XOrExpression__Group_1__1__Impl" + // InternalExpression.g:9035:1: rule__XOrExpression__Group_1__1__Impl : ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XOrExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9039:1: ( ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExpression.g:9040:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExpression.g:9040:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) + // InternalExpression.g:9041:2: ( rule__XOrExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExpression.g:9042:2: ( rule__XOrExpression__RightOperandAssignment_1_1 ) + // InternalExpression.g:9042:3: rule__XOrExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0__0" + // InternalExpression.g:9051:1: rule__XOrExpression__Group_1_0__0 : rule__XOrExpression__Group_1_0__0__Impl ; + public final void rule__XOrExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9055:1: ( rule__XOrExpression__Group_1_0__0__Impl ) + // InternalExpression.g:9056:2: rule__XOrExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0__0" + + + // $ANTLR start "rule__XOrExpression__Group_1_0__0__Impl" + // InternalExpression.g:9062:1: rule__XOrExpression__Group_1_0__0__Impl : ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ; + public final void rule__XOrExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9066:1: ( ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:9067:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:9067:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:9068:2: ( rule__XOrExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:9069:2: ( rule__XOrExpression__Group_1_0_0__0 ) + // InternalExpression.g:9069:3: rule__XOrExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__0" + // InternalExpression.g:9078:1: rule__XOrExpression__Group_1_0_0__0 : rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ; + public final void rule__XOrExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9082:1: ( rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ) + // InternalExpression.g:9083:2: rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_20); + rule__XOrExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:9090:1: rule__XOrExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XOrExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9094:1: ( ( () ) ) + // InternalExpression.g:9095:1: ( () ) + { + // InternalExpression.g:9095:1: ( () ) + // InternalExpression.g:9096:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExpression.g:9097:2: () + // InternalExpression.g:9097:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__1" + // InternalExpression.g:9105:1: rule__XOrExpression__Group_1_0_0__1 : rule__XOrExpression__Group_1_0_0__1__Impl ; + public final void rule__XOrExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9109:1: ( rule__XOrExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:9110:2: rule__XOrExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:9116:1: rule__XOrExpression__Group_1_0_0__1__Impl : ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XOrExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9120:1: ( ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExpression.g:9121:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExpression.g:9121:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExpression.g:9122:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExpression.g:9123:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) + // InternalExpression.g:9123:3: rule__XOrExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group__0" + // InternalExpression.g:9132:1: rule__XAndExpression__Group__0 : rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ; + public final void rule__XAndExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9136:1: ( rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ) + // InternalExpression.g:9137:2: rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 + { + pushFollow(FOLLOW_22); + rule__XAndExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__0" + + + // $ANTLR start "rule__XAndExpression__Group__0__Impl" + // InternalExpression.g:9144:1: rule__XAndExpression__Group__0__Impl : ( ruleXEqualityExpression ) ; + public final void rule__XAndExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9148:1: ( ( ruleXEqualityExpression ) ) + // InternalExpression.g:9149:1: ( ruleXEqualityExpression ) + { + // InternalExpression.g:9149:1: ( ruleXEqualityExpression ) + // InternalExpression.g:9150:2: ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group__1" + // InternalExpression.g:9159:1: rule__XAndExpression__Group__1 : rule__XAndExpression__Group__1__Impl ; + public final void rule__XAndExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9163:1: ( rule__XAndExpression__Group__1__Impl ) + // InternalExpression.g:9164:2: rule__XAndExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__1" + + + // $ANTLR start "rule__XAndExpression__Group__1__Impl" + // InternalExpression.g:9170:1: rule__XAndExpression__Group__1__Impl : ( ( rule__XAndExpression__Group_1__0 )* ) ; + public final void rule__XAndExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9174:1: ( ( ( rule__XAndExpression__Group_1__0 )* ) ) + // InternalExpression.g:9175:1: ( ( rule__XAndExpression__Group_1__0 )* ) + { + // InternalExpression.g:9175:1: ( ( rule__XAndExpression__Group_1__0 )* ) + // InternalExpression.g:9176:2: ( rule__XAndExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1()); + } + // InternalExpression.g:9177:2: ( rule__XAndExpression__Group_1__0 )* + loop81: + do { + int alt81=2; + int LA81_0 = input.LA(1); + + if ( (LA81_0==16) ) { + int LA81_2 = input.LA(2); + + if ( (synpred154_InternalExpression()) ) { + alt81=1; + } + + + } + + + switch (alt81) { + case 1 : + // InternalExpression.g:9177:3: rule__XAndExpression__Group_1__0 + { + pushFollow(FOLLOW_23); + rule__XAndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop81; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1__0" + // InternalExpression.g:9186:1: rule__XAndExpression__Group_1__0 : rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ; + public final void rule__XAndExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9190:1: ( rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ) + // InternalExpression.g:9191:2: rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 + { + pushFollow(FOLLOW_48); + rule__XAndExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__0" + + + // $ANTLR start "rule__XAndExpression__Group_1__0__Impl" + // InternalExpression.g:9198:1: rule__XAndExpression__Group_1__0__Impl : ( ( rule__XAndExpression__Group_1_0__0 ) ) ; + public final void rule__XAndExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9202:1: ( ( ( rule__XAndExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:9203:1: ( ( rule__XAndExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:9203:1: ( ( rule__XAndExpression__Group_1_0__0 ) ) + // InternalExpression.g:9204:2: ( rule__XAndExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:9205:2: ( rule__XAndExpression__Group_1_0__0 ) + // InternalExpression.g:9205:3: rule__XAndExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1__1" + // InternalExpression.g:9213:1: rule__XAndExpression__Group_1__1 : rule__XAndExpression__Group_1__1__Impl ; + public final void rule__XAndExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9217:1: ( rule__XAndExpression__Group_1__1__Impl ) + // InternalExpression.g:9218:2: rule__XAndExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__1" + + + // $ANTLR start "rule__XAndExpression__Group_1__1__Impl" + // InternalExpression.g:9224:1: rule__XAndExpression__Group_1__1__Impl : ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XAndExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9228:1: ( ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExpression.g:9229:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExpression.g:9229:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) + // InternalExpression.g:9230:2: ( rule__XAndExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExpression.g:9231:2: ( rule__XAndExpression__RightOperandAssignment_1_1 ) + // InternalExpression.g:9231:3: rule__XAndExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0__0" + // InternalExpression.g:9240:1: rule__XAndExpression__Group_1_0__0 : rule__XAndExpression__Group_1_0__0__Impl ; + public final void rule__XAndExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9244:1: ( rule__XAndExpression__Group_1_0__0__Impl ) + // InternalExpression.g:9245:2: rule__XAndExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0__0" + + + // $ANTLR start "rule__XAndExpression__Group_1_0__0__Impl" + // InternalExpression.g:9251:1: rule__XAndExpression__Group_1_0__0__Impl : ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ; + public final void rule__XAndExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9255:1: ( ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:9256:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:9256:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:9257:2: ( rule__XAndExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:9258:2: ( rule__XAndExpression__Group_1_0_0__0 ) + // InternalExpression.g:9258:3: rule__XAndExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__0" + // InternalExpression.g:9267:1: rule__XAndExpression__Group_1_0_0__0 : rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ; + public final void rule__XAndExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9271:1: ( rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ) + // InternalExpression.g:9272:2: rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_22); + rule__XAndExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:9279:1: rule__XAndExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XAndExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9283:1: ( ( () ) ) + // InternalExpression.g:9284:1: ( () ) + { + // InternalExpression.g:9284:1: ( () ) + // InternalExpression.g:9285:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExpression.g:9286:2: () + // InternalExpression.g:9286:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__1" + // InternalExpression.g:9294:1: rule__XAndExpression__Group_1_0_0__1 : rule__XAndExpression__Group_1_0_0__1__Impl ; + public final void rule__XAndExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9298:1: ( rule__XAndExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:9299:2: rule__XAndExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:9305:1: rule__XAndExpression__Group_1_0_0__1__Impl : ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XAndExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9309:1: ( ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExpression.g:9310:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExpression.g:9310:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExpression.g:9311:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExpression.g:9312:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) + // InternalExpression.g:9312:3: rule__XAndExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group__0" + // InternalExpression.g:9321:1: rule__XEqualityExpression__Group__0 : rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ; + public final void rule__XEqualityExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9325:1: ( rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ) + // InternalExpression.g:9326:2: rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 + { + pushFollow(FOLLOW_52); + rule__XEqualityExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__0" + + + // $ANTLR start "rule__XEqualityExpression__Group__0__Impl" + // InternalExpression.g:9333:1: rule__XEqualityExpression__Group__0__Impl : ( ruleXRelationalExpression ) ; + public final void rule__XEqualityExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9337:1: ( ( ruleXRelationalExpression ) ) + // InternalExpression.g:9338:1: ( ruleXRelationalExpression ) + { + // InternalExpression.g:9338:1: ( ruleXRelationalExpression ) + // InternalExpression.g:9339:2: ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group__1" + // InternalExpression.g:9348:1: rule__XEqualityExpression__Group__1 : rule__XEqualityExpression__Group__1__Impl ; + public final void rule__XEqualityExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9352:1: ( rule__XEqualityExpression__Group__1__Impl ) + // InternalExpression.g:9353:2: rule__XEqualityExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__1" + + + // $ANTLR start "rule__XEqualityExpression__Group__1__Impl" + // InternalExpression.g:9359:1: rule__XEqualityExpression__Group__1__Impl : ( ( rule__XEqualityExpression__Group_1__0 )* ) ; + public final void rule__XEqualityExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9363:1: ( ( ( rule__XEqualityExpression__Group_1__0 )* ) ) + // InternalExpression.g:9364:1: ( ( rule__XEqualityExpression__Group_1__0 )* ) + { + // InternalExpression.g:9364:1: ( ( rule__XEqualityExpression__Group_1__0 )* ) + // InternalExpression.g:9365:2: ( rule__XEqualityExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); + } + // InternalExpression.g:9366:2: ( rule__XEqualityExpression__Group_1__0 )* + loop82: + do { + int alt82=2; + switch ( input.LA(1) ) { + case 17: + { + int LA82_2 = input.LA(2); + + if ( (synpred155_InternalExpression()) ) { + alt82=1; + } + + + } + break; + case 18: + { + int LA82_3 = input.LA(2); + + if ( (synpred155_InternalExpression()) ) { + alt82=1; + } + + + } + break; + case 46: + { + int LA82_4 = input.LA(2); + + if ( (synpred155_InternalExpression()) ) { + alt82=1; + } + + + } + break; + case 47: + { + int LA82_5 = input.LA(2); + + if ( (synpred155_InternalExpression()) ) { + alt82=1; + } + + + } + break; + + } + + switch (alt82) { + case 1 : + // InternalExpression.g:9366:3: rule__XEqualityExpression__Group_1__0 + { + pushFollow(FOLLOW_53); + rule__XEqualityExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop82; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__0" + // InternalExpression.g:9375:1: rule__XEqualityExpression__Group_1__0 : rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ; + public final void rule__XEqualityExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9379:1: ( rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ) + // InternalExpression.g:9380:2: rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 + { + pushFollow(FOLLOW_48); + rule__XEqualityExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__0__Impl" + // InternalExpression.g:9387:1: rule__XEqualityExpression__Group_1__0__Impl : ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ; + public final void rule__XEqualityExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9391:1: ( ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:9392:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:9392:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) ) + // InternalExpression.g:9393:2: ( rule__XEqualityExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:9394:2: ( rule__XEqualityExpression__Group_1_0__0 ) + // InternalExpression.g:9394:3: rule__XEqualityExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__1" + // InternalExpression.g:9402:1: rule__XEqualityExpression__Group_1__1 : rule__XEqualityExpression__Group_1__1__Impl ; + public final void rule__XEqualityExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9406:1: ( rule__XEqualityExpression__Group_1__1__Impl ) + // InternalExpression.g:9407:2: rule__XEqualityExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__1" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__1__Impl" + // InternalExpression.g:9413:1: rule__XEqualityExpression__Group_1__1__Impl : ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XEqualityExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9417:1: ( ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExpression.g:9418:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExpression.g:9418:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) + // InternalExpression.g:9419:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExpression.g:9420:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) + // InternalExpression.g:9420:3: rule__XEqualityExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0__0" + // InternalExpression.g:9429:1: rule__XEqualityExpression__Group_1_0__0 : rule__XEqualityExpression__Group_1_0__0__Impl ; + public final void rule__XEqualityExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9433:1: ( rule__XEqualityExpression__Group_1_0__0__Impl ) + // InternalExpression.g:9434:2: rule__XEqualityExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0__0__Impl" + // InternalExpression.g:9440:1: rule__XEqualityExpression__Group_1_0__0__Impl : ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ; + public final void rule__XEqualityExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9444:1: ( ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:9445:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:9445:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:9446:2: ( rule__XEqualityExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:9447:2: ( rule__XEqualityExpression__Group_1_0_0__0 ) + // InternalExpression.g:9447:3: rule__XEqualityExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0" + // InternalExpression.g:9456:1: rule__XEqualityExpression__Group_1_0_0__0 : rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ; + public final void rule__XEqualityExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9460:1: ( rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ) + // InternalExpression.g:9461:2: rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_52); + rule__XEqualityExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:9468:1: rule__XEqualityExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XEqualityExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9472:1: ( ( () ) ) + // InternalExpression.g:9473:1: ( () ) + { + // InternalExpression.g:9473:1: ( () ) + // InternalExpression.g:9474:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExpression.g:9475:2: () + // InternalExpression.g:9475:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1" + // InternalExpression.g:9483:1: rule__XEqualityExpression__Group_1_0_0__1 : rule__XEqualityExpression__Group_1_0_0__1__Impl ; + public final void rule__XEqualityExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9487:1: ( rule__XEqualityExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:9488:2: rule__XEqualityExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:9494:1: rule__XEqualityExpression__Group_1_0_0__1__Impl : ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XEqualityExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9498:1: ( ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExpression.g:9499:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExpression.g:9499:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExpression.g:9500:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExpression.g:9501:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) + // InternalExpression.g:9501:3: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group__0" + // InternalExpression.g:9510:1: rule__XRelationalExpression__Group__0 : rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ; + public final void rule__XRelationalExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9514:1: ( rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ) + // InternalExpression.g:9515:2: rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 + { + pushFollow(FOLLOW_54); + rule__XRelationalExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__0" + + + // $ANTLR start "rule__XRelationalExpression__Group__0__Impl" + // InternalExpression.g:9522:1: rule__XRelationalExpression__Group__0__Impl : ( ruleXOtherOperatorExpression ) ; + public final void rule__XRelationalExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9526:1: ( ( ruleXOtherOperatorExpression ) ) + // InternalExpression.g:9527:1: ( ruleXOtherOperatorExpression ) + { + // InternalExpression.g:9527:1: ( ruleXOtherOperatorExpression ) + // InternalExpression.g:9528:2: ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group__1" + // InternalExpression.g:9537:1: rule__XRelationalExpression__Group__1 : rule__XRelationalExpression__Group__1__Impl ; + public final void rule__XRelationalExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9541:1: ( rule__XRelationalExpression__Group__1__Impl ) + // InternalExpression.g:9542:2: rule__XRelationalExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__1" + + + // $ANTLR start "rule__XRelationalExpression__Group__1__Impl" + // InternalExpression.g:9548:1: rule__XRelationalExpression__Group__1__Impl : ( ( rule__XRelationalExpression__Alternatives_1 )* ) ; + public final void rule__XRelationalExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9552:1: ( ( ( rule__XRelationalExpression__Alternatives_1 )* ) ) + // InternalExpression.g:9553:1: ( ( rule__XRelationalExpression__Alternatives_1 )* ) + { + // InternalExpression.g:9553:1: ( ( rule__XRelationalExpression__Alternatives_1 )* ) + // InternalExpression.g:9554:2: ( rule__XRelationalExpression__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); + } + // InternalExpression.g:9555:2: ( rule__XRelationalExpression__Alternatives_1 )* + loop83: + do { + int alt83=2; + switch ( input.LA(1) ) { + case 22: + { + int LA83_2 = input.LA(2); + + if ( (synpred156_InternalExpression()) ) { + alt83=1; + } + + + } + break; + case 21: + { + int LA83_3 = input.LA(2); + + if ( (synpred156_InternalExpression()) ) { + alt83=1; + } + + + } + break; + case 85: + { + int LA83_4 = input.LA(2); + + if ( (synpred156_InternalExpression()) ) { + alt83=1; + } + + + } + break; + case 19: + { + int LA83_5 = input.LA(2); + + if ( (synpred156_InternalExpression()) ) { + alt83=1; + } + + + } + break; + + } + + switch (alt83) { + case 1 : + // InternalExpression.g:9555:3: rule__XRelationalExpression__Alternatives_1 + { + pushFollow(FOLLOW_55); + rule__XRelationalExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop83; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__0" + // InternalExpression.g:9564:1: rule__XRelationalExpression__Group_1_0__0 : rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ; + public final void rule__XRelationalExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9568:1: ( rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ) + // InternalExpression.g:9569:2: rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 + { + pushFollow(FOLLOW_56); + rule__XRelationalExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__0__Impl" + // InternalExpression.g:9576:1: rule__XRelationalExpression__Group_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9580:1: ( ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:9581:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:9581:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:9582:2: ( rule__XRelationalExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:9583:2: ( rule__XRelationalExpression__Group_1_0_0__0 ) + // InternalExpression.g:9583:3: rule__XRelationalExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__1" + // InternalExpression.g:9591:1: rule__XRelationalExpression__Group_1_0__1 : rule__XRelationalExpression__Group_1_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9595:1: ( rule__XRelationalExpression__Group_1_0__1__Impl ) + // InternalExpression.g:9596:2: rule__XRelationalExpression__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__1__Impl" + // InternalExpression.g:9602:1: rule__XRelationalExpression__Group_1_0__1__Impl : ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9606:1: ( ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ) + // InternalExpression.g:9607:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) + { + // InternalExpression.g:9607:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) + // InternalExpression.g:9608:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); + } + // InternalExpression.g:9609:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) + // InternalExpression.g:9609:3: rule__XRelationalExpression__TypeAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__TypeAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0" + // InternalExpression.g:9618:1: rule__XRelationalExpression__Group_1_0_0__0 : rule__XRelationalExpression__Group_1_0_0__0__Impl ; + public final void rule__XRelationalExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9622:1: ( rule__XRelationalExpression__Group_1_0_0__0__Impl ) + // InternalExpression.g:9623:2: rule__XRelationalExpression__Group_1_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:9629:1: rule__XRelationalExpression__Group_1_0_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9633:1: ( ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ) + // InternalExpression.g:9634:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) + { + // InternalExpression.g:9634:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) + // InternalExpression.g:9635:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); + } + // InternalExpression.g:9636:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 ) + // InternalExpression.g:9636:3: rule__XRelationalExpression__Group_1_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0" + // InternalExpression.g:9645:1: rule__XRelationalExpression__Group_1_0_0_0__0 : rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ; + public final void rule__XRelationalExpression__Group_1_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9649:1: ( rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ) + // InternalExpression.g:9650:2: rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 + { + pushFollow(FOLLOW_57); + rule__XRelationalExpression__Group_1_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0__Impl" + // InternalExpression.g:9657:1: rule__XRelationalExpression__Group_1_0_0_0__0__Impl : ( () ) ; + public final void rule__XRelationalExpression__Group_1_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9661:1: ( ( () ) ) + // InternalExpression.g:9662:1: ( () ) + { + // InternalExpression.g:9662:1: ( () ) + // InternalExpression.g:9663:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); + } + // InternalExpression.g:9664:2: () + // InternalExpression.g:9664:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1" + // InternalExpression.g:9672:1: rule__XRelationalExpression__Group_1_0_0_0__1 : rule__XRelationalExpression__Group_1_0_0_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9676:1: ( rule__XRelationalExpression__Group_1_0_0_0__1__Impl ) + // InternalExpression.g:9677:2: rule__XRelationalExpression__Group_1_0_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1__Impl" + // InternalExpression.g:9683:1: rule__XRelationalExpression__Group_1_0_0_0__1__Impl : ( 'instanceof' ) ; + public final void rule__XRelationalExpression__Group_1_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9687:1: ( ( 'instanceof' ) ) + // InternalExpression.g:9688:1: ( 'instanceof' ) + { + // InternalExpression.g:9688:1: ( 'instanceof' ) + // InternalExpression.g:9689:2: 'instanceof' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + match(input,85,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__0" + // InternalExpression.g:9699:1: rule__XRelationalExpression__Group_1_1__0 : rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ; + public final void rule__XRelationalExpression__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9703:1: ( rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ) + // InternalExpression.g:9704:2: rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 + { + pushFollow(FOLLOW_48); + rule__XRelationalExpression__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__0__Impl" + // InternalExpression.g:9711:1: rule__XRelationalExpression__Group_1_1__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9715:1: ( ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ) + // InternalExpression.g:9716:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) + { + // InternalExpression.g:9716:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) + // InternalExpression.g:9717:2: ( rule__XRelationalExpression__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); + } + // InternalExpression.g:9718:2: ( rule__XRelationalExpression__Group_1_1_0__0 ) + // InternalExpression.g:9718:3: rule__XRelationalExpression__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__1" + // InternalExpression.g:9726:1: rule__XRelationalExpression__Group_1_1__1 : rule__XRelationalExpression__Group_1_1__1__Impl ; + public final void rule__XRelationalExpression__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9730:1: ( rule__XRelationalExpression__Group_1_1__1__Impl ) + // InternalExpression.g:9731:2: rule__XRelationalExpression__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__1__Impl" + // InternalExpression.g:9737:1: rule__XRelationalExpression__Group_1_1__1__Impl : ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9741:1: ( ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ) + // InternalExpression.g:9742:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) + { + // InternalExpression.g:9742:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) + // InternalExpression.g:9743:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); + } + // InternalExpression.g:9744:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) + // InternalExpression.g:9744:3: rule__XRelationalExpression__RightOperandAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__RightOperandAssignment_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0" + // InternalExpression.g:9753:1: rule__XRelationalExpression__Group_1_1_0__0 : rule__XRelationalExpression__Group_1_1_0__0__Impl ; + public final void rule__XRelationalExpression__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9757:1: ( rule__XRelationalExpression__Group_1_1_0__0__Impl ) + // InternalExpression.g:9758:2: rule__XRelationalExpression__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0__Impl" + // InternalExpression.g:9764:1: rule__XRelationalExpression__Group_1_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9768:1: ( ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ) + // InternalExpression.g:9769:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) + { + // InternalExpression.g:9769:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) + // InternalExpression.g:9770:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); + } + // InternalExpression.g:9771:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 ) + // InternalExpression.g:9771:3: rule__XRelationalExpression__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0" + // InternalExpression.g:9780:1: rule__XRelationalExpression__Group_1_1_0_0__0 : rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ; + public final void rule__XRelationalExpression__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9784:1: ( rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ) + // InternalExpression.g:9785:2: rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_54); + rule__XRelationalExpression__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0__Impl" + // InternalExpression.g:9792:1: rule__XRelationalExpression__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XRelationalExpression__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9796:1: ( ( () ) ) + // InternalExpression.g:9797:1: ( () ) + { + // InternalExpression.g:9797:1: ( () ) + // InternalExpression.g:9798:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + // InternalExpression.g:9799:2: () + // InternalExpression.g:9799:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1" + // InternalExpression.g:9807:1: rule__XRelationalExpression__Group_1_1_0_0__1 : rule__XRelationalExpression__Group_1_1_0_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9811:1: ( rule__XRelationalExpression__Group_1_1_0_0__1__Impl ) + // InternalExpression.g:9812:2: rule__XRelationalExpression__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1__Impl" + // InternalExpression.g:9818:1: rule__XRelationalExpression__Group_1_1_0_0__1__Impl : ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9822:1: ( ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ) + // InternalExpression.g:9823:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) + { + // InternalExpression.g:9823:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) + // InternalExpression.g:9824:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); + } + // InternalExpression.g:9825:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) + // InternalExpression.g:9825:3: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpCompare__Group_1__0" + // InternalExpression.g:9834:1: rule__OpCompare__Group_1__0 : rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ; + public final void rule__OpCompare__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9838:1: ( rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ) + // InternalExpression.g:9839:2: rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 + { + pushFollow(FOLLOW_5); + rule__OpCompare__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__0" + + + // $ANTLR start "rule__OpCompare__Group_1__0__Impl" + // InternalExpression.g:9846:1: rule__OpCompare__Group_1__0__Impl : ( '<' ) ; + public final void rule__OpCompare__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9850:1: ( ( '<' ) ) + // InternalExpression.g:9851:1: ( '<' ) + { + // InternalExpression.g:9851:1: ( '<' ) + // InternalExpression.g:9852:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__0__Impl" + + + // $ANTLR start "rule__OpCompare__Group_1__1" + // InternalExpression.g:9861:1: rule__OpCompare__Group_1__1 : rule__OpCompare__Group_1__1__Impl ; + public final void rule__OpCompare__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9865:1: ( rule__OpCompare__Group_1__1__Impl ) + // InternalExpression.g:9866:2: rule__OpCompare__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__1" + + + // $ANTLR start "rule__OpCompare__Group_1__1__Impl" + // InternalExpression.g:9872:1: rule__OpCompare__Group_1__1__Impl : ( '=' ) ; + public final void rule__OpCompare__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9876:1: ( ( '=' ) ) + // InternalExpression.g:9877:1: ( '=' ) + { + // InternalExpression.g:9877:1: ( '=' ) + // InternalExpression.g:9878:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__0" + // InternalExpression.g:9888:1: rule__XOtherOperatorExpression__Group__0 : rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ; + public final void rule__XOtherOperatorExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9892:1: ( rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ) + // InternalExpression.g:9893:2: rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 + { + pushFollow(FOLLOW_58); + rule__XOtherOperatorExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__0__Impl" + // InternalExpression.g:9900:1: rule__XOtherOperatorExpression__Group__0__Impl : ( ruleXAdditiveExpression ) ; + public final void rule__XOtherOperatorExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9904:1: ( ( ruleXAdditiveExpression ) ) + // InternalExpression.g:9905:1: ( ruleXAdditiveExpression ) + { + // InternalExpression.g:9905:1: ( ruleXAdditiveExpression ) + // InternalExpression.g:9906:2: ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__1" + // InternalExpression.g:9915:1: rule__XOtherOperatorExpression__Group__1 : rule__XOtherOperatorExpression__Group__1__Impl ; + public final void rule__XOtherOperatorExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9919:1: ( rule__XOtherOperatorExpression__Group__1__Impl ) + // InternalExpression.g:9920:2: rule__XOtherOperatorExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__1__Impl" + // InternalExpression.g:9926:1: rule__XOtherOperatorExpression__Group__1__Impl : ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ; + public final void rule__XOtherOperatorExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9930:1: ( ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ) + // InternalExpression.g:9931:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) + { + // InternalExpression.g:9931:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) + // InternalExpression.g:9932:2: ( rule__XOtherOperatorExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); + } + // InternalExpression.g:9933:2: ( rule__XOtherOperatorExpression__Group_1__0 )* + loop84: + do { + int alt84=2; + alt84 = dfa84.predict(input); + switch (alt84) { + case 1 : + // InternalExpression.g:9933:3: rule__XOtherOperatorExpression__Group_1__0 + { + pushFollow(FOLLOW_59); + rule__XOtherOperatorExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop84; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0" + // InternalExpression.g:9942:1: rule__XOtherOperatorExpression__Group_1__0 : rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ; + public final void rule__XOtherOperatorExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9946:1: ( rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ) + // InternalExpression.g:9947:2: rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 + { + pushFollow(FOLLOW_48); + rule__XOtherOperatorExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0__Impl" + // InternalExpression.g:9954:1: rule__XOtherOperatorExpression__Group_1__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9958:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:9959:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:9959:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) + // InternalExpression.g:9960:2: ( rule__XOtherOperatorExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:9961:2: ( rule__XOtherOperatorExpression__Group_1_0__0 ) + // InternalExpression.g:9961:3: rule__XOtherOperatorExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1" + // InternalExpression.g:9969:1: rule__XOtherOperatorExpression__Group_1__1 : rule__XOtherOperatorExpression__Group_1__1__Impl ; + public final void rule__XOtherOperatorExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9973:1: ( rule__XOtherOperatorExpression__Group_1__1__Impl ) + // InternalExpression.g:9974:2: rule__XOtherOperatorExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1__Impl" + // InternalExpression.g:9980:1: rule__XOtherOperatorExpression__Group_1__1__Impl : ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:9984:1: ( ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExpression.g:9985:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExpression.g:9985:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) + // InternalExpression.g:9986:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExpression.g:9987:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) + // InternalExpression.g:9987:3: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0" + // InternalExpression.g:9996:1: rule__XOtherOperatorExpression__Group_1_0__0 : rule__XOtherOperatorExpression__Group_1_0__0__Impl ; + public final void rule__XOtherOperatorExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10000:1: ( rule__XOtherOperatorExpression__Group_1_0__0__Impl ) + // InternalExpression.g:10001:2: rule__XOtherOperatorExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0__Impl" + // InternalExpression.g:10007:1: rule__XOtherOperatorExpression__Group_1_0__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10011:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:10012:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:10012:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:10013:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:10014:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) + // InternalExpression.g:10014:3: rule__XOtherOperatorExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0" + // InternalExpression.g:10023:1: rule__XOtherOperatorExpression__Group_1_0_0__0 : rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10027:1: ( rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ) + // InternalExpression.g:10028:2: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_58); + rule__XOtherOperatorExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:10035:1: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10039:1: ( ( () ) ) + // InternalExpression.g:10040:1: ( () ) + { + // InternalExpression.g:10040:1: ( () ) + // InternalExpression.g:10041:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExpression.g:10042:2: () + // InternalExpression.g:10042:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1" + // InternalExpression.g:10050:1: rule__XOtherOperatorExpression__Group_1_0_0__1 : rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10054:1: ( rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:10055:2: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:10061:1: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl : ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10065:1: ( ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExpression.g:10066:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExpression.g:10066:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExpression.g:10067:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExpression.g:10068:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) + // InternalExpression.g:10068:3: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_2__0" + // InternalExpression.g:10077:1: rule__OpOther__Group_2__0 : rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ; + public final void rule__OpOther__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10081:1: ( rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ) + // InternalExpression.g:10082:2: rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 + { + pushFollow(FOLLOW_60); + rule__OpOther__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__0" + + + // $ANTLR start "rule__OpOther__Group_2__0__Impl" + // InternalExpression.g:10089:1: rule__OpOther__Group_2__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10093:1: ( ( '>' ) ) + // InternalExpression.g:10094:1: ( '>' ) + { + // InternalExpression.g:10094:1: ( '>' ) + // InternalExpression.g:10095:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_2__1" + // InternalExpression.g:10104:1: rule__OpOther__Group_2__1 : rule__OpOther__Group_2__1__Impl ; + public final void rule__OpOther__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10108:1: ( rule__OpOther__Group_2__1__Impl ) + // InternalExpression.g:10109:2: rule__OpOther__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__1" + + + // $ANTLR start "rule__OpOther__Group_2__1__Impl" + // InternalExpression.g:10115:1: rule__OpOther__Group_2__1__Impl : ( '..' ) ; + public final void rule__OpOther__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10119:1: ( ( '..' ) ) + // InternalExpression.g:10120:1: ( '..' ) + { + // InternalExpression.g:10120:1: ( '..' ) + // InternalExpression.g:10121:2: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + match(input,50,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_5__0" + // InternalExpression.g:10131:1: rule__OpOther__Group_5__0 : rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ; + public final void rule__OpOther__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10135:1: ( rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ) + // InternalExpression.g:10136:2: rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 + { + pushFollow(FOLLOW_61); + rule__OpOther__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__0" + + + // $ANTLR start "rule__OpOther__Group_5__0__Impl" + // InternalExpression.g:10143:1: rule__OpOther__Group_5__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10147:1: ( ( '>' ) ) + // InternalExpression.g:10148:1: ( '>' ) + { + // InternalExpression.g:10148:1: ( '>' ) + // InternalExpression.g:10149:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5__1" + // InternalExpression.g:10158:1: rule__OpOther__Group_5__1 : rule__OpOther__Group_5__1__Impl ; + public final void rule__OpOther__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10162:1: ( rule__OpOther__Group_5__1__Impl ) + // InternalExpression.g:10163:2: rule__OpOther__Group_5__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__1" + + + // $ANTLR start "rule__OpOther__Group_5__1__Impl" + // InternalExpression.g:10169:1: rule__OpOther__Group_5__1__Impl : ( ( rule__OpOther__Alternatives_5_1 ) ) ; + public final void rule__OpOther__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10173:1: ( ( ( rule__OpOther__Alternatives_5_1 ) ) ) + // InternalExpression.g:10174:1: ( ( rule__OpOther__Alternatives_5_1 ) ) + { + // InternalExpression.g:10174:1: ( ( rule__OpOther__Alternatives_5_1 ) ) + // InternalExpression.g:10175:2: ( rule__OpOther__Alternatives_5_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); + } + // InternalExpression.g:10176:2: ( rule__OpOther__Alternatives_5_1 ) + // InternalExpression.g:10176:3: rule__OpOther__Alternatives_5_1 + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives_5_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0__0" + // InternalExpression.g:10185:1: rule__OpOther__Group_5_1_0__0 : rule__OpOther__Group_5_1_0__0__Impl ; + public final void rule__OpOther__Group_5_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10189:1: ( rule__OpOther__Group_5_1_0__0__Impl ) + // InternalExpression.g:10190:2: rule__OpOther__Group_5_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0__0" + + + // $ANTLR start "rule__OpOther__Group_5_1_0__0__Impl" + // InternalExpression.g:10196:1: rule__OpOther__Group_5_1_0__0__Impl : ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ; + public final void rule__OpOther__Group_5_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10200:1: ( ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ) + // InternalExpression.g:10201:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) ) + { + // InternalExpression.g:10201:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) ) + // InternalExpression.g:10202:2: ( rule__OpOther__Group_5_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); + } + // InternalExpression.g:10203:2: ( rule__OpOther__Group_5_1_0_0__0 ) + // InternalExpression.g:10203:3: rule__OpOther__Group_5_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__0" + // InternalExpression.g:10212:1: rule__OpOther__Group_5_1_0_0__0 : rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ; + public final void rule__OpOther__Group_5_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10216:1: ( rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ) + // InternalExpression.g:10217:2: rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 + { + pushFollow(FOLLOW_61); + rule__OpOther__Group_5_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__0" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__0__Impl" + // InternalExpression.g:10224:1: rule__OpOther__Group_5_1_0_0__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10228:1: ( ( '>' ) ) + // InternalExpression.g:10229:1: ( '>' ) + { + // InternalExpression.g:10229:1: ( '>' ) + // InternalExpression.g:10230:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__1" + // InternalExpression.g:10239:1: rule__OpOther__Group_5_1_0_0__1 : rule__OpOther__Group_5_1_0_0__1__Impl ; + public final void rule__OpOther__Group_5_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10243:1: ( rule__OpOther__Group_5_1_0_0__1__Impl ) + // InternalExpression.g:10244:2: rule__OpOther__Group_5_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__1" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__1__Impl" + // InternalExpression.g:10250:1: rule__OpOther__Group_5_1_0_0__1__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10254:1: ( ( '>' ) ) + // InternalExpression.g:10255:1: ( '>' ) + { + // InternalExpression.g:10255:1: ( '>' ) + // InternalExpression.g:10256:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_6__0" + // InternalExpression.g:10266:1: rule__OpOther__Group_6__0 : rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ; + public final void rule__OpOther__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10270:1: ( rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ) + // InternalExpression.g:10271:2: rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 + { + pushFollow(FOLLOW_62); + rule__OpOther__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__0" + + + // $ANTLR start "rule__OpOther__Group_6__0__Impl" + // InternalExpression.g:10278:1: rule__OpOther__Group_6__0__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10282:1: ( ( '<' ) ) + // InternalExpression.g:10283:1: ( '<' ) + { + // InternalExpression.g:10283:1: ( '<' ) + // InternalExpression.g:10284:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6__1" + // InternalExpression.g:10293:1: rule__OpOther__Group_6__1 : rule__OpOther__Group_6__1__Impl ; + public final void rule__OpOther__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10297:1: ( rule__OpOther__Group_6__1__Impl ) + // InternalExpression.g:10298:2: rule__OpOther__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__1" + + + // $ANTLR start "rule__OpOther__Group_6__1__Impl" + // InternalExpression.g:10304:1: rule__OpOther__Group_6__1__Impl : ( ( rule__OpOther__Alternatives_6_1 ) ) ; + public final void rule__OpOther__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10308:1: ( ( ( rule__OpOther__Alternatives_6_1 ) ) ) + // InternalExpression.g:10309:1: ( ( rule__OpOther__Alternatives_6_1 ) ) + { + // InternalExpression.g:10309:1: ( ( rule__OpOther__Alternatives_6_1 ) ) + // InternalExpression.g:10310:2: ( rule__OpOther__Alternatives_6_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); + } + // InternalExpression.g:10311:2: ( rule__OpOther__Alternatives_6_1 ) + // InternalExpression.g:10311:3: rule__OpOther__Alternatives_6_1 + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives_6_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0__0" + // InternalExpression.g:10320:1: rule__OpOther__Group_6_1_0__0 : rule__OpOther__Group_6_1_0__0__Impl ; + public final void rule__OpOther__Group_6_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10324:1: ( rule__OpOther__Group_6_1_0__0__Impl ) + // InternalExpression.g:10325:2: rule__OpOther__Group_6_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0__0" + + + // $ANTLR start "rule__OpOther__Group_6_1_0__0__Impl" + // InternalExpression.g:10331:1: rule__OpOther__Group_6_1_0__0__Impl : ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ; + public final void rule__OpOther__Group_6_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10335:1: ( ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ) + // InternalExpression.g:10336:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) ) + { + // InternalExpression.g:10336:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) ) + // InternalExpression.g:10337:2: ( rule__OpOther__Group_6_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); + } + // InternalExpression.g:10338:2: ( rule__OpOther__Group_6_1_0_0__0 ) + // InternalExpression.g:10338:3: rule__OpOther__Group_6_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__0" + // InternalExpression.g:10347:1: rule__OpOther__Group_6_1_0_0__0 : rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ; + public final void rule__OpOther__Group_6_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10351:1: ( rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ) + // InternalExpression.g:10352:2: rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 + { + pushFollow(FOLLOW_50); + rule__OpOther__Group_6_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__0" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__0__Impl" + // InternalExpression.g:10359:1: rule__OpOther__Group_6_1_0_0__0__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10363:1: ( ( '<' ) ) + // InternalExpression.g:10364:1: ( '<' ) + { + // InternalExpression.g:10364:1: ( '<' ) + // InternalExpression.g:10365:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__1" + // InternalExpression.g:10374:1: rule__OpOther__Group_6_1_0_0__1 : rule__OpOther__Group_6_1_0_0__1__Impl ; + public final void rule__OpOther__Group_6_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10378:1: ( rule__OpOther__Group_6_1_0_0__1__Impl ) + // InternalExpression.g:10379:2: rule__OpOther__Group_6_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__1" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__1__Impl" + // InternalExpression.g:10385:1: rule__OpOther__Group_6_1_0_0__1__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10389:1: ( ( '<' ) ) + // InternalExpression.g:10390:1: ( '<' ) + { + // InternalExpression.g:10390:1: ( '<' ) + // InternalExpression.g:10391:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group__0" + // InternalExpression.g:10401:1: rule__XAdditiveExpression__Group__0 : rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ; + public final void rule__XAdditiveExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10405:1: ( rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ) + // InternalExpression.g:10406:2: rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 + { + pushFollow(FOLLOW_28); + rule__XAdditiveExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group__0__Impl" + // InternalExpression.g:10413:1: rule__XAdditiveExpression__Group__0__Impl : ( ruleXMultiplicativeExpression ) ; + public final void rule__XAdditiveExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10417:1: ( ( ruleXMultiplicativeExpression ) ) + // InternalExpression.g:10418:1: ( ruleXMultiplicativeExpression ) + { + // InternalExpression.g:10418:1: ( ruleXMultiplicativeExpression ) + // InternalExpression.g:10419:2: ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group__1" + // InternalExpression.g:10428:1: rule__XAdditiveExpression__Group__1 : rule__XAdditiveExpression__Group__1__Impl ; + public final void rule__XAdditiveExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10432:1: ( rule__XAdditiveExpression__Group__1__Impl ) + // InternalExpression.g:10433:2: rule__XAdditiveExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group__1__Impl" + // InternalExpression.g:10439:1: rule__XAdditiveExpression__Group__1__Impl : ( ( rule__XAdditiveExpression__Group_1__0 )* ) ; + public final void rule__XAdditiveExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10443:1: ( ( ( rule__XAdditiveExpression__Group_1__0 )* ) ) + // InternalExpression.g:10444:1: ( ( rule__XAdditiveExpression__Group_1__0 )* ) + { + // InternalExpression.g:10444:1: ( ( rule__XAdditiveExpression__Group_1__0 )* ) + // InternalExpression.g:10445:2: ( rule__XAdditiveExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); + } + // InternalExpression.g:10446:2: ( rule__XAdditiveExpression__Group_1__0 )* + loop85: + do { + int alt85=2; + int LA85_0 = input.LA(1); + + if ( (LA85_0==24) ) { + int LA85_2 = input.LA(2); + + if ( (synpred158_InternalExpression()) ) { + alt85=1; + } + + + } + else if ( (LA85_0==23) ) { + int LA85_3 = input.LA(2); + + if ( (synpred158_InternalExpression()) ) { + alt85=1; + } + + + } + + + switch (alt85) { + case 1 : + // InternalExpression.g:10446:3: rule__XAdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_29); + rule__XAdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop85; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__0" + // InternalExpression.g:10455:1: rule__XAdditiveExpression__Group_1__0 : rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ; + public final void rule__XAdditiveExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10459:1: ( rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ) + // InternalExpression.g:10460:2: rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 + { + pushFollow(FOLLOW_48); + rule__XAdditiveExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__0__Impl" + // InternalExpression.g:10467:1: rule__XAdditiveExpression__Group_1__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ; + public final void rule__XAdditiveExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10471:1: ( ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:10472:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:10472:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) + // InternalExpression.g:10473:2: ( rule__XAdditiveExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:10474:2: ( rule__XAdditiveExpression__Group_1_0__0 ) + // InternalExpression.g:10474:3: rule__XAdditiveExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__1" + // InternalExpression.g:10482:1: rule__XAdditiveExpression__Group_1__1 : rule__XAdditiveExpression__Group_1__1__Impl ; + public final void rule__XAdditiveExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10486:1: ( rule__XAdditiveExpression__Group_1__1__Impl ) + // InternalExpression.g:10487:2: rule__XAdditiveExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__1__Impl" + // InternalExpression.g:10493:1: rule__XAdditiveExpression__Group_1__1__Impl : ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XAdditiveExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10497:1: ( ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExpression.g:10498:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExpression.g:10498:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) + // InternalExpression.g:10499:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExpression.g:10500:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) + // InternalExpression.g:10500:3: rule__XAdditiveExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0" + // InternalExpression.g:10509:1: rule__XAdditiveExpression__Group_1_0__0 : rule__XAdditiveExpression__Group_1_0__0__Impl ; + public final void rule__XAdditiveExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10513:1: ( rule__XAdditiveExpression__Group_1_0__0__Impl ) + // InternalExpression.g:10514:2: rule__XAdditiveExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0__Impl" + // InternalExpression.g:10520:1: rule__XAdditiveExpression__Group_1_0__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ; + public final void rule__XAdditiveExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10524:1: ( ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:10525:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:10525:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:10526:2: ( rule__XAdditiveExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:10527:2: ( rule__XAdditiveExpression__Group_1_0_0__0 ) + // InternalExpression.g:10527:3: rule__XAdditiveExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0" + // InternalExpression.g:10536:1: rule__XAdditiveExpression__Group_1_0_0__0 : rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ; + public final void rule__XAdditiveExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10540:1: ( rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ) + // InternalExpression.g:10541:2: rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_28); + rule__XAdditiveExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:10548:1: rule__XAdditiveExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XAdditiveExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10552:1: ( ( () ) ) + // InternalExpression.g:10553:1: ( () ) + { + // InternalExpression.g:10553:1: ( () ) + // InternalExpression.g:10554:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExpression.g:10555:2: () + // InternalExpression.g:10555:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1" + // InternalExpression.g:10563:1: rule__XAdditiveExpression__Group_1_0_0__1 : rule__XAdditiveExpression__Group_1_0_0__1__Impl ; + public final void rule__XAdditiveExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10567:1: ( rule__XAdditiveExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:10568:2: rule__XAdditiveExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:10574:1: rule__XAdditiveExpression__Group_1_0_0__1__Impl : ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XAdditiveExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10578:1: ( ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExpression.g:10579:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExpression.g:10579:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExpression.g:10580:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExpression.g:10581:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) + // InternalExpression.g:10581:3: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__0" + // InternalExpression.g:10590:1: rule__XMultiplicativeExpression__Group__0 : rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ; + public final void rule__XMultiplicativeExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10594:1: ( rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ) + // InternalExpression.g:10595:2: rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 + { + pushFollow(FOLLOW_63); + rule__XMultiplicativeExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__0__Impl" + // InternalExpression.g:10602:1: rule__XMultiplicativeExpression__Group__0__Impl : ( ruleXUnaryOperation ) ; + public final void rule__XMultiplicativeExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10606:1: ( ( ruleXUnaryOperation ) ) + // InternalExpression.g:10607:1: ( ruleXUnaryOperation ) + { + // InternalExpression.g:10607:1: ( ruleXUnaryOperation ) + // InternalExpression.g:10608:2: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__1" + // InternalExpression.g:10617:1: rule__XMultiplicativeExpression__Group__1 : rule__XMultiplicativeExpression__Group__1__Impl ; + public final void rule__XMultiplicativeExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10621:1: ( rule__XMultiplicativeExpression__Group__1__Impl ) + // InternalExpression.g:10622:2: rule__XMultiplicativeExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__1__Impl" + // InternalExpression.g:10628:1: rule__XMultiplicativeExpression__Group__1__Impl : ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ; + public final void rule__XMultiplicativeExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10632:1: ( ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ) + // InternalExpression.g:10633:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) + { + // InternalExpression.g:10633:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) + // InternalExpression.g:10634:2: ( rule__XMultiplicativeExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); + } + // InternalExpression.g:10635:2: ( rule__XMultiplicativeExpression__Group_1__0 )* + loop86: + do { + int alt86=2; + switch ( input.LA(1) ) { + case 25: + { + int LA86_2 = input.LA(2); + + if ( (synpred159_InternalExpression()) ) { + alt86=1; + } + + + } + break; + case 54: + { + int LA86_3 = input.LA(2); + + if ( (synpred159_InternalExpression()) ) { + alt86=1; + } + + + } + break; + case 26: + { + int LA86_4 = input.LA(2); + + if ( (synpred159_InternalExpression()) ) { + alt86=1; + } + + + } + break; + case 55: + { + int LA86_5 = input.LA(2); + + if ( (synpred159_InternalExpression()) ) { + alt86=1; + } + + + } + break; + + } + + switch (alt86) { + case 1 : + // InternalExpression.g:10635:3: rule__XMultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_64); + rule__XMultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop86; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0" + // InternalExpression.g:10644:1: rule__XMultiplicativeExpression__Group_1__0 : rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ; + public final void rule__XMultiplicativeExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10648:1: ( rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ) + // InternalExpression.g:10649:2: rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 + { + pushFollow(FOLLOW_48); + rule__XMultiplicativeExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0__Impl" + // InternalExpression.g:10656:1: rule__XMultiplicativeExpression__Group_1__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10660:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:10661:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:10661:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) + // InternalExpression.g:10662:2: ( rule__XMultiplicativeExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:10663:2: ( rule__XMultiplicativeExpression__Group_1_0__0 ) + // InternalExpression.g:10663:3: rule__XMultiplicativeExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1" + // InternalExpression.g:10671:1: rule__XMultiplicativeExpression__Group_1__1 : rule__XMultiplicativeExpression__Group_1__1__Impl ; + public final void rule__XMultiplicativeExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10675:1: ( rule__XMultiplicativeExpression__Group_1__1__Impl ) + // InternalExpression.g:10676:2: rule__XMultiplicativeExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1__Impl" + // InternalExpression.g:10682:1: rule__XMultiplicativeExpression__Group_1__1__Impl : ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10686:1: ( ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ) + // InternalExpression.g:10687:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) + { + // InternalExpression.g:10687:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) + // InternalExpression.g:10688:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalExpression.g:10689:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) + // InternalExpression.g:10689:3: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0" + // InternalExpression.g:10698:1: rule__XMultiplicativeExpression__Group_1_0__0 : rule__XMultiplicativeExpression__Group_1_0__0__Impl ; + public final void rule__XMultiplicativeExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10702:1: ( rule__XMultiplicativeExpression__Group_1_0__0__Impl ) + // InternalExpression.g:10703:2: rule__XMultiplicativeExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0__Impl" + // InternalExpression.g:10709:1: rule__XMultiplicativeExpression__Group_1_0__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10713:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:10714:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:10714:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:10715:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:10716:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) + // InternalExpression.g:10716:3: rule__XMultiplicativeExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0" + // InternalExpression.g:10725:1: rule__XMultiplicativeExpression__Group_1_0_0__0 : rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10729:1: ( rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ) + // InternalExpression.g:10730:2: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_63); + rule__XMultiplicativeExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:10737:1: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10741:1: ( ( () ) ) + // InternalExpression.g:10742:1: ( () ) + { + // InternalExpression.g:10742:1: ( () ) + // InternalExpression.g:10743:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalExpression.g:10744:2: () + // InternalExpression.g:10744:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1" + // InternalExpression.g:10752:1: rule__XMultiplicativeExpression__Group_1_0_0__1 : rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10756:1: ( rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:10757:2: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:10763:1: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl : ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10767:1: ( ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalExpression.g:10768:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalExpression.g:10768:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalExpression.g:10769:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalExpression.g:10770:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) + // InternalExpression.g:10770:3: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__0" + // InternalExpression.g:10779:1: rule__XUnaryOperation__Group_0__0 : rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ; + public final void rule__XUnaryOperation__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10783:1: ( rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ) + // InternalExpression.g:10784:2: rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 + { + pushFollow(FOLLOW_65); + rule__XUnaryOperation__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__0" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__0__Impl" + // InternalExpression.g:10791:1: rule__XUnaryOperation__Group_0__0__Impl : ( () ) ; + public final void rule__XUnaryOperation__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10795:1: ( ( () ) ) + // InternalExpression.g:10796:1: ( () ) + { + // InternalExpression.g:10796:1: ( () ) + // InternalExpression.g:10797:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); + } + // InternalExpression.g:10798:2: () + // InternalExpression.g:10798:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__0__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__1" + // InternalExpression.g:10806:1: rule__XUnaryOperation__Group_0__1 : rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ; + public final void rule__XUnaryOperation__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10810:1: ( rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ) + // InternalExpression.g:10811:2: rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 + { + pushFollow(FOLLOW_48); + rule__XUnaryOperation__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__1" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__1__Impl" + // InternalExpression.g:10818:1: rule__XUnaryOperation__Group_0__1__Impl : ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ; + public final void rule__XUnaryOperation__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10822:1: ( ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ) + // InternalExpression.g:10823:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) + { + // InternalExpression.g:10823:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) + // InternalExpression.g:10824:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); + } + // InternalExpression.g:10825:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 ) + // InternalExpression.g:10825:3: rule__XUnaryOperation__FeatureAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__FeatureAssignment_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__1__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__2" + // InternalExpression.g:10833:1: rule__XUnaryOperation__Group_0__2 : rule__XUnaryOperation__Group_0__2__Impl ; + public final void rule__XUnaryOperation__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10837:1: ( rule__XUnaryOperation__Group_0__2__Impl ) + // InternalExpression.g:10838:2: rule__XUnaryOperation__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__2" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__2__Impl" + // InternalExpression.g:10844:1: rule__XUnaryOperation__Group_0__2__Impl : ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ; + public final void rule__XUnaryOperation__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10848:1: ( ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ) + // InternalExpression.g:10849:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) + { + // InternalExpression.g:10849:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) + // InternalExpression.g:10850:2: ( rule__XUnaryOperation__OperandAssignment_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); + } + // InternalExpression.g:10851:2: ( rule__XUnaryOperation__OperandAssignment_0_2 ) + // InternalExpression.g:10851:3: rule__XUnaryOperation__OperandAssignment_0_2 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__OperandAssignment_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__2__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group__0" + // InternalExpression.g:10860:1: rule__XCastedExpression__Group__0 : rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ; + public final void rule__XCastedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10864:1: ( rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ) + // InternalExpression.g:10865:2: rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 + { + pushFollow(FOLLOW_66); + rule__XCastedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__0" + + + // $ANTLR start "rule__XCastedExpression__Group__0__Impl" + // InternalExpression.g:10872:1: rule__XCastedExpression__Group__0__Impl : ( ruleXPostfixOperation ) ; + public final void rule__XCastedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10876:1: ( ( ruleXPostfixOperation ) ) + // InternalExpression.g:10877:1: ( ruleXPostfixOperation ) + { + // InternalExpression.g:10877:1: ( ruleXPostfixOperation ) + // InternalExpression.g:10878:2: ruleXPostfixOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group__1" + // InternalExpression.g:10887:1: rule__XCastedExpression__Group__1 : rule__XCastedExpression__Group__1__Impl ; + public final void rule__XCastedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10891:1: ( rule__XCastedExpression__Group__1__Impl ) + // InternalExpression.g:10892:2: rule__XCastedExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__1" + + + // $ANTLR start "rule__XCastedExpression__Group__1__Impl" + // InternalExpression.g:10898:1: rule__XCastedExpression__Group__1__Impl : ( ( rule__XCastedExpression__Group_1__0 )* ) ; + public final void rule__XCastedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10902:1: ( ( ( rule__XCastedExpression__Group_1__0 )* ) ) + // InternalExpression.g:10903:1: ( ( rule__XCastedExpression__Group_1__0 )* ) + { + // InternalExpression.g:10903:1: ( ( rule__XCastedExpression__Group_1__0 )* ) + // InternalExpression.g:10904:2: ( rule__XCastedExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); + } + // InternalExpression.g:10905:2: ( rule__XCastedExpression__Group_1__0 )* + loop87: + do { + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==86) ) { + int LA87_2 = input.LA(2); + + if ( (synpred160_InternalExpression()) ) { + alt87=1; + } + + + } + + + switch (alt87) { + case 1 : + // InternalExpression.g:10905:3: rule__XCastedExpression__Group_1__0 + { + pushFollow(FOLLOW_67); + rule__XCastedExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop87; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1__0" + // InternalExpression.g:10914:1: rule__XCastedExpression__Group_1__0 : rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ; + public final void rule__XCastedExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10918:1: ( rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ) + // InternalExpression.g:10919:2: rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 + { + pushFollow(FOLLOW_56); + rule__XCastedExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1__0__Impl" + // InternalExpression.g:10926:1: rule__XCastedExpression__Group_1__0__Impl : ( ( rule__XCastedExpression__Group_1_0__0 ) ) ; + public final void rule__XCastedExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10930:1: ( ( ( rule__XCastedExpression__Group_1_0__0 ) ) ) + // InternalExpression.g:10931:1: ( ( rule__XCastedExpression__Group_1_0__0 ) ) + { + // InternalExpression.g:10931:1: ( ( rule__XCastedExpression__Group_1_0__0 ) ) + // InternalExpression.g:10932:2: ( rule__XCastedExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); + } + // InternalExpression.g:10933:2: ( rule__XCastedExpression__Group_1_0__0 ) + // InternalExpression.g:10933:3: rule__XCastedExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1__1" + // InternalExpression.g:10941:1: rule__XCastedExpression__Group_1__1 : rule__XCastedExpression__Group_1__1__Impl ; + public final void rule__XCastedExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10945:1: ( rule__XCastedExpression__Group_1__1__Impl ) + // InternalExpression.g:10946:2: rule__XCastedExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__1" + + + // $ANTLR start "rule__XCastedExpression__Group_1__1__Impl" + // InternalExpression.g:10952:1: rule__XCastedExpression__Group_1__1__Impl : ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ; + public final void rule__XCastedExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10956:1: ( ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ) + // InternalExpression.g:10957:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) + { + // InternalExpression.g:10957:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) + // InternalExpression.g:10958:2: ( rule__XCastedExpression__TypeAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); + } + // InternalExpression.g:10959:2: ( rule__XCastedExpression__TypeAssignment_1_1 ) + // InternalExpression.g:10959:3: rule__XCastedExpression__TypeAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__TypeAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0__0" + // InternalExpression.g:10968:1: rule__XCastedExpression__Group_1_0__0 : rule__XCastedExpression__Group_1_0__0__Impl ; + public final void rule__XCastedExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10972:1: ( rule__XCastedExpression__Group_1_0__0__Impl ) + // InternalExpression.g:10973:2: rule__XCastedExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0__0__Impl" + // InternalExpression.g:10979:1: rule__XCastedExpression__Group_1_0__0__Impl : ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ; + public final void rule__XCastedExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10983:1: ( ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ) + // InternalExpression.g:10984:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) + { + // InternalExpression.g:10984:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) + // InternalExpression.g:10985:2: ( rule__XCastedExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); + } + // InternalExpression.g:10986:2: ( rule__XCastedExpression__Group_1_0_0__0 ) + // InternalExpression.g:10986:3: rule__XCastedExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0" + // InternalExpression.g:10995:1: rule__XCastedExpression__Group_1_0_0__0 : rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ; + public final void rule__XCastedExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:10999:1: ( rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ) + // InternalExpression.g:11000:2: rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_66); + rule__XCastedExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0__Impl" + // InternalExpression.g:11007:1: rule__XCastedExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XCastedExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11011:1: ( ( () ) ) + // InternalExpression.g:11012:1: ( () ) + { + // InternalExpression.g:11012:1: ( () ) + // InternalExpression.g:11013:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); + } + // InternalExpression.g:11014:2: () + // InternalExpression.g:11014:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1" + // InternalExpression.g:11022:1: rule__XCastedExpression__Group_1_0_0__1 : rule__XCastedExpression__Group_1_0_0__1__Impl ; + public final void rule__XCastedExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11026:1: ( rule__XCastedExpression__Group_1_0_0__1__Impl ) + // InternalExpression.g:11027:2: rule__XCastedExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1__Impl" + // InternalExpression.g:11033:1: rule__XCastedExpression__Group_1_0_0__1__Impl : ( 'as' ) ; + public final void rule__XCastedExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11037:1: ( ( 'as' ) ) + // InternalExpression.g:11038:1: ( 'as' ) + { + // InternalExpression.g:11038:1: ( 'as' ) + // InternalExpression.g:11039:2: 'as' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group__0" + // InternalExpression.g:11049:1: rule__XPostfixOperation__Group__0 : rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ; + public final void rule__XPostfixOperation__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11053:1: ( rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ) + // InternalExpression.g:11054:2: rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 + { + pushFollow(FOLLOW_68); + rule__XPostfixOperation__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__0" + + + // $ANTLR start "rule__XPostfixOperation__Group__0__Impl" + // InternalExpression.g:11061:1: rule__XPostfixOperation__Group__0__Impl : ( ruleXMemberFeatureCall ) ; + public final void rule__XPostfixOperation__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11065:1: ( ( ruleXMemberFeatureCall ) ) + // InternalExpression.g:11066:1: ( ruleXMemberFeatureCall ) + { + // InternalExpression.g:11066:1: ( ruleXMemberFeatureCall ) + // InternalExpression.g:11067:2: ruleXMemberFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group__1" + // InternalExpression.g:11076:1: rule__XPostfixOperation__Group__1 : rule__XPostfixOperation__Group__1__Impl ; + public final void rule__XPostfixOperation__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11080:1: ( rule__XPostfixOperation__Group__1__Impl ) + // InternalExpression.g:11081:2: rule__XPostfixOperation__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__1" + + + // $ANTLR start "rule__XPostfixOperation__Group__1__Impl" + // InternalExpression.g:11087:1: rule__XPostfixOperation__Group__1__Impl : ( ( rule__XPostfixOperation__Group_1__0 )? ) ; + public final void rule__XPostfixOperation__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11091:1: ( ( ( rule__XPostfixOperation__Group_1__0 )? ) ) + // InternalExpression.g:11092:1: ( ( rule__XPostfixOperation__Group_1__0 )? ) + { + // InternalExpression.g:11092:1: ( ( rule__XPostfixOperation__Group_1__0 )? ) + // InternalExpression.g:11093:2: ( rule__XPostfixOperation__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); + } + // InternalExpression.g:11094:2: ( rule__XPostfixOperation__Group_1__0 )? + int alt88=2; + int LA88_0 = input.LA(1); + + if ( (LA88_0==56) ) { + int LA88_1 = input.LA(2); + + if ( (synpred161_InternalExpression()) ) { + alt88=1; + } + } + else if ( (LA88_0==57) ) { + int LA88_2 = input.LA(2); + + if ( (synpred161_InternalExpression()) ) { + alt88=1; + } + } + switch (alt88) { + case 1 : + // InternalExpression.g:11094:3: rule__XPostfixOperation__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__1__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1__0" + // InternalExpression.g:11103:1: rule__XPostfixOperation__Group_1__0 : rule__XPostfixOperation__Group_1__0__Impl ; + public final void rule__XPostfixOperation__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11107:1: ( rule__XPostfixOperation__Group_1__0__Impl ) + // InternalExpression.g:11108:2: rule__XPostfixOperation__Group_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1__0" + + + // $ANTLR start "rule__XPostfixOperation__Group_1__0__Impl" + // InternalExpression.g:11114:1: rule__XPostfixOperation__Group_1__0__Impl : ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ; + public final void rule__XPostfixOperation__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11118:1: ( ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ) + // InternalExpression.g:11119:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) ) + { + // InternalExpression.g:11119:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) ) + // InternalExpression.g:11120:2: ( rule__XPostfixOperation__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); + } + // InternalExpression.g:11121:2: ( rule__XPostfixOperation__Group_1_0__0 ) + // InternalExpression.g:11121:3: rule__XPostfixOperation__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__0" + // InternalExpression.g:11130:1: rule__XPostfixOperation__Group_1_0__0 : rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ; + public final void rule__XPostfixOperation__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11134:1: ( rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ) + // InternalExpression.g:11135:2: rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 + { + pushFollow(FOLLOW_68); + rule__XPostfixOperation__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__0" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__0__Impl" + // InternalExpression.g:11142:1: rule__XPostfixOperation__Group_1_0__0__Impl : ( () ) ; + public final void rule__XPostfixOperation__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11146:1: ( ( () ) ) + // InternalExpression.g:11147:1: ( () ) + { + // InternalExpression.g:11147:1: ( () ) + // InternalExpression.g:11148:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); + } + // InternalExpression.g:11149:2: () + // InternalExpression.g:11149:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__1" + // InternalExpression.g:11157:1: rule__XPostfixOperation__Group_1_0__1 : rule__XPostfixOperation__Group_1_0__1__Impl ; + public final void rule__XPostfixOperation__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11161:1: ( rule__XPostfixOperation__Group_1_0__1__Impl ) + // InternalExpression.g:11162:2: rule__XPostfixOperation__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__1" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__1__Impl" + // InternalExpression.g:11168:1: rule__XPostfixOperation__Group_1_0__1__Impl : ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ; + public final void rule__XPostfixOperation__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11172:1: ( ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ) + // InternalExpression.g:11173:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) + { + // InternalExpression.g:11173:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) + // InternalExpression.g:11174:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); + } + // InternalExpression.g:11175:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) + // InternalExpression.g:11175:3: rule__XPostfixOperation__FeatureAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__FeatureAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__0" + // InternalExpression.g:11184:1: rule__XMemberFeatureCall__Group__0 : rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ; + public final void rule__XMemberFeatureCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11188:1: ( rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ) + // InternalExpression.g:11189:2: rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 + { + pushFollow(FOLLOW_69); + rule__XMemberFeatureCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__0__Impl" + // InternalExpression.g:11196:1: rule__XMemberFeatureCall__Group__0__Impl : ( ruleXPrimaryExpression ) ; + public final void rule__XMemberFeatureCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11200:1: ( ( ruleXPrimaryExpression ) ) + // InternalExpression.g:11201:1: ( ruleXPrimaryExpression ) + { + // InternalExpression.g:11201:1: ( ruleXPrimaryExpression ) + // InternalExpression.g:11202:2: ruleXPrimaryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__1" + // InternalExpression.g:11211:1: rule__XMemberFeatureCall__Group__1 : rule__XMemberFeatureCall__Group__1__Impl ; + public final void rule__XMemberFeatureCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11215:1: ( rule__XMemberFeatureCall__Group__1__Impl ) + // InternalExpression.g:11216:2: rule__XMemberFeatureCall__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__1__Impl" + // InternalExpression.g:11222:1: rule__XMemberFeatureCall__Group__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ; + public final void rule__XMemberFeatureCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11226:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ) + // InternalExpression.g:11227:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) + { + // InternalExpression.g:11227:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) + // InternalExpression.g:11228:2: ( rule__XMemberFeatureCall__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); + } + // InternalExpression.g:11229:2: ( rule__XMemberFeatureCall__Alternatives_1 )* + loop89: + do { + int alt89=2; + switch ( input.LA(1) ) { + case 58: + { + int LA89_2 = input.LA(2); + + if ( (synpred162_InternalExpression()) ) { + alt89=1; + } + + + } + break; + case 84: + { + int LA89_3 = input.LA(2); + + if ( (synpred162_InternalExpression()) ) { + alt89=1; + } + + + } + break; + case 103: + { + int LA89_4 = input.LA(2); + + if ( (synpred162_InternalExpression()) ) { + alt89=1; + } + + + } + break; + + } + + switch (alt89) { + case 1 : + // InternalExpression.g:11229:3: rule__XMemberFeatureCall__Alternatives_1 + { + pushFollow(FOLLOW_70); + rule__XMemberFeatureCall__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop89; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0" + // InternalExpression.g:11238:1: rule__XMemberFeatureCall__Group_1_0__0 : rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11242:1: ( rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ) + // InternalExpression.g:11243:2: rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 + { + pushFollow(FOLLOW_48); + rule__XMemberFeatureCall__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0__Impl" + // InternalExpression.g:11250:1: rule__XMemberFeatureCall__Group_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11254:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ) + // InternalExpression.g:11255:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) + { + // InternalExpression.g:11255:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) + // InternalExpression.g:11256:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); + } + // InternalExpression.g:11257:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 ) + // InternalExpression.g:11257:3: rule__XMemberFeatureCall__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1" + // InternalExpression.g:11265:1: rule__XMemberFeatureCall__Group_1_0__1 : rule__XMemberFeatureCall__Group_1_0__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11269:1: ( rule__XMemberFeatureCall__Group_1_0__1__Impl ) + // InternalExpression.g:11270:2: rule__XMemberFeatureCall__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1__Impl" + // InternalExpression.g:11276:1: rule__XMemberFeatureCall__Group_1_0__1__Impl : ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11280:1: ( ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ) + // InternalExpression.g:11281:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) + { + // InternalExpression.g:11281:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) + // InternalExpression.g:11282:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); + } + // InternalExpression.g:11283:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) + // InternalExpression.g:11283:3: rule__XMemberFeatureCall__ValueAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ValueAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0" + // InternalExpression.g:11292:1: rule__XMemberFeatureCall__Group_1_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0__0__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11296:1: ( rule__XMemberFeatureCall__Group_1_0_0__0__Impl ) + // InternalExpression.g:11297:2: rule__XMemberFeatureCall__Group_1_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0__Impl" + // InternalExpression.g:11303:1: rule__XMemberFeatureCall__Group_1_0_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11307:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ) + // InternalExpression.g:11308:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) + { + // InternalExpression.g:11308:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) + // InternalExpression.g:11309:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); + } + // InternalExpression.g:11310:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) + // InternalExpression.g:11310:3: rule__XMemberFeatureCall__Group_1_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0" + // InternalExpression.g:11319:1: rule__XMemberFeatureCall__Group_1_0_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11323:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ) + // InternalExpression.g:11324:2: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 + { + pushFollow(FOLLOW_71); + rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl" + // InternalExpression.g:11331:1: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl : ( () ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11335:1: ( ( () ) ) + // InternalExpression.g:11336:1: ( () ) + { + // InternalExpression.g:11336:1: ( () ) + // InternalExpression.g:11337:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); + } + // InternalExpression.g:11338:2: () + // InternalExpression.g:11338:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1" + // InternalExpression.g:11346:1: rule__XMemberFeatureCall__Group_1_0_0_0__1 : rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11350:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ) + // InternalExpression.g:11351:2: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 + { + pushFollow(FOLLOW_47); + rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl" + // InternalExpression.g:11358:1: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11362:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ) + // InternalExpression.g:11363:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) + { + // InternalExpression.g:11363:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) + // InternalExpression.g:11364:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); + } + // InternalExpression.g:11365:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) + // InternalExpression.g:11365:3: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_0_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2" + // InternalExpression.g:11373:1: rule__XMemberFeatureCall__Group_1_0_0_0__2 : rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11377:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ) + // InternalExpression.g:11378:2: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 + { + pushFollow(FOLLOW_5); + rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl" + // InternalExpression.g:11385:1: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11389:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ) + // InternalExpression.g:11390:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) + { + // InternalExpression.g:11390:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) + // InternalExpression.g:11391:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); + } + // InternalExpression.g:11392:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) + // InternalExpression.g:11392:3: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3" + // InternalExpression.g:11400:1: rule__XMemberFeatureCall__Group_1_0_0_0__3 : rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11404:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ) + // InternalExpression.g:11405:2: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl" + // InternalExpression.g:11411:1: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl : ( ruleOpSingleAssign ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11415:1: ( ( ruleOpSingleAssign ) ) + // InternalExpression.g:11416:1: ( ruleOpSingleAssign ) + { + // InternalExpression.g:11416:1: ( ruleOpSingleAssign ) + // InternalExpression.g:11417:2: ruleOpSingleAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0" + // InternalExpression.g:11427:1: rule__XMemberFeatureCall__Group_1_1__0 : rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11431:1: ( rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ) + // InternalExpression.g:11432:2: rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 + { + pushFollow(FOLLOW_72); + rule__XMemberFeatureCall__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0__Impl" + // InternalExpression.g:11439:1: rule__XMemberFeatureCall__Group_1_1__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11443:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ) + // InternalExpression.g:11444:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) + { + // InternalExpression.g:11444:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) + // InternalExpression.g:11445:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); + } + // InternalExpression.g:11446:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 ) + // InternalExpression.g:11446:3: rule__XMemberFeatureCall__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1" + // InternalExpression.g:11454:1: rule__XMemberFeatureCall__Group_1_1__1 : rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ; + public final void rule__XMemberFeatureCall__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11458:1: ( rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ) + // InternalExpression.g:11459:2: rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 + { + pushFollow(FOLLOW_72); + rule__XMemberFeatureCall__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1__Impl" + // InternalExpression.g:11466:1: rule__XMemberFeatureCall__Group_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11470:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ) + // InternalExpression.g:11471:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) + { + // InternalExpression.g:11471:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) + // InternalExpression.g:11472:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); + } + // InternalExpression.g:11473:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )? + int alt90=2; + int LA90_0 = input.LA(1); + + if ( (LA90_0==22) ) { + alt90=1; + } + switch (alt90) { + case 1 : + // InternalExpression.g:11473:3: rule__XMemberFeatureCall__Group_1_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2" + // InternalExpression.g:11481:1: rule__XMemberFeatureCall__Group_1_1__2 : rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ; + public final void rule__XMemberFeatureCall__Group_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11485:1: ( rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ) + // InternalExpression.g:11486:2: rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 + { + pushFollow(FOLLOW_73); + rule__XMemberFeatureCall__Group_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2__Impl" + // InternalExpression.g:11493:1: rule__XMemberFeatureCall__Group_1_1__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11497:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ) + // InternalExpression.g:11498:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) + { + // InternalExpression.g:11498:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) + // InternalExpression.g:11499:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); + } + // InternalExpression.g:11500:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) + // InternalExpression.g:11500:3: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__FeatureAssignment_1_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3" + // InternalExpression.g:11508:1: rule__XMemberFeatureCall__Group_1_1__3 : rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ; + public final void rule__XMemberFeatureCall__Group_1_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11512:1: ( rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ) + // InternalExpression.g:11513:2: rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 + { + pushFollow(FOLLOW_73); + rule__XMemberFeatureCall__Group_1_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3__Impl" + // InternalExpression.g:11520:1: rule__XMemberFeatureCall__Group_1_1__3__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11524:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ) + // InternalExpression.g:11525:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) + { + // InternalExpression.g:11525:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) + // InternalExpression.g:11526:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); + } + // InternalExpression.g:11527:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )? + int alt91=2; + alt91 = dfa91.predict(input); + switch (alt91) { + case 1 : + // InternalExpression.g:11527:3: rule__XMemberFeatureCall__Group_1_1_3__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4" + // InternalExpression.g:11535:1: rule__XMemberFeatureCall__Group_1_1__4 : rule__XMemberFeatureCall__Group_1_1__4__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11539:1: ( rule__XMemberFeatureCall__Group_1_1__4__Impl ) + // InternalExpression.g:11540:2: rule__XMemberFeatureCall__Group_1_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4__Impl" + // InternalExpression.g:11546:1: rule__XMemberFeatureCall__Group_1_1__4__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11550:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ) + // InternalExpression.g:11551:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) + { + // InternalExpression.g:11551:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) + // InternalExpression.g:11552:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); + } + // InternalExpression.g:11553:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? + int alt92=2; + alt92 = dfa92.predict(input); + switch (alt92) { + case 1 : + // InternalExpression.g:11553:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0" + // InternalExpression.g:11562:1: rule__XMemberFeatureCall__Group_1_1_0__0 : rule__XMemberFeatureCall__Group_1_1_0__0__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11566:1: ( rule__XMemberFeatureCall__Group_1_1_0__0__Impl ) + // InternalExpression.g:11567:2: rule__XMemberFeatureCall__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0__Impl" + // InternalExpression.g:11573:1: rule__XMemberFeatureCall__Group_1_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11577:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ) + // InternalExpression.g:11578:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) + { + // InternalExpression.g:11578:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) + // InternalExpression.g:11579:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); + } + // InternalExpression.g:11580:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) + // InternalExpression.g:11580:3: rule__XMemberFeatureCall__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0" + // InternalExpression.g:11589:1: rule__XMemberFeatureCall__Group_1_1_0_0__0 : rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11593:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ) + // InternalExpression.g:11594:2: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_69); + rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl" + // InternalExpression.g:11601:1: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11605:1: ( ( () ) ) + // InternalExpression.g:11606:1: ( () ) + { + // InternalExpression.g:11606:1: ( () ) + // InternalExpression.g:11607:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); + } + // InternalExpression.g:11608:2: () + // InternalExpression.g:11608:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1" + // InternalExpression.g:11616:1: rule__XMemberFeatureCall__Group_1_1_0_0__1 : rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11620:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ) + // InternalExpression.g:11621:2: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl" + // InternalExpression.g:11627:1: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11631:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ) + // InternalExpression.g:11632:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) + { + // InternalExpression.g:11632:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) + // InternalExpression.g:11633:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); + } + // InternalExpression.g:11634:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) + // InternalExpression.g:11634:3: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0" + // InternalExpression.g:11643:1: rule__XMemberFeatureCall__Group_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11647:1: ( rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ) + // InternalExpression.g:11648:2: rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 + { + pushFollow(FOLLOW_74); + rule__XMemberFeatureCall__Group_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0__Impl" + // InternalExpression.g:11655:1: rule__XMemberFeatureCall__Group_1_1_1__0__Impl : ( '<' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11659:1: ( ( '<' ) ) + // InternalExpression.g:11660:1: ( '<' ) + { + // InternalExpression.g:11660:1: ( '<' ) + // InternalExpression.g:11661:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1" + // InternalExpression.g:11670:1: rule__XMemberFeatureCall__Group_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11674:1: ( rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ) + // InternalExpression.g:11675:2: rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 + { + pushFollow(FOLLOW_75); + rule__XMemberFeatureCall__Group_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1__Impl" + // InternalExpression.g:11682:1: rule__XMemberFeatureCall__Group_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11686:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ) + // InternalExpression.g:11687:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) + { + // InternalExpression.g:11687:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) + // InternalExpression.g:11688:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); + } + // InternalExpression.g:11689:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) + // InternalExpression.g:11689:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2" + // InternalExpression.g:11697:1: rule__XMemberFeatureCall__Group_1_1_1__2 : rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11701:1: ( rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ) + // InternalExpression.g:11702:2: rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 + { + pushFollow(FOLLOW_75); + rule__XMemberFeatureCall__Group_1_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2__Impl" + // InternalExpression.g:11709:1: rule__XMemberFeatureCall__Group_1_1_1__2__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11713:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ) + // InternalExpression.g:11714:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) + { + // InternalExpression.g:11714:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) + // InternalExpression.g:11715:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); + } + // InternalExpression.g:11716:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* + loop93: + do { + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==78) ) { + alt93=1; + } + + + switch (alt93) { + case 1 : + // InternalExpression.g:11716:3: rule__XMemberFeatureCall__Group_1_1_1_2__0 + { + pushFollow(FOLLOW_37); + rule__XMemberFeatureCall__Group_1_1_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop93; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3" + // InternalExpression.g:11724:1: rule__XMemberFeatureCall__Group_1_1_1__3 : rule__XMemberFeatureCall__Group_1_1_1__3__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11728:1: ( rule__XMemberFeatureCall__Group_1_1_1__3__Impl ) + // InternalExpression.g:11729:2: rule__XMemberFeatureCall__Group_1_1_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3__Impl" + // InternalExpression.g:11735:1: rule__XMemberFeatureCall__Group_1_1_1__3__Impl : ( '>' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11739:1: ( ( '>' ) ) + // InternalExpression.g:11740:1: ( '>' ) + { + // InternalExpression.g:11740:1: ( '>' ) + // InternalExpression.g:11741:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0" + // InternalExpression.g:11751:1: rule__XMemberFeatureCall__Group_1_1_1_2__0 : rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11755:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ) + // InternalExpression.g:11756:2: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 + { + pushFollow(FOLLOW_74); + rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl" + // InternalExpression.g:11763:1: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl : ( ',' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11767:1: ( ( ',' ) ) + // InternalExpression.g:11768:1: ( ',' ) + { + // InternalExpression.g:11768:1: ( ',' ) + // InternalExpression.g:11769:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1" + // InternalExpression.g:11778:1: rule__XMemberFeatureCall__Group_1_1_1_2__1 : rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11782:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ) + // InternalExpression.g:11783:2: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl" + // InternalExpression.g:11789:1: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11793:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ) + // InternalExpression.g:11794:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) + { + // InternalExpression.g:11794:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) + // InternalExpression.g:11795:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); + } + // InternalExpression.g:11796:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) + // InternalExpression.g:11796:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0" + // InternalExpression.g:11805:1: rule__XMemberFeatureCall__Group_1_1_3__0 : rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11809:1: ( rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ) + // InternalExpression.g:11810:2: rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 + { + pushFollow(FOLLOW_76); + rule__XMemberFeatureCall__Group_1_1_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0__Impl" + // InternalExpression.g:11817:1: rule__XMemberFeatureCall__Group_1_1_3__0__Impl : ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11821:1: ( ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ) + // InternalExpression.g:11822:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) + { + // InternalExpression.g:11822:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) + // InternalExpression.g:11823:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); + } + // InternalExpression.g:11824:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) + // InternalExpression.g:11824:3: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1" + // InternalExpression.g:11832:1: rule__XMemberFeatureCall__Group_1_1_3__1 : rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ; + public final void rule__XMemberFeatureCall__Group_1_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11836:1: ( rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ) + // InternalExpression.g:11837:2: rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 + { + pushFollow(FOLLOW_76); + rule__XMemberFeatureCall__Group_1_1_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1__Impl" + // InternalExpression.g:11844:1: rule__XMemberFeatureCall__Group_1_1_3__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11848:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ) + // InternalExpression.g:11849:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) + { + // InternalExpression.g:11849:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) + // InternalExpression.g:11850:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); + } + // InternalExpression.g:11851:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? + int alt94=2; + int LA94_0 = input.LA(1); + + if ( ((LA94_0>=RULE_ID && LA94_0<=RULE_DECIMAL)||LA94_0==RULE_STRING||(LA94_0>=22 && LA94_0<=24)||LA94_0==27||(LA94_0>=36 && LA94_0<=37)||LA94_0==51||(LA94_0>=60 && LA94_0<=64)||LA94_0==67||LA94_0==70||(LA94_0>=73 && LA94_0<=74)||LA94_0==79||(LA94_0>=81 && LA94_0<=82)||LA94_0==87||(LA94_0>=89 && LA94_0<=96)||LA94_0==98) ) { + alt94=1; + } + switch (alt94) { + case 1 : + // InternalExpression.g:11851:3: rule__XMemberFeatureCall__Alternatives_1_1_3_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_1_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2" + // InternalExpression.g:11859:1: rule__XMemberFeatureCall__Group_1_1_3__2 : rule__XMemberFeatureCall__Group_1_1_3__2__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11863:1: ( rule__XMemberFeatureCall__Group_1_1_3__2__Impl ) + // InternalExpression.g:11864:2: rule__XMemberFeatureCall__Group_1_1_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2__Impl" + // InternalExpression.g:11870:1: rule__XMemberFeatureCall__Group_1_1_3__2__Impl : ( ')' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11874:1: ( ( ')' ) ) + // InternalExpression.g:11875:1: ( ')' ) + { + // InternalExpression.g:11875:1: ( ')' ) + // InternalExpression.g:11876:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0" + // InternalExpression.g:11886:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11890:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ) + // InternalExpression.g:11891:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 + { + pushFollow(FOLLOW_36); + rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl" + // InternalExpression.g:11898:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11902:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ) + // InternalExpression.g:11903:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) + { + // InternalExpression.g:11903:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) + // InternalExpression.g:11904:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); + } + // InternalExpression.g:11905:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) + // InternalExpression.g:11905:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1" + // InternalExpression.g:11913:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11917:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ) + // InternalExpression.g:11918:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl" + // InternalExpression.g:11924:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11928:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ) + // InternalExpression.g:11929:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) + { + // InternalExpression.g:11929:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) + // InternalExpression.g:11930:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); + } + // InternalExpression.g:11931:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* + loop95: + do { + int alt95=2; + int LA95_0 = input.LA(1); + + if ( (LA95_0==78) ) { + alt95=1; + } + + + switch (alt95) { + case 1 : + // InternalExpression.g:11931:3: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 + { + pushFollow(FOLLOW_37); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop95; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0" + // InternalExpression.g:11940:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11944:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ) + // InternalExpression.g:11945:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 + { + pushFollow(FOLLOW_77); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl" + // InternalExpression.g:11952:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11956:1: ( ( ',' ) ) + // InternalExpression.g:11957:1: ( ',' ) + { + // InternalExpression.g:11957:1: ( ',' ) + // InternalExpression.g:11958:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1" + // InternalExpression.g:11967:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11971:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ) + // InternalExpression.g:11972:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl" + // InternalExpression.g:11978:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11982:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ) + // InternalExpression.g:11983:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) + { + // InternalExpression.g:11983:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) + // InternalExpression.g:11984:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); + } + // InternalExpression.g:11985:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) + // InternalExpression.g:11985:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__0" + // InternalExpression.g:11994:1: rule__XSetLiteral__Group__0 : rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ; + public final void rule__XSetLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:11998:1: ( rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ) + // InternalExpression.g:11999:2: rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 + { + pushFollow(FOLLOW_78); + rule__XSetLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__0" + + + // $ANTLR start "rule__XSetLiteral__Group__0__Impl" + // InternalExpression.g:12006:1: rule__XSetLiteral__Group__0__Impl : ( () ) ; + public final void rule__XSetLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12010:1: ( ( () ) ) + // InternalExpression.g:12011:1: ( () ) + { + // InternalExpression.g:12011:1: ( () ) + // InternalExpression.g:12012:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); + } + // InternalExpression.g:12013:2: () + // InternalExpression.g:12013:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__1" + // InternalExpression.g:12021:1: rule__XSetLiteral__Group__1 : rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ; + public final void rule__XSetLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12025:1: ( rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ) + // InternalExpression.g:12026:2: rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 + { + pushFollow(FOLLOW_41); + rule__XSetLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__1" + + + // $ANTLR start "rule__XSetLiteral__Group__1__Impl" + // InternalExpression.g:12033:1: rule__XSetLiteral__Group__1__Impl : ( '#' ) ; + public final void rule__XSetLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12037:1: ( ( '#' ) ) + // InternalExpression.g:12038:1: ( '#' ) + { + // InternalExpression.g:12038:1: ( '#' ) + // InternalExpression.g:12039:2: '#' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + match(input,87,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__2" + // InternalExpression.g:12048:1: rule__XSetLiteral__Group__2 : rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ; + public final void rule__XSetLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12052:1: ( rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ) + // InternalExpression.g:12053:2: rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 + { + pushFollow(FOLLOW_79); + rule__XSetLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__2" + + + // $ANTLR start "rule__XSetLiteral__Group__2__Impl" + // InternalExpression.g:12060:1: rule__XSetLiteral__Group__2__Impl : ( '{' ) ; + public final void rule__XSetLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12064:1: ( ( '{' ) ) + // InternalExpression.g:12065:1: ( '{' ) + { + // InternalExpression.g:12065:1: ( '{' ) + // InternalExpression.g:12066:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__3" + // InternalExpression.g:12075:1: rule__XSetLiteral__Group__3 : rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ; + public final void rule__XSetLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12079:1: ( rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ) + // InternalExpression.g:12080:2: rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 + { + pushFollow(FOLLOW_79); + rule__XSetLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__3" + + + // $ANTLR start "rule__XSetLiteral__Group__3__Impl" + // InternalExpression.g:12087:1: rule__XSetLiteral__Group__3__Impl : ( ( rule__XSetLiteral__Group_3__0 )? ) ; + public final void rule__XSetLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12091:1: ( ( ( rule__XSetLiteral__Group_3__0 )? ) ) + // InternalExpression.g:12092:1: ( ( rule__XSetLiteral__Group_3__0 )? ) + { + // InternalExpression.g:12092:1: ( ( rule__XSetLiteral__Group_3__0 )? ) + // InternalExpression.g:12093:2: ( rule__XSetLiteral__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup_3()); + } + // InternalExpression.g:12094:2: ( rule__XSetLiteral__Group_3__0 )? + int alt96=2; + int LA96_0 = input.LA(1); + + if ( ((LA96_0>=RULE_ID && LA96_0<=RULE_DECIMAL)||LA96_0==RULE_STRING||(LA96_0>=22 && LA96_0<=24)||LA96_0==27||(LA96_0>=36 && LA96_0<=37)||(LA96_0>=60 && LA96_0<=64)||LA96_0==67||LA96_0==70||(LA96_0>=73 && LA96_0<=74)||(LA96_0>=81 && LA96_0<=82)||LA96_0==87||(LA96_0>=89 && LA96_0<=96)||LA96_0==98) ) { + alt96=1; + } + switch (alt96) { + case 1 : + // InternalExpression.g:12094:3: rule__XSetLiteral__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__4" + // InternalExpression.g:12102:1: rule__XSetLiteral__Group__4 : rule__XSetLiteral__Group__4__Impl ; + public final void rule__XSetLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12106:1: ( rule__XSetLiteral__Group__4__Impl ) + // InternalExpression.g:12107:2: rule__XSetLiteral__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__4" + + + // $ANTLR start "rule__XSetLiteral__Group__4__Impl" + // InternalExpression.g:12113:1: rule__XSetLiteral__Group__4__Impl : ( '}' ) ; + public final void rule__XSetLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12117:1: ( ( '}' ) ) + // InternalExpression.g:12118:1: ( '}' ) + { + // InternalExpression.g:12118:1: ( '}' ) + // InternalExpression.g:12119:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + match(input,76,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3__0" + // InternalExpression.g:12129:1: rule__XSetLiteral__Group_3__0 : rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ; + public final void rule__XSetLiteral__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12133:1: ( rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ) + // InternalExpression.g:12134:2: rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 + { + pushFollow(FOLLOW_36); + rule__XSetLiteral__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__0" + + + // $ANTLR start "rule__XSetLiteral__Group_3__0__Impl" + // InternalExpression.g:12141:1: rule__XSetLiteral__Group_3__0__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ; + public final void rule__XSetLiteral__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12145:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ) + // InternalExpression.g:12146:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) + { + // InternalExpression.g:12146:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) + // InternalExpression.g:12147:2: ( rule__XSetLiteral__ElementsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); + } + // InternalExpression.g:12148:2: ( rule__XSetLiteral__ElementsAssignment_3_0 ) + // InternalExpression.g:12148:3: rule__XSetLiteral__ElementsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__ElementsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3__1" + // InternalExpression.g:12156:1: rule__XSetLiteral__Group_3__1 : rule__XSetLiteral__Group_3__1__Impl ; + public final void rule__XSetLiteral__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12160:1: ( rule__XSetLiteral__Group_3__1__Impl ) + // InternalExpression.g:12161:2: rule__XSetLiteral__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__1" + + + // $ANTLR start "rule__XSetLiteral__Group_3__1__Impl" + // InternalExpression.g:12167:1: rule__XSetLiteral__Group_3__1__Impl : ( ( rule__XSetLiteral__Group_3_1__0 )* ) ; + public final void rule__XSetLiteral__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12171:1: ( ( ( rule__XSetLiteral__Group_3_1__0 )* ) ) + // InternalExpression.g:12172:1: ( ( rule__XSetLiteral__Group_3_1__0 )* ) + { + // InternalExpression.g:12172:1: ( ( rule__XSetLiteral__Group_3_1__0 )* ) + // InternalExpression.g:12173:2: ( rule__XSetLiteral__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); + } + // InternalExpression.g:12174:2: ( rule__XSetLiteral__Group_3_1__0 )* + loop97: + do { + int alt97=2; + int LA97_0 = input.LA(1); + + if ( (LA97_0==78) ) { + alt97=1; + } + + + switch (alt97) { + case 1 : + // InternalExpression.g:12174:3: rule__XSetLiteral__Group_3_1__0 + { + pushFollow(FOLLOW_37); + rule__XSetLiteral__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop97; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__0" + // InternalExpression.g:12183:1: rule__XSetLiteral__Group_3_1__0 : rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ; + public final void rule__XSetLiteral__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12187:1: ( rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ) + // InternalExpression.g:12188:2: rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 + { + pushFollow(FOLLOW_77); + rule__XSetLiteral__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__0" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__0__Impl" + // InternalExpression.g:12195:1: rule__XSetLiteral__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XSetLiteral__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12199:1: ( ( ',' ) ) + // InternalExpression.g:12200:1: ( ',' ) + { + // InternalExpression.g:12200:1: ( ',' ) + // InternalExpression.g:12201:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__1" + // InternalExpression.g:12210:1: rule__XSetLiteral__Group_3_1__1 : rule__XSetLiteral__Group_3_1__1__Impl ; + public final void rule__XSetLiteral__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12214:1: ( rule__XSetLiteral__Group_3_1__1__Impl ) + // InternalExpression.g:12215:2: rule__XSetLiteral__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__1" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__1__Impl" + // InternalExpression.g:12221:1: rule__XSetLiteral__Group_3_1__1__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ; + public final void rule__XSetLiteral__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12225:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ) + // InternalExpression.g:12226:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) + { + // InternalExpression.g:12226:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) + // InternalExpression.g:12227:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); + } + // InternalExpression.g:12228:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) + // InternalExpression.g:12228:3: rule__XSetLiteral__ElementsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__ElementsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__0" + // InternalExpression.g:12237:1: rule__XListLiteral__Group__0 : rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ; + public final void rule__XListLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12241:1: ( rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ) + // InternalExpression.g:12242:2: rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 + { + pushFollow(FOLLOW_78); + rule__XListLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__0" + + + // $ANTLR start "rule__XListLiteral__Group__0__Impl" + // InternalExpression.g:12249:1: rule__XListLiteral__Group__0__Impl : ( () ) ; + public final void rule__XListLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12253:1: ( ( () ) ) + // InternalExpression.g:12254:1: ( () ) + { + // InternalExpression.g:12254:1: ( () ) + // InternalExpression.g:12255:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); + } + // InternalExpression.g:12256:2: () + // InternalExpression.g:12256:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__1" + // InternalExpression.g:12264:1: rule__XListLiteral__Group__1 : rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ; + public final void rule__XListLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12268:1: ( rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ) + // InternalExpression.g:12269:2: rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 + { + pushFollow(FOLLOW_43); + rule__XListLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__1" + + + // $ANTLR start "rule__XListLiteral__Group__1__Impl" + // InternalExpression.g:12276:1: rule__XListLiteral__Group__1__Impl : ( '#' ) ; + public final void rule__XListLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12280:1: ( ( '#' ) ) + // InternalExpression.g:12281:1: ( '#' ) + { + // InternalExpression.g:12281:1: ( '#' ) + // InternalExpression.g:12282:2: '#' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + match(input,87,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__2" + // InternalExpression.g:12291:1: rule__XListLiteral__Group__2 : rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ; + public final void rule__XListLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12295:1: ( rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ) + // InternalExpression.g:12296:2: rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 + { + pushFollow(FOLLOW_80); + rule__XListLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__2" + + + // $ANTLR start "rule__XListLiteral__Group__2__Impl" + // InternalExpression.g:12303:1: rule__XListLiteral__Group__2__Impl : ( '[' ) ; + public final void rule__XListLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12307:1: ( ( '[' ) ) + // InternalExpression.g:12308:1: ( '[' ) + { + // InternalExpression.g:12308:1: ( '[' ) + // InternalExpression.g:12309:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__3" + // InternalExpression.g:12318:1: rule__XListLiteral__Group__3 : rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ; + public final void rule__XListLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12322:1: ( rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ) + // InternalExpression.g:12323:2: rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 + { + pushFollow(FOLLOW_80); + rule__XListLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__3" + + + // $ANTLR start "rule__XListLiteral__Group__3__Impl" + // InternalExpression.g:12330:1: rule__XListLiteral__Group__3__Impl : ( ( rule__XListLiteral__Group_3__0 )? ) ; + public final void rule__XListLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12334:1: ( ( ( rule__XListLiteral__Group_3__0 )? ) ) + // InternalExpression.g:12335:1: ( ( rule__XListLiteral__Group_3__0 )? ) + { + // InternalExpression.g:12335:1: ( ( rule__XListLiteral__Group_3__0 )? ) + // InternalExpression.g:12336:2: ( rule__XListLiteral__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup_3()); + } + // InternalExpression.g:12337:2: ( rule__XListLiteral__Group_3__0 )? + int alt98=2; + int LA98_0 = input.LA(1); + + if ( ((LA98_0>=RULE_ID && LA98_0<=RULE_DECIMAL)||LA98_0==RULE_STRING||(LA98_0>=22 && LA98_0<=24)||LA98_0==27||(LA98_0>=36 && LA98_0<=37)||(LA98_0>=60 && LA98_0<=64)||LA98_0==67||LA98_0==70||(LA98_0>=73 && LA98_0<=74)||(LA98_0>=81 && LA98_0<=82)||LA98_0==87||(LA98_0>=89 && LA98_0<=96)||LA98_0==98) ) { + alt98=1; + } + switch (alt98) { + case 1 : + // InternalExpression.g:12337:3: rule__XListLiteral__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__4" + // InternalExpression.g:12345:1: rule__XListLiteral__Group__4 : rule__XListLiteral__Group__4__Impl ; + public final void rule__XListLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12349:1: ( rule__XListLiteral__Group__4__Impl ) + // InternalExpression.g:12350:2: rule__XListLiteral__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__4" + + + // $ANTLR start "rule__XListLiteral__Group__4__Impl" + // InternalExpression.g:12356:1: rule__XListLiteral__Group__4__Impl : ( ']' ) ; + public final void rule__XListLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12360:1: ( ( ']' ) ) + // InternalExpression.g:12361:1: ( ']' ) + { + // InternalExpression.g:12361:1: ( ']' ) + // InternalExpression.g:12362:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3__0" + // InternalExpression.g:12372:1: rule__XListLiteral__Group_3__0 : rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ; + public final void rule__XListLiteral__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12376:1: ( rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ) + // InternalExpression.g:12377:2: rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 + { + pushFollow(FOLLOW_36); + rule__XListLiteral__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__0" + + + // $ANTLR start "rule__XListLiteral__Group_3__0__Impl" + // InternalExpression.g:12384:1: rule__XListLiteral__Group_3__0__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ; + public final void rule__XListLiteral__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12388:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ) + // InternalExpression.g:12389:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) + { + // InternalExpression.g:12389:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) + // InternalExpression.g:12390:2: ( rule__XListLiteral__ElementsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); + } + // InternalExpression.g:12391:2: ( rule__XListLiteral__ElementsAssignment_3_0 ) + // InternalExpression.g:12391:3: rule__XListLiteral__ElementsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__ElementsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3__1" + // InternalExpression.g:12399:1: rule__XListLiteral__Group_3__1 : rule__XListLiteral__Group_3__1__Impl ; + public final void rule__XListLiteral__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12403:1: ( rule__XListLiteral__Group_3__1__Impl ) + // InternalExpression.g:12404:2: rule__XListLiteral__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__1" + + + // $ANTLR start "rule__XListLiteral__Group_3__1__Impl" + // InternalExpression.g:12410:1: rule__XListLiteral__Group_3__1__Impl : ( ( rule__XListLiteral__Group_3_1__0 )* ) ; + public final void rule__XListLiteral__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12414:1: ( ( ( rule__XListLiteral__Group_3_1__0 )* ) ) + // InternalExpression.g:12415:1: ( ( rule__XListLiteral__Group_3_1__0 )* ) + { + // InternalExpression.g:12415:1: ( ( rule__XListLiteral__Group_3_1__0 )* ) + // InternalExpression.g:12416:2: ( rule__XListLiteral__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); + } + // InternalExpression.g:12417:2: ( rule__XListLiteral__Group_3_1__0 )* + loop99: + do { + int alt99=2; + int LA99_0 = input.LA(1); + + if ( (LA99_0==78) ) { + alt99=1; + } + + + switch (alt99) { + case 1 : + // InternalExpression.g:12417:3: rule__XListLiteral__Group_3_1__0 + { + pushFollow(FOLLOW_37); + rule__XListLiteral__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop99; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__0" + // InternalExpression.g:12426:1: rule__XListLiteral__Group_3_1__0 : rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ; + public final void rule__XListLiteral__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12430:1: ( rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ) + // InternalExpression.g:12431:2: rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 + { + pushFollow(FOLLOW_77); + rule__XListLiteral__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__0" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__0__Impl" + // InternalExpression.g:12438:1: rule__XListLiteral__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XListLiteral__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12442:1: ( ( ',' ) ) + // InternalExpression.g:12443:1: ( ',' ) + { + // InternalExpression.g:12443:1: ( ',' ) + // InternalExpression.g:12444:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__1" + // InternalExpression.g:12453:1: rule__XListLiteral__Group_3_1__1 : rule__XListLiteral__Group_3_1__1__Impl ; + public final void rule__XListLiteral__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12457:1: ( rule__XListLiteral__Group_3_1__1__Impl ) + // InternalExpression.g:12458:2: rule__XListLiteral__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__1" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__1__Impl" + // InternalExpression.g:12464:1: rule__XListLiteral__Group_3_1__1__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ; + public final void rule__XListLiteral__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12468:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ) + // InternalExpression.g:12469:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) + { + // InternalExpression.g:12469:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) + // InternalExpression.g:12470:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); + } + // InternalExpression.g:12471:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 ) + // InternalExpression.g:12471:3: rule__XListLiteral__ElementsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__ElementsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XClosure__Group__0" + // InternalExpression.g:12480:1: rule__XClosure__Group__0 : rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ; + public final void rule__XClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12484:1: ( rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ) + // InternalExpression.g:12485:2: rule__XClosure__Group__0__Impl rule__XClosure__Group__1 + { + pushFollow(FOLLOW_81); + rule__XClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__0" + + + // $ANTLR start "rule__XClosure__Group__0__Impl" + // InternalExpression.g:12492:1: rule__XClosure__Group__0__Impl : ( ( rule__XClosure__Group_0__0 ) ) ; + public final void rule__XClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12496:1: ( ( ( rule__XClosure__Group_0__0 ) ) ) + // InternalExpression.g:12497:1: ( ( rule__XClosure__Group_0__0 ) ) + { + // InternalExpression.g:12497:1: ( ( rule__XClosure__Group_0__0 ) ) + // InternalExpression.g:12498:2: ( rule__XClosure__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_0()); + } + // InternalExpression.g:12499:2: ( rule__XClosure__Group_0__0 ) + // InternalExpression.g:12499:3: rule__XClosure__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__0__Impl" + + + // $ANTLR start "rule__XClosure__Group__1" + // InternalExpression.g:12507:1: rule__XClosure__Group__1 : rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ; + public final void rule__XClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12511:1: ( rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ) + // InternalExpression.g:12512:2: rule__XClosure__Group__1__Impl rule__XClosure__Group__2 + { + pushFollow(FOLLOW_81); + rule__XClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__1" + + + // $ANTLR start "rule__XClosure__Group__1__Impl" + // InternalExpression.g:12519:1: rule__XClosure__Group__1__Impl : ( ( rule__XClosure__Group_1__0 )? ) ; + public final void rule__XClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12523:1: ( ( ( rule__XClosure__Group_1__0 )? ) ) + // InternalExpression.g:12524:1: ( ( rule__XClosure__Group_1__0 )? ) + { + // InternalExpression.g:12524:1: ( ( rule__XClosure__Group_1__0 )? ) + // InternalExpression.g:12525:2: ( rule__XClosure__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1()); + } + // InternalExpression.g:12526:2: ( rule__XClosure__Group_1__0 )? + int alt100=2; + alt100 = dfa100.predict(input); + switch (alt100) { + case 1 : + // InternalExpression.g:12526:3: rule__XClosure__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__1__Impl" + + + // $ANTLR start "rule__XClosure__Group__2" + // InternalExpression.g:12534:1: rule__XClosure__Group__2 : rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ; + public final void rule__XClosure__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12538:1: ( rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ) + // InternalExpression.g:12539:2: rule__XClosure__Group__2__Impl rule__XClosure__Group__3 + { + pushFollow(FOLLOW_44); + rule__XClosure__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__2" + + + // $ANTLR start "rule__XClosure__Group__2__Impl" + // InternalExpression.g:12546:1: rule__XClosure__Group__2__Impl : ( ( rule__XClosure__ExpressionAssignment_2 ) ) ; + public final void rule__XClosure__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12550:1: ( ( ( rule__XClosure__ExpressionAssignment_2 ) ) ) + // InternalExpression.g:12551:1: ( ( rule__XClosure__ExpressionAssignment_2 ) ) + { + // InternalExpression.g:12551:1: ( ( rule__XClosure__ExpressionAssignment_2 ) ) + // InternalExpression.g:12552:2: ( rule__XClosure__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); + } + // InternalExpression.g:12553:2: ( rule__XClosure__ExpressionAssignment_2 ) + // InternalExpression.g:12553:3: rule__XClosure__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XClosure__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__2__Impl" + + + // $ANTLR start "rule__XClosure__Group__3" + // InternalExpression.g:12561:1: rule__XClosure__Group__3 : rule__XClosure__Group__3__Impl ; + public final void rule__XClosure__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12565:1: ( rule__XClosure__Group__3__Impl ) + // InternalExpression.g:12566:2: rule__XClosure__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__3" + + + // $ANTLR start "rule__XClosure__Group__3__Impl" + // InternalExpression.g:12572:1: rule__XClosure__Group__3__Impl : ( ']' ) ; + public final void rule__XClosure__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12576:1: ( ( ']' ) ) + // InternalExpression.g:12577:1: ( ']' ) + { + // InternalExpression.g:12577:1: ( ']' ) + // InternalExpression.g:12578:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__3__Impl" + + + // $ANTLR start "rule__XClosure__Group_0__0" + // InternalExpression.g:12588:1: rule__XClosure__Group_0__0 : rule__XClosure__Group_0__0__Impl ; + public final void rule__XClosure__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12592:1: ( rule__XClosure__Group_0__0__Impl ) + // InternalExpression.g:12593:2: rule__XClosure__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0__0" + + + // $ANTLR start "rule__XClosure__Group_0__0__Impl" + // InternalExpression.g:12599:1: rule__XClosure__Group_0__0__Impl : ( ( rule__XClosure__Group_0_0__0 ) ) ; + public final void rule__XClosure__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12603:1: ( ( ( rule__XClosure__Group_0_0__0 ) ) ) + // InternalExpression.g:12604:1: ( ( rule__XClosure__Group_0_0__0 ) ) + { + // InternalExpression.g:12604:1: ( ( rule__XClosure__Group_0_0__0 ) ) + // InternalExpression.g:12605:2: ( rule__XClosure__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_0_0()); + } + // InternalExpression.g:12606:2: ( rule__XClosure__Group_0_0__0 ) + // InternalExpression.g:12606:3: rule__XClosure__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_0_0__0" + // InternalExpression.g:12615:1: rule__XClosure__Group_0_0__0 : rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ; + public final void rule__XClosure__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12619:1: ( rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ) + // InternalExpression.g:12620:2: rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 + { + pushFollow(FOLLOW_43); + rule__XClosure__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__0" + + + // $ANTLR start "rule__XClosure__Group_0_0__0__Impl" + // InternalExpression.g:12627:1: rule__XClosure__Group_0_0__0__Impl : ( () ) ; + public final void rule__XClosure__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12631:1: ( ( () ) ) + // InternalExpression.g:12632:1: ( () ) + { + // InternalExpression.g:12632:1: ( () ) + // InternalExpression.g:12633:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); + } + // InternalExpression.g:12634:2: () + // InternalExpression.g:12634:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_0_0__1" + // InternalExpression.g:12642:1: rule__XClosure__Group_0_0__1 : rule__XClosure__Group_0_0__1__Impl ; + public final void rule__XClosure__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12646:1: ( rule__XClosure__Group_0_0__1__Impl ) + // InternalExpression.g:12647:2: rule__XClosure__Group_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__1" + + + // $ANTLR start "rule__XClosure__Group_0_0__1__Impl" + // InternalExpression.g:12653:1: rule__XClosure__Group_0_0__1__Impl : ( '[' ) ; + public final void rule__XClosure__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12657:1: ( ( '[' ) ) + // InternalExpression.g:12658:1: ( '[' ) + { + // InternalExpression.g:12658:1: ( '[' ) + // InternalExpression.g:12659:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1__0" + // InternalExpression.g:12669:1: rule__XClosure__Group_1__0 : rule__XClosure__Group_1__0__Impl ; + public final void rule__XClosure__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12673:1: ( rule__XClosure__Group_1__0__Impl ) + // InternalExpression.g:12674:2: rule__XClosure__Group_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1__0" + + + // $ANTLR start "rule__XClosure__Group_1__0__Impl" + // InternalExpression.g:12680:1: rule__XClosure__Group_1__0__Impl : ( ( rule__XClosure__Group_1_0__0 ) ) ; + public final void rule__XClosure__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12684:1: ( ( ( rule__XClosure__Group_1_0__0 ) ) ) + // InternalExpression.g:12685:1: ( ( rule__XClosure__Group_1_0__0 ) ) + { + // InternalExpression.g:12685:1: ( ( rule__XClosure__Group_1_0__0 ) ) + // InternalExpression.g:12686:2: ( rule__XClosure__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0()); + } + // InternalExpression.g:12687:2: ( rule__XClosure__Group_1_0__0 ) + // InternalExpression.g:12687:3: rule__XClosure__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0__0" + // InternalExpression.g:12696:1: rule__XClosure__Group_1_0__0 : rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ; + public final void rule__XClosure__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12700:1: ( rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ) + // InternalExpression.g:12701:2: rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 + { + pushFollow(FOLLOW_82); + rule__XClosure__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__0" + + + // $ANTLR start "rule__XClosure__Group_1_0__0__Impl" + // InternalExpression.g:12708:1: rule__XClosure__Group_1_0__0__Impl : ( ( rule__XClosure__Group_1_0_0__0 )? ) ; + public final void rule__XClosure__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12712:1: ( ( ( rule__XClosure__Group_1_0_0__0 )? ) ) + // InternalExpression.g:12713:1: ( ( rule__XClosure__Group_1_0_0__0 )? ) + { + // InternalExpression.g:12713:1: ( ( rule__XClosure__Group_1_0_0__0 )? ) + // InternalExpression.g:12714:2: ( rule__XClosure__Group_1_0_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); + } + // InternalExpression.g:12715:2: ( rule__XClosure__Group_1_0_0__0 )? + int alt101=2; + int LA101_0 = input.LA(1); + + if ( (LA101_0==RULE_ID||LA101_0==51||LA101_0==67) ) { + alt101=1; + } + switch (alt101) { + case 1 : + // InternalExpression.g:12715:3: rule__XClosure__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0__1" + // InternalExpression.g:12723:1: rule__XClosure__Group_1_0__1 : rule__XClosure__Group_1_0__1__Impl ; + public final void rule__XClosure__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12727:1: ( rule__XClosure__Group_1_0__1__Impl ) + // InternalExpression.g:12728:2: rule__XClosure__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__1" + + + // $ANTLR start "rule__XClosure__Group_1_0__1__Impl" + // InternalExpression.g:12734:1: rule__XClosure__Group_1_0__1__Impl : ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ; + public final void rule__XClosure__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12738:1: ( ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ) + // InternalExpression.g:12739:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) + { + // InternalExpression.g:12739:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) + // InternalExpression.g:12740:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); + } + // InternalExpression.g:12741:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) + // InternalExpression.g:12741:3: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XClosure__ExplicitSyntaxAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__0" + // InternalExpression.g:12750:1: rule__XClosure__Group_1_0_0__0 : rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ; + public final void rule__XClosure__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12754:1: ( rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ) + // InternalExpression.g:12755:2: rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 + { + pushFollow(FOLLOW_36); + rule__XClosure__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__0" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__0__Impl" + // InternalExpression.g:12762:1: rule__XClosure__Group_1_0_0__0__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ; + public final void rule__XClosure__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12766:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ) + // InternalExpression.g:12767:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) + { + // InternalExpression.g:12767:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) + // InternalExpression.g:12768:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); + } + // InternalExpression.g:12769:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) + // InternalExpression.g:12769:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__1" + // InternalExpression.g:12777:1: rule__XClosure__Group_1_0_0__1 : rule__XClosure__Group_1_0_0__1__Impl ; + public final void rule__XClosure__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12781:1: ( rule__XClosure__Group_1_0_0__1__Impl ) + // InternalExpression.g:12782:2: rule__XClosure__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__1" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__1__Impl" + // InternalExpression.g:12788:1: rule__XClosure__Group_1_0_0__1__Impl : ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ; + public final void rule__XClosure__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12792:1: ( ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ) + // InternalExpression.g:12793:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* ) + { + // InternalExpression.g:12793:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* ) + // InternalExpression.g:12794:2: ( rule__XClosure__Group_1_0_0_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); + } + // InternalExpression.g:12795:2: ( rule__XClosure__Group_1_0_0_1__0 )* + loop102: + do { + int alt102=2; + int LA102_0 = input.LA(1); + + if ( (LA102_0==78) ) { + alt102=1; + } + + + switch (alt102) { + case 1 : + // InternalExpression.g:12795:3: rule__XClosure__Group_1_0_0_1__0 + { + pushFollow(FOLLOW_37); + rule__XClosure__Group_1_0_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop102; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__0" + // InternalExpression.g:12804:1: rule__XClosure__Group_1_0_0_1__0 : rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ; + public final void rule__XClosure__Group_1_0_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12808:1: ( rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ) + // InternalExpression.g:12809:2: rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 + { + pushFollow(FOLLOW_56); + rule__XClosure__Group_1_0_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__0" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__0__Impl" + // InternalExpression.g:12816:1: rule__XClosure__Group_1_0_0_1__0__Impl : ( ',' ) ; + public final void rule__XClosure__Group_1_0_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12820:1: ( ( ',' ) ) + // InternalExpression.g:12821:1: ( ',' ) + { + // InternalExpression.g:12821:1: ( ',' ) + // InternalExpression.g:12822:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__1" + // InternalExpression.g:12831:1: rule__XClosure__Group_1_0_0_1__1 : rule__XClosure__Group_1_0_0_1__1__Impl ; + public final void rule__XClosure__Group_1_0_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12835:1: ( rule__XClosure__Group_1_0_0_1__1__Impl ) + // InternalExpression.g:12836:2: rule__XClosure__Group_1_0_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__1" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__1__Impl" + // InternalExpression.g:12842:1: rule__XClosure__Group_1_0_0_1__1__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ; + public final void rule__XClosure__Group_1_0_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12846:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ) + // InternalExpression.g:12847:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) + { + // InternalExpression.g:12847:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) + // InternalExpression.g:12848:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); + } + // InternalExpression.g:12849:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) + // InternalExpression.g:12849:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__1__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group__0" + // InternalExpression.g:12858:1: rule__XExpressionInClosure__Group__0 : rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ; + public final void rule__XExpressionInClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12862:1: ( rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ) + // InternalExpression.g:12863:2: rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 + { + pushFollow(FOLLOW_81); + rule__XExpressionInClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__0" + + + // $ANTLR start "rule__XExpressionInClosure__Group__0__Impl" + // InternalExpression.g:12870:1: rule__XExpressionInClosure__Group__0__Impl : ( () ) ; + public final void rule__XExpressionInClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12874:1: ( ( () ) ) + // InternalExpression.g:12875:1: ( () ) + { + // InternalExpression.g:12875:1: ( () ) + // InternalExpression.g:12876:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); + } + // InternalExpression.g:12877:2: () + // InternalExpression.g:12877:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__0__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group__1" + // InternalExpression.g:12885:1: rule__XExpressionInClosure__Group__1 : rule__XExpressionInClosure__Group__1__Impl ; + public final void rule__XExpressionInClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12889:1: ( rule__XExpressionInClosure__Group__1__Impl ) + // InternalExpression.g:12890:2: rule__XExpressionInClosure__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__1" + + + // $ANTLR start "rule__XExpressionInClosure__Group__1__Impl" + // InternalExpression.g:12896:1: rule__XExpressionInClosure__Group__1__Impl : ( ( rule__XExpressionInClosure__Group_1__0 )* ) ; + public final void rule__XExpressionInClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12900:1: ( ( ( rule__XExpressionInClosure__Group_1__0 )* ) ) + // InternalExpression.g:12901:1: ( ( rule__XExpressionInClosure__Group_1__0 )* ) + { + // InternalExpression.g:12901:1: ( ( rule__XExpressionInClosure__Group_1__0 )* ) + // InternalExpression.g:12902:2: ( rule__XExpressionInClosure__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); + } + // InternalExpression.g:12903:2: ( rule__XExpressionInClosure__Group_1__0 )* + loop103: + do { + int alt103=2; + int LA103_0 = input.LA(1); + + if ( ((LA103_0>=RULE_ID && LA103_0<=RULE_DECIMAL)||LA103_0==RULE_STRING||(LA103_0>=22 && LA103_0<=24)||LA103_0==27||(LA103_0>=36 && LA103_0<=37)||(LA103_0>=59 && LA103_0<=64)||LA103_0==67||LA103_0==70||(LA103_0>=73 && LA103_0<=74)||(LA103_0>=81 && LA103_0<=82)||LA103_0==87||(LA103_0>=89 && LA103_0<=96)||LA103_0==98||LA103_0==104) ) { + alt103=1; + } + + + switch (alt103) { + case 1 : + // InternalExpression.g:12903:3: rule__XExpressionInClosure__Group_1__0 + { + pushFollow(FOLLOW_83); + rule__XExpressionInClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop103; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__1__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__0" + // InternalExpression.g:12912:1: rule__XExpressionInClosure__Group_1__0 : rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ; + public final void rule__XExpressionInClosure__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12916:1: ( rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ) + // InternalExpression.g:12917:2: rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 + { + pushFollow(FOLLOW_84); + rule__XExpressionInClosure__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__0" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__0__Impl" + // InternalExpression.g:12924:1: rule__XExpressionInClosure__Group_1__0__Impl : ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ; + public final void rule__XExpressionInClosure__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12928:1: ( ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ) + // InternalExpression.g:12929:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) + { + // InternalExpression.g:12929:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) + // InternalExpression.g:12930:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); + } + // InternalExpression.g:12931:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) + // InternalExpression.g:12931:3: rule__XExpressionInClosure__ExpressionsAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__ExpressionsAssignment_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__0__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__1" + // InternalExpression.g:12939:1: rule__XExpressionInClosure__Group_1__1 : rule__XExpressionInClosure__Group_1__1__Impl ; + public final void rule__XExpressionInClosure__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12943:1: ( rule__XExpressionInClosure__Group_1__1__Impl ) + // InternalExpression.g:12944:2: rule__XExpressionInClosure__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__1" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__1__Impl" + // InternalExpression.g:12950:1: rule__XExpressionInClosure__Group_1__1__Impl : ( ( ';' )? ) ; + public final void rule__XExpressionInClosure__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12954:1: ( ( ( ';' )? ) ) + // InternalExpression.g:12955:1: ( ( ';' )? ) + { + // InternalExpression.g:12955:1: ( ( ';' )? ) + // InternalExpression.g:12956:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + // InternalExpression.g:12957:2: ( ';' )? + int alt104=2; + int LA104_0 = input.LA(1); + + if ( (LA104_0==88) ) { + alt104=1; + } + switch (alt104) { + case 1 : + // InternalExpression.g:12957:3: ';' + { + match(input,88,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group__0" + // InternalExpression.g:12966:1: rule__XShortClosure__Group__0 : rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ; + public final void rule__XShortClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12970:1: ( rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ) + // InternalExpression.g:12971:2: rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 + { + pushFollow(FOLLOW_77); + rule__XShortClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__0" + + + // $ANTLR start "rule__XShortClosure__Group__0__Impl" + // InternalExpression.g:12978:1: rule__XShortClosure__Group__0__Impl : ( ( rule__XShortClosure__Group_0__0 ) ) ; + public final void rule__XShortClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12982:1: ( ( ( rule__XShortClosure__Group_0__0 ) ) ) + // InternalExpression.g:12983:1: ( ( rule__XShortClosure__Group_0__0 ) ) + { + // InternalExpression.g:12983:1: ( ( rule__XShortClosure__Group_0__0 ) ) + // InternalExpression.g:12984:2: ( rule__XShortClosure__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0()); + } + // InternalExpression.g:12985:2: ( rule__XShortClosure__Group_0__0 ) + // InternalExpression.g:12985:3: rule__XShortClosure__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group__1" + // InternalExpression.g:12993:1: rule__XShortClosure__Group__1 : rule__XShortClosure__Group__1__Impl ; + public final void rule__XShortClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:12997:1: ( rule__XShortClosure__Group__1__Impl ) + // InternalExpression.g:12998:2: rule__XShortClosure__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__1" + + + // $ANTLR start "rule__XShortClosure__Group__1__Impl" + // InternalExpression.g:13004:1: rule__XShortClosure__Group__1__Impl : ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ; + public final void rule__XShortClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13008:1: ( ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ) + // InternalExpression.g:13009:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) + { + // InternalExpression.g:13009:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) + // InternalExpression.g:13010:2: ( rule__XShortClosure__ExpressionAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); + } + // InternalExpression.g:13011:2: ( rule__XShortClosure__ExpressionAssignment_1 ) + // InternalExpression.g:13011:3: rule__XShortClosure__ExpressionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__ExpressionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0__0" + // InternalExpression.g:13020:1: rule__XShortClosure__Group_0__0 : rule__XShortClosure__Group_0__0__Impl ; + public final void rule__XShortClosure__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13024:1: ( rule__XShortClosure__Group_0__0__Impl ) + // InternalExpression.g:13025:2: rule__XShortClosure__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0__0" + + + // $ANTLR start "rule__XShortClosure__Group_0__0__Impl" + // InternalExpression.g:13031:1: rule__XShortClosure__Group_0__0__Impl : ( ( rule__XShortClosure__Group_0_0__0 ) ) ; + public final void rule__XShortClosure__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13035:1: ( ( ( rule__XShortClosure__Group_0_0__0 ) ) ) + // InternalExpression.g:13036:1: ( ( rule__XShortClosure__Group_0_0__0 ) ) + { + // InternalExpression.g:13036:1: ( ( rule__XShortClosure__Group_0_0__0 ) ) + // InternalExpression.g:13037:2: ( rule__XShortClosure__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); + } + // InternalExpression.g:13038:2: ( rule__XShortClosure__Group_0_0__0 ) + // InternalExpression.g:13038:3: rule__XShortClosure__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__0" + // InternalExpression.g:13047:1: rule__XShortClosure__Group_0_0__0 : rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ; + public final void rule__XShortClosure__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13051:1: ( rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ) + // InternalExpression.g:13052:2: rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 + { + pushFollow(FOLLOW_82); + rule__XShortClosure__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__0__Impl" + // InternalExpression.g:13059:1: rule__XShortClosure__Group_0_0__0__Impl : ( () ) ; + public final void rule__XShortClosure__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13063:1: ( ( () ) ) + // InternalExpression.g:13064:1: ( () ) + { + // InternalExpression.g:13064:1: ( () ) + // InternalExpression.g:13065:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); + } + // InternalExpression.g:13066:2: () + // InternalExpression.g:13066:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__1" + // InternalExpression.g:13074:1: rule__XShortClosure__Group_0_0__1 : rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ; + public final void rule__XShortClosure__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13078:1: ( rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ) + // InternalExpression.g:13079:2: rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 + { + pushFollow(FOLLOW_82); + rule__XShortClosure__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__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__XShortClosure__Group_0_0__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__1__Impl" + // InternalExpression.g:13086:1: rule__XShortClosure__Group_0_0__1__Impl : ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ; + public final void rule__XShortClosure__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13090:1: ( ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ) + // InternalExpression.g:13091:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? ) + { + // InternalExpression.g:13091:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? ) + // InternalExpression.g:13092:2: ( rule__XShortClosure__Group_0_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); + } + // InternalExpression.g:13093:2: ( rule__XShortClosure__Group_0_0_1__0 )? + int alt105=2; + int LA105_0 = input.LA(1); + + if ( (LA105_0==RULE_ID||LA105_0==51||LA105_0==67) ) { + alt105=1; + } + switch (alt105) { + case 1 : + // InternalExpression.g:13093:3: rule__XShortClosure__Group_0_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__2" + // InternalExpression.g:13101:1: rule__XShortClosure__Group_0_0__2 : rule__XShortClosure__Group_0_0__2__Impl ; + public final void rule__XShortClosure__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13105:1: ( rule__XShortClosure__Group_0_0__2__Impl ) + // InternalExpression.g:13106:2: rule__XShortClosure__Group_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__2" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__2__Impl" + // InternalExpression.g:13112:1: rule__XShortClosure__Group_0_0__2__Impl : ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ; + public final void rule__XShortClosure__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13116:1: ( ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ) + // InternalExpression.g:13117:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) + { + // InternalExpression.g:13117:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) + // InternalExpression.g:13118:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); + } + // InternalExpression.g:13119:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) + // InternalExpression.g:13119:3: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__0" + // InternalExpression.g:13128:1: rule__XShortClosure__Group_0_0_1__0 : rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ; + public final void rule__XShortClosure__Group_0_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13132:1: ( rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ) + // InternalExpression.g:13133:2: rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 + { + pushFollow(FOLLOW_36); + rule__XShortClosure__Group_0_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__0__Impl" + // InternalExpression.g:13140:1: rule__XShortClosure__Group_0_0_1__0__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ; + public final void rule__XShortClosure__Group_0_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13144:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ) + // InternalExpression.g:13145:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) + { + // InternalExpression.g:13145:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) + // InternalExpression.g:13146:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); + } + // InternalExpression.g:13147:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) + // InternalExpression.g:13147:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__1" + // InternalExpression.g:13155:1: rule__XShortClosure__Group_0_0_1__1 : rule__XShortClosure__Group_0_0_1__1__Impl ; + public final void rule__XShortClosure__Group_0_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13159:1: ( rule__XShortClosure__Group_0_0_1__1__Impl ) + // InternalExpression.g:13160:2: rule__XShortClosure__Group_0_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__1__Impl" + // InternalExpression.g:13166:1: rule__XShortClosure__Group_0_0_1__1__Impl : ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ; + public final void rule__XShortClosure__Group_0_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13170:1: ( ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ) + // InternalExpression.g:13171:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) + { + // InternalExpression.g:13171:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) + // InternalExpression.g:13172:2: ( rule__XShortClosure__Group_0_0_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); + } + // InternalExpression.g:13173:2: ( rule__XShortClosure__Group_0_0_1_1__0 )* + loop106: + do { + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==78) ) { + alt106=1; + } + + + switch (alt106) { + case 1 : + // InternalExpression.g:13173:3: rule__XShortClosure__Group_0_0_1_1__0 + { + pushFollow(FOLLOW_37); + rule__XShortClosure__Group_0_0_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop106; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0" + // InternalExpression.g:13182:1: rule__XShortClosure__Group_0_0_1_1__0 : rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ; + public final void rule__XShortClosure__Group_0_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13186:1: ( rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ) + // InternalExpression.g:13187:2: rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 + { + pushFollow(FOLLOW_56); + rule__XShortClosure__Group_0_0_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0__Impl" + // InternalExpression.g:13194:1: rule__XShortClosure__Group_0_0_1_1__0__Impl : ( ',' ) ; + public final void rule__XShortClosure__Group_0_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13198:1: ( ( ',' ) ) + // InternalExpression.g:13199:1: ( ',' ) + { + // InternalExpression.g:13199:1: ( ',' ) + // InternalExpression.g:13200:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1" + // InternalExpression.g:13209:1: rule__XShortClosure__Group_0_0_1_1__1 : rule__XShortClosure__Group_0_0_1_1__1__Impl ; + public final void rule__XShortClosure__Group_0_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13213:1: ( rule__XShortClosure__Group_0_0_1_1__1__Impl ) + // InternalExpression.g:13214:2: rule__XShortClosure__Group_0_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1__Impl" + // InternalExpression.g:13220:1: rule__XShortClosure__Group_0_0_1_1__1__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ; + public final void rule__XShortClosure__Group_0_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13224:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ) + // InternalExpression.g:13225:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) + { + // InternalExpression.g:13225:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) + // InternalExpression.g:13226:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); + } + // InternalExpression.g:13227:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) + // InternalExpression.g:13227:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__0" + // InternalExpression.g:13236:1: rule__XParenthesizedExpression__Group__0 : rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ; + public final void rule__XParenthesizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13240:1: ( rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ) + // InternalExpression.g:13241:2: rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 + { + pushFollow(FOLLOW_77); + rule__XParenthesizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__0" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__0__Impl" + // InternalExpression.g:13248:1: rule__XParenthesizedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__XParenthesizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13252:1: ( ( '(' ) ) + // InternalExpression.g:13253:1: ( '(' ) + { + // InternalExpression.g:13253:1: ( '(' ) + // InternalExpression.g:13254:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__1" + // InternalExpression.g:13263:1: rule__XParenthesizedExpression__Group__1 : rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ; + public final void rule__XParenthesizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13267:1: ( rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ) + // InternalExpression.g:13268:2: rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 + { + pushFollow(FOLLOW_9); + rule__XParenthesizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__1" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__1__Impl" + // InternalExpression.g:13275:1: rule__XParenthesizedExpression__Group__1__Impl : ( ruleXExpression ) ; + public final void rule__XParenthesizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13279:1: ( ( ruleXExpression ) ) + // InternalExpression.g:13280:1: ( ruleXExpression ) + { + // InternalExpression.g:13280:1: ( ruleXExpression ) + // InternalExpression.g:13281:2: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__2" + // InternalExpression.g:13290:1: rule__XParenthesizedExpression__Group__2 : rule__XParenthesizedExpression__Group__2__Impl ; + public final void rule__XParenthesizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13294:1: ( rule__XParenthesizedExpression__Group__2__Impl ) + // InternalExpression.g:13295:2: rule__XParenthesizedExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__2" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__2__Impl" + // InternalExpression.g:13301:1: rule__XParenthesizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XParenthesizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13305:1: ( ( ')' ) ) + // InternalExpression.g:13306:1: ( ')' ) + { + // InternalExpression.g:13306:1: ( ')' ) + // InternalExpression.g:13307:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__0" + // InternalExpression.g:13317:1: rule__XIfExpression__Group__0 : rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ; + public final void rule__XIfExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13321:1: ( rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ) + // InternalExpression.g:13322:2: rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 + { + pushFollow(FOLLOW_85); + rule__XIfExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__0" + + + // $ANTLR start "rule__XIfExpression__Group__0__Impl" + // InternalExpression.g:13329:1: rule__XIfExpression__Group__0__Impl : ( () ) ; + public final void rule__XIfExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13333:1: ( ( () ) ) + // InternalExpression.g:13334:1: ( () ) + { + // InternalExpression.g:13334:1: ( () ) + // InternalExpression.g:13335:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); + } + // InternalExpression.g:13336:2: () + // InternalExpression.g:13336:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__0__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__1" + // InternalExpression.g:13344:1: rule__XIfExpression__Group__1 : rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ; + public final void rule__XIfExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13348:1: ( rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ) + // InternalExpression.g:13349:2: rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 + { + pushFollow(FOLLOW_34); + rule__XIfExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__1" + + + // $ANTLR start "rule__XIfExpression__Group__1__Impl" + // InternalExpression.g:13356:1: rule__XIfExpression__Group__1__Impl : ( 'if' ) ; + public final void rule__XIfExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13360:1: ( ( 'if' ) ) + // InternalExpression.g:13361:1: ( 'if' ) + { + // InternalExpression.g:13361:1: ( 'if' ) + // InternalExpression.g:13362:2: 'if' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + match(input,70,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__1__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__2" + // InternalExpression.g:13371:1: rule__XIfExpression__Group__2 : rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ; + public final void rule__XIfExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13375:1: ( rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ) + // InternalExpression.g:13376:2: rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 + { + pushFollow(FOLLOW_77); + rule__XIfExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__2" + + + // $ANTLR start "rule__XIfExpression__Group__2__Impl" + // InternalExpression.g:13383:1: rule__XIfExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XIfExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13387:1: ( ( '(' ) ) + // InternalExpression.g:13388:1: ( '(' ) + { + // InternalExpression.g:13388:1: ( '(' ) + // InternalExpression.g:13389:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__2__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__3" + // InternalExpression.g:13398:1: rule__XIfExpression__Group__3 : rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ; + public final void rule__XIfExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13402:1: ( rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ) + // InternalExpression.g:13403:2: rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 + { + pushFollow(FOLLOW_9); + rule__XIfExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__3" + + + // $ANTLR start "rule__XIfExpression__Group__3__Impl" + // InternalExpression.g:13410:1: rule__XIfExpression__Group__3__Impl : ( ( rule__XIfExpression__IfAssignment_3 ) ) ; + public final void rule__XIfExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13414:1: ( ( ( rule__XIfExpression__IfAssignment_3 ) ) ) + // InternalExpression.g:13415:1: ( ( rule__XIfExpression__IfAssignment_3 ) ) + { + // InternalExpression.g:13415:1: ( ( rule__XIfExpression__IfAssignment_3 ) ) + // InternalExpression.g:13416:2: ( rule__XIfExpression__IfAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); + } + // InternalExpression.g:13417:2: ( rule__XIfExpression__IfAssignment_3 ) + // InternalExpression.g:13417:3: rule__XIfExpression__IfAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__IfAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__3__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__4" + // InternalExpression.g:13425:1: rule__XIfExpression__Group__4 : rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ; + public final void rule__XIfExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13429:1: ( rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ) + // InternalExpression.g:13430:2: rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 + { + pushFollow(FOLLOW_77); + rule__XIfExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__4" + + + // $ANTLR start "rule__XIfExpression__Group__4__Impl" + // InternalExpression.g:13437:1: rule__XIfExpression__Group__4__Impl : ( ')' ) ; + public final void rule__XIfExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13441:1: ( ( ')' ) ) + // InternalExpression.g:13442:1: ( ')' ) + { + // InternalExpression.g:13442:1: ( ')' ) + // InternalExpression.g:13443:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__4__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__5" + // InternalExpression.g:13452:1: rule__XIfExpression__Group__5 : rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ; + public final void rule__XIfExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13456:1: ( rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ) + // InternalExpression.g:13457:2: rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 + { + pushFollow(FOLLOW_14); + rule__XIfExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__5" + + + // $ANTLR start "rule__XIfExpression__Group__5__Impl" + // InternalExpression.g:13464:1: rule__XIfExpression__Group__5__Impl : ( ( rule__XIfExpression__ThenAssignment_5 ) ) ; + public final void rule__XIfExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13468:1: ( ( ( rule__XIfExpression__ThenAssignment_5 ) ) ) + // InternalExpression.g:13469:1: ( ( rule__XIfExpression__ThenAssignment_5 ) ) + { + // InternalExpression.g:13469:1: ( ( rule__XIfExpression__ThenAssignment_5 ) ) + // InternalExpression.g:13470:2: ( rule__XIfExpression__ThenAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); + } + // InternalExpression.g:13471:2: ( rule__XIfExpression__ThenAssignment_5 ) + // InternalExpression.g:13471:3: rule__XIfExpression__ThenAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__ThenAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__5__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__6" + // InternalExpression.g:13479:1: rule__XIfExpression__Group__6 : rule__XIfExpression__Group__6__Impl ; + public final void rule__XIfExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13483:1: ( rule__XIfExpression__Group__6__Impl ) + // InternalExpression.g:13484:2: rule__XIfExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__6" + + + // $ANTLR start "rule__XIfExpression__Group__6__Impl" + // InternalExpression.g:13490:1: rule__XIfExpression__Group__6__Impl : ( ( rule__XIfExpression__Group_6__0 )? ) ; + public final void rule__XIfExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13494:1: ( ( ( rule__XIfExpression__Group_6__0 )? ) ) + // InternalExpression.g:13495:1: ( ( rule__XIfExpression__Group_6__0 )? ) + { + // InternalExpression.g:13495:1: ( ( rule__XIfExpression__Group_6__0 )? ) + // InternalExpression.g:13496:2: ( rule__XIfExpression__Group_6__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getGroup_6()); + } + // InternalExpression.g:13497:2: ( rule__XIfExpression__Group_6__0 )? + int alt107=2; + int LA107_0 = input.LA(1); + + if ( (LA107_0==72) ) { + int LA107_1 = input.LA(2); + + if ( (synpred180_InternalExpression()) ) { + alt107=1; + } + } + switch (alt107) { + case 1 : + // InternalExpression.g:13497:3: rule__XIfExpression__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getGroup_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__6__Impl" + + + // $ANTLR start "rule__XIfExpression__Group_6__0" + // InternalExpression.g:13506:1: rule__XIfExpression__Group_6__0 : rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ; + public final void rule__XIfExpression__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13510:1: ( rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ) + // InternalExpression.g:13511:2: rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 + { + pushFollow(FOLLOW_77); + rule__XIfExpression__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__0" + + + // $ANTLR start "rule__XIfExpression__Group_6__0__Impl" + // InternalExpression.g:13518:1: rule__XIfExpression__Group_6__0__Impl : ( ( 'else' ) ) ; + public final void rule__XIfExpression__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13522:1: ( ( ( 'else' ) ) ) + // InternalExpression.g:13523:1: ( ( 'else' ) ) + { + // InternalExpression.g:13523:1: ( ( 'else' ) ) + // InternalExpression.g:13524:2: ( 'else' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + // InternalExpression.g:13525:2: ( 'else' ) + // InternalExpression.g:13525:3: 'else' + { + match(input,72,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__0__Impl" + + + // $ANTLR start "rule__XIfExpression__Group_6__1" + // InternalExpression.g:13533:1: rule__XIfExpression__Group_6__1 : rule__XIfExpression__Group_6__1__Impl ; + public final void rule__XIfExpression__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13537:1: ( rule__XIfExpression__Group_6__1__Impl ) + // InternalExpression.g:13538:2: rule__XIfExpression__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__1" + + + // $ANTLR start "rule__XIfExpression__Group_6__1__Impl" + // InternalExpression.g:13544:1: rule__XIfExpression__Group_6__1__Impl : ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ; + public final void rule__XIfExpression__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13548:1: ( ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ) + // InternalExpression.g:13549:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) + { + // InternalExpression.g:13549:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) + // InternalExpression.g:13550:2: ( rule__XIfExpression__ElseAssignment_6_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); + } + // InternalExpression.g:13551:2: ( rule__XIfExpression__ElseAssignment_6_1 ) + // InternalExpression.g:13551:3: rule__XIfExpression__ElseAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__ElseAssignment_6_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__0" + // InternalExpression.g:13560:1: rule__XSwitchExpression__Group__0 : rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ; + public final void rule__XSwitchExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13564:1: ( rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ) + // InternalExpression.g:13565:2: rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 + { + pushFollow(FOLLOW_86); + rule__XSwitchExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__0" + + + // $ANTLR start "rule__XSwitchExpression__Group__0__Impl" + // InternalExpression.g:13572:1: rule__XSwitchExpression__Group__0__Impl : ( () ) ; + public final void rule__XSwitchExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13576:1: ( ( () ) ) + // InternalExpression.g:13577:1: ( () ) + { + // InternalExpression.g:13577:1: ( () ) + // InternalExpression.g:13578:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); + } + // InternalExpression.g:13579:2: () + // InternalExpression.g:13579:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__1" + // InternalExpression.g:13587:1: rule__XSwitchExpression__Group__1 : rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ; + public final void rule__XSwitchExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13591:1: ( rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ) + // InternalExpression.g:13592:2: rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 + { + pushFollow(FOLLOW_77); + rule__XSwitchExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__1" + + + // $ANTLR start "rule__XSwitchExpression__Group__1__Impl" + // InternalExpression.g:13599:1: rule__XSwitchExpression__Group__1__Impl : ( 'switch' ) ; + public final void rule__XSwitchExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13603:1: ( ( 'switch' ) ) + // InternalExpression.g:13604:1: ( 'switch' ) + { + // InternalExpression.g:13604:1: ( 'switch' ) + // InternalExpression.g:13605:2: 'switch' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__2" + // InternalExpression.g:13614:1: rule__XSwitchExpression__Group__2 : rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ; + public final void rule__XSwitchExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13618:1: ( rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ) + // InternalExpression.g:13619:2: rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 + { + pushFollow(FOLLOW_41); + rule__XSwitchExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__2" + + + // $ANTLR start "rule__XSwitchExpression__Group__2__Impl" + // InternalExpression.g:13626:1: rule__XSwitchExpression__Group__2__Impl : ( ( rule__XSwitchExpression__Alternatives_2 ) ) ; + public final void rule__XSwitchExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13630:1: ( ( ( rule__XSwitchExpression__Alternatives_2 ) ) ) + // InternalExpression.g:13631:1: ( ( rule__XSwitchExpression__Alternatives_2 ) ) + { + // InternalExpression.g:13631:1: ( ( rule__XSwitchExpression__Alternatives_2 ) ) + // InternalExpression.g:13632:2: ( rule__XSwitchExpression__Alternatives_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); + } + // InternalExpression.g:13633:2: ( rule__XSwitchExpression__Alternatives_2 ) + // InternalExpression.g:13633:3: rule__XSwitchExpression__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__3" + // InternalExpression.g:13641:1: rule__XSwitchExpression__Group__3 : rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ; + public final void rule__XSwitchExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13645:1: ( rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ) + // InternalExpression.g:13646:2: rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 + { + pushFollow(FOLLOW_87); + rule__XSwitchExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__3" + + + // $ANTLR start "rule__XSwitchExpression__Group__3__Impl" + // InternalExpression.g:13653:1: rule__XSwitchExpression__Group__3__Impl : ( '{' ) ; + public final void rule__XSwitchExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13657:1: ( ( '{' ) ) + // InternalExpression.g:13658:1: ( '{' ) + { + // InternalExpression.g:13658:1: ( '{' ) + // InternalExpression.g:13659:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__3__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__4" + // InternalExpression.g:13668:1: rule__XSwitchExpression__Group__4 : rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ; + public final void rule__XSwitchExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13672:1: ( rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ) + // InternalExpression.g:13673:2: rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 + { + pushFollow(FOLLOW_87); + rule__XSwitchExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__4" + + + // $ANTLR start "rule__XSwitchExpression__Group__4__Impl" + // InternalExpression.g:13680:1: rule__XSwitchExpression__Group__4__Impl : ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ; + public final void rule__XSwitchExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13684:1: ( ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ) + // InternalExpression.g:13685:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) + { + // InternalExpression.g:13685:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) + // InternalExpression.g:13686:2: ( rule__XSwitchExpression__CasesAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); + } + // InternalExpression.g:13687:2: ( rule__XSwitchExpression__CasesAssignment_4 )* + loop108: + do { + int alt108=2; + int LA108_0 = input.LA(1); + + if ( (LA108_0==RULE_ID||LA108_0==51||(LA108_0>=66 && LA108_0<=67)||(LA108_0>=77 && LA108_0<=78)) ) { + alt108=1; + } + + + switch (alt108) { + case 1 : + // InternalExpression.g:13687:3: rule__XSwitchExpression__CasesAssignment_4 + { + pushFollow(FOLLOW_88); + rule__XSwitchExpression__CasesAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop108; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__4__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__5" + // InternalExpression.g:13695:1: rule__XSwitchExpression__Group__5 : rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ; + public final void rule__XSwitchExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13699:1: ( rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ) + // InternalExpression.g:13700:2: rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 + { + pushFollow(FOLLOW_87); + rule__XSwitchExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__5" + + + // $ANTLR start "rule__XSwitchExpression__Group__5__Impl" + // InternalExpression.g:13707:1: rule__XSwitchExpression__Group__5__Impl : ( ( rule__XSwitchExpression__Group_5__0 )? ) ; + public final void rule__XSwitchExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13711:1: ( ( ( rule__XSwitchExpression__Group_5__0 )? ) ) + // InternalExpression.g:13712:1: ( ( rule__XSwitchExpression__Group_5__0 )? ) + { + // InternalExpression.g:13712:1: ( ( rule__XSwitchExpression__Group_5__0 )? ) + // InternalExpression.g:13713:2: ( rule__XSwitchExpression__Group_5__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); + } + // InternalExpression.g:13714:2: ( rule__XSwitchExpression__Group_5__0 )? + int alt109=2; + int LA109_0 = input.LA(1); + + if ( (LA109_0==75) ) { + alt109=1; + } + switch (alt109) { + case 1 : + // InternalExpression.g:13714:3: rule__XSwitchExpression__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__5__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__6" + // InternalExpression.g:13722:1: rule__XSwitchExpression__Group__6 : rule__XSwitchExpression__Group__6__Impl ; + public final void rule__XSwitchExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13726:1: ( rule__XSwitchExpression__Group__6__Impl ) + // InternalExpression.g:13727:2: rule__XSwitchExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__6" + + + // $ANTLR start "rule__XSwitchExpression__Group__6__Impl" + // InternalExpression.g:13733:1: rule__XSwitchExpression__Group__6__Impl : ( '}' ) ; + public final void rule__XSwitchExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13737:1: ( ( '}' ) ) + // InternalExpression.g:13738:1: ( '}' ) + { + // InternalExpression.g:13738:1: ( '}' ) + // InternalExpression.g:13739:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + match(input,76,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__6__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__0" + // InternalExpression.g:13749:1: rule__XSwitchExpression__Group_2_0__0 : rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ; + public final void rule__XSwitchExpression__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13753:1: ( rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ) + // InternalExpression.g:13754:2: rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 + { + pushFollow(FOLLOW_77); + rule__XSwitchExpression__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__0__Impl" + // InternalExpression.g:13761:1: rule__XSwitchExpression__Group_2_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13765:1: ( ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ) + // InternalExpression.g:13766:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) + { + // InternalExpression.g:13766:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) + // InternalExpression.g:13767:2: ( rule__XSwitchExpression__Group_2_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); + } + // InternalExpression.g:13768:2: ( rule__XSwitchExpression__Group_2_0_0__0 ) + // InternalExpression.g:13768:3: rule__XSwitchExpression__Group_2_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__1" + // InternalExpression.g:13776:1: rule__XSwitchExpression__Group_2_0__1 : rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ; + public final void rule__XSwitchExpression__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13780:1: ( rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ) + // InternalExpression.g:13781:2: rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 + { + pushFollow(FOLLOW_9); + rule__XSwitchExpression__Group_2_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__1__Impl" + // InternalExpression.g:13788:1: rule__XSwitchExpression__Group_2_0__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13792:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ) + // InternalExpression.g:13793:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) + { + // InternalExpression.g:13793:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) + // InternalExpression.g:13794:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); + } + // InternalExpression.g:13795:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) + // InternalExpression.g:13795:3: rule__XSwitchExpression__SwitchAssignment_2_0_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__SwitchAssignment_2_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__2" + // InternalExpression.g:13803:1: rule__XSwitchExpression__Group_2_0__2 : rule__XSwitchExpression__Group_2_0__2__Impl ; + public final void rule__XSwitchExpression__Group_2_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13807:1: ( rule__XSwitchExpression__Group_2_0__2__Impl ) + // InternalExpression.g:13808:2: rule__XSwitchExpression__Group_2_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__2__Impl" + // InternalExpression.g:13814:1: rule__XSwitchExpression__Group_2_0__2__Impl : ( ')' ) ; + public final void rule__XSwitchExpression__Group_2_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13818:1: ( ( ')' ) ) + // InternalExpression.g:13819:1: ( ')' ) + { + // InternalExpression.g:13819:1: ( ')' ) + // InternalExpression.g:13820:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0" + // InternalExpression.g:13830:1: rule__XSwitchExpression__Group_2_0_0__0 : rule__XSwitchExpression__Group_2_0_0__0__Impl ; + public final void rule__XSwitchExpression__Group_2_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13834:1: ( rule__XSwitchExpression__Group_2_0_0__0__Impl ) + // InternalExpression.g:13835:2: rule__XSwitchExpression__Group_2_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0__Impl" + // InternalExpression.g:13841:1: rule__XSwitchExpression__Group_2_0_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13845:1: ( ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ) + // InternalExpression.g:13846:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) + { + // InternalExpression.g:13846:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) + // InternalExpression.g:13847:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); + } + // InternalExpression.g:13848:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 ) + // InternalExpression.g:13848:3: rule__XSwitchExpression__Group_2_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0" + // InternalExpression.g:13857:1: rule__XSwitchExpression__Group_2_0_0_0__0 : rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ; + public final void rule__XSwitchExpression__Group_2_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13861:1: ( rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ) + // InternalExpression.g:13862:2: rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 + { + pushFollow(FOLLOW_56); + rule__XSwitchExpression__Group_2_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0__Impl" + // InternalExpression.g:13869:1: rule__XSwitchExpression__Group_2_0_0_0__0__Impl : ( '(' ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13873:1: ( ( '(' ) ) + // InternalExpression.g:13874:1: ( '(' ) + { + // InternalExpression.g:13874:1: ( '(' ) + // InternalExpression.g:13875:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1" + // InternalExpression.g:13884:1: rule__XSwitchExpression__Group_2_0_0_0__1 : rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ; + public final void rule__XSwitchExpression__Group_2_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13888:1: ( rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ) + // InternalExpression.g:13889:2: rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 + { + pushFollow(FOLLOW_7); + rule__XSwitchExpression__Group_2_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1__Impl" + // InternalExpression.g:13896:1: rule__XSwitchExpression__Group_2_0_0_0__1__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13900:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ) + // InternalExpression.g:13901:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) + { + // InternalExpression.g:13901:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) + // InternalExpression.g:13902:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); + } + // InternalExpression.g:13903:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) + // InternalExpression.g:13903:3: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2" + // InternalExpression.g:13911:1: rule__XSwitchExpression__Group_2_0_0_0__2 : rule__XSwitchExpression__Group_2_0_0_0__2__Impl ; + public final void rule__XSwitchExpression__Group_2_0_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13915:1: ( rule__XSwitchExpression__Group_2_0_0_0__2__Impl ) + // InternalExpression.g:13916:2: rule__XSwitchExpression__Group_2_0_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2__Impl" + // InternalExpression.g:13922:1: rule__XSwitchExpression__Group_2_0_0_0__2__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13926:1: ( ( ':' ) ) + // InternalExpression.g:13927:1: ( ':' ) + { + // InternalExpression.g:13927:1: ( ':' ) + // InternalExpression.g:13928:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__0" + // InternalExpression.g:13938:1: rule__XSwitchExpression__Group_2_1__0 : rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ; + public final void rule__XSwitchExpression__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13942:1: ( rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ) + // InternalExpression.g:13943:2: rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 + { + pushFollow(FOLLOW_77); + rule__XSwitchExpression__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__0__Impl" + // InternalExpression.g:13950:1: rule__XSwitchExpression__Group_2_1__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ; + public final void rule__XSwitchExpression__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13954:1: ( ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ) + // InternalExpression.g:13955:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) + { + // InternalExpression.g:13955:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) + // InternalExpression.g:13956:2: ( rule__XSwitchExpression__Group_2_1_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); + } + // InternalExpression.g:13957:2: ( rule__XSwitchExpression__Group_2_1_0__0 )? + int alt110=2; + alt110 = dfa110.predict(input); + switch (alt110) { + case 1 : + // InternalExpression.g:13957:3: rule__XSwitchExpression__Group_2_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__1" + // InternalExpression.g:13965:1: rule__XSwitchExpression__Group_2_1__1 : rule__XSwitchExpression__Group_2_1__1__Impl ; + public final void rule__XSwitchExpression__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13969:1: ( rule__XSwitchExpression__Group_2_1__1__Impl ) + // InternalExpression.g:13970:2: rule__XSwitchExpression__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__1__Impl" + // InternalExpression.g:13976:1: rule__XSwitchExpression__Group_2_1__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13980:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ) + // InternalExpression.g:13981:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) + { + // InternalExpression.g:13981:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) + // InternalExpression.g:13982:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); + } + // InternalExpression.g:13983:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) + // InternalExpression.g:13983:3: rule__XSwitchExpression__SwitchAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__SwitchAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0" + // InternalExpression.g:13992:1: rule__XSwitchExpression__Group_2_1_0__0 : rule__XSwitchExpression__Group_2_1_0__0__Impl ; + public final void rule__XSwitchExpression__Group_2_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:13996:1: ( rule__XSwitchExpression__Group_2_1_0__0__Impl ) + // InternalExpression.g:13997:2: rule__XSwitchExpression__Group_2_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0__Impl" + // InternalExpression.g:14003:1: rule__XSwitchExpression__Group_2_1_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14007:1: ( ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ) + // InternalExpression.g:14008:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) + { + // InternalExpression.g:14008:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) + // InternalExpression.g:14009:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); + } + // InternalExpression.g:14010:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 ) + // InternalExpression.g:14010:3: rule__XSwitchExpression__Group_2_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0" + // InternalExpression.g:14019:1: rule__XSwitchExpression__Group_2_1_0_0__0 : rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ; + public final void rule__XSwitchExpression__Group_2_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14023:1: ( rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ) + // InternalExpression.g:14024:2: rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 + { + pushFollow(FOLLOW_7); + rule__XSwitchExpression__Group_2_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0__Impl" + // InternalExpression.g:14031:1: rule__XSwitchExpression__Group_2_1_0_0__0__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ; + public final void rule__XSwitchExpression__Group_2_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14035:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ) + // InternalExpression.g:14036:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) + { + // InternalExpression.g:14036:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) + // InternalExpression.g:14037:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); + } + // InternalExpression.g:14038:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) + // InternalExpression.g:14038:3: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1" + // InternalExpression.g:14046:1: rule__XSwitchExpression__Group_2_1_0_0__1 : rule__XSwitchExpression__Group_2_1_0_0__1__Impl ; + public final void rule__XSwitchExpression__Group_2_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14050:1: ( rule__XSwitchExpression__Group_2_1_0_0__1__Impl ) + // InternalExpression.g:14051:2: rule__XSwitchExpression__Group_2_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1__Impl" + // InternalExpression.g:14057:1: rule__XSwitchExpression__Group_2_1_0_0__1__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_2_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14061:1: ( ( ':' ) ) + // InternalExpression.g:14062:1: ( ':' ) + { + // InternalExpression.g:14062:1: ( ':' ) + // InternalExpression.g:14063:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__0" + // InternalExpression.g:14073:1: rule__XSwitchExpression__Group_5__0 : rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ; + public final void rule__XSwitchExpression__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14077:1: ( rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ) + // InternalExpression.g:14078:2: rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 + { + pushFollow(FOLLOW_7); + rule__XSwitchExpression__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__0__Impl" + // InternalExpression.g:14085:1: rule__XSwitchExpression__Group_5__0__Impl : ( 'default' ) ; + public final void rule__XSwitchExpression__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14089:1: ( ( 'default' ) ) + // InternalExpression.g:14090:1: ( 'default' ) + { + // InternalExpression.g:14090:1: ( 'default' ) + // InternalExpression.g:14091:2: 'default' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + match(input,75,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__1" + // InternalExpression.g:14100:1: rule__XSwitchExpression__Group_5__1 : rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ; + public final void rule__XSwitchExpression__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14104:1: ( rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ) + // InternalExpression.g:14105:2: rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 + { + pushFollow(FOLLOW_77); + rule__XSwitchExpression__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__1__Impl" + // InternalExpression.g:14112:1: rule__XSwitchExpression__Group_5__1__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14116:1: ( ( ':' ) ) + // InternalExpression.g:14117:1: ( ':' ) + { + // InternalExpression.g:14117:1: ( ':' ) + // InternalExpression.g:14118:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__2" + // InternalExpression.g:14127:1: rule__XSwitchExpression__Group_5__2 : rule__XSwitchExpression__Group_5__2__Impl ; + public final void rule__XSwitchExpression__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14131:1: ( rule__XSwitchExpression__Group_5__2__Impl ) + // InternalExpression.g:14132:2: rule__XSwitchExpression__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__2__Impl" + // InternalExpression.g:14138:1: rule__XSwitchExpression__Group_5__2__Impl : ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ; + public final void rule__XSwitchExpression__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14142:1: ( ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ) + // InternalExpression.g:14143:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) + { + // InternalExpression.g:14143:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) + // InternalExpression.g:14144:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); + } + // InternalExpression.g:14145:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 ) + // InternalExpression.g:14145:3: rule__XSwitchExpression__DefaultAssignment_5_2 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DefaultAssignment_5_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__2__Impl" + + + // $ANTLR start "rule__XCasePart__Group__0" + // InternalExpression.g:14154:1: rule__XCasePart__Group__0 : rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ; + public final void rule__XCasePart__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14158:1: ( rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ) + // InternalExpression.g:14159:2: rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 + { + pushFollow(FOLLOW_89); + rule__XCasePart__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__0" + + + // $ANTLR start "rule__XCasePart__Group__0__Impl" + // InternalExpression.g:14166:1: rule__XCasePart__Group__0__Impl : ( () ) ; + public final void rule__XCasePart__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14170:1: ( ( () ) ) + // InternalExpression.g:14171:1: ( () ) + { + // InternalExpression.g:14171:1: ( () ) + // InternalExpression.g:14172:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); + } + // InternalExpression.g:14173:2: () + // InternalExpression.g:14173:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group__1" + // InternalExpression.g:14181:1: rule__XCasePart__Group__1 : rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ; + public final void rule__XCasePart__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14185:1: ( rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ) + // InternalExpression.g:14186:2: rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 + { + pushFollow(FOLLOW_89); + rule__XCasePart__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__1" + + + // $ANTLR start "rule__XCasePart__Group__1__Impl" + // InternalExpression.g:14193:1: rule__XCasePart__Group__1__Impl : ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ; + public final void rule__XCasePart__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14197:1: ( ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ) + // InternalExpression.g:14198:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) + { + // InternalExpression.g:14198:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) + // InternalExpression.g:14199:2: ( rule__XCasePart__TypeGuardAssignment_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); + } + // InternalExpression.g:14200:2: ( rule__XCasePart__TypeGuardAssignment_1 )? + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==RULE_ID||LA111_0==51||LA111_0==67) ) { + alt111=1; + } + switch (alt111) { + case 1 : + // InternalExpression.g:14200:3: rule__XCasePart__TypeGuardAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__TypeGuardAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__1__Impl" + + + // $ANTLR start "rule__XCasePart__Group__2" + // InternalExpression.g:14208:1: rule__XCasePart__Group__2 : rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ; + public final void rule__XCasePart__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14212:1: ( rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ) + // InternalExpression.g:14213:2: rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 + { + pushFollow(FOLLOW_89); + rule__XCasePart__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__2" + + + // $ANTLR start "rule__XCasePart__Group__2__Impl" + // InternalExpression.g:14220:1: rule__XCasePart__Group__2__Impl : ( ( rule__XCasePart__Group_2__0 )? ) ; + public final void rule__XCasePart__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14224:1: ( ( ( rule__XCasePart__Group_2__0 )? ) ) + // InternalExpression.g:14225:1: ( ( rule__XCasePart__Group_2__0 )? ) + { + // InternalExpression.g:14225:1: ( ( rule__XCasePart__Group_2__0 )? ) + // InternalExpression.g:14226:2: ( rule__XCasePart__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup_2()); + } + // InternalExpression.g:14227:2: ( rule__XCasePart__Group_2__0 )? + int alt112=2; + int LA112_0 = input.LA(1); + + if ( (LA112_0==77) ) { + alt112=1; + } + switch (alt112) { + case 1 : + // InternalExpression.g:14227:3: rule__XCasePart__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__2__Impl" + + + // $ANTLR start "rule__XCasePart__Group__3" + // InternalExpression.g:14235:1: rule__XCasePart__Group__3 : rule__XCasePart__Group__3__Impl ; + public final void rule__XCasePart__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14239:1: ( rule__XCasePart__Group__3__Impl ) + // InternalExpression.g:14240:2: rule__XCasePart__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__3" + + + // $ANTLR start "rule__XCasePart__Group__3__Impl" + // InternalExpression.g:14246:1: rule__XCasePart__Group__3__Impl : ( ( rule__XCasePart__Alternatives_3 ) ) ; + public final void rule__XCasePart__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14250:1: ( ( ( rule__XCasePart__Alternatives_3 ) ) ) + // InternalExpression.g:14251:1: ( ( rule__XCasePart__Alternatives_3 ) ) + { + // InternalExpression.g:14251:1: ( ( rule__XCasePart__Alternatives_3 ) ) + // InternalExpression.g:14252:2: ( rule__XCasePart__Alternatives_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getAlternatives_3()); + } + // InternalExpression.g:14253:2: ( rule__XCasePart__Alternatives_3 ) + // InternalExpression.g:14253:3: rule__XCasePart__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getAlternatives_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__3__Impl" + + + // $ANTLR start "rule__XCasePart__Group_2__0" + // InternalExpression.g:14262:1: rule__XCasePart__Group_2__0 : rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ; + public final void rule__XCasePart__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14266:1: ( rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ) + // InternalExpression.g:14267:2: rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 + { + pushFollow(FOLLOW_77); + rule__XCasePart__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__0" + + + // $ANTLR start "rule__XCasePart__Group_2__0__Impl" + // InternalExpression.g:14274:1: rule__XCasePart__Group_2__0__Impl : ( 'case' ) ; + public final void rule__XCasePart__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14278:1: ( ( 'case' ) ) + // InternalExpression.g:14279:1: ( 'case' ) + { + // InternalExpression.g:14279:1: ( 'case' ) + // InternalExpression.g:14280:2: 'case' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group_2__1" + // InternalExpression.g:14289:1: rule__XCasePart__Group_2__1 : rule__XCasePart__Group_2__1__Impl ; + public final void rule__XCasePart__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14293:1: ( rule__XCasePart__Group_2__1__Impl ) + // InternalExpression.g:14294:2: rule__XCasePart__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__1" + + + // $ANTLR start "rule__XCasePart__Group_2__1__Impl" + // InternalExpression.g:14300:1: rule__XCasePart__Group_2__1__Impl : ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ; + public final void rule__XCasePart__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14304:1: ( ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ) + // InternalExpression.g:14305:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) ) + { + // InternalExpression.g:14305:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) ) + // InternalExpression.g:14306:2: ( rule__XCasePart__CaseAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); + } + // InternalExpression.g:14307:2: ( rule__XCasePart__CaseAssignment_2_1 ) + // InternalExpression.g:14307:3: rule__XCasePart__CaseAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__CaseAssignment_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__1__Impl" + + + // $ANTLR start "rule__XCasePart__Group_3_0__0" + // InternalExpression.g:14316:1: rule__XCasePart__Group_3_0__0 : rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ; + public final void rule__XCasePart__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14320:1: ( rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ) + // InternalExpression.g:14321:2: rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 + { + pushFollow(FOLLOW_77); + rule__XCasePart__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__0" + + + // $ANTLR start "rule__XCasePart__Group_3_0__0__Impl" + // InternalExpression.g:14328:1: rule__XCasePart__Group_3_0__0__Impl : ( ':' ) ; + public final void rule__XCasePart__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14332:1: ( ( ':' ) ) + // InternalExpression.g:14333:1: ( ':' ) + { + // InternalExpression.g:14333:1: ( ':' ) + // InternalExpression.g:14334:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group_3_0__1" + // InternalExpression.g:14343:1: rule__XCasePart__Group_3_0__1 : rule__XCasePart__Group_3_0__1__Impl ; + public final void rule__XCasePart__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14347:1: ( rule__XCasePart__Group_3_0__1__Impl ) + // InternalExpression.g:14348:2: rule__XCasePart__Group_3_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__1" + + + // $ANTLR start "rule__XCasePart__Group_3_0__1__Impl" + // InternalExpression.g:14354:1: rule__XCasePart__Group_3_0__1__Impl : ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ; + public final void rule__XCasePart__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14358:1: ( ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ) + // InternalExpression.g:14359:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) + { + // InternalExpression.g:14359:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) + // InternalExpression.g:14360:2: ( rule__XCasePart__ThenAssignment_3_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); + } + // InternalExpression.g:14361:2: ( rule__XCasePart__ThenAssignment_3_0_1 ) + // InternalExpression.g:14361:3: rule__XCasePart__ThenAssignment_3_0_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__ThenAssignment_3_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__0" + // InternalExpression.g:14370:1: rule__XForLoopExpression__Group__0 : rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ; + public final void rule__XForLoopExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14374:1: ( rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ) + // InternalExpression.g:14375:2: rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 + { + pushFollow(FOLLOW_77); + rule__XForLoopExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__0" + + + // $ANTLR start "rule__XForLoopExpression__Group__0__Impl" + // InternalExpression.g:14382:1: rule__XForLoopExpression__Group__0__Impl : ( ( rule__XForLoopExpression__Group_0__0 ) ) ; + public final void rule__XForLoopExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14386:1: ( ( ( rule__XForLoopExpression__Group_0__0 ) ) ) + // InternalExpression.g:14387:1: ( ( rule__XForLoopExpression__Group_0__0 ) ) + { + // InternalExpression.g:14387:1: ( ( rule__XForLoopExpression__Group_0__0 ) ) + // InternalExpression.g:14388:2: ( rule__XForLoopExpression__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); + } + // InternalExpression.g:14389:2: ( rule__XForLoopExpression__Group_0__0 ) + // InternalExpression.g:14389:3: rule__XForLoopExpression__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__1" + // InternalExpression.g:14397:1: rule__XForLoopExpression__Group__1 : rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ; + public final void rule__XForLoopExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14401:1: ( rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ) + // InternalExpression.g:14402:2: rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 + { + pushFollow(FOLLOW_9); + rule__XForLoopExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__1" + + + // $ANTLR start "rule__XForLoopExpression__Group__1__Impl" + // InternalExpression.g:14409:1: rule__XForLoopExpression__Group__1__Impl : ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ; + public final void rule__XForLoopExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14413:1: ( ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ) + // InternalExpression.g:14414:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) + { + // InternalExpression.g:14414:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) + // InternalExpression.g:14415:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); + } + // InternalExpression.g:14416:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 ) + // InternalExpression.g:14416:3: rule__XForLoopExpression__ForExpressionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__ForExpressionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__2" + // InternalExpression.g:14424:1: rule__XForLoopExpression__Group__2 : rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ; + public final void rule__XForLoopExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14428:1: ( rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ) + // InternalExpression.g:14429:2: rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 + { + pushFollow(FOLLOW_77); + rule__XForLoopExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__2" + + + // $ANTLR start "rule__XForLoopExpression__Group__2__Impl" + // InternalExpression.g:14436:1: rule__XForLoopExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XForLoopExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14440:1: ( ( ')' ) ) + // InternalExpression.g:14441:1: ( ')' ) + { + // InternalExpression.g:14441:1: ( ')' ) + // InternalExpression.g:14442:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__2__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__3" + // InternalExpression.g:14451:1: rule__XForLoopExpression__Group__3 : rule__XForLoopExpression__Group__3__Impl ; + public final void rule__XForLoopExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14455:1: ( rule__XForLoopExpression__Group__3__Impl ) + // InternalExpression.g:14456:2: rule__XForLoopExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__3" + + + // $ANTLR start "rule__XForLoopExpression__Group__3__Impl" + // InternalExpression.g:14462:1: rule__XForLoopExpression__Group__3__Impl : ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ; + public final void rule__XForLoopExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14466:1: ( ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ) + // InternalExpression.g:14467:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) + { + // InternalExpression.g:14467:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) + // InternalExpression.g:14468:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); + } + // InternalExpression.g:14469:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 ) + // InternalExpression.g:14469:3: rule__XForLoopExpression__EachExpressionAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__EachExpressionAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__3__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0__0" + // InternalExpression.g:14478:1: rule__XForLoopExpression__Group_0__0 : rule__XForLoopExpression__Group_0__0__Impl ; + public final void rule__XForLoopExpression__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14482:1: ( rule__XForLoopExpression__Group_0__0__Impl ) + // InternalExpression.g:14483:2: rule__XForLoopExpression__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0__0" + + + // $ANTLR start "rule__XForLoopExpression__Group_0__0__Impl" + // InternalExpression.g:14489:1: rule__XForLoopExpression__Group_0__0__Impl : ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ; + public final void rule__XForLoopExpression__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14493:1: ( ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ) + // InternalExpression.g:14494:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) ) + { + // InternalExpression.g:14494:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) ) + // InternalExpression.g:14495:2: ( rule__XForLoopExpression__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); + } + // InternalExpression.g:14496:2: ( rule__XForLoopExpression__Group_0_0__0 ) + // InternalExpression.g:14496:3: rule__XForLoopExpression__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__0" + // InternalExpression.g:14505:1: rule__XForLoopExpression__Group_0_0__0 : rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ; + public final void rule__XForLoopExpression__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14509:1: ( rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ) + // InternalExpression.g:14510:2: rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 + { + pushFollow(FOLLOW_90); + rule__XForLoopExpression__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__0" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__0__Impl" + // InternalExpression.g:14517:1: rule__XForLoopExpression__Group_0_0__0__Impl : ( () ) ; + public final void rule__XForLoopExpression__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14521:1: ( ( () ) ) + // InternalExpression.g:14522:1: ( () ) + { + // InternalExpression.g:14522:1: ( () ) + // InternalExpression.g:14523:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); + } + // InternalExpression.g:14524:2: () + // InternalExpression.g:14524:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__1" + // InternalExpression.g:14532:1: rule__XForLoopExpression__Group_0_0__1 : rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ; + public final void rule__XForLoopExpression__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14536:1: ( rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ) + // InternalExpression.g:14537:2: rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 + { + pushFollow(FOLLOW_34); + rule__XForLoopExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__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__XForLoopExpression__Group_0_0__1" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__1__Impl" + // InternalExpression.g:14544:1: rule__XForLoopExpression__Group_0_0__1__Impl : ( 'for' ) ; + public final void rule__XForLoopExpression__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14548:1: ( ( 'for' ) ) + // InternalExpression.g:14549:1: ( 'for' ) + { + // InternalExpression.g:14549:1: ( 'for' ) + // InternalExpression.g:14550:2: 'for' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + match(input,89,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__2" + // InternalExpression.g:14559:1: rule__XForLoopExpression__Group_0_0__2 : rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ; + public final void rule__XForLoopExpression__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14563:1: ( rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ) + // InternalExpression.g:14564:2: rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 + { + pushFollow(FOLLOW_56); + rule__XForLoopExpression__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__2" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__2__Impl" + // InternalExpression.g:14571:1: rule__XForLoopExpression__Group_0_0__2__Impl : ( '(' ) ; + public final void rule__XForLoopExpression__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14575:1: ( ( '(' ) ) + // InternalExpression.g:14576:1: ( '(' ) + { + // InternalExpression.g:14576:1: ( '(' ) + // InternalExpression.g:14577:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__3" + // InternalExpression.g:14586:1: rule__XForLoopExpression__Group_0_0__3 : rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ; + public final void rule__XForLoopExpression__Group_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14590:1: ( rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ) + // InternalExpression.g:14591:2: rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 + { + pushFollow(FOLLOW_7); + rule__XForLoopExpression__Group_0_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__3" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__3__Impl" + // InternalExpression.g:14598:1: rule__XForLoopExpression__Group_0_0__3__Impl : ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ; + public final void rule__XForLoopExpression__Group_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14602:1: ( ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ) + // InternalExpression.g:14603:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) + { + // InternalExpression.g:14603:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) + // InternalExpression.g:14604:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); + } + // InternalExpression.g:14605:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) + // InternalExpression.g:14605:3: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__DeclaredParamAssignment_0_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__3__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__4" + // InternalExpression.g:14613:1: rule__XForLoopExpression__Group_0_0__4 : rule__XForLoopExpression__Group_0_0__4__Impl ; + public final void rule__XForLoopExpression__Group_0_0__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14617:1: ( rule__XForLoopExpression__Group_0_0__4__Impl ) + // InternalExpression.g:14618:2: rule__XForLoopExpression__Group_0_0__4__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__4" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__4__Impl" + // InternalExpression.g:14624:1: rule__XForLoopExpression__Group_0_0__4__Impl : ( ':' ) ; + public final void rule__XForLoopExpression__Group_0_0__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14628:1: ( ( ':' ) ) + // InternalExpression.g:14629:1: ( ':' ) + { + // InternalExpression.g:14629:1: ( ':' ) + // InternalExpression.g:14630:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__4__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__0" + // InternalExpression.g:14640:1: rule__XBasicForLoopExpression__Group__0 : rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ; + public final void rule__XBasicForLoopExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14644:1: ( rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ) + // InternalExpression.g:14645:2: rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 + { + pushFollow(FOLLOW_90); + rule__XBasicForLoopExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__0__Impl" + // InternalExpression.g:14652:1: rule__XBasicForLoopExpression__Group__0__Impl : ( () ) ; + public final void rule__XBasicForLoopExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14656:1: ( ( () ) ) + // InternalExpression.g:14657:1: ( () ) + { + // InternalExpression.g:14657:1: ( () ) + // InternalExpression.g:14658:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); + } + // InternalExpression.g:14659:2: () + // InternalExpression.g:14659:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__1" + // InternalExpression.g:14667:1: rule__XBasicForLoopExpression__Group__1 : rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ; + public final void rule__XBasicForLoopExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14671:1: ( rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ) + // InternalExpression.g:14672:2: rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 + { + pushFollow(FOLLOW_34); + rule__XBasicForLoopExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__1__Impl" + // InternalExpression.g:14679:1: rule__XBasicForLoopExpression__Group__1__Impl : ( 'for' ) ; + public final void rule__XBasicForLoopExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14683:1: ( ( 'for' ) ) + // InternalExpression.g:14684:1: ( 'for' ) + { + // InternalExpression.g:14684:1: ( 'for' ) + // InternalExpression.g:14685:2: 'for' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + match(input,89,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__2" + // InternalExpression.g:14694:1: rule__XBasicForLoopExpression__Group__2 : rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ; + public final void rule__XBasicForLoopExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14698:1: ( rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ) + // InternalExpression.g:14699:2: rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 + { + pushFollow(FOLLOW_91); + rule__XBasicForLoopExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__2" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__2__Impl" + // InternalExpression.g:14706:1: rule__XBasicForLoopExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XBasicForLoopExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14710:1: ( ( '(' ) ) + // InternalExpression.g:14711:1: ( '(' ) + { + // InternalExpression.g:14711:1: ( '(' ) + // InternalExpression.g:14712:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__2__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__3" + // InternalExpression.g:14721:1: rule__XBasicForLoopExpression__Group__3 : rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ; + public final void rule__XBasicForLoopExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14725:1: ( rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ) + // InternalExpression.g:14726:2: rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 + { + pushFollow(FOLLOW_91); + rule__XBasicForLoopExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__3" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__3__Impl" + // InternalExpression.g:14733:1: rule__XBasicForLoopExpression__Group__3__Impl : ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ; + public final void rule__XBasicForLoopExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14737:1: ( ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ) + // InternalExpression.g:14738:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) + { + // InternalExpression.g:14738:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) + // InternalExpression.g:14739:2: ( rule__XBasicForLoopExpression__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); + } + // InternalExpression.g:14740:2: ( rule__XBasicForLoopExpression__Group_3__0 )? + int alt113=2; + int LA113_0 = input.LA(1); + + if ( ((LA113_0>=RULE_ID && LA113_0<=RULE_DECIMAL)||LA113_0==RULE_STRING||(LA113_0>=22 && LA113_0<=24)||LA113_0==27||(LA113_0>=36 && LA113_0<=37)||(LA113_0>=59 && LA113_0<=64)||LA113_0==67||LA113_0==70||(LA113_0>=73 && LA113_0<=74)||(LA113_0>=81 && LA113_0<=82)||LA113_0==87||(LA113_0>=89 && LA113_0<=96)||LA113_0==98||LA113_0==104) ) { + alt113=1; + } + switch (alt113) { + case 1 : + // InternalExpression.g:14740:3: rule__XBasicForLoopExpression__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__3__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__4" + // InternalExpression.g:14748:1: rule__XBasicForLoopExpression__Group__4 : rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ; + public final void rule__XBasicForLoopExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14752:1: ( rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ) + // InternalExpression.g:14753:2: rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 + { + pushFollow(FOLLOW_92); + rule__XBasicForLoopExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__4" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__4__Impl" + // InternalExpression.g:14760:1: rule__XBasicForLoopExpression__Group__4__Impl : ( ';' ) ; + public final void rule__XBasicForLoopExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14764:1: ( ( ';' ) ) + // InternalExpression.g:14765:1: ( ';' ) + { + // InternalExpression.g:14765:1: ( ';' ) + // InternalExpression.g:14766:2: ';' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + match(input,88,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__4__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__5" + // InternalExpression.g:14775:1: rule__XBasicForLoopExpression__Group__5 : rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ; + public final void rule__XBasicForLoopExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14779:1: ( rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ) + // InternalExpression.g:14780:2: rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 + { + pushFollow(FOLLOW_92); + rule__XBasicForLoopExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__5" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__5__Impl" + // InternalExpression.g:14787:1: rule__XBasicForLoopExpression__Group__5__Impl : ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ; + public final void rule__XBasicForLoopExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14791:1: ( ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ) + // InternalExpression.g:14792:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) + { + // InternalExpression.g:14792:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) + // InternalExpression.g:14793:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); + } + // InternalExpression.g:14794:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? + int alt114=2; + int LA114_0 = input.LA(1); + + if ( ((LA114_0>=RULE_ID && LA114_0<=RULE_DECIMAL)||LA114_0==RULE_STRING||(LA114_0>=22 && LA114_0<=24)||LA114_0==27||(LA114_0>=36 && LA114_0<=37)||(LA114_0>=60 && LA114_0<=64)||LA114_0==67||LA114_0==70||(LA114_0>=73 && LA114_0<=74)||(LA114_0>=81 && LA114_0<=82)||LA114_0==87||(LA114_0>=89 && LA114_0<=96)||LA114_0==98) ) { + alt114=1; + } + switch (alt114) { + case 1 : + // InternalExpression.g:14794:3: rule__XBasicForLoopExpression__ExpressionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__ExpressionAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__5__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__6" + // InternalExpression.g:14802:1: rule__XBasicForLoopExpression__Group__6 : rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ; + public final void rule__XBasicForLoopExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14806:1: ( rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ) + // InternalExpression.g:14807:2: rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 + { + pushFollow(FOLLOW_76); + rule__XBasicForLoopExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__7(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__6" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__6__Impl" + // InternalExpression.g:14814:1: rule__XBasicForLoopExpression__Group__6__Impl : ( ';' ) ; + public final void rule__XBasicForLoopExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14818:1: ( ( ';' ) ) + // InternalExpression.g:14819:1: ( ';' ) + { + // InternalExpression.g:14819:1: ( ';' ) + // InternalExpression.g:14820:2: ';' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + match(input,88,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__6__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__7" + // InternalExpression.g:14829:1: rule__XBasicForLoopExpression__Group__7 : rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ; + public final void rule__XBasicForLoopExpression__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14833:1: ( rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ) + // InternalExpression.g:14834:2: rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 + { + pushFollow(FOLLOW_76); + rule__XBasicForLoopExpression__Group__7__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__8(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__7" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__7__Impl" + // InternalExpression.g:14841:1: rule__XBasicForLoopExpression__Group__7__Impl : ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ; + public final void rule__XBasicForLoopExpression__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14845:1: ( ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ) + // InternalExpression.g:14846:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) + { + // InternalExpression.g:14846:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) + // InternalExpression.g:14847:2: ( rule__XBasicForLoopExpression__Group_7__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); + } + // InternalExpression.g:14848:2: ( rule__XBasicForLoopExpression__Group_7__0 )? + int alt115=2; + int LA115_0 = input.LA(1); + + if ( ((LA115_0>=RULE_ID && LA115_0<=RULE_DECIMAL)||LA115_0==RULE_STRING||(LA115_0>=22 && LA115_0<=24)||LA115_0==27||(LA115_0>=36 && LA115_0<=37)||(LA115_0>=60 && LA115_0<=64)||LA115_0==67||LA115_0==70||(LA115_0>=73 && LA115_0<=74)||(LA115_0>=81 && LA115_0<=82)||LA115_0==87||(LA115_0>=89 && LA115_0<=96)||LA115_0==98) ) { + alt115=1; + } + switch (alt115) { + case 1 : + // InternalExpression.g:14848:3: rule__XBasicForLoopExpression__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__7__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__8" + // InternalExpression.g:14856:1: rule__XBasicForLoopExpression__Group__8 : rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ; + public final void rule__XBasicForLoopExpression__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14860:1: ( rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ) + // InternalExpression.g:14861:2: rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 + { + pushFollow(FOLLOW_77); + rule__XBasicForLoopExpression__Group__8__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__9(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__8" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__8__Impl" + // InternalExpression.g:14868:1: rule__XBasicForLoopExpression__Group__8__Impl : ( ')' ) ; + public final void rule__XBasicForLoopExpression__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14872:1: ( ( ')' ) ) + // InternalExpression.g:14873:1: ( ')' ) + { + // InternalExpression.g:14873:1: ( ')' ) + // InternalExpression.g:14874:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__8__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__9" + // InternalExpression.g:14883:1: rule__XBasicForLoopExpression__Group__9 : rule__XBasicForLoopExpression__Group__9__Impl ; + public final void rule__XBasicForLoopExpression__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14887:1: ( rule__XBasicForLoopExpression__Group__9__Impl ) + // InternalExpression.g:14888:2: rule__XBasicForLoopExpression__Group__9__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__9__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__9" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__9__Impl" + // InternalExpression.g:14894:1: rule__XBasicForLoopExpression__Group__9__Impl : ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ; + public final void rule__XBasicForLoopExpression__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14898:1: ( ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ) + // InternalExpression.g:14899:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) + { + // InternalExpression.g:14899:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) + // InternalExpression.g:14900:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); + } + // InternalExpression.g:14901:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) + // InternalExpression.g:14901:3: rule__XBasicForLoopExpression__EachExpressionAssignment_9 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__EachExpressionAssignment_9(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__9__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0" + // InternalExpression.g:14910:1: rule__XBasicForLoopExpression__Group_3__0 : rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ; + public final void rule__XBasicForLoopExpression__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14914:1: ( rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ) + // InternalExpression.g:14915:2: rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 + { + pushFollow(FOLLOW_36); + rule__XBasicForLoopExpression__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0__Impl" + // InternalExpression.g:14922:1: rule__XBasicForLoopExpression__Group_3__0__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ; + public final void rule__XBasicForLoopExpression__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14926:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ) + // InternalExpression.g:14927:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) + { + // InternalExpression.g:14927:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) + // InternalExpression.g:14928:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); + } + // InternalExpression.g:14929:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) + // InternalExpression.g:14929:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1" + // InternalExpression.g:14937:1: rule__XBasicForLoopExpression__Group_3__1 : rule__XBasicForLoopExpression__Group_3__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14941:1: ( rule__XBasicForLoopExpression__Group_3__1__Impl ) + // InternalExpression.g:14942:2: rule__XBasicForLoopExpression__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1__Impl" + // InternalExpression.g:14948:1: rule__XBasicForLoopExpression__Group_3__1__Impl : ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ; + public final void rule__XBasicForLoopExpression__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14952:1: ( ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ) + // InternalExpression.g:14953:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) + { + // InternalExpression.g:14953:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) + // InternalExpression.g:14954:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); + } + // InternalExpression.g:14955:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )* + loop116: + do { + int alt116=2; + int LA116_0 = input.LA(1); + + if ( (LA116_0==78) ) { + alt116=1; + } + + + switch (alt116) { + case 1 : + // InternalExpression.g:14955:3: rule__XBasicForLoopExpression__Group_3_1__0 + { + pushFollow(FOLLOW_37); + rule__XBasicForLoopExpression__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop116; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0" + // InternalExpression.g:14964:1: rule__XBasicForLoopExpression__Group_3_1__0 : rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ; + public final void rule__XBasicForLoopExpression__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14968:1: ( rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ) + // InternalExpression.g:14969:2: rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 + { + pushFollow(FOLLOW_81); + rule__XBasicForLoopExpression__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0__Impl" + // InternalExpression.g:14976:1: rule__XBasicForLoopExpression__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XBasicForLoopExpression__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14980:1: ( ( ',' ) ) + // InternalExpression.g:14981:1: ( ',' ) + { + // InternalExpression.g:14981:1: ( ',' ) + // InternalExpression.g:14982:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1" + // InternalExpression.g:14991:1: rule__XBasicForLoopExpression__Group_3_1__1 : rule__XBasicForLoopExpression__Group_3_1__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:14995:1: ( rule__XBasicForLoopExpression__Group_3_1__1__Impl ) + // InternalExpression.g:14996:2: rule__XBasicForLoopExpression__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1__Impl" + // InternalExpression.g:15002:1: rule__XBasicForLoopExpression__Group_3_1__1__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ; + public final void rule__XBasicForLoopExpression__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15006:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ) + // InternalExpression.g:15007:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) + { + // InternalExpression.g:15007:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) + // InternalExpression.g:15008:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); + } + // InternalExpression.g:15009:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) + // InternalExpression.g:15009:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0" + // InternalExpression.g:15018:1: rule__XBasicForLoopExpression__Group_7__0 : rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ; + public final void rule__XBasicForLoopExpression__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15022:1: ( rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ) + // InternalExpression.g:15023:2: rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 + { + pushFollow(FOLLOW_36); + rule__XBasicForLoopExpression__Group_7__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0__Impl" + // InternalExpression.g:15030:1: rule__XBasicForLoopExpression__Group_7__0__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ; + public final void rule__XBasicForLoopExpression__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15034:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ) + // InternalExpression.g:15035:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) + { + // InternalExpression.g:15035:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) + // InternalExpression.g:15036:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); + } + // InternalExpression.g:15037:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) + // InternalExpression.g:15037:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1" + // InternalExpression.g:15045:1: rule__XBasicForLoopExpression__Group_7__1 : rule__XBasicForLoopExpression__Group_7__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15049:1: ( rule__XBasicForLoopExpression__Group_7__1__Impl ) + // InternalExpression.g:15050:2: rule__XBasicForLoopExpression__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1__Impl" + // InternalExpression.g:15056:1: rule__XBasicForLoopExpression__Group_7__1__Impl : ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ; + public final void rule__XBasicForLoopExpression__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15060:1: ( ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ) + // InternalExpression.g:15061:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) + { + // InternalExpression.g:15061:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) + // InternalExpression.g:15062:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); + } + // InternalExpression.g:15063:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )* + loop117: + do { + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==78) ) { + alt117=1; + } + + + switch (alt117) { + case 1 : + // InternalExpression.g:15063:3: rule__XBasicForLoopExpression__Group_7_1__0 + { + pushFollow(FOLLOW_37); + rule__XBasicForLoopExpression__Group_7_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop117; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0" + // InternalExpression.g:15072:1: rule__XBasicForLoopExpression__Group_7_1__0 : rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ; + public final void rule__XBasicForLoopExpression__Group_7_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15076:1: ( rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ) + // InternalExpression.g:15077:2: rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 + { + pushFollow(FOLLOW_77); + rule__XBasicForLoopExpression__Group_7_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0__Impl" + // InternalExpression.g:15084:1: rule__XBasicForLoopExpression__Group_7_1__0__Impl : ( ',' ) ; + public final void rule__XBasicForLoopExpression__Group_7_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15088:1: ( ( ',' ) ) + // InternalExpression.g:15089:1: ( ',' ) + { + // InternalExpression.g:15089:1: ( ',' ) + // InternalExpression.g:15090:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1" + // InternalExpression.g:15099:1: rule__XBasicForLoopExpression__Group_7_1__1 : rule__XBasicForLoopExpression__Group_7_1__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_7_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15103:1: ( rule__XBasicForLoopExpression__Group_7_1__1__Impl ) + // InternalExpression.g:15104:2: rule__XBasicForLoopExpression__Group_7_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1__Impl" + // InternalExpression.g:15110:1: rule__XBasicForLoopExpression__Group_7_1__1__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ; + public final void rule__XBasicForLoopExpression__Group_7_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15114:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ) + // InternalExpression.g:15115:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) + { + // InternalExpression.g:15115:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) + // InternalExpression.g:15116:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); + } + // InternalExpression.g:15117:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) + // InternalExpression.g:15117:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__0" + // InternalExpression.g:15126:1: rule__XWhileExpression__Group__0 : rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ; + public final void rule__XWhileExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15130:1: ( rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ) + // InternalExpression.g:15131:2: rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 + { + pushFollow(FOLLOW_93); + rule__XWhileExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__0" + + + // $ANTLR start "rule__XWhileExpression__Group__0__Impl" + // InternalExpression.g:15138:1: rule__XWhileExpression__Group__0__Impl : ( () ) ; + public final void rule__XWhileExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15142:1: ( ( () ) ) + // InternalExpression.g:15143:1: ( () ) + { + // InternalExpression.g:15143:1: ( () ) + // InternalExpression.g:15144:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); + } + // InternalExpression.g:15145:2: () + // InternalExpression.g:15145:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__0__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__1" + // InternalExpression.g:15153:1: rule__XWhileExpression__Group__1 : rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ; + public final void rule__XWhileExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15157:1: ( rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ) + // InternalExpression.g:15158:2: rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 + { + pushFollow(FOLLOW_34); + rule__XWhileExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__1" + + + // $ANTLR start "rule__XWhileExpression__Group__1__Impl" + // InternalExpression.g:15165:1: rule__XWhileExpression__Group__1__Impl : ( 'while' ) ; + public final void rule__XWhileExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15169:1: ( ( 'while' ) ) + // InternalExpression.g:15170:1: ( 'while' ) + { + // InternalExpression.g:15170:1: ( 'while' ) + // InternalExpression.g:15171:2: 'while' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + match(input,90,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__1__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__2" + // InternalExpression.g:15180:1: rule__XWhileExpression__Group__2 : rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ; + public final void rule__XWhileExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15184:1: ( rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ) + // InternalExpression.g:15185:2: rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 + { + pushFollow(FOLLOW_77); + rule__XWhileExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__2" + + + // $ANTLR start "rule__XWhileExpression__Group__2__Impl" + // InternalExpression.g:15192:1: rule__XWhileExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XWhileExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15196:1: ( ( '(' ) ) + // InternalExpression.g:15197:1: ( '(' ) + { + // InternalExpression.g:15197:1: ( '(' ) + // InternalExpression.g:15198:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__2__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__3" + // InternalExpression.g:15207:1: rule__XWhileExpression__Group__3 : rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ; + public final void rule__XWhileExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15211:1: ( rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ) + // InternalExpression.g:15212:2: rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 + { + pushFollow(FOLLOW_9); + rule__XWhileExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__3" + + + // $ANTLR start "rule__XWhileExpression__Group__3__Impl" + // InternalExpression.g:15219:1: rule__XWhileExpression__Group__3__Impl : ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ; + public final void rule__XWhileExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15223:1: ( ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ) + // InternalExpression.g:15224:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) + { + // InternalExpression.g:15224:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) + // InternalExpression.g:15225:2: ( rule__XWhileExpression__PredicateAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); + } + // InternalExpression.g:15226:2: ( rule__XWhileExpression__PredicateAssignment_3 ) + // InternalExpression.g:15226:3: rule__XWhileExpression__PredicateAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__PredicateAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__3__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__4" + // InternalExpression.g:15234:1: rule__XWhileExpression__Group__4 : rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ; + public final void rule__XWhileExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15238:1: ( rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ) + // InternalExpression.g:15239:2: rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 + { + pushFollow(FOLLOW_77); + rule__XWhileExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__4" + + + // $ANTLR start "rule__XWhileExpression__Group__4__Impl" + // InternalExpression.g:15246:1: rule__XWhileExpression__Group__4__Impl : ( ')' ) ; + public final void rule__XWhileExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15250:1: ( ( ')' ) ) + // InternalExpression.g:15251:1: ( ')' ) + { + // InternalExpression.g:15251:1: ( ')' ) + // InternalExpression.g:15252:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__4__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__5" + // InternalExpression.g:15261:1: rule__XWhileExpression__Group__5 : rule__XWhileExpression__Group__5__Impl ; + public final void rule__XWhileExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15265:1: ( rule__XWhileExpression__Group__5__Impl ) + // InternalExpression.g:15266:2: rule__XWhileExpression__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__5" + + + // $ANTLR start "rule__XWhileExpression__Group__5__Impl" + // InternalExpression.g:15272:1: rule__XWhileExpression__Group__5__Impl : ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ; + public final void rule__XWhileExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15276:1: ( ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ) + // InternalExpression.g:15277:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) ) + { + // InternalExpression.g:15277:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) ) + // InternalExpression.g:15278:2: ( rule__XWhileExpression__BodyAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); + } + // InternalExpression.g:15279:2: ( rule__XWhileExpression__BodyAssignment_5 ) + // InternalExpression.g:15279:3: rule__XWhileExpression__BodyAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__BodyAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__5__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__0" + // InternalExpression.g:15288:1: rule__XDoWhileExpression__Group__0 : rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ; + public final void rule__XDoWhileExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15292:1: ( rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ) + // InternalExpression.g:15293:2: rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 + { + pushFollow(FOLLOW_94); + rule__XDoWhileExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__0" + + + // $ANTLR start "rule__XDoWhileExpression__Group__0__Impl" + // InternalExpression.g:15300:1: rule__XDoWhileExpression__Group__0__Impl : ( () ) ; + public final void rule__XDoWhileExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15304:1: ( ( () ) ) + // InternalExpression.g:15305:1: ( () ) + { + // InternalExpression.g:15305:1: ( () ) + // InternalExpression.g:15306:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); + } + // InternalExpression.g:15307:2: () + // InternalExpression.g:15307:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__0__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__1" + // InternalExpression.g:15315:1: rule__XDoWhileExpression__Group__1 : rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ; + public final void rule__XDoWhileExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15319:1: ( rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ) + // InternalExpression.g:15320:2: rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 + { + pushFollow(FOLLOW_77); + rule__XDoWhileExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__1" + + + // $ANTLR start "rule__XDoWhileExpression__Group__1__Impl" + // InternalExpression.g:15327:1: rule__XDoWhileExpression__Group__1__Impl : ( 'do' ) ; + public final void rule__XDoWhileExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15331:1: ( ( 'do' ) ) + // InternalExpression.g:15332:1: ( 'do' ) + { + // InternalExpression.g:15332:1: ( 'do' ) + // InternalExpression.g:15333:2: 'do' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + match(input,91,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__1__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__2" + // InternalExpression.g:15342:1: rule__XDoWhileExpression__Group__2 : rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ; + public final void rule__XDoWhileExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15346:1: ( rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ) + // InternalExpression.g:15347:2: rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 + { + pushFollow(FOLLOW_93); + rule__XDoWhileExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__2" + + + // $ANTLR start "rule__XDoWhileExpression__Group__2__Impl" + // InternalExpression.g:15354:1: rule__XDoWhileExpression__Group__2__Impl : ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ; + public final void rule__XDoWhileExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15358:1: ( ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ) + // InternalExpression.g:15359:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) + { + // InternalExpression.g:15359:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) + // InternalExpression.g:15360:2: ( rule__XDoWhileExpression__BodyAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); + } + // InternalExpression.g:15361:2: ( rule__XDoWhileExpression__BodyAssignment_2 ) + // InternalExpression.g:15361:3: rule__XDoWhileExpression__BodyAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__BodyAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__2__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__3" + // InternalExpression.g:15369:1: rule__XDoWhileExpression__Group__3 : rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ; + public final void rule__XDoWhileExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15373:1: ( rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ) + // InternalExpression.g:15374:2: rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 + { + pushFollow(FOLLOW_34); + rule__XDoWhileExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__3" + + + // $ANTLR start "rule__XDoWhileExpression__Group__3__Impl" + // InternalExpression.g:15381:1: rule__XDoWhileExpression__Group__3__Impl : ( 'while' ) ; + public final void rule__XDoWhileExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15385:1: ( ( 'while' ) ) + // InternalExpression.g:15386:1: ( 'while' ) + { + // InternalExpression.g:15386:1: ( 'while' ) + // InternalExpression.g:15387:2: 'while' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + match(input,90,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__3__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__4" + // InternalExpression.g:15396:1: rule__XDoWhileExpression__Group__4 : rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ; + public final void rule__XDoWhileExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15400:1: ( rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ) + // InternalExpression.g:15401:2: rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 + { + pushFollow(FOLLOW_77); + rule__XDoWhileExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__4" + + + // $ANTLR start "rule__XDoWhileExpression__Group__4__Impl" + // InternalExpression.g:15408:1: rule__XDoWhileExpression__Group__4__Impl : ( '(' ) ; + public final void rule__XDoWhileExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15412:1: ( ( '(' ) ) + // InternalExpression.g:15413:1: ( '(' ) + { + // InternalExpression.g:15413:1: ( '(' ) + // InternalExpression.g:15414:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__4__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__5" + // InternalExpression.g:15423:1: rule__XDoWhileExpression__Group__5 : rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ; + public final void rule__XDoWhileExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15427:1: ( rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ) + // InternalExpression.g:15428:2: rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 + { + pushFollow(FOLLOW_9); + rule__XDoWhileExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__5" + + + // $ANTLR start "rule__XDoWhileExpression__Group__5__Impl" + // InternalExpression.g:15435:1: rule__XDoWhileExpression__Group__5__Impl : ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ; + public final void rule__XDoWhileExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15439:1: ( ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ) + // InternalExpression.g:15440:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) + { + // InternalExpression.g:15440:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) + // InternalExpression.g:15441:2: ( rule__XDoWhileExpression__PredicateAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); + } + // InternalExpression.g:15442:2: ( rule__XDoWhileExpression__PredicateAssignment_5 ) + // InternalExpression.g:15442:3: rule__XDoWhileExpression__PredicateAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__PredicateAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__5__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__6" + // InternalExpression.g:15450:1: rule__XDoWhileExpression__Group__6 : rule__XDoWhileExpression__Group__6__Impl ; + public final void rule__XDoWhileExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15454:1: ( rule__XDoWhileExpression__Group__6__Impl ) + // InternalExpression.g:15455:2: rule__XDoWhileExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__6" + + + // $ANTLR start "rule__XDoWhileExpression__Group__6__Impl" + // InternalExpression.g:15461:1: rule__XDoWhileExpression__Group__6__Impl : ( ')' ) ; + public final void rule__XDoWhileExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15465:1: ( ( ')' ) ) + // InternalExpression.g:15466:1: ( ')' ) + { + // InternalExpression.g:15466:1: ( ')' ) + // InternalExpression.g:15467:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__6__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__0" + // InternalExpression.g:15477:1: rule__XBlockExpression__Group__0 : rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ; + public final void rule__XBlockExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15481:1: ( rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ) + // InternalExpression.g:15482:2: rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 + { + pushFollow(FOLLOW_41); + rule__XBlockExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__0" + + + // $ANTLR start "rule__XBlockExpression__Group__0__Impl" + // InternalExpression.g:15489:1: rule__XBlockExpression__Group__0__Impl : ( () ) ; + public final void rule__XBlockExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15493:1: ( ( () ) ) + // InternalExpression.g:15494:1: ( () ) + { + // InternalExpression.g:15494:1: ( () ) + // InternalExpression.g:15495:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); + } + // InternalExpression.g:15496:2: () + // InternalExpression.g:15496:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__0__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__1" + // InternalExpression.g:15504:1: rule__XBlockExpression__Group__1 : rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ; + public final void rule__XBlockExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15508:1: ( rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ) + // InternalExpression.g:15509:2: rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 + { + pushFollow(FOLLOW_95); + rule__XBlockExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__1" + + + // $ANTLR start "rule__XBlockExpression__Group__1__Impl" + // InternalExpression.g:15516:1: rule__XBlockExpression__Group__1__Impl : ( '{' ) ; + public final void rule__XBlockExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15520:1: ( ( '{' ) ) + // InternalExpression.g:15521:1: ( '{' ) + { + // InternalExpression.g:15521:1: ( '{' ) + // InternalExpression.g:15522:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__1__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__2" + // InternalExpression.g:15531:1: rule__XBlockExpression__Group__2 : rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ; + public final void rule__XBlockExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15535:1: ( rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ) + // InternalExpression.g:15536:2: rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 + { + pushFollow(FOLLOW_95); + rule__XBlockExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__2" + + + // $ANTLR start "rule__XBlockExpression__Group__2__Impl" + // InternalExpression.g:15543:1: rule__XBlockExpression__Group__2__Impl : ( ( rule__XBlockExpression__Group_2__0 )* ) ; + public final void rule__XBlockExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15547:1: ( ( ( rule__XBlockExpression__Group_2__0 )* ) ) + // InternalExpression.g:15548:1: ( ( rule__XBlockExpression__Group_2__0 )* ) + { + // InternalExpression.g:15548:1: ( ( rule__XBlockExpression__Group_2__0 )* ) + // InternalExpression.g:15549:2: ( rule__XBlockExpression__Group_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); + } + // InternalExpression.g:15550:2: ( rule__XBlockExpression__Group_2__0 )* + loop118: + do { + int alt118=2; + int LA118_0 = input.LA(1); + + if ( ((LA118_0>=RULE_ID && LA118_0<=RULE_DECIMAL)||LA118_0==RULE_STRING||(LA118_0>=22 && LA118_0<=24)||LA118_0==27||(LA118_0>=36 && LA118_0<=37)||(LA118_0>=59 && LA118_0<=64)||LA118_0==67||LA118_0==70||(LA118_0>=73 && LA118_0<=74)||(LA118_0>=81 && LA118_0<=82)||LA118_0==87||(LA118_0>=89 && LA118_0<=96)||LA118_0==98||LA118_0==104) ) { + alt118=1; + } + + + switch (alt118) { + case 1 : + // InternalExpression.g:15550:3: rule__XBlockExpression__Group_2__0 + { + pushFollow(FOLLOW_83); + rule__XBlockExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop118; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__2__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__3" + // InternalExpression.g:15558:1: rule__XBlockExpression__Group__3 : rule__XBlockExpression__Group__3__Impl ; + public final void rule__XBlockExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15562:1: ( rule__XBlockExpression__Group__3__Impl ) + // InternalExpression.g:15563:2: rule__XBlockExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__3" + + + // $ANTLR start "rule__XBlockExpression__Group__3__Impl" + // InternalExpression.g:15569:1: rule__XBlockExpression__Group__3__Impl : ( '}' ) ; + public final void rule__XBlockExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15573:1: ( ( '}' ) ) + // InternalExpression.g:15574:1: ( '}' ) + { + // InternalExpression.g:15574:1: ( '}' ) + // InternalExpression.g:15575:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + match(input,76,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__3__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group_2__0" + // InternalExpression.g:15585:1: rule__XBlockExpression__Group_2__0 : rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ; + public final void rule__XBlockExpression__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15589:1: ( rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ) + // InternalExpression.g:15590:2: rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 + { + pushFollow(FOLLOW_84); + rule__XBlockExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__0" + + + // $ANTLR start "rule__XBlockExpression__Group_2__0__Impl" + // InternalExpression.g:15597:1: rule__XBlockExpression__Group_2__0__Impl : ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ; + public final void rule__XBlockExpression__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15601:1: ( ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ) + // InternalExpression.g:15602:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) + { + // InternalExpression.g:15602:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) + // InternalExpression.g:15603:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); + } + // InternalExpression.g:15604:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) + // InternalExpression.g:15604:3: rule__XBlockExpression__ExpressionsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__ExpressionsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__0__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group_2__1" + // InternalExpression.g:15612:1: rule__XBlockExpression__Group_2__1 : rule__XBlockExpression__Group_2__1__Impl ; + public final void rule__XBlockExpression__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15616:1: ( rule__XBlockExpression__Group_2__1__Impl ) + // InternalExpression.g:15617:2: rule__XBlockExpression__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__1" + + + // $ANTLR start "rule__XBlockExpression__Group_2__1__Impl" + // InternalExpression.g:15623:1: rule__XBlockExpression__Group_2__1__Impl : ( ( ';' )? ) ; + public final void rule__XBlockExpression__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15627:1: ( ( ( ';' )? ) ) + // InternalExpression.g:15628:1: ( ( ';' )? ) + { + // InternalExpression.g:15628:1: ( ( ';' )? ) + // InternalExpression.g:15629:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + // InternalExpression.g:15630:2: ( ';' )? + int alt119=2; + int LA119_0 = input.LA(1); + + if ( (LA119_0==88) ) { + alt119=1; + } + switch (alt119) { + case 1 : + // InternalExpression.g:15630:3: ';' + { + match(input,88,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__0" + // InternalExpression.g:15639:1: rule__XVariableDeclaration__Group__0 : rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ; + public final void rule__XVariableDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15643:1: ( rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ) + // InternalExpression.g:15644:2: rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 + { + pushFollow(FOLLOW_96); + rule__XVariableDeclaration__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group__0__Impl" + // InternalExpression.g:15651:1: rule__XVariableDeclaration__Group__0__Impl : ( () ) ; + public final void rule__XVariableDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15655:1: ( ( () ) ) + // InternalExpression.g:15656:1: ( () ) + { + // InternalExpression.g:15656:1: ( () ) + // InternalExpression.g:15657:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); + } + // InternalExpression.g:15658:2: () + // InternalExpression.g:15658:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__1" + // InternalExpression.g:15666:1: rule__XVariableDeclaration__Group__1 : rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ; + public final void rule__XVariableDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15670:1: ( rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ) + // InternalExpression.g:15671:2: rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 + { + pushFollow(FOLLOW_56); + rule__XVariableDeclaration__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group__1__Impl" + // InternalExpression.g:15678:1: rule__XVariableDeclaration__Group__1__Impl : ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ; + public final void rule__XVariableDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15682:1: ( ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ) + // InternalExpression.g:15683:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) ) + { + // InternalExpression.g:15683:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) ) + // InternalExpression.g:15684:2: ( rule__XVariableDeclaration__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); + } + // InternalExpression.g:15685:2: ( rule__XVariableDeclaration__Alternatives_1 ) + // InternalExpression.g:15685:3: rule__XVariableDeclaration__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__2" + // InternalExpression.g:15693:1: rule__XVariableDeclaration__Group__2 : rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ; + public final void rule__XVariableDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15697:1: ( rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ) + // InternalExpression.g:15698:2: rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 + { + pushFollow(FOLLOW_5); + rule__XVariableDeclaration__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__2" + + + // $ANTLR start "rule__XVariableDeclaration__Group__2__Impl" + // InternalExpression.g:15705:1: rule__XVariableDeclaration__Group__2__Impl : ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ; + public final void rule__XVariableDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15709:1: ( ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ) + // InternalExpression.g:15710:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) ) + { + // InternalExpression.g:15710:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) ) + // InternalExpression.g:15711:2: ( rule__XVariableDeclaration__Alternatives_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); + } + // InternalExpression.g:15712:2: ( rule__XVariableDeclaration__Alternatives_2 ) + // InternalExpression.g:15712:3: rule__XVariableDeclaration__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__3" + // InternalExpression.g:15720:1: rule__XVariableDeclaration__Group__3 : rule__XVariableDeclaration__Group__3__Impl ; + public final void rule__XVariableDeclaration__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15724:1: ( rule__XVariableDeclaration__Group__3__Impl ) + // InternalExpression.g:15725:2: rule__XVariableDeclaration__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__3" + + + // $ANTLR start "rule__XVariableDeclaration__Group__3__Impl" + // InternalExpression.g:15731:1: rule__XVariableDeclaration__Group__3__Impl : ( ( rule__XVariableDeclaration__Group_3__0 )? ) ; + public final void rule__XVariableDeclaration__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15735:1: ( ( ( rule__XVariableDeclaration__Group_3__0 )? ) ) + // InternalExpression.g:15736:1: ( ( rule__XVariableDeclaration__Group_3__0 )? ) + { + // InternalExpression.g:15736:1: ( ( rule__XVariableDeclaration__Group_3__0 )? ) + // InternalExpression.g:15737:2: ( rule__XVariableDeclaration__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); + } + // InternalExpression.g:15738:2: ( rule__XVariableDeclaration__Group_3__0 )? + int alt120=2; + int LA120_0 = input.LA(1); + + if ( (LA120_0==14) ) { + alt120=1; + } + switch (alt120) { + case 1 : + // InternalExpression.g:15738:3: rule__XVariableDeclaration__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__3__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0" + // InternalExpression.g:15747:1: rule__XVariableDeclaration__Group_2_0__0 : rule__XVariableDeclaration__Group_2_0__0__Impl ; + public final void rule__XVariableDeclaration__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15751:1: ( rule__XVariableDeclaration__Group_2_0__0__Impl ) + // InternalExpression.g:15752:2: rule__XVariableDeclaration__Group_2_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0__Impl" + // InternalExpression.g:15758:1: rule__XVariableDeclaration__Group_2_0__0__Impl : ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15762:1: ( ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ) + // InternalExpression.g:15763:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) + { + // InternalExpression.g:15763:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) + // InternalExpression.g:15764:2: ( rule__XVariableDeclaration__Group_2_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); + } + // InternalExpression.g:15765:2: ( rule__XVariableDeclaration__Group_2_0_0__0 ) + // InternalExpression.g:15765:3: rule__XVariableDeclaration__Group_2_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0" + // InternalExpression.g:15774:1: rule__XVariableDeclaration__Group_2_0_0__0 : rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ; + public final void rule__XVariableDeclaration__Group_2_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15778:1: ( rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ) + // InternalExpression.g:15779:2: rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 + { + pushFollow(FOLLOW_4); + rule__XVariableDeclaration__Group_2_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0__Impl" + // InternalExpression.g:15786:1: rule__XVariableDeclaration__Group_2_0_0__0__Impl : ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15790:1: ( ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ) + // InternalExpression.g:15791:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) + { + // InternalExpression.g:15791:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) + // InternalExpression.g:15792:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); + } + // InternalExpression.g:15793:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) + // InternalExpression.g:15793:3: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__TypeAssignment_2_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1" + // InternalExpression.g:15801:1: rule__XVariableDeclaration__Group_2_0_0__1 : rule__XVariableDeclaration__Group_2_0_0__1__Impl ; + public final void rule__XVariableDeclaration__Group_2_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15805:1: ( rule__XVariableDeclaration__Group_2_0_0__1__Impl ) + // InternalExpression.g:15806:2: rule__XVariableDeclaration__Group_2_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1__Impl" + // InternalExpression.g:15812:1: rule__XVariableDeclaration__Group_2_0_0__1__Impl : ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15816:1: ( ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ) + // InternalExpression.g:15817:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) + { + // InternalExpression.g:15817:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) + // InternalExpression.g:15818:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); + } + // InternalExpression.g:15819:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) + // InternalExpression.g:15819:3: rule__XVariableDeclaration__NameAssignment_2_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__NameAssignment_2_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__0" + // InternalExpression.g:15828:1: rule__XVariableDeclaration__Group_3__0 : rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ; + public final void rule__XVariableDeclaration__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15832:1: ( rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ) + // InternalExpression.g:15833:2: rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 + { + pushFollow(FOLLOW_77); + rule__XVariableDeclaration__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__0__Impl" + // InternalExpression.g:15840:1: rule__XVariableDeclaration__Group_3__0__Impl : ( '=' ) ; + public final void rule__XVariableDeclaration__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15844:1: ( ( '=' ) ) + // InternalExpression.g:15845:1: ( '=' ) + { + // InternalExpression.g:15845:1: ( '=' ) + // InternalExpression.g:15846:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__1" + // InternalExpression.g:15855:1: rule__XVariableDeclaration__Group_3__1 : rule__XVariableDeclaration__Group_3__1__Impl ; + public final void rule__XVariableDeclaration__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15859:1: ( rule__XVariableDeclaration__Group_3__1__Impl ) + // InternalExpression.g:15860:2: rule__XVariableDeclaration__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__1__Impl" + // InternalExpression.g:15866:1: rule__XVariableDeclaration__Group_3__1__Impl : ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ; + public final void rule__XVariableDeclaration__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15870:1: ( ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ) + // InternalExpression.g:15871:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) + { + // InternalExpression.g:15871:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) + // InternalExpression.g:15872:2: ( rule__XVariableDeclaration__RightAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); + } + // InternalExpression.g:15873:2: ( rule__XVariableDeclaration__RightAssignment_3_1 ) + // InternalExpression.g:15873:3: rule__XVariableDeclaration__RightAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__RightAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__1__Impl" + + + // $ANTLR start "rule__JvmFormalParameter__Group__0" + // InternalExpression.g:15882:1: rule__JvmFormalParameter__Group__0 : rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ; + public final void rule__JvmFormalParameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15886:1: ( rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ) + // InternalExpression.g:15887:2: rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 + { + pushFollow(FOLLOW_56); + rule__JvmFormalParameter__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__0" + + + // $ANTLR start "rule__JvmFormalParameter__Group__0__Impl" + // InternalExpression.g:15894:1: rule__JvmFormalParameter__Group__0__Impl : ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ; + public final void rule__JvmFormalParameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15898:1: ( ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ) + // InternalExpression.g:15899:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) + { + // InternalExpression.g:15899:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) + // InternalExpression.g:15900:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + // InternalExpression.g:15901:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? + int alt121=2; + int LA121_0 = input.LA(1); + + if ( (LA121_0==RULE_ID) ) { + int LA121_1 = input.LA(2); + + if ( (LA121_1==RULE_ID||LA121_1==22||LA121_1==58||LA121_1==82) ) { + alt121=1; + } + } + else if ( (LA121_0==51||LA121_0==67) ) { + alt121=1; + } + switch (alt121) { + case 1 : + // InternalExpression.g:15901:3: rule__JvmFormalParameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__ParameterTypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__0__Impl" + + + // $ANTLR start "rule__JvmFormalParameter__Group__1" + // InternalExpression.g:15909:1: rule__JvmFormalParameter__Group__1 : rule__JvmFormalParameter__Group__1__Impl ; + public final void rule__JvmFormalParameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15913:1: ( rule__JvmFormalParameter__Group__1__Impl ) + // InternalExpression.g:15914:2: rule__JvmFormalParameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__1" + + + // $ANTLR start "rule__JvmFormalParameter__Group__1__Impl" + // InternalExpression.g:15920:1: rule__JvmFormalParameter__Group__1__Impl : ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ; + public final void rule__JvmFormalParameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15924:1: ( ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ) + // InternalExpression.g:15925:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) + { + // InternalExpression.g:15925:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) + // InternalExpression.g:15926:2: ( rule__JvmFormalParameter__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); + } + // InternalExpression.g:15927:2: ( rule__JvmFormalParameter__NameAssignment_1 ) + // InternalExpression.g:15927:3: rule__JvmFormalParameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__1__Impl" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__0" + // InternalExpression.g:15936:1: rule__FullJvmFormalParameter__Group__0 : rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ; + public final void rule__FullJvmFormalParameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15940:1: ( rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ) + // InternalExpression.g:15941:2: rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 + { + pushFollow(FOLLOW_4); + rule__FullJvmFormalParameter__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__0" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__0__Impl" + // InternalExpression.g:15948:1: rule__FullJvmFormalParameter__Group__0__Impl : ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ; + public final void rule__FullJvmFormalParameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15952:1: ( ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ) + // InternalExpression.g:15953:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) + { + // InternalExpression.g:15953:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) + // InternalExpression.g:15954:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + // InternalExpression.g:15955:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) + // InternalExpression.g:15955:3: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__ParameterTypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__0__Impl" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__1" + // InternalExpression.g:15963:1: rule__FullJvmFormalParameter__Group__1 : rule__FullJvmFormalParameter__Group__1__Impl ; + public final void rule__FullJvmFormalParameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15967:1: ( rule__FullJvmFormalParameter__Group__1__Impl ) + // InternalExpression.g:15968:2: rule__FullJvmFormalParameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__1" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__1__Impl" + // InternalExpression.g:15974:1: rule__FullJvmFormalParameter__Group__1__Impl : ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ; + public final void rule__FullJvmFormalParameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15978:1: ( ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ) + // InternalExpression.g:15979:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) + { + // InternalExpression.g:15979:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) + // InternalExpression.g:15980:2: ( rule__FullJvmFormalParameter__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); + } + // InternalExpression.g:15981:2: ( rule__FullJvmFormalParameter__NameAssignment_1 ) + // InternalExpression.g:15981:3: rule__FullJvmFormalParameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__0" + // InternalExpression.g:15990:1: rule__XFeatureCall__Group__0 : rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ; + public final void rule__XFeatureCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:15994:1: ( rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ) + // InternalExpression.g:15995:2: rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 + { + pushFollow(FOLLOW_72); + rule__XFeatureCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__0" + + + // $ANTLR start "rule__XFeatureCall__Group__0__Impl" + // InternalExpression.g:16002:1: rule__XFeatureCall__Group__0__Impl : ( () ) ; + public final void rule__XFeatureCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16006:1: ( ( () ) ) + // InternalExpression.g:16007:1: ( () ) + { + // InternalExpression.g:16007:1: ( () ) + // InternalExpression.g:16008:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); + } + // InternalExpression.g:16009:2: () + // InternalExpression.g:16009:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__1" + // InternalExpression.g:16017:1: rule__XFeatureCall__Group__1 : rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ; + public final void rule__XFeatureCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16021:1: ( rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ) + // InternalExpression.g:16022:2: rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 + { + pushFollow(FOLLOW_72); + rule__XFeatureCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__1" + + + // $ANTLR start "rule__XFeatureCall__Group__1__Impl" + // InternalExpression.g:16029:1: rule__XFeatureCall__Group__1__Impl : ( ( rule__XFeatureCall__Group_1__0 )? ) ; + public final void rule__XFeatureCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16033:1: ( ( ( rule__XFeatureCall__Group_1__0 )? ) ) + // InternalExpression.g:16034:1: ( ( rule__XFeatureCall__Group_1__0 )? ) + { + // InternalExpression.g:16034:1: ( ( rule__XFeatureCall__Group_1__0 )? ) + // InternalExpression.g:16035:2: ( rule__XFeatureCall__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_1()); + } + // InternalExpression.g:16036:2: ( rule__XFeatureCall__Group_1__0 )? + int alt122=2; + int LA122_0 = input.LA(1); + + if ( (LA122_0==22) ) { + alt122=1; + } + switch (alt122) { + case 1 : + // InternalExpression.g:16036:3: rule__XFeatureCall__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__2" + // InternalExpression.g:16044:1: rule__XFeatureCall__Group__2 : rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ; + public final void rule__XFeatureCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16048:1: ( rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ) + // InternalExpression.g:16049:2: rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 + { + pushFollow(FOLLOW_73); + rule__XFeatureCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__2" + + + // $ANTLR start "rule__XFeatureCall__Group__2__Impl" + // InternalExpression.g:16056:1: rule__XFeatureCall__Group__2__Impl : ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ; + public final void rule__XFeatureCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16060:1: ( ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ) + // InternalExpression.g:16061:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) + { + // InternalExpression.g:16061:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) + // InternalExpression.g:16062:2: ( rule__XFeatureCall__FeatureAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); + } + // InternalExpression.g:16063:2: ( rule__XFeatureCall__FeatureAssignment_2 ) + // InternalExpression.g:16063:3: rule__XFeatureCall__FeatureAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__3" + // InternalExpression.g:16071:1: rule__XFeatureCall__Group__3 : rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ; + public final void rule__XFeatureCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16075:1: ( rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ) + // InternalExpression.g:16076:2: rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 + { + pushFollow(FOLLOW_73); + rule__XFeatureCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__3" + + + // $ANTLR start "rule__XFeatureCall__Group__3__Impl" + // InternalExpression.g:16083:1: rule__XFeatureCall__Group__3__Impl : ( ( rule__XFeatureCall__Group_3__0 )? ) ; + public final void rule__XFeatureCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16087:1: ( ( ( rule__XFeatureCall__Group_3__0 )? ) ) + // InternalExpression.g:16088:1: ( ( rule__XFeatureCall__Group_3__0 )? ) + { + // InternalExpression.g:16088:1: ( ( rule__XFeatureCall__Group_3__0 )? ) + // InternalExpression.g:16089:2: ( rule__XFeatureCall__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3()); + } + // InternalExpression.g:16090:2: ( rule__XFeatureCall__Group_3__0 )? + int alt123=2; + alt123 = dfa123.predict(input); + switch (alt123) { + case 1 : + // InternalExpression.g:16090:3: rule__XFeatureCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__3__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__4" + // InternalExpression.g:16098:1: rule__XFeatureCall__Group__4 : rule__XFeatureCall__Group__4__Impl ; + public final void rule__XFeatureCall__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16102:1: ( rule__XFeatureCall__Group__4__Impl ) + // InternalExpression.g:16103:2: rule__XFeatureCall__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__4" + + + // $ANTLR start "rule__XFeatureCall__Group__4__Impl" + // InternalExpression.g:16109:1: rule__XFeatureCall__Group__4__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ; + public final void rule__XFeatureCall__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16113:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ) + // InternalExpression.g:16114:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) + { + // InternalExpression.g:16114:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) + // InternalExpression.g:16115:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); + } + // InternalExpression.g:16116:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? + int alt124=2; + alt124 = dfa124.predict(input); + switch (alt124) { + case 1 : + // InternalExpression.g:16116:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__4__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__0" + // InternalExpression.g:16125:1: rule__XFeatureCall__Group_1__0 : rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ; + public final void rule__XFeatureCall__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16129:1: ( rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ) + // InternalExpression.g:16130:2: rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 + { + pushFollow(FOLLOW_74); + rule__XFeatureCall__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_1__0__Impl" + // InternalExpression.g:16137:1: rule__XFeatureCall__Group_1__0__Impl : ( '<' ) ; + public final void rule__XFeatureCall__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16141:1: ( ( '<' ) ) + // InternalExpression.g:16142:1: ( '<' ) + { + // InternalExpression.g:16142:1: ( '<' ) + // InternalExpression.g:16143:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__1" + // InternalExpression.g:16152:1: rule__XFeatureCall__Group_1__1 : rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ; + public final void rule__XFeatureCall__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16156:1: ( rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ) + // InternalExpression.g:16157:2: rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 + { + pushFollow(FOLLOW_75); + rule__XFeatureCall__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_1__1__Impl" + // InternalExpression.g:16164:1: rule__XFeatureCall__Group_1__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ; + public final void rule__XFeatureCall__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16168:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ) + // InternalExpression.g:16169:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) + { + // InternalExpression.g:16169:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) + // InternalExpression.g:16170:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); + } + // InternalExpression.g:16171:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) + // InternalExpression.g:16171:3: rule__XFeatureCall__TypeArgumentsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__TypeArgumentsAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__2" + // InternalExpression.g:16179:1: rule__XFeatureCall__Group_1__2 : rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ; + public final void rule__XFeatureCall__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16183:1: ( rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ) + // InternalExpression.g:16184:2: rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 + { + pushFollow(FOLLOW_75); + rule__XFeatureCall__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__2" + + + // $ANTLR start "rule__XFeatureCall__Group_1__2__Impl" + // InternalExpression.g:16191:1: rule__XFeatureCall__Group_1__2__Impl : ( ( rule__XFeatureCall__Group_1_2__0 )* ) ; + public final void rule__XFeatureCall__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16195:1: ( ( ( rule__XFeatureCall__Group_1_2__0 )* ) ) + // InternalExpression.g:16196:1: ( ( rule__XFeatureCall__Group_1_2__0 )* ) + { + // InternalExpression.g:16196:1: ( ( rule__XFeatureCall__Group_1_2__0 )* ) + // InternalExpression.g:16197:2: ( rule__XFeatureCall__Group_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); + } + // InternalExpression.g:16198:2: ( rule__XFeatureCall__Group_1_2__0 )* + loop125: + do { + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==78) ) { + alt125=1; + } + + + switch (alt125) { + case 1 : + // InternalExpression.g:16198:3: rule__XFeatureCall__Group_1_2__0 + { + pushFollow(FOLLOW_37); + rule__XFeatureCall__Group_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop125; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__3" + // InternalExpression.g:16206:1: rule__XFeatureCall__Group_1__3 : rule__XFeatureCall__Group_1__3__Impl ; + public final void rule__XFeatureCall__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16210:1: ( rule__XFeatureCall__Group_1__3__Impl ) + // InternalExpression.g:16211:2: rule__XFeatureCall__Group_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__3" + + + // $ANTLR start "rule__XFeatureCall__Group_1__3__Impl" + // InternalExpression.g:16217:1: rule__XFeatureCall__Group_1__3__Impl : ( '>' ) ; + public final void rule__XFeatureCall__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16221:1: ( ( '>' ) ) + // InternalExpression.g:16222:1: ( '>' ) + { + // InternalExpression.g:16222:1: ( '>' ) + // InternalExpression.g:16223:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__3__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__0" + // InternalExpression.g:16233:1: rule__XFeatureCall__Group_1_2__0 : rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ; + public final void rule__XFeatureCall__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16237:1: ( rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ) + // InternalExpression.g:16238:2: rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 + { + pushFollow(FOLLOW_74); + rule__XFeatureCall__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__0" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__0__Impl" + // InternalExpression.g:16245:1: rule__XFeatureCall__Group_1_2__0__Impl : ( ',' ) ; + public final void rule__XFeatureCall__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16249:1: ( ( ',' ) ) + // InternalExpression.g:16250:1: ( ',' ) + { + // InternalExpression.g:16250:1: ( ',' ) + // InternalExpression.g:16251:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__1" + // InternalExpression.g:16260:1: rule__XFeatureCall__Group_1_2__1 : rule__XFeatureCall__Group_1_2__1__Impl ; + public final void rule__XFeatureCall__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16264:1: ( rule__XFeatureCall__Group_1_2__1__Impl ) + // InternalExpression.g:16265:2: rule__XFeatureCall__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__1" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__1__Impl" + // InternalExpression.g:16271:1: rule__XFeatureCall__Group_1_2__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ; + public final void rule__XFeatureCall__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16275:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ) + // InternalExpression.g:16276:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) + { + // InternalExpression.g:16276:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) + // InternalExpression.g:16277:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); + } + // InternalExpression.g:16278:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) + // InternalExpression.g:16278:3: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__TypeArgumentsAssignment_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__0" + // InternalExpression.g:16287:1: rule__XFeatureCall__Group_3__0 : rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ; + public final void rule__XFeatureCall__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16291:1: ( rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ) + // InternalExpression.g:16292:2: rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 + { + pushFollow(FOLLOW_76); + rule__XFeatureCall__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3__0__Impl" + // InternalExpression.g:16299:1: rule__XFeatureCall__Group_3__0__Impl : ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ; + public final void rule__XFeatureCall__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16303:1: ( ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ) + // InternalExpression.g:16304:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) + { + // InternalExpression.g:16304:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) + // InternalExpression.g:16305:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); + } + // InternalExpression.g:16306:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) + // InternalExpression.g:16306:3: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__ExplicitOperationCallAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__1" + // InternalExpression.g:16314:1: rule__XFeatureCall__Group_3__1 : rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ; + public final void rule__XFeatureCall__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16318:1: ( rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ) + // InternalExpression.g:16319:2: rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 + { + pushFollow(FOLLOW_76); + rule__XFeatureCall__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3__1__Impl" + // InternalExpression.g:16326:1: rule__XFeatureCall__Group_3__1__Impl : ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ; + public final void rule__XFeatureCall__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16330:1: ( ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ) + // InternalExpression.g:16331:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? ) + { + // InternalExpression.g:16331:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? ) + // InternalExpression.g:16332:2: ( rule__XFeatureCall__Alternatives_3_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); + } + // InternalExpression.g:16333:2: ( rule__XFeatureCall__Alternatives_3_1 )? + int alt126=2; + int LA126_0 = input.LA(1); + + if ( ((LA126_0>=RULE_ID && LA126_0<=RULE_DECIMAL)||LA126_0==RULE_STRING||(LA126_0>=22 && LA126_0<=24)||LA126_0==27||(LA126_0>=36 && LA126_0<=37)||LA126_0==51||(LA126_0>=60 && LA126_0<=64)||LA126_0==67||LA126_0==70||(LA126_0>=73 && LA126_0<=74)||LA126_0==79||(LA126_0>=81 && LA126_0<=82)||LA126_0==87||(LA126_0>=89 && LA126_0<=96)||LA126_0==98) ) { + alt126=1; + } + switch (alt126) { + case 1 : + // InternalExpression.g:16333:3: rule__XFeatureCall__Alternatives_3_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Alternatives_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__2" + // InternalExpression.g:16341:1: rule__XFeatureCall__Group_3__2 : rule__XFeatureCall__Group_3__2__Impl ; + public final void rule__XFeatureCall__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16345:1: ( rule__XFeatureCall__Group_3__2__Impl ) + // InternalExpression.g:16346:2: rule__XFeatureCall__Group_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__2" + + + // $ANTLR start "rule__XFeatureCall__Group_3__2__Impl" + // InternalExpression.g:16352:1: rule__XFeatureCall__Group_3__2__Impl : ( ')' ) ; + public final void rule__XFeatureCall__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16356:1: ( ( ')' ) ) + // InternalExpression.g:16357:1: ( ')' ) + { + // InternalExpression.g:16357:1: ( ')' ) + // InternalExpression.g:16358:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0" + // InternalExpression.g:16368:1: rule__XFeatureCall__Group_3_1_1__0 : rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ; + public final void rule__XFeatureCall__Group_3_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16372:1: ( rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ) + // InternalExpression.g:16373:2: rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 + { + pushFollow(FOLLOW_36); + rule__XFeatureCall__Group_3_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0__Impl" + // InternalExpression.g:16380:1: rule__XFeatureCall__Group_3_1_1__0__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ; + public final void rule__XFeatureCall__Group_3_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16384:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ) + // InternalExpression.g:16385:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) + { + // InternalExpression.g:16385:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) + // InternalExpression.g:16386:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); + } + // InternalExpression.g:16387:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) + // InternalExpression.g:16387:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1" + // InternalExpression.g:16395:1: rule__XFeatureCall__Group_3_1_1__1 : rule__XFeatureCall__Group_3_1_1__1__Impl ; + public final void rule__XFeatureCall__Group_3_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16399:1: ( rule__XFeatureCall__Group_3_1_1__1__Impl ) + // InternalExpression.g:16400:2: rule__XFeatureCall__Group_3_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1__Impl" + // InternalExpression.g:16406:1: rule__XFeatureCall__Group_3_1_1__1__Impl : ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ; + public final void rule__XFeatureCall__Group_3_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16410:1: ( ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ) + // InternalExpression.g:16411:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) + { + // InternalExpression.g:16411:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) + // InternalExpression.g:16412:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); + } + // InternalExpression.g:16413:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )* + loop127: + do { + int alt127=2; + int LA127_0 = input.LA(1); + + if ( (LA127_0==78) ) { + alt127=1; + } + + + switch (alt127) { + case 1 : + // InternalExpression.g:16413:3: rule__XFeatureCall__Group_3_1_1_1__0 + { + pushFollow(FOLLOW_37); + rule__XFeatureCall__Group_3_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop127; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0" + // InternalExpression.g:16422:1: rule__XFeatureCall__Group_3_1_1_1__0 : rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ; + public final void rule__XFeatureCall__Group_3_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16426:1: ( rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ) + // InternalExpression.g:16427:2: rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 + { + pushFollow(FOLLOW_77); + rule__XFeatureCall__Group_3_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0__Impl" + // InternalExpression.g:16434:1: rule__XFeatureCall__Group_3_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XFeatureCall__Group_3_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16438:1: ( ( ',' ) ) + // InternalExpression.g:16439:1: ( ',' ) + { + // InternalExpression.g:16439:1: ( ',' ) + // InternalExpression.g:16440:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1" + // InternalExpression.g:16449:1: rule__XFeatureCall__Group_3_1_1_1__1 : rule__XFeatureCall__Group_3_1_1_1__1__Impl ; + public final void rule__XFeatureCall__Group_3_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16453:1: ( rule__XFeatureCall__Group_3_1_1_1__1__Impl ) + // InternalExpression.g:16454:2: rule__XFeatureCall__Group_3_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1__Impl" + // InternalExpression.g:16460:1: rule__XFeatureCall__Group_3_1_1_1__1__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ; + public final void rule__XFeatureCall__Group_3_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16464:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ) + // InternalExpression.g:16465:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) + { + // InternalExpression.g:16465:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) + // InternalExpression.g:16466:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); + } + // InternalExpression.g:16467:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) + // InternalExpression.g:16467:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__0" + // InternalExpression.g:16476:1: rule__XConstructorCall__Group__0 : rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ; + public final void rule__XConstructorCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16480:1: ( rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ) + // InternalExpression.g:16481:2: rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 + { + pushFollow(FOLLOW_97); + rule__XConstructorCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__0" + + + // $ANTLR start "rule__XConstructorCall__Group__0__Impl" + // InternalExpression.g:16488:1: rule__XConstructorCall__Group__0__Impl : ( () ) ; + public final void rule__XConstructorCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16492:1: ( ( () ) ) + // InternalExpression.g:16493:1: ( () ) + { + // InternalExpression.g:16493:1: ( () ) + // InternalExpression.g:16494:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); + } + // InternalExpression.g:16495:2: () + // InternalExpression.g:16495:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__1" + // InternalExpression.g:16503:1: rule__XConstructorCall__Group__1 : rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ; + public final void rule__XConstructorCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16507:1: ( rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ) + // InternalExpression.g:16508:2: rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 + { + pushFollow(FOLLOW_4); + rule__XConstructorCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__1" + + + // $ANTLR start "rule__XConstructorCall__Group__1__Impl" + // InternalExpression.g:16515:1: rule__XConstructorCall__Group__1__Impl : ( 'new' ) ; + public final void rule__XConstructorCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16519:1: ( ( 'new' ) ) + // InternalExpression.g:16520:1: ( 'new' ) + { + // InternalExpression.g:16520:1: ( 'new' ) + // InternalExpression.g:16521:2: 'new' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + match(input,81,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__2" + // InternalExpression.g:16530:1: rule__XConstructorCall__Group__2 : rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ; + public final void rule__XConstructorCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16534:1: ( rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ) + // InternalExpression.g:16535:2: rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 + { + pushFollow(FOLLOW_98); + rule__XConstructorCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__2" + + + // $ANTLR start "rule__XConstructorCall__Group__2__Impl" + // InternalExpression.g:16542:1: rule__XConstructorCall__Group__2__Impl : ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ; + public final void rule__XConstructorCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16546:1: ( ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ) + // InternalExpression.g:16547:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) + { + // InternalExpression.g:16547:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) + // InternalExpression.g:16548:2: ( rule__XConstructorCall__ConstructorAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); + } + // InternalExpression.g:16549:2: ( rule__XConstructorCall__ConstructorAssignment_2 ) + // InternalExpression.g:16549:3: rule__XConstructorCall__ConstructorAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ConstructorAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__3" + // InternalExpression.g:16557:1: rule__XConstructorCall__Group__3 : rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ; + public final void rule__XConstructorCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16561:1: ( rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ) + // InternalExpression.g:16562:2: rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 + { + pushFollow(FOLLOW_98); + rule__XConstructorCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__3" + + + // $ANTLR start "rule__XConstructorCall__Group__3__Impl" + // InternalExpression.g:16569:1: rule__XConstructorCall__Group__3__Impl : ( ( rule__XConstructorCall__Group_3__0 )? ) ; + public final void rule__XConstructorCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16573:1: ( ( ( rule__XConstructorCall__Group_3__0 )? ) ) + // InternalExpression.g:16574:1: ( ( rule__XConstructorCall__Group_3__0 )? ) + { + // InternalExpression.g:16574:1: ( ( rule__XConstructorCall__Group_3__0 )? ) + // InternalExpression.g:16575:2: ( rule__XConstructorCall__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_3()); + } + // InternalExpression.g:16576:2: ( rule__XConstructorCall__Group_3__0 )? + int alt128=2; + alt128 = dfa128.predict(input); + switch (alt128) { + case 1 : + // InternalExpression.g:16576:3: rule__XConstructorCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__3__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__4" + // InternalExpression.g:16584:1: rule__XConstructorCall__Group__4 : rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ; + public final void rule__XConstructorCall__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16588:1: ( rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ) + // InternalExpression.g:16589:2: rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 + { + pushFollow(FOLLOW_98); + rule__XConstructorCall__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__4" + + + // $ANTLR start "rule__XConstructorCall__Group__4__Impl" + // InternalExpression.g:16596:1: rule__XConstructorCall__Group__4__Impl : ( ( rule__XConstructorCall__Group_4__0 )? ) ; + public final void rule__XConstructorCall__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16600:1: ( ( ( rule__XConstructorCall__Group_4__0 )? ) ) + // InternalExpression.g:16601:1: ( ( rule__XConstructorCall__Group_4__0 )? ) + { + // InternalExpression.g:16601:1: ( ( rule__XConstructorCall__Group_4__0 )? ) + // InternalExpression.g:16602:2: ( rule__XConstructorCall__Group_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4()); + } + // InternalExpression.g:16603:2: ( rule__XConstructorCall__Group_4__0 )? + int alt129=2; + alt129 = dfa129.predict(input); + switch (alt129) { + case 1 : + // InternalExpression.g:16603:3: rule__XConstructorCall__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__4__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__5" + // InternalExpression.g:16611:1: rule__XConstructorCall__Group__5 : rule__XConstructorCall__Group__5__Impl ; + public final void rule__XConstructorCall__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16615:1: ( rule__XConstructorCall__Group__5__Impl ) + // InternalExpression.g:16616:2: rule__XConstructorCall__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__5" + + + // $ANTLR start "rule__XConstructorCall__Group__5__Impl" + // InternalExpression.g:16622:1: rule__XConstructorCall__Group__5__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ; + public final void rule__XConstructorCall__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16626:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ) + // InternalExpression.g:16627:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) + { + // InternalExpression.g:16627:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) + // InternalExpression.g:16628:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); + } + // InternalExpression.g:16629:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )? + int alt130=2; + alt130 = dfa130.predict(input); + switch (alt130) { + case 1 : + // InternalExpression.g:16629:3: rule__XConstructorCall__ArgumentsAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__5__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__0" + // InternalExpression.g:16638:1: rule__XConstructorCall__Group_3__0 : rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ; + public final void rule__XConstructorCall__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16642:1: ( rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ) + // InternalExpression.g:16643:2: rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 + { + pushFollow(FOLLOW_74); + rule__XConstructorCall__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__0" + + + // $ANTLR start "rule__XConstructorCall__Group_3__0__Impl" + // InternalExpression.g:16650:1: rule__XConstructorCall__Group_3__0__Impl : ( ( '<' ) ) ; + public final void rule__XConstructorCall__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16654:1: ( ( ( '<' ) ) ) + // InternalExpression.g:16655:1: ( ( '<' ) ) + { + // InternalExpression.g:16655:1: ( ( '<' ) ) + // InternalExpression.g:16656:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + // InternalExpression.g:16657:2: ( '<' ) + // InternalExpression.g:16657:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__1" + // InternalExpression.g:16665:1: rule__XConstructorCall__Group_3__1 : rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ; + public final void rule__XConstructorCall__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16669:1: ( rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ) + // InternalExpression.g:16670:2: rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 + { + pushFollow(FOLLOW_75); + rule__XConstructorCall__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__1" + + + // $ANTLR start "rule__XConstructorCall__Group_3__1__Impl" + // InternalExpression.g:16677:1: rule__XConstructorCall__Group_3__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ; + public final void rule__XConstructorCall__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16681:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ) + // InternalExpression.g:16682:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) + { + // InternalExpression.g:16682:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) + // InternalExpression.g:16683:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); + } + // InternalExpression.g:16684:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) + // InternalExpression.g:16684:3: rule__XConstructorCall__TypeArgumentsAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__TypeArgumentsAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__2" + // InternalExpression.g:16692:1: rule__XConstructorCall__Group_3__2 : rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ; + public final void rule__XConstructorCall__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16696:1: ( rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ) + // InternalExpression.g:16697:2: rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 + { + pushFollow(FOLLOW_75); + rule__XConstructorCall__Group_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__2" + + + // $ANTLR start "rule__XConstructorCall__Group_3__2__Impl" + // InternalExpression.g:16704:1: rule__XConstructorCall__Group_3__2__Impl : ( ( rule__XConstructorCall__Group_3_2__0 )* ) ; + public final void rule__XConstructorCall__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16708:1: ( ( ( rule__XConstructorCall__Group_3_2__0 )* ) ) + // InternalExpression.g:16709:1: ( ( rule__XConstructorCall__Group_3_2__0 )* ) + { + // InternalExpression.g:16709:1: ( ( rule__XConstructorCall__Group_3_2__0 )* ) + // InternalExpression.g:16710:2: ( rule__XConstructorCall__Group_3_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); + } + // InternalExpression.g:16711:2: ( rule__XConstructorCall__Group_3_2__0 )* + loop131: + do { + int alt131=2; + int LA131_0 = input.LA(1); + + if ( (LA131_0==78) ) { + alt131=1; + } + + + switch (alt131) { + case 1 : + // InternalExpression.g:16711:3: rule__XConstructorCall__Group_3_2__0 + { + pushFollow(FOLLOW_37); + rule__XConstructorCall__Group_3_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop131; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__3" + // InternalExpression.g:16719:1: rule__XConstructorCall__Group_3__3 : rule__XConstructorCall__Group_3__3__Impl ; + public final void rule__XConstructorCall__Group_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16723:1: ( rule__XConstructorCall__Group_3__3__Impl ) + // InternalExpression.g:16724:2: rule__XConstructorCall__Group_3__3__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__3" + + + // $ANTLR start "rule__XConstructorCall__Group_3__3__Impl" + // InternalExpression.g:16730:1: rule__XConstructorCall__Group_3__3__Impl : ( '>' ) ; + public final void rule__XConstructorCall__Group_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16734:1: ( ( '>' ) ) + // InternalExpression.g:16735:1: ( '>' ) + { + // InternalExpression.g:16735:1: ( '>' ) + // InternalExpression.g:16736:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__3__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__0" + // InternalExpression.g:16746:1: rule__XConstructorCall__Group_3_2__0 : rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ; + public final void rule__XConstructorCall__Group_3_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16750:1: ( rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ) + // InternalExpression.g:16751:2: rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 + { + pushFollow(FOLLOW_74); + rule__XConstructorCall__Group_3_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__0" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__0__Impl" + // InternalExpression.g:16758:1: rule__XConstructorCall__Group_3_2__0__Impl : ( ',' ) ; + public final void rule__XConstructorCall__Group_3_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16762:1: ( ( ',' ) ) + // InternalExpression.g:16763:1: ( ',' ) + { + // InternalExpression.g:16763:1: ( ',' ) + // InternalExpression.g:16764:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__1" + // InternalExpression.g:16773:1: rule__XConstructorCall__Group_3_2__1 : rule__XConstructorCall__Group_3_2__1__Impl ; + public final void rule__XConstructorCall__Group_3_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16777:1: ( rule__XConstructorCall__Group_3_2__1__Impl ) + // InternalExpression.g:16778:2: rule__XConstructorCall__Group_3_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__1" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__1__Impl" + // InternalExpression.g:16784:1: rule__XConstructorCall__Group_3_2__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ; + public final void rule__XConstructorCall__Group_3_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16788:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ) + // InternalExpression.g:16789:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) + { + // InternalExpression.g:16789:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) + // InternalExpression.g:16790:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); + } + // InternalExpression.g:16791:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) + // InternalExpression.g:16791:3: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__TypeArgumentsAssignment_3_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__0" + // InternalExpression.g:16800:1: rule__XConstructorCall__Group_4__0 : rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ; + public final void rule__XConstructorCall__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16804:1: ( rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ) + // InternalExpression.g:16805:2: rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 + { + pushFollow(FOLLOW_76); + rule__XConstructorCall__Group_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4__0__Impl" + // InternalExpression.g:16812:1: rule__XConstructorCall__Group_4__0__Impl : ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ; + public final void rule__XConstructorCall__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16816:1: ( ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ) + // InternalExpression.g:16817:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) + { + // InternalExpression.g:16817:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) + // InternalExpression.g:16818:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); + } + // InternalExpression.g:16819:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) + // InternalExpression.g:16819:3: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__1" + // InternalExpression.g:16827:1: rule__XConstructorCall__Group_4__1 : rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ; + public final void rule__XConstructorCall__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16831:1: ( rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ) + // InternalExpression.g:16832:2: rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 + { + pushFollow(FOLLOW_76); + rule__XConstructorCall__Group_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4__1__Impl" + // InternalExpression.g:16839:1: rule__XConstructorCall__Group_4__1__Impl : ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ; + public final void rule__XConstructorCall__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16843:1: ( ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ) + // InternalExpression.g:16844:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? ) + { + // InternalExpression.g:16844:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? ) + // InternalExpression.g:16845:2: ( rule__XConstructorCall__Alternatives_4_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); + } + // InternalExpression.g:16846:2: ( rule__XConstructorCall__Alternatives_4_1 )? + int alt132=2; + int LA132_0 = input.LA(1); + + if ( ((LA132_0>=RULE_ID && LA132_0<=RULE_DECIMAL)||LA132_0==RULE_STRING||(LA132_0>=22 && LA132_0<=24)||LA132_0==27||(LA132_0>=36 && LA132_0<=37)||LA132_0==51||(LA132_0>=60 && LA132_0<=64)||LA132_0==67||LA132_0==70||(LA132_0>=73 && LA132_0<=74)||LA132_0==79||(LA132_0>=81 && LA132_0<=82)||LA132_0==87||(LA132_0>=89 && LA132_0<=96)||LA132_0==98) ) { + alt132=1; + } + switch (alt132) { + case 1 : + // InternalExpression.g:16846:3: rule__XConstructorCall__Alternatives_4_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Alternatives_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__2" + // InternalExpression.g:16854:1: rule__XConstructorCall__Group_4__2 : rule__XConstructorCall__Group_4__2__Impl ; + public final void rule__XConstructorCall__Group_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16858:1: ( rule__XConstructorCall__Group_4__2__Impl ) + // InternalExpression.g:16859:2: rule__XConstructorCall__Group_4__2__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__2" + + + // $ANTLR start "rule__XConstructorCall__Group_4__2__Impl" + // InternalExpression.g:16865:1: rule__XConstructorCall__Group_4__2__Impl : ( ')' ) ; + public final void rule__XConstructorCall__Group_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16869:1: ( ( ')' ) ) + // InternalExpression.g:16870:1: ( ')' ) + { + // InternalExpression.g:16870:1: ( ')' ) + // InternalExpression.g:16871:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0" + // InternalExpression.g:16881:1: rule__XConstructorCall__Group_4_1_1__0 : rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ; + public final void rule__XConstructorCall__Group_4_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16885:1: ( rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ) + // InternalExpression.g:16886:2: rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 + { + pushFollow(FOLLOW_36); + rule__XConstructorCall__Group_4_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0__Impl" + // InternalExpression.g:16893:1: rule__XConstructorCall__Group_4_1_1__0__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ; + public final void rule__XConstructorCall__Group_4_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16897:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ) + // InternalExpression.g:16898:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) + { + // InternalExpression.g:16898:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) + // InternalExpression.g:16899:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); + } + // InternalExpression.g:16900:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) + // InternalExpression.g:16900:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1" + // InternalExpression.g:16908:1: rule__XConstructorCall__Group_4_1_1__1 : rule__XConstructorCall__Group_4_1_1__1__Impl ; + public final void rule__XConstructorCall__Group_4_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16912:1: ( rule__XConstructorCall__Group_4_1_1__1__Impl ) + // InternalExpression.g:16913:2: rule__XConstructorCall__Group_4_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1__Impl" + // InternalExpression.g:16919:1: rule__XConstructorCall__Group_4_1_1__1__Impl : ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ; + public final void rule__XConstructorCall__Group_4_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16923:1: ( ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ) + // InternalExpression.g:16924:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) + { + // InternalExpression.g:16924:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) + // InternalExpression.g:16925:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); + } + // InternalExpression.g:16926:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )* + loop133: + do { + int alt133=2; + int LA133_0 = input.LA(1); + + if ( (LA133_0==78) ) { + alt133=1; + } + + + switch (alt133) { + case 1 : + // InternalExpression.g:16926:3: rule__XConstructorCall__Group_4_1_1_1__0 + { + pushFollow(FOLLOW_37); + rule__XConstructorCall__Group_4_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop133; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0" + // InternalExpression.g:16935:1: rule__XConstructorCall__Group_4_1_1_1__0 : rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ; + public final void rule__XConstructorCall__Group_4_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16939:1: ( rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ) + // InternalExpression.g:16940:2: rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 + { + pushFollow(FOLLOW_77); + rule__XConstructorCall__Group_4_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0__Impl" + // InternalExpression.g:16947:1: rule__XConstructorCall__Group_4_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XConstructorCall__Group_4_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16951:1: ( ( ',' ) ) + // InternalExpression.g:16952:1: ( ',' ) + { + // InternalExpression.g:16952:1: ( ',' ) + // InternalExpression.g:16953:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1" + // InternalExpression.g:16962:1: rule__XConstructorCall__Group_4_1_1_1__1 : rule__XConstructorCall__Group_4_1_1_1__1__Impl ; + public final void rule__XConstructorCall__Group_4_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16966:1: ( rule__XConstructorCall__Group_4_1_1_1__1__Impl ) + // InternalExpression.g:16967:2: rule__XConstructorCall__Group_4_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1__Impl" + // InternalExpression.g:16973:1: rule__XConstructorCall__Group_4_1_1_1__1__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ; + public final void rule__XConstructorCall__Group_4_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16977:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ) + // InternalExpression.g:16978:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) + { + // InternalExpression.g:16978:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) + // InternalExpression.g:16979:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); + } + // InternalExpression.g:16980:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) + // InternalExpression.g:16980:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1__Impl" + + + // $ANTLR start "rule__XBooleanLiteral__Group__0" + // InternalExpression.g:16989:1: rule__XBooleanLiteral__Group__0 : rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ; + public final void rule__XBooleanLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:16993:1: ( rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ) + // InternalExpression.g:16994:2: rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 + { + pushFollow(FOLLOW_99); + rule__XBooleanLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__0" + + + // $ANTLR start "rule__XBooleanLiteral__Group__0__Impl" + // InternalExpression.g:17001:1: rule__XBooleanLiteral__Group__0__Impl : ( () ) ; + public final void rule__XBooleanLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17005:1: ( ( () ) ) + // InternalExpression.g:17006:1: ( () ) + { + // InternalExpression.g:17006:1: ( () ) + // InternalExpression.g:17007:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); + } + // InternalExpression.g:17008:2: () + // InternalExpression.g:17008:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XBooleanLiteral__Group__1" + // InternalExpression.g:17016:1: rule__XBooleanLiteral__Group__1 : rule__XBooleanLiteral__Group__1__Impl ; + public final void rule__XBooleanLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17020:1: ( rule__XBooleanLiteral__Group__1__Impl ) + // InternalExpression.g:17021:2: rule__XBooleanLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__1" + + + // $ANTLR start "rule__XBooleanLiteral__Group__1__Impl" + // InternalExpression.g:17027:1: rule__XBooleanLiteral__Group__1__Impl : ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ; + public final void rule__XBooleanLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17031:1: ( ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ) + // InternalExpression.g:17032:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) ) + { + // InternalExpression.g:17032:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) ) + // InternalExpression.g:17033:2: ( rule__XBooleanLiteral__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); + } + // InternalExpression.g:17034:2: ( rule__XBooleanLiteral__Alternatives_1 ) + // InternalExpression.g:17034:3: rule__XBooleanLiteral__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XNullLiteral__Group__0" + // InternalExpression.g:17043:1: rule__XNullLiteral__Group__0 : rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ; + public final void rule__XNullLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17047:1: ( rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ) + // InternalExpression.g:17048:2: rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 + { + pushFollow(FOLLOW_100); + rule__XNullLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__0" + + + // $ANTLR start "rule__XNullLiteral__Group__0__Impl" + // InternalExpression.g:17055:1: rule__XNullLiteral__Group__0__Impl : ( () ) ; + public final void rule__XNullLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17059:1: ( ( () ) ) + // InternalExpression.g:17060:1: ( () ) + { + // InternalExpression.g:17060:1: ( () ) + // InternalExpression.g:17061:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); + } + // InternalExpression.g:17062:2: () + // InternalExpression.g:17062:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XNullLiteral__Group__1" + // InternalExpression.g:17070:1: rule__XNullLiteral__Group__1 : rule__XNullLiteral__Group__1__Impl ; + public final void rule__XNullLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17074:1: ( rule__XNullLiteral__Group__1__Impl ) + // InternalExpression.g:17075:2: rule__XNullLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__1" + + + // $ANTLR start "rule__XNullLiteral__Group__1__Impl" + // InternalExpression.g:17081:1: rule__XNullLiteral__Group__1__Impl : ( 'null' ) ; + public final void rule__XNullLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17085:1: ( ( 'null' ) ) + // InternalExpression.g:17086:1: ( 'null' ) + { + // InternalExpression.g:17086:1: ( 'null' ) + // InternalExpression.g:17087:2: 'null' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XNumberLiteral__Group__0" + // InternalExpression.g:17097:1: rule__XNumberLiteral__Group__0 : rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ; + public final void rule__XNumberLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17101:1: ( rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ) + // InternalExpression.g:17102:2: rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 + { + pushFollow(FOLLOW_101); + rule__XNumberLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__0" + + + // $ANTLR start "rule__XNumberLiteral__Group__0__Impl" + // InternalExpression.g:17109:1: rule__XNumberLiteral__Group__0__Impl : ( () ) ; + public final void rule__XNumberLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17113:1: ( ( () ) ) + // InternalExpression.g:17114:1: ( () ) + { + // InternalExpression.g:17114:1: ( () ) + // InternalExpression.g:17115:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); + } + // InternalExpression.g:17116:2: () + // InternalExpression.g:17116:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XNumberLiteral__Group__1" + // InternalExpression.g:17124:1: rule__XNumberLiteral__Group__1 : rule__XNumberLiteral__Group__1__Impl ; + public final void rule__XNumberLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17128:1: ( rule__XNumberLiteral__Group__1__Impl ) + // InternalExpression.g:17129:2: rule__XNumberLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__1" + + + // $ANTLR start "rule__XNumberLiteral__Group__1__Impl" + // InternalExpression.g:17135:1: rule__XNumberLiteral__Group__1__Impl : ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ; + public final void rule__XNumberLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17139:1: ( ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ) + // InternalExpression.g:17140:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) + { + // InternalExpression.g:17140:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) + // InternalExpression.g:17141:2: ( rule__XNumberLiteral__ValueAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); + } + // InternalExpression.g:17142:2: ( rule__XNumberLiteral__ValueAssignment_1 ) + // InternalExpression.g:17142:3: rule__XNumberLiteral__ValueAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__ValueAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XStringLiteral__Group__0" + // InternalExpression.g:17151:1: rule__XStringLiteral__Group__0 : rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ; + public final void rule__XStringLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17155:1: ( rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ) + // InternalExpression.g:17156:2: rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 + { + pushFollow(FOLLOW_102); + rule__XStringLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__0" + + + // $ANTLR start "rule__XStringLiteral__Group__0__Impl" + // InternalExpression.g:17163:1: rule__XStringLiteral__Group__0__Impl : ( () ) ; + public final void rule__XStringLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17167:1: ( ( () ) ) + // InternalExpression.g:17168:1: ( () ) + { + // InternalExpression.g:17168:1: ( () ) + // InternalExpression.g:17169:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); + } + // InternalExpression.g:17170:2: () + // InternalExpression.g:17170:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XStringLiteral__Group__1" + // InternalExpression.g:17178:1: rule__XStringLiteral__Group__1 : rule__XStringLiteral__Group__1__Impl ; + public final void rule__XStringLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17182:1: ( rule__XStringLiteral__Group__1__Impl ) + // InternalExpression.g:17183:2: rule__XStringLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__1" + + + // $ANTLR start "rule__XStringLiteral__Group__1__Impl" + // InternalExpression.g:17189:1: rule__XStringLiteral__Group__1__Impl : ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ; + public final void rule__XStringLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17193:1: ( ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ) + // InternalExpression.g:17194:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) ) + { + // InternalExpression.g:17194:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) ) + // InternalExpression.g:17195:2: ( rule__XStringLiteral__ValueAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); + } + // InternalExpression.g:17196:2: ( rule__XStringLiteral__ValueAssignment_1 ) + // InternalExpression.g:17196:3: rule__XStringLiteral__ValueAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__ValueAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__0" + // InternalExpression.g:17205:1: rule__XTypeLiteral__Group__0 : rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ; + public final void rule__XTypeLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17209:1: ( rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ) + // InternalExpression.g:17210:2: rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 + { + pushFollow(FOLLOW_103); + rule__XTypeLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__0" + + + // $ANTLR start "rule__XTypeLiteral__Group__0__Impl" + // InternalExpression.g:17217:1: rule__XTypeLiteral__Group__0__Impl : ( () ) ; + public final void rule__XTypeLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17221:1: ( ( () ) ) + // InternalExpression.g:17222:1: ( () ) + { + // InternalExpression.g:17222:1: ( () ) + // InternalExpression.g:17223:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); + } + // InternalExpression.g:17224:2: () + // InternalExpression.g:17224:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__1" + // InternalExpression.g:17232:1: rule__XTypeLiteral__Group__1 : rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ; + public final void rule__XTypeLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17236:1: ( rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ) + // InternalExpression.g:17237:2: rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 + { + pushFollow(FOLLOW_34); + rule__XTypeLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__1" + + + // $ANTLR start "rule__XTypeLiteral__Group__1__Impl" + // InternalExpression.g:17244:1: rule__XTypeLiteral__Group__1__Impl : ( 'typeof' ) ; + public final void rule__XTypeLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17248:1: ( ( 'typeof' ) ) + // InternalExpression.g:17249:1: ( 'typeof' ) + { + // InternalExpression.g:17249:1: ( 'typeof' ) + // InternalExpression.g:17250:2: 'typeof' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__2" + // InternalExpression.g:17259:1: rule__XTypeLiteral__Group__2 : rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ; + public final void rule__XTypeLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17263:1: ( rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ) + // InternalExpression.g:17264:2: rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 + { + pushFollow(FOLLOW_4); + rule__XTypeLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__2" + + + // $ANTLR start "rule__XTypeLiteral__Group__2__Impl" + // InternalExpression.g:17271:1: rule__XTypeLiteral__Group__2__Impl : ( '(' ) ; + public final void rule__XTypeLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17275:1: ( ( '(' ) ) + // InternalExpression.g:17276:1: ( '(' ) + { + // InternalExpression.g:17276:1: ( '(' ) + // InternalExpression.g:17277:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__3" + // InternalExpression.g:17286:1: rule__XTypeLiteral__Group__3 : rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ; + public final void rule__XTypeLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17290:1: ( rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ) + // InternalExpression.g:17291:2: rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 + { + pushFollow(FOLLOW_104); + rule__XTypeLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__3" + + + // $ANTLR start "rule__XTypeLiteral__Group__3__Impl" + // InternalExpression.g:17298:1: rule__XTypeLiteral__Group__3__Impl : ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ; + public final void rule__XTypeLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17302:1: ( ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ) + // InternalExpression.g:17303:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) + { + // InternalExpression.g:17303:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) + // InternalExpression.g:17304:2: ( rule__XTypeLiteral__TypeAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); + } + // InternalExpression.g:17305:2: ( rule__XTypeLiteral__TypeAssignment_3 ) + // InternalExpression.g:17305:3: rule__XTypeLiteral__TypeAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__TypeAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__4" + // InternalExpression.g:17313:1: rule__XTypeLiteral__Group__4 : rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ; + public final void rule__XTypeLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17317:1: ( rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ) + // InternalExpression.g:17318:2: rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 + { + pushFollow(FOLLOW_104); + rule__XTypeLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__4" + + + // $ANTLR start "rule__XTypeLiteral__Group__4__Impl" + // InternalExpression.g:17325:1: rule__XTypeLiteral__Group__4__Impl : ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ; + public final void rule__XTypeLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17329:1: ( ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ) + // InternalExpression.g:17330:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) + { + // InternalExpression.g:17330:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) + // InternalExpression.g:17331:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); + } + // InternalExpression.g:17332:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* + loop134: + do { + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==82) ) { + alt134=1; + } + + + switch (alt134) { + case 1 : + // InternalExpression.g:17332:3: rule__XTypeLiteral__ArrayDimensionsAssignment_4 + { + pushFollow(FOLLOW_105); + rule__XTypeLiteral__ArrayDimensionsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop134; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__5" + // InternalExpression.g:17340:1: rule__XTypeLiteral__Group__5 : rule__XTypeLiteral__Group__5__Impl ; + public final void rule__XTypeLiteral__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17344:1: ( rule__XTypeLiteral__Group__5__Impl ) + // InternalExpression.g:17345:2: rule__XTypeLiteral__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__5" + + + // $ANTLR start "rule__XTypeLiteral__Group__5__Impl" + // InternalExpression.g:17351:1: rule__XTypeLiteral__Group__5__Impl : ( ')' ) ; + public final void rule__XTypeLiteral__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17355:1: ( ( ')' ) ) + // InternalExpression.g:17356:1: ( ')' ) + { + // InternalExpression.g:17356:1: ( ')' ) + // InternalExpression.g:17357:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__5__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__0" + // InternalExpression.g:17367:1: rule__XThrowExpression__Group__0 : rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ; + public final void rule__XThrowExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17371:1: ( rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ) + // InternalExpression.g:17372:2: rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 + { + pushFollow(FOLLOW_106); + rule__XThrowExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__0" + + + // $ANTLR start "rule__XThrowExpression__Group__0__Impl" + // InternalExpression.g:17379:1: rule__XThrowExpression__Group__0__Impl : ( () ) ; + public final void rule__XThrowExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17383:1: ( ( () ) ) + // InternalExpression.g:17384:1: ( () ) + { + // InternalExpression.g:17384:1: ( () ) + // InternalExpression.g:17385:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); + } + // InternalExpression.g:17386:2: () + // InternalExpression.g:17386:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__0__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__1" + // InternalExpression.g:17394:1: rule__XThrowExpression__Group__1 : rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ; + public final void rule__XThrowExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17398:1: ( rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ) + // InternalExpression.g:17399:2: rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 + { + pushFollow(FOLLOW_77); + rule__XThrowExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__1" + + + // $ANTLR start "rule__XThrowExpression__Group__1__Impl" + // InternalExpression.g:17406:1: rule__XThrowExpression__Group__1__Impl : ( 'throw' ) ; + public final void rule__XThrowExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17410:1: ( ( 'throw' ) ) + // InternalExpression.g:17411:1: ( 'throw' ) + { + // InternalExpression.g:17411:1: ( 'throw' ) + // InternalExpression.g:17412:2: 'throw' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + match(input,94,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__1__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__2" + // InternalExpression.g:17421:1: rule__XThrowExpression__Group__2 : rule__XThrowExpression__Group__2__Impl ; + public final void rule__XThrowExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17425:1: ( rule__XThrowExpression__Group__2__Impl ) + // InternalExpression.g:17426:2: rule__XThrowExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__2" + + + // $ANTLR start "rule__XThrowExpression__Group__2__Impl" + // InternalExpression.g:17432:1: rule__XThrowExpression__Group__2__Impl : ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ; + public final void rule__XThrowExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17436:1: ( ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ) + // InternalExpression.g:17437:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) + { + // InternalExpression.g:17437:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) + // InternalExpression.g:17438:2: ( rule__XThrowExpression__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); + } + // InternalExpression.g:17439:2: ( rule__XThrowExpression__ExpressionAssignment_2 ) + // InternalExpression.g:17439:3: rule__XThrowExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__2__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__0" + // InternalExpression.g:17448:1: rule__XReturnExpression__Group__0 : rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ; + public final void rule__XReturnExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17452:1: ( rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ) + // InternalExpression.g:17453:2: rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 + { + pushFollow(FOLLOW_107); + rule__XReturnExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__0" + + + // $ANTLR start "rule__XReturnExpression__Group__0__Impl" + // InternalExpression.g:17460:1: rule__XReturnExpression__Group__0__Impl : ( () ) ; + public final void rule__XReturnExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17464:1: ( ( () ) ) + // InternalExpression.g:17465:1: ( () ) + { + // InternalExpression.g:17465:1: ( () ) + // InternalExpression.g:17466:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); + } + // InternalExpression.g:17467:2: () + // InternalExpression.g:17467:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__0__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__1" + // InternalExpression.g:17475:1: rule__XReturnExpression__Group__1 : rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ; + public final void rule__XReturnExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17479:1: ( rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ) + // InternalExpression.g:17480:2: rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 + { + pushFollow(FOLLOW_77); + rule__XReturnExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__1" + + + // $ANTLR start "rule__XReturnExpression__Group__1__Impl" + // InternalExpression.g:17487:1: rule__XReturnExpression__Group__1__Impl : ( 'return' ) ; + public final void rule__XReturnExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17491:1: ( ( 'return' ) ) + // InternalExpression.g:17492:1: ( 'return' ) + { + // InternalExpression.g:17492:1: ( 'return' ) + // InternalExpression.g:17493:2: 'return' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__1__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__2" + // InternalExpression.g:17502:1: rule__XReturnExpression__Group__2 : rule__XReturnExpression__Group__2__Impl ; + public final void rule__XReturnExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17506:1: ( rule__XReturnExpression__Group__2__Impl ) + // InternalExpression.g:17507:2: rule__XReturnExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__2" + + + // $ANTLR start "rule__XReturnExpression__Group__2__Impl" + // InternalExpression.g:17513:1: rule__XReturnExpression__Group__2__Impl : ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ; + public final void rule__XReturnExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17517:1: ( ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ) + // InternalExpression.g:17518:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) + { + // InternalExpression.g:17518:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) + // InternalExpression.g:17519:2: ( rule__XReturnExpression__ExpressionAssignment_2 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); + } + // InternalExpression.g:17520:2: ( rule__XReturnExpression__ExpressionAssignment_2 )? + int alt135=2; + alt135 = dfa135.predict(input); + switch (alt135) { + case 1 : + // InternalExpression.g:17520:3: rule__XReturnExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__2__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0" + // InternalExpression.g:17529:1: rule__XTryCatchFinallyExpression__Group__0 : rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ; + public final void rule__XTryCatchFinallyExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17533:1: ( rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ) + // InternalExpression.g:17534:2: rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 + { + pushFollow(FOLLOW_108); + rule__XTryCatchFinallyExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0__Impl" + // InternalExpression.g:17541:1: rule__XTryCatchFinallyExpression__Group__0__Impl : ( () ) ; + public final void rule__XTryCatchFinallyExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17545:1: ( ( () ) ) + // InternalExpression.g:17546:1: ( () ) + { + // InternalExpression.g:17546:1: ( () ) + // InternalExpression.g:17547:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); + } + // InternalExpression.g:17548:2: () + // InternalExpression.g:17548:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1" + // InternalExpression.g:17556:1: rule__XTryCatchFinallyExpression__Group__1 : rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ; + public final void rule__XTryCatchFinallyExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17560:1: ( rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ) + // InternalExpression.g:17561:2: rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 + { + pushFollow(FOLLOW_77); + rule__XTryCatchFinallyExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1__Impl" + // InternalExpression.g:17568:1: rule__XTryCatchFinallyExpression__Group__1__Impl : ( 'try' ) ; + public final void rule__XTryCatchFinallyExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17572:1: ( ( 'try' ) ) + // InternalExpression.g:17573:1: ( 'try' ) + { + // InternalExpression.g:17573:1: ( 'try' ) + // InternalExpression.g:17574:2: 'try' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + match(input,96,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2" + // InternalExpression.g:17583:1: rule__XTryCatchFinallyExpression__Group__2 : rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ; + public final void rule__XTryCatchFinallyExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17587:1: ( rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ) + // InternalExpression.g:17588:2: rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 + { + pushFollow(FOLLOW_109); + rule__XTryCatchFinallyExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2__Impl" + // InternalExpression.g:17595:1: rule__XTryCatchFinallyExpression__Group__2__Impl : ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17599:1: ( ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ) + // InternalExpression.g:17600:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) + { + // InternalExpression.g:17600:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) + // InternalExpression.g:17601:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); + } + // InternalExpression.g:17602:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) + // InternalExpression.g:17602:3: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3" + // InternalExpression.g:17610:1: rule__XTryCatchFinallyExpression__Group__3 : rule__XTryCatchFinallyExpression__Group__3__Impl ; + public final void rule__XTryCatchFinallyExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17614:1: ( rule__XTryCatchFinallyExpression__Group__3__Impl ) + // InternalExpression.g:17615:2: rule__XTryCatchFinallyExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3__Impl" + // InternalExpression.g:17621:1: rule__XTryCatchFinallyExpression__Group__3__Impl : ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17625:1: ( ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ) + // InternalExpression.g:17626:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) + { + // InternalExpression.g:17626:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) + // InternalExpression.g:17627:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); + } + // InternalExpression.g:17628:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 ) + // InternalExpression.g:17628:3: rule__XTryCatchFinallyExpression__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0" + // InternalExpression.g:17637:1: rule__XTryCatchFinallyExpression__Group_3_0__0 : rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17641:1: ( rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ) + // InternalExpression.g:17642:2: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 + { + pushFollow(FOLLOW_110); + rule__XTryCatchFinallyExpression__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl" + // InternalExpression.g:17649:1: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl : ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17653:1: ( ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ) + // InternalExpression.g:17654:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) + { + // InternalExpression.g:17654:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) + // InternalExpression.g:17655:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) + { + // InternalExpression.g:17655:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) + // InternalExpression.g:17656:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + // InternalExpression.g:17657:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + // InternalExpression.g:17657:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_111); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + + } + + // InternalExpression.g:17660:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) + // InternalExpression.g:17661:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + // InternalExpression.g:17662:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* + loop136: + do { + int alt136=2; + int LA136_0 = input.LA(1); + + if ( (LA136_0==99) ) { + int LA136_2 = input.LA(2); + + if ( (synpred209_InternalExpression()) ) { + alt136=1; + } + + + } + + + switch (alt136) { + case 1 : + // InternalExpression.g:17662:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_111); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop136; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + + } + + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1" + // InternalExpression.g:17671:1: rule__XTryCatchFinallyExpression__Group_3_0__1 : rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17675:1: ( rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ) + // InternalExpression.g:17676:2: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl" + // InternalExpression.g:17682:1: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl : ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17686:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ) + // InternalExpression.g:17687:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) + { + // InternalExpression.g:17687:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) + // InternalExpression.g:17688:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); + } + // InternalExpression.g:17689:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? + int alt137=2; + int LA137_0 = input.LA(1); + + if ( (LA137_0==97) ) { + int LA137_1 = input.LA(2); + + if ( (synpred210_InternalExpression()) ) { + alt137=1; + } + } + switch (alt137) { + case 1 : + // InternalExpression.g:17689:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0" + // InternalExpression.g:17698:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0 : rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17702:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ) + // InternalExpression.g:17703:2: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 + { + pushFollow(FOLLOW_77); + rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl" + // InternalExpression.g:17710:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl : ( ( 'finally' ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17714:1: ( ( ( 'finally' ) ) ) + // InternalExpression.g:17715:1: ( ( 'finally' ) ) + { + // InternalExpression.g:17715:1: ( ( 'finally' ) ) + // InternalExpression.g:17716:2: ( 'finally' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + // InternalExpression.g:17717:2: ( 'finally' ) + // InternalExpression.g:17717:3: 'finally' + { + match(input,97,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1" + // InternalExpression.g:17725:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1 : rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17729:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ) + // InternalExpression.g:17730:2: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl" + // InternalExpression.g:17736:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17740:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ) + // InternalExpression.g:17741:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) + { + // InternalExpression.g:17741:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) + // InternalExpression.g:17742:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); + } + // InternalExpression.g:17743:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) + // InternalExpression.g:17743:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0" + // InternalExpression.g:17752:1: rule__XTryCatchFinallyExpression__Group_3_1__0 : rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17756:1: ( rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ) + // InternalExpression.g:17757:2: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 + { + pushFollow(FOLLOW_77); + rule__XTryCatchFinallyExpression__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl" + // InternalExpression.g:17764:1: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl : ( 'finally' ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17768:1: ( ( 'finally' ) ) + // InternalExpression.g:17769:1: ( 'finally' ) + { + // InternalExpression.g:17769:1: ( 'finally' ) + // InternalExpression.g:17770:2: 'finally' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + match(input,97,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1" + // InternalExpression.g:17779:1: rule__XTryCatchFinallyExpression__Group_3_1__1 : rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17783:1: ( rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ) + // InternalExpression.g:17784:2: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl" + // InternalExpression.g:17790:1: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17794:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ) + // InternalExpression.g:17795:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) + { + // InternalExpression.g:17795:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) + // InternalExpression.g:17796:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); + } + // InternalExpression.g:17797:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) + // InternalExpression.g:17797:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__0" + // InternalExpression.g:17806:1: rule__XSynchronizedExpression__Group__0 : rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ; + public final void rule__XSynchronizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17810:1: ( rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ) + // InternalExpression.g:17811:2: rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 + { + pushFollow(FOLLOW_77); + rule__XSynchronizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__0__Impl" + // InternalExpression.g:17818:1: rule__XSynchronizedExpression__Group__0__Impl : ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ; + public final void rule__XSynchronizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17822:1: ( ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ) + // InternalExpression.g:17823:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) ) + { + // InternalExpression.g:17823:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) ) + // InternalExpression.g:17824:2: ( rule__XSynchronizedExpression__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); + } + // InternalExpression.g:17825:2: ( rule__XSynchronizedExpression__Group_0__0 ) + // InternalExpression.g:17825:3: rule__XSynchronizedExpression__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__1" + // InternalExpression.g:17833:1: rule__XSynchronizedExpression__Group__1 : rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ; + public final void rule__XSynchronizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17837:1: ( rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ) + // InternalExpression.g:17838:2: rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 + { + pushFollow(FOLLOW_9); + rule__XSynchronizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__1" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__1__Impl" + // InternalExpression.g:17845:1: rule__XSynchronizedExpression__Group__1__Impl : ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ; + public final void rule__XSynchronizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17849:1: ( ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ) + // InternalExpression.g:17850:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) + { + // InternalExpression.g:17850:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) + // InternalExpression.g:17851:2: ( rule__XSynchronizedExpression__ParamAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); + } + // InternalExpression.g:17852:2: ( rule__XSynchronizedExpression__ParamAssignment_1 ) + // InternalExpression.g:17852:3: rule__XSynchronizedExpression__ParamAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__ParamAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__2" + // InternalExpression.g:17860:1: rule__XSynchronizedExpression__Group__2 : rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ; + public final void rule__XSynchronizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17864:1: ( rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ) + // InternalExpression.g:17865:2: rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 + { + pushFollow(FOLLOW_77); + rule__XSynchronizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__2" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__2__Impl" + // InternalExpression.g:17872:1: rule__XSynchronizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XSynchronizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17876:1: ( ( ')' ) ) + // InternalExpression.g:17877:1: ( ')' ) + { + // InternalExpression.g:17877:1: ( ')' ) + // InternalExpression.g:17878:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__3" + // InternalExpression.g:17887:1: rule__XSynchronizedExpression__Group__3 : rule__XSynchronizedExpression__Group__3__Impl ; + public final void rule__XSynchronizedExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17891:1: ( rule__XSynchronizedExpression__Group__3__Impl ) + // InternalExpression.g:17892:2: rule__XSynchronizedExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__3" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__3__Impl" + // InternalExpression.g:17898:1: rule__XSynchronizedExpression__Group__3__Impl : ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ; + public final void rule__XSynchronizedExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17902:1: ( ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ) + // InternalExpression.g:17903:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) + { + // InternalExpression.g:17903:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) + // InternalExpression.g:17904:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); + } + // InternalExpression.g:17905:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) + // InternalExpression.g:17905:3: rule__XSynchronizedExpression__ExpressionAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__ExpressionAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__3__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0__0" + // InternalExpression.g:17914:1: rule__XSynchronizedExpression__Group_0__0 : rule__XSynchronizedExpression__Group_0__0__Impl ; + public final void rule__XSynchronizedExpression__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17918:1: ( rule__XSynchronizedExpression__Group_0__0__Impl ) + // InternalExpression.g:17919:2: rule__XSynchronizedExpression__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0__0__Impl" + // InternalExpression.g:17925:1: rule__XSynchronizedExpression__Group_0__0__Impl : ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ; + public final void rule__XSynchronizedExpression__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17929:1: ( ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ) + // InternalExpression.g:17930:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) + { + // InternalExpression.g:17930:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) + // InternalExpression.g:17931:2: ( rule__XSynchronizedExpression__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); + } + // InternalExpression.g:17932:2: ( rule__XSynchronizedExpression__Group_0_0__0 ) + // InternalExpression.g:17932:3: rule__XSynchronizedExpression__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0" + // InternalExpression.g:17941:1: rule__XSynchronizedExpression__Group_0_0__0 : rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ; + public final void rule__XSynchronizedExpression__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17945:1: ( rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ) + // InternalExpression.g:17946:2: rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 + { + pushFollow(FOLLOW_112); + rule__XSynchronizedExpression__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0__Impl" + // InternalExpression.g:17953:1: rule__XSynchronizedExpression__Group_0_0__0__Impl : ( () ) ; + public final void rule__XSynchronizedExpression__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17957:1: ( ( () ) ) + // InternalExpression.g:17958:1: ( () ) + { + // InternalExpression.g:17958:1: ( () ) + // InternalExpression.g:17959:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); + } + // InternalExpression.g:17960:2: () + // InternalExpression.g:17960:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1" + // InternalExpression.g:17968:1: rule__XSynchronizedExpression__Group_0_0__1 : rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ; + public final void rule__XSynchronizedExpression__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17972:1: ( rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ) + // InternalExpression.g:17973:2: rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 + { + pushFollow(FOLLOW_34); + rule__XSynchronizedExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__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__XSynchronizedExpression__Group_0_0__1" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1__Impl" + // InternalExpression.g:17980:1: rule__XSynchronizedExpression__Group_0_0__1__Impl : ( 'synchronized' ) ; + public final void rule__XSynchronizedExpression__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17984:1: ( ( 'synchronized' ) ) + // InternalExpression.g:17985:1: ( 'synchronized' ) + { + // InternalExpression.g:17985:1: ( 'synchronized' ) + // InternalExpression.g:17986:2: 'synchronized' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + match(input,98,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2" + // InternalExpression.g:17995:1: rule__XSynchronizedExpression__Group_0_0__2 : rule__XSynchronizedExpression__Group_0_0__2__Impl ; + public final void rule__XSynchronizedExpression__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:17999:1: ( rule__XSynchronizedExpression__Group_0_0__2__Impl ) + // InternalExpression.g:18000:2: rule__XSynchronizedExpression__Group_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2__Impl" + // InternalExpression.g:18006:1: rule__XSynchronizedExpression__Group_0_0__2__Impl : ( '(' ) ; + public final void rule__XSynchronizedExpression__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18010:1: ( ( '(' ) ) + // InternalExpression.g:18011:1: ( '(' ) + { + // InternalExpression.g:18011:1: ( '(' ) + // InternalExpression.g:18012:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__0" + // InternalExpression.g:18022:1: rule__XCatchClause__Group__0 : rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ; + public final void rule__XCatchClause__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18026:1: ( rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ) + // InternalExpression.g:18027:2: rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 + { + pushFollow(FOLLOW_34); + rule__XCatchClause__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__0" + + + // $ANTLR start "rule__XCatchClause__Group__0__Impl" + // InternalExpression.g:18034:1: rule__XCatchClause__Group__0__Impl : ( ( 'catch' ) ) ; + public final void rule__XCatchClause__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18038:1: ( ( ( 'catch' ) ) ) + // InternalExpression.g:18039:1: ( ( 'catch' ) ) + { + // InternalExpression.g:18039:1: ( ( 'catch' ) ) + // InternalExpression.g:18040:2: ( 'catch' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + // InternalExpression.g:18041:2: ( 'catch' ) + // InternalExpression.g:18041:3: 'catch' + { + match(input,99,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__0__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__1" + // InternalExpression.g:18049:1: rule__XCatchClause__Group__1 : rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ; + public final void rule__XCatchClause__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18053:1: ( rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ) + // InternalExpression.g:18054:2: rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 + { + pushFollow(FOLLOW_56); + rule__XCatchClause__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__1" + + + // $ANTLR start "rule__XCatchClause__Group__1__Impl" + // InternalExpression.g:18061:1: rule__XCatchClause__Group__1__Impl : ( '(' ) ; + public final void rule__XCatchClause__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18065:1: ( ( '(' ) ) + // InternalExpression.g:18066:1: ( '(' ) + { + // InternalExpression.g:18066:1: ( '(' ) + // InternalExpression.g:18067:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__1__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__2" + // InternalExpression.g:18076:1: rule__XCatchClause__Group__2 : rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ; + public final void rule__XCatchClause__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18080:1: ( rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ) + // InternalExpression.g:18081:2: rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 + { + pushFollow(FOLLOW_9); + rule__XCatchClause__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__2" + + + // $ANTLR start "rule__XCatchClause__Group__2__Impl" + // InternalExpression.g:18088:1: rule__XCatchClause__Group__2__Impl : ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ; + public final void rule__XCatchClause__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18092:1: ( ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ) + // InternalExpression.g:18093:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) + { + // InternalExpression.g:18093:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) + // InternalExpression.g:18094:2: ( rule__XCatchClause__DeclaredParamAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); + } + // InternalExpression.g:18095:2: ( rule__XCatchClause__DeclaredParamAssignment_2 ) + // InternalExpression.g:18095:3: rule__XCatchClause__DeclaredParamAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__DeclaredParamAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__2__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__3" + // InternalExpression.g:18103:1: rule__XCatchClause__Group__3 : rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ; + public final void rule__XCatchClause__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18107:1: ( rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ) + // InternalExpression.g:18108:2: rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 + { + pushFollow(FOLLOW_77); + rule__XCatchClause__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__3" + + + // $ANTLR start "rule__XCatchClause__Group__3__Impl" + // InternalExpression.g:18115:1: rule__XCatchClause__Group__3__Impl : ( ')' ) ; + public final void rule__XCatchClause__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18119:1: ( ( ')' ) ) + // InternalExpression.g:18120:1: ( ')' ) + { + // InternalExpression.g:18120:1: ( ')' ) + // InternalExpression.g:18121:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__3__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__4" + // InternalExpression.g:18130:1: rule__XCatchClause__Group__4 : rule__XCatchClause__Group__4__Impl ; + public final void rule__XCatchClause__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18134:1: ( rule__XCatchClause__Group__4__Impl ) + // InternalExpression.g:18135:2: rule__XCatchClause__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__4" + + + // $ANTLR start "rule__XCatchClause__Group__4__Impl" + // InternalExpression.g:18141:1: rule__XCatchClause__Group__4__Impl : ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ; + public final void rule__XCatchClause__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18145:1: ( ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ) + // InternalExpression.g:18146:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) + { + // InternalExpression.g:18146:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) + // InternalExpression.g:18147:2: ( rule__XCatchClause__ExpressionAssignment_4 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); + } + // InternalExpression.g:18148:2: ( rule__XCatchClause__ExpressionAssignment_4 ) + // InternalExpression.g:18148:3: rule__XCatchClause__ExpressionAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__ExpressionAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__4__Impl" + + + // $ANTLR start "rule__QualifiedName__Group__0" + // InternalExpression.g:18157: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 { + // InternalExpression.g:18161:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) + // InternalExpression.g:18162:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 + { + pushFollow(FOLLOW_32); + rule__QualifiedName__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__0" + + + // $ANTLR start "rule__QualifiedName__Group__0__Impl" + // InternalExpression.g:18169:1: rule__QualifiedName__Group__0__Impl : ( ruleValidID ) ; + public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18173:1: ( ( ruleValidID ) ) + // InternalExpression.g:18174:1: ( ruleValidID ) + { + // InternalExpression.g:18174:1: ( ruleValidID ) + // InternalExpression.g:18175:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group__1" + // InternalExpression.g:18184:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; + public final void rule__QualifiedName__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18188:1: ( rule__QualifiedName__Group__1__Impl ) + // InternalExpression.g:18189:2: rule__QualifiedName__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__1" + + + // $ANTLR start "rule__QualifiedName__Group__1__Impl" + // InternalExpression.g:18195: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 { + // InternalExpression.g:18199:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) + // InternalExpression.g:18200:1: ( ( rule__QualifiedName__Group_1__0 )* ) + { + // InternalExpression.g:18200:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalExpression.g:18201:2: ( rule__QualifiedName__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getGroup_1()); + } + // InternalExpression.g:18202:2: ( rule__QualifiedName__Group_1__0 )* + loop138: + do { + int alt138=2; + int LA138_0 = input.LA(1); + + if ( (LA138_0==58) ) { + int LA138_2 = input.LA(2); + + if ( (LA138_2==RULE_ID) ) { + int LA138_3 = input.LA(3); + + if ( (synpred211_InternalExpression()) ) { + alt138=1; + } + + + } + + + } + + + switch (alt138) { + case 1 : + // InternalExpression.g:18202:3: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_33); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop138; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__0" + // InternalExpression.g:18211: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 { + // InternalExpression.g:18215:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) + // InternalExpression.g:18216:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 + { + pushFollow(FOLLOW_4); + rule__QualifiedName__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0" + + + // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" + // InternalExpression.g:18223:1: rule__QualifiedName__Group_1__0__Impl : ( ( '.' ) ) ; + public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18227:1: ( ( ( '.' ) ) ) + // InternalExpression.g:18228:1: ( ( '.' ) ) + { + // InternalExpression.g:18228:1: ( ( '.' ) ) + // InternalExpression.g:18229:2: ( '.' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + // InternalExpression.g:18230:2: ( '.' ) + // InternalExpression.g:18230:3: '.' + { + match(input,58,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__1" + // InternalExpression.g:18238: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 { + // InternalExpression.g:18242:1: ( rule__QualifiedName__Group_1__1__Impl ) + // InternalExpression.g:18243:2: rule__QualifiedName__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1" + + + // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" + // InternalExpression.g:18249:1: rule__QualifiedName__Group_1__1__Impl : ( ruleValidID ) ; + public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18253:1: ( ( ruleValidID ) ) + // InternalExpression.g:18254:1: ( ruleValidID ) + { + // InternalExpression.g:18254:1: ( ruleValidID ) + // InternalExpression.g:18255:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1__Impl" + + + // $ANTLR start "rule__Number__Group_1__0" + // InternalExpression.g:18265:1: rule__Number__Group_1__0 : rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ; + public final void rule__Number__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18269:1: ( rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ) + // InternalExpression.g:18270:2: rule__Number__Group_1__0__Impl rule__Number__Group_1__1 + { + pushFollow(FOLLOW_32); + rule__Number__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Number__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__0" + + + // $ANTLR start "rule__Number__Group_1__0__Impl" + // InternalExpression.g:18277:1: rule__Number__Group_1__0__Impl : ( ( rule__Number__Alternatives_1_0 ) ) ; + public final void rule__Number__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18281:1: ( ( ( rule__Number__Alternatives_1_0 ) ) ) + // InternalExpression.g:18282:1: ( ( rule__Number__Alternatives_1_0 ) ) + { + // InternalExpression.g:18282:1: ( ( rule__Number__Alternatives_1_0 ) ) + // InternalExpression.g:18283:2: ( rule__Number__Alternatives_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives_1_0()); + } + // InternalExpression.g:18284:2: ( rule__Number__Alternatives_1_0 ) + // InternalExpression.g:18284:3: rule__Number__Alternatives_1_0 + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getAlternatives_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__0__Impl" + + + // $ANTLR start "rule__Number__Group_1__1" + // InternalExpression.g:18292:1: rule__Number__Group_1__1 : rule__Number__Group_1__1__Impl ; + public final void rule__Number__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18296:1: ( rule__Number__Group_1__1__Impl ) + // InternalExpression.g:18297:2: rule__Number__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Number__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__1" + + + // $ANTLR start "rule__Number__Group_1__1__Impl" + // InternalExpression.g:18303:1: rule__Number__Group_1__1__Impl : ( ( rule__Number__Group_1_1__0 )? ) ; + public final void rule__Number__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18307:1: ( ( ( rule__Number__Group_1_1__0 )? ) ) + // InternalExpression.g:18308:1: ( ( rule__Number__Group_1_1__0 )? ) + { + // InternalExpression.g:18308:1: ( ( rule__Number__Group_1_1__0 )? ) + // InternalExpression.g:18309:2: ( rule__Number__Group_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getGroup_1_1()); + } + // InternalExpression.g:18310:2: ( rule__Number__Group_1_1__0 )? + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==58) ) { + int LA139_1 = input.LA(2); + + if ( ((LA139_1>=RULE_INT && LA139_1<=RULE_DECIMAL)) ) { + alt139=1; + } + } + switch (alt139) { + case 1 : + // InternalExpression.g:18310:3: rule__Number__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getGroup_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__1__Impl" + + + // $ANTLR start "rule__Number__Group_1_1__0" + // InternalExpression.g:18319:1: rule__Number__Group_1_1__0 : rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ; + public final void rule__Number__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18323:1: ( rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ) + // InternalExpression.g:18324:2: rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 + { + pushFollow(FOLLOW_113); + rule__Number__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__0" + + + // $ANTLR start "rule__Number__Group_1_1__0__Impl" + // InternalExpression.g:18331:1: rule__Number__Group_1_1__0__Impl : ( '.' ) ; + public final void rule__Number__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18335:1: ( ( '.' ) ) + // InternalExpression.g:18336:1: ( '.' ) + { + // InternalExpression.g:18336:1: ( '.' ) + // InternalExpression.g:18337:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__0__Impl" + + + // $ANTLR start "rule__Number__Group_1_1__1" + // InternalExpression.g:18346:1: rule__Number__Group_1_1__1 : rule__Number__Group_1_1__1__Impl ; + public final void rule__Number__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18350:1: ( rule__Number__Group_1_1__1__Impl ) + // InternalExpression.g:18351:2: rule__Number__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__1" + + + // $ANTLR start "rule__Number__Group_1_1__1__Impl" + // InternalExpression.g:18357:1: rule__Number__Group_1_1__1__Impl : ( ( rule__Number__Alternatives_1_1_1 ) ) ; + public final void rule__Number__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18361:1: ( ( ( rule__Number__Alternatives_1_1_1 ) ) ) + // InternalExpression.g:18362:1: ( ( rule__Number__Alternatives_1_1_1 ) ) + { + // InternalExpression.g:18362:1: ( ( rule__Number__Alternatives_1_1_1 ) ) + // InternalExpression.g:18363:2: ( rule__Number__Alternatives_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); + } + // InternalExpression.g:18364:2: ( rule__Number__Alternatives_1_1_1 ) + // InternalExpression.g:18364:3: rule__Number__Alternatives_1_1_1 + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__1__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__0" + // InternalExpression.g:18373:1: rule__JvmTypeReference__Group_0__0 : rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ; + public final void rule__JvmTypeReference__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18377:1: ( rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ) + // InternalExpression.g:18378:2: rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 + { + pushFollow(FOLLOW_43); + rule__JvmTypeReference__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__0__Impl" + // InternalExpression.g:18385:1: rule__JvmTypeReference__Group_0__0__Impl : ( ruleJvmParameterizedTypeReference ) ; + public final void rule__JvmTypeReference__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18389:1: ( ( ruleJvmParameterizedTypeReference ) ) + // InternalExpression.g:18390:1: ( ruleJvmParameterizedTypeReference ) + { + // InternalExpression.g:18390:1: ( ruleJvmParameterizedTypeReference ) + // InternalExpression.g:18391:2: ruleJvmParameterizedTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__1" + // InternalExpression.g:18400:1: rule__JvmTypeReference__Group_0__1 : rule__JvmTypeReference__Group_0__1__Impl ; + public final void rule__JvmTypeReference__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18404:1: ( rule__JvmTypeReference__Group_0__1__Impl ) + // InternalExpression.g:18405:2: rule__JvmTypeReference__Group_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__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__JvmTypeReference__Group_0__1" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__1__Impl" + // InternalExpression.g:18411:1: rule__JvmTypeReference__Group_0__1__Impl : ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ; + public final void rule__JvmTypeReference__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18415:1: ( ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ) + // InternalExpression.g:18416:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) + { + // InternalExpression.g:18416:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) + // InternalExpression.g:18417:2: ( rule__JvmTypeReference__Group_0_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); + } + // InternalExpression.g:18418:2: ( rule__JvmTypeReference__Group_0_1__0 )* + loop140: + do { + int alt140=2; + int LA140_0 = input.LA(1); + + if ( (LA140_0==82) ) { + int LA140_2 = input.LA(2); + + if ( (LA140_2==83) ) { + int LA140_3 = input.LA(3); + + if ( (synpred213_InternalExpression()) ) { + alt140=1; + } + + + } + + + } + + + switch (alt140) { + case 1 : + // InternalExpression.g:18418:3: rule__JvmTypeReference__Group_0_1__0 + { + pushFollow(FOLLOW_105); + rule__JvmTypeReference__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop140; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__1__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1__0" + // InternalExpression.g:18427:1: rule__JvmTypeReference__Group_0_1__0 : rule__JvmTypeReference__Group_0_1__0__Impl ; + public final void rule__JvmTypeReference__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18431:1: ( rule__JvmTypeReference__Group_0_1__0__Impl ) + // InternalExpression.g:18432:2: rule__JvmTypeReference__Group_0_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1__0__Impl" + // InternalExpression.g:18438:1: rule__JvmTypeReference__Group_0_1__0__Impl : ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ; + public final void rule__JvmTypeReference__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18442:1: ( ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ) + // InternalExpression.g:18443:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) + { + // InternalExpression.g:18443:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) + // InternalExpression.g:18444:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); + } + // InternalExpression.g:18445:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) + // InternalExpression.g:18445:3: rule__JvmTypeReference__Group_0_1_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0" + // InternalExpression.g:18454:1: rule__JvmTypeReference__Group_0_1_0__0 : rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ; + public final void rule__JvmTypeReference__Group_0_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18458:1: ( rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ) + // InternalExpression.g:18459:2: rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 + { + pushFollow(FOLLOW_43); + rule__JvmTypeReference__Group_0_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0__Impl" + // InternalExpression.g:18466:1: rule__JvmTypeReference__Group_0_1_0__0__Impl : ( () ) ; + public final void rule__JvmTypeReference__Group_0_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18470:1: ( ( () ) ) + // InternalExpression.g:18471:1: ( () ) + { + // InternalExpression.g:18471:1: ( () ) + // InternalExpression.g:18472:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); + } + // InternalExpression.g:18473:2: () + // InternalExpression.g:18473:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1" + // InternalExpression.g:18481:1: rule__JvmTypeReference__Group_0_1_0__1 : rule__JvmTypeReference__Group_0_1_0__1__Impl ; + public final void rule__JvmTypeReference__Group_0_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18485:1: ( rule__JvmTypeReference__Group_0_1_0__1__Impl ) + // InternalExpression.g:18486:2: rule__JvmTypeReference__Group_0_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1__Impl" + // InternalExpression.g:18492:1: rule__JvmTypeReference__Group_0_1_0__1__Impl : ( ruleArrayBrackets ) ; + public final void rule__JvmTypeReference__Group_0_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18496:1: ( ( ruleArrayBrackets ) ) + // InternalExpression.g:18497:1: ( ruleArrayBrackets ) + { + // InternalExpression.g:18497:1: ( ruleArrayBrackets ) + // InternalExpression.g:18498:2: ruleArrayBrackets + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1__Impl" + + + // $ANTLR start "rule__ArrayBrackets__Group__0" + // InternalExpression.g:18508:1: rule__ArrayBrackets__Group__0 : rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ; + public final void rule__ArrayBrackets__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18512:1: ( rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ) + // InternalExpression.g:18513:2: rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 + { + pushFollow(FOLLOW_44); + rule__ArrayBrackets__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__0" + + + // $ANTLR start "rule__ArrayBrackets__Group__0__Impl" + // InternalExpression.g:18520:1: rule__ArrayBrackets__Group__0__Impl : ( '[' ) ; + public final void rule__ArrayBrackets__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18524:1: ( ( '[' ) ) + // InternalExpression.g:18525:1: ( '[' ) + { + // InternalExpression.g:18525:1: ( '[' ) + // InternalExpression.g:18526:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__0__Impl" + + + // $ANTLR start "rule__ArrayBrackets__Group__1" + // InternalExpression.g:18535:1: rule__ArrayBrackets__Group__1 : rule__ArrayBrackets__Group__1__Impl ; + public final void rule__ArrayBrackets__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18539:1: ( rule__ArrayBrackets__Group__1__Impl ) + // InternalExpression.g:18540:2: rule__ArrayBrackets__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__1" + + + // $ANTLR start "rule__ArrayBrackets__Group__1__Impl" + // InternalExpression.g:18546:1: rule__ArrayBrackets__Group__1__Impl : ( ']' ) ; + public final void rule__ArrayBrackets__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18550:1: ( ( ']' ) ) + // InternalExpression.g:18551:1: ( ']' ) + { + // InternalExpression.g:18551:1: ( ']' ) + // InternalExpression.g:18552:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__0" + // InternalExpression.g:18562:1: rule__XFunctionTypeRef__Group__0 : rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ; + public final void rule__XFunctionTypeRef__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18566:1: ( rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ) + // InternalExpression.g:18567:2: rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 + { + pushFollow(FOLLOW_56); + rule__XFunctionTypeRef__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__0__Impl" + // InternalExpression.g:18574:1: rule__XFunctionTypeRef__Group__0__Impl : ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ; + public final void rule__XFunctionTypeRef__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18578:1: ( ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ) + // InternalExpression.g:18579:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) + { + // InternalExpression.g:18579:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) + // InternalExpression.g:18580:2: ( rule__XFunctionTypeRef__Group_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); + } + // InternalExpression.g:18581:2: ( rule__XFunctionTypeRef__Group_0__0 )? + int alt141=2; + int LA141_0 = input.LA(1); + + if ( (LA141_0==67) ) { + alt141=1; + } + switch (alt141) { + case 1 : + // InternalExpression.g:18581:3: rule__XFunctionTypeRef__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__1" + // InternalExpression.g:18589:1: rule__XFunctionTypeRef__Group__1 : rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ; + public final void rule__XFunctionTypeRef__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18593:1: ( rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ) + // InternalExpression.g:18594:2: rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 + { + pushFollow(FOLLOW_56); + rule__XFunctionTypeRef__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__1__Impl" + // InternalExpression.g:18601:1: rule__XFunctionTypeRef__Group__1__Impl : ( '=>' ) ; + public final void rule__XFunctionTypeRef__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18605:1: ( ( '=>' ) ) + // InternalExpression.g:18606:1: ( '=>' ) + { + // InternalExpression.g:18606:1: ( '=>' ) + // InternalExpression.g:18607:2: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__2" + // InternalExpression.g:18616:1: rule__XFunctionTypeRef__Group__2 : rule__XFunctionTypeRef__Group__2__Impl ; + public final void rule__XFunctionTypeRef__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18620:1: ( rule__XFunctionTypeRef__Group__2__Impl ) + // InternalExpression.g:18621:2: rule__XFunctionTypeRef__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__2" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__2__Impl" + // InternalExpression.g:18627:1: rule__XFunctionTypeRef__Group__2__Impl : ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ; + public final void rule__XFunctionTypeRef__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18631:1: ( ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ) + // InternalExpression.g:18632:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) + { + // InternalExpression.g:18632:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) + // InternalExpression.g:18633:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); + } + // InternalExpression.g:18634:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) + // InternalExpression.g:18634:3: rule__XFunctionTypeRef__ReturnTypeAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ReturnTypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__2__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__0" + // InternalExpression.g:18643:1: rule__XFunctionTypeRef__Group_0__0 : rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ; + public final void rule__XFunctionTypeRef__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18647:1: ( rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ) + // InternalExpression.g:18648:2: rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 + { + pushFollow(FOLLOW_114); + rule__XFunctionTypeRef__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__0__Impl" + // InternalExpression.g:18655:1: rule__XFunctionTypeRef__Group_0__0__Impl : ( '(' ) ; + public final void rule__XFunctionTypeRef__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18659:1: ( ( '(' ) ) + // InternalExpression.g:18660:1: ( '(' ) + { + // InternalExpression.g:18660:1: ( '(' ) + // InternalExpression.g:18661:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__1" + // InternalExpression.g:18670:1: rule__XFunctionTypeRef__Group_0__1 : rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ; + public final void rule__XFunctionTypeRef__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18674:1: ( rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ) + // InternalExpression.g:18675:2: rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 + { + pushFollow(FOLLOW_114); + rule__XFunctionTypeRef__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__1__Impl" + // InternalExpression.g:18682:1: rule__XFunctionTypeRef__Group_0__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ; + public final void rule__XFunctionTypeRef__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18686:1: ( ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ) + // InternalExpression.g:18687:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) + { + // InternalExpression.g:18687:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) + // InternalExpression.g:18688:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); + } + // InternalExpression.g:18689:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==RULE_ID||LA142_0==51||LA142_0==67) ) { + alt142=1; + } + switch (alt142) { + case 1 : + // InternalExpression.g:18689:3: rule__XFunctionTypeRef__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__2" + // InternalExpression.g:18697:1: rule__XFunctionTypeRef__Group_0__2 : rule__XFunctionTypeRef__Group_0__2__Impl ; + public final void rule__XFunctionTypeRef__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18701:1: ( rule__XFunctionTypeRef__Group_0__2__Impl ) + // InternalExpression.g:18702:2: rule__XFunctionTypeRef__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__2" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__2__Impl" + // InternalExpression.g:18708:1: rule__XFunctionTypeRef__Group_0__2__Impl : ( ')' ) ; + public final void rule__XFunctionTypeRef__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18712:1: ( ( ')' ) ) + // InternalExpression.g:18713:1: ( ')' ) + { + // InternalExpression.g:18713:1: ( ')' ) + // InternalExpression.g:18714:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + match(input,68,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__2__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0" + // InternalExpression.g:18724:1: rule__XFunctionTypeRef__Group_0_1__0 : rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ; + public final void rule__XFunctionTypeRef__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18728:1: ( rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ) + // InternalExpression.g:18729:2: rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 + { + pushFollow(FOLLOW_36); + rule__XFunctionTypeRef__Group_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0__Impl" + // InternalExpression.g:18736:1: rule__XFunctionTypeRef__Group_0_1__0__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ; + public final void rule__XFunctionTypeRef__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18740:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ) + // InternalExpression.g:18741:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) + { + // InternalExpression.g:18741:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) + // InternalExpression.g:18742:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); + } + // InternalExpression.g:18743:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) + // InternalExpression.g:18743:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1" + // InternalExpression.g:18751:1: rule__XFunctionTypeRef__Group_0_1__1 : rule__XFunctionTypeRef__Group_0_1__1__Impl ; + public final void rule__XFunctionTypeRef__Group_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18755:1: ( rule__XFunctionTypeRef__Group_0_1__1__Impl ) + // InternalExpression.g:18756:2: rule__XFunctionTypeRef__Group_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1__Impl" + // InternalExpression.g:18762:1: rule__XFunctionTypeRef__Group_0_1__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ; + public final void rule__XFunctionTypeRef__Group_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18766:1: ( ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ) + // InternalExpression.g:18767:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) + { + // InternalExpression.g:18767:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) + // InternalExpression.g:18768:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); + } + // InternalExpression.g:18769:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* + loop143: + do { + int alt143=2; + int LA143_0 = input.LA(1); + + if ( (LA143_0==78) ) { + alt143=1; + } + + + switch (alt143) { + case 1 : + // InternalExpression.g:18769:3: rule__XFunctionTypeRef__Group_0_1_1__0 + { + pushFollow(FOLLOW_37); + rule__XFunctionTypeRef__Group_0_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop143; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0" + // InternalExpression.g:18778:1: rule__XFunctionTypeRef__Group_0_1_1__0 : rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ; + public final void rule__XFunctionTypeRef__Group_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18782:1: ( rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ) + // InternalExpression.g:18783:2: rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 + { + pushFollow(FOLLOW_56); + rule__XFunctionTypeRef__Group_0_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" + // InternalExpression.g:18790:1: rule__XFunctionTypeRef__Group_0_1_1__0__Impl : ( ',' ) ; + public final void rule__XFunctionTypeRef__Group_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18794:1: ( ( ',' ) ) + // InternalExpression.g:18795:1: ( ',' ) + { + // InternalExpression.g:18795:1: ( ',' ) + // InternalExpression.g:18796:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1" + // InternalExpression.g:18805:1: rule__XFunctionTypeRef__Group_0_1_1__1 : rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; + public final void rule__XFunctionTypeRef__Group_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18809:1: ( rule__XFunctionTypeRef__Group_0_1_1__1__Impl ) + // InternalExpression.g:18810:2: rule__XFunctionTypeRef__Group_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" + // InternalExpression.g:18816:1: rule__XFunctionTypeRef__Group_0_1_1__1__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ; + public final void rule__XFunctionTypeRef__Group_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18820:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ) + // InternalExpression.g:18821:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) + { + // InternalExpression.g:18821:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) + // InternalExpression.g:18822:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); + } + // InternalExpression.g:18823:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) + // InternalExpression.g:18823:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0" + // InternalExpression.g:18832:1: rule__JvmParameterizedTypeReference__Group__0 : rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ; + public final void rule__JvmParameterizedTypeReference__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18836:1: ( rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ) + // InternalExpression.g:18837:2: rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 + { + pushFollow(FOLLOW_50); + rule__JvmParameterizedTypeReference__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0__Impl" + // InternalExpression.g:18844:1: rule__JvmParameterizedTypeReference__Group__0__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18848:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ) + // InternalExpression.g:18849:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) + { + // InternalExpression.g:18849:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) + // InternalExpression.g:18850:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); + } + // InternalExpression.g:18851:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) + // InternalExpression.g:18851:3: rule__JvmParameterizedTypeReference__TypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__TypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1" + // InternalExpression.g:18859:1: rule__JvmParameterizedTypeReference__Group__1 : rule__JvmParameterizedTypeReference__Group__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18863:1: ( rule__JvmParameterizedTypeReference__Group__1__Impl ) + // InternalExpression.g:18864:2: rule__JvmParameterizedTypeReference__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1__Impl" + // InternalExpression.g:18870:1: rule__JvmParameterizedTypeReference__Group__1__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ; + public final void rule__JvmParameterizedTypeReference__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18874:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ) + // InternalExpression.g:18875:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) + { + // InternalExpression.g:18875:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) + // InternalExpression.g:18876:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); + } + // InternalExpression.g:18877:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? + int alt144=2; + alt144 = dfa144.predict(input); + switch (alt144) { + case 1 : + // InternalExpression.g:18877:3: rule__JvmParameterizedTypeReference__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0" + // InternalExpression.g:18886:1: rule__JvmParameterizedTypeReference__Group_1__0 : rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18890:1: ( rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ) + // InternalExpression.g:18891:2: rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 + { + pushFollow(FOLLOW_74); + rule__JvmParameterizedTypeReference__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0__Impl" + // InternalExpression.g:18898:1: rule__JvmParameterizedTypeReference__Group_1__0__Impl : ( ( '<' ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18902:1: ( ( ( '<' ) ) ) + // InternalExpression.g:18903:1: ( ( '<' ) ) + { + // InternalExpression.g:18903:1: ( ( '<' ) ) + // InternalExpression.g:18904:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + // InternalExpression.g:18905:2: ( '<' ) + // InternalExpression.g:18905:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1" + // InternalExpression.g:18913:1: rule__JvmParameterizedTypeReference__Group_1__1 : rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18917:1: ( rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ) + // InternalExpression.g:18918:2: rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 + { + pushFollow(FOLLOW_75); + rule__JvmParameterizedTypeReference__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1__Impl" + // InternalExpression.g:18925:1: rule__JvmParameterizedTypeReference__Group_1__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18929:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ) + // InternalExpression.g:18930:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) + { + // InternalExpression.g:18930:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) + // InternalExpression.g:18931:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); + } + // InternalExpression.g:18932:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) + // InternalExpression.g:18932:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2" + // InternalExpression.g:18940:1: rule__JvmParameterizedTypeReference__Group_1__2 : rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ; + public final void rule__JvmParameterizedTypeReference__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18944:1: ( rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ) + // InternalExpression.g:18945:2: rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 + { + pushFollow(FOLLOW_75); + rule__JvmParameterizedTypeReference__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2__Impl" + // InternalExpression.g:18952:1: rule__JvmParameterizedTypeReference__Group_1__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18956:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ) + // InternalExpression.g:18957:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) + { + // InternalExpression.g:18957:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) + // InternalExpression.g:18958:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); + } + // InternalExpression.g:18959:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* + loop145: + do { + int alt145=2; + int LA145_0 = input.LA(1); + + if ( (LA145_0==78) ) { + alt145=1; + } + + + switch (alt145) { + case 1 : + // InternalExpression.g:18959:3: rule__JvmParameterizedTypeReference__Group_1_2__0 + { + pushFollow(FOLLOW_37); + rule__JvmParameterizedTypeReference__Group_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop145; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3" + // InternalExpression.g:18967:1: rule__JvmParameterizedTypeReference__Group_1__3 : rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ; + public final void rule__JvmParameterizedTypeReference__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18971:1: ( rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ) + // InternalExpression.g:18972:2: rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 + { + pushFollow(FOLLOW_32); + rule__JvmParameterizedTypeReference__Group_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3__Impl" + // InternalExpression.g:18979:1: rule__JvmParameterizedTypeReference__Group_1__3__Impl : ( '>' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18983:1: ( ( '>' ) ) + // InternalExpression.g:18984:1: ( '>' ) + { + // InternalExpression.g:18984:1: ( '>' ) + // InternalExpression.g:18985:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4" + // InternalExpression.g:18994:1: rule__JvmParameterizedTypeReference__Group_1__4 : rule__JvmParameterizedTypeReference__Group_1__4__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:18998:1: ( rule__JvmParameterizedTypeReference__Group_1__4__Impl ) + // InternalExpression.g:18999:2: rule__JvmParameterizedTypeReference__Group_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4__Impl" + // InternalExpression.g:19005:1: rule__JvmParameterizedTypeReference__Group_1__4__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19009:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ) + // InternalExpression.g:19010:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) + { + // InternalExpression.g:19010:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) + // InternalExpression.g:19011:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); + } + // InternalExpression.g:19012:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* + loop146: + do { + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==58) ) { + int LA146_2 = input.LA(2); + + if ( (LA146_2==RULE_ID) ) { + int LA146_3 = input.LA(3); + + if ( (synpred219_InternalExpression()) ) { + alt146=1; + } + + + } + + + } + + + switch (alt146) { + case 1 : + // InternalExpression.g:19012:3: rule__JvmParameterizedTypeReference__Group_1_4__0 + { + pushFollow(FOLLOW_33); + rule__JvmParameterizedTypeReference__Group_1_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop146; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0" + // InternalExpression.g:19021:1: rule__JvmParameterizedTypeReference__Group_1_2__0 : rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19025:1: ( rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ) + // InternalExpression.g:19026:2: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 + { + pushFollow(FOLLOW_74); + rule__JvmParameterizedTypeReference__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" + // InternalExpression.g:19033:1: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl : ( ',' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19037:1: ( ( ',' ) ) + // InternalExpression.g:19038:1: ( ',' ) + { + // InternalExpression.g:19038:1: ( ',' ) + // InternalExpression.g:19039:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1" + // InternalExpression.g:19048:1: rule__JvmParameterizedTypeReference__Group_1_2__1 : rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19052:1: ( rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ) + // InternalExpression.g:19053:2: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" + // InternalExpression.g:19059:1: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19063:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ) + // InternalExpression.g:19064:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) + { + // InternalExpression.g:19064:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) + // InternalExpression.g:19065:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); + } + // InternalExpression.g:19066:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) + // InternalExpression.g:19066:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0" + // InternalExpression.g:19075:1: rule__JvmParameterizedTypeReference__Group_1_4__0 : rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19079:1: ( rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ) + // InternalExpression.g:19080:2: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 + { + pushFollow(FOLLOW_4); + rule__JvmParameterizedTypeReference__Group_1_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" + // InternalExpression.g:19087:1: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19091:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ) + // InternalExpression.g:19092:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) + { + // InternalExpression.g:19092:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) + // InternalExpression.g:19093:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); + } + // InternalExpression.g:19094:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) + // InternalExpression.g:19094:3: rule__JvmParameterizedTypeReference__Group_1_4_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1" + // InternalExpression.g:19102:1: rule__JvmParameterizedTypeReference__Group_1_4__1 : rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19106:1: ( rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ) + // InternalExpression.g:19107:2: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 + { + pushFollow(FOLLOW_50); + rule__JvmParameterizedTypeReference__Group_1_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" + // InternalExpression.g:19114:1: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19118:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ) + // InternalExpression.g:19119:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) + { + // InternalExpression.g:19119:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) + // InternalExpression.g:19120:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); + } + // InternalExpression.g:19121:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) + // InternalExpression.g:19121:3: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2" + // InternalExpression.g:19129:1: rule__JvmParameterizedTypeReference__Group_1_4__2 : rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19133:1: ( rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ) + // InternalExpression.g:19134:2: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" + // InternalExpression.g:19140:1: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19144:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ) + // InternalExpression.g:19145:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) + { + // InternalExpression.g:19145:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) + // InternalExpression.g:19146:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); + } + // InternalExpression.g:19147:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? + int alt147=2; + alt147 = dfa147.predict(input); + switch (alt147) { + case 1 : + // InternalExpression.g:19147:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0" + // InternalExpression.g:19156:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19160:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ) + // InternalExpression.g:19161:2: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" + // InternalExpression.g:19167:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19171:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ) + // InternalExpression.g:19172:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) + { + // InternalExpression.g:19172:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) + // InternalExpression.g:19173:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); + } + // InternalExpression.g:19174:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) + // InternalExpression.g:19174:3: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" + // InternalExpression.g:19183:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19187:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ) + // InternalExpression.g:19188:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 + { + pushFollow(FOLLOW_32); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" + // InternalExpression.g:19195:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl : ( () ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19199:1: ( ( () ) ) + // InternalExpression.g:19200:1: ( () ) + { + // InternalExpression.g:19200:1: ( () ) + // InternalExpression.g:19201:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); + } + // InternalExpression.g:19202:2: () + // InternalExpression.g:19202:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" + // InternalExpression.g:19210:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19214:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ) + // InternalExpression.g:19215:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" + // InternalExpression.g:19221:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl : ( '.' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19225:1: ( ( '.' ) ) + // InternalExpression.g:19226:1: ( '.' ) + { + // InternalExpression.g:19226:1: ( '.' ) + // InternalExpression.g:19227:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0" + // InternalExpression.g:19237:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19241:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ) + // InternalExpression.g:19242:2: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 + { + pushFollow(FOLLOW_74); + rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" + // InternalExpression.g:19249:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl : ( ( '<' ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19253:1: ( ( ( '<' ) ) ) + // InternalExpression.g:19254:1: ( ( '<' ) ) + { + // InternalExpression.g:19254:1: ( ( '<' ) ) + // InternalExpression.g:19255:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + // InternalExpression.g:19256:2: ( '<' ) + // InternalExpression.g:19256:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1" + // InternalExpression.g:19264:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19268:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ) + // InternalExpression.g:19269:2: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 + { + pushFollow(FOLLOW_75); + rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" + // InternalExpression.g:19276:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19280:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ) + // InternalExpression.g:19281:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) + { + // InternalExpression.g:19281:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) + // InternalExpression.g:19282:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); + } + // InternalExpression.g:19283:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) + // InternalExpression.g:19283:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2" + // InternalExpression.g:19291:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2 : rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19295:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ) + // InternalExpression.g:19296:2: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 + { + pushFollow(FOLLOW_75); + rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" + // InternalExpression.g:19303:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19307:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ) + // InternalExpression.g:19308:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) + { + // InternalExpression.g:19308:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) + // InternalExpression.g:19309:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); + } + // InternalExpression.g:19310:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* + loop148: + do { + int alt148=2; + int LA148_0 = input.LA(1); + + if ( (LA148_0==78) ) { + alt148=1; + } + + + switch (alt148) { + case 1 : + // InternalExpression.g:19310:3: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 + { + pushFollow(FOLLOW_37); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop148; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3" + // InternalExpression.g:19318:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3 : rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19322:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ) + // InternalExpression.g:19323:2: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" + // InternalExpression.g:19329:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl : ( '>' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19333:1: ( ( '>' ) ) + // InternalExpression.g:19334:1: ( '>' ) + { + // InternalExpression.g:19334:1: ( '>' ) + // InternalExpression.g:19335:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" + // InternalExpression.g:19345:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19349:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ) + // InternalExpression.g:19350:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 + { + pushFollow(FOLLOW_74); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" + // InternalExpression.g:19357:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl : ( ',' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19361:1: ( ( ',' ) ) + // InternalExpression.g:19362:1: ( ',' ) + { + // InternalExpression.g:19362:1: ( ',' ) + // InternalExpression.g:19363:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" + // InternalExpression.g:19372:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19376:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ) + // InternalExpression.g:19377:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" + // InternalExpression.g:19383:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19387:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ) + // InternalExpression.g:19388:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) + { + // InternalExpression.g:19388:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) + // InternalExpression.g:19389:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); + } + // InternalExpression.g:19390:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) + // InternalExpression.g:19390:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__0" + // InternalExpression.g:19399:1: rule__JvmWildcardTypeReference__Group__0 : rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ; + public final void rule__JvmWildcardTypeReference__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19403:1: ( rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ) + // InternalExpression.g:19404:2: rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 + { + pushFollow(FOLLOW_74); + rule__JvmWildcardTypeReference__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__0__Impl" + // InternalExpression.g:19411:1: rule__JvmWildcardTypeReference__Group__0__Impl : ( () ) ; + public final void rule__JvmWildcardTypeReference__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19415:1: ( ( () ) ) + // InternalExpression.g:19416:1: ( () ) + { + // InternalExpression.g:19416:1: ( () ) + // InternalExpression.g:19417:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); + } + // InternalExpression.g:19418:2: () + // InternalExpression.g:19418:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__1" + // InternalExpression.g:19426:1: rule__JvmWildcardTypeReference__Group__1 : rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ; + public final void rule__JvmWildcardTypeReference__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19430:1: ( rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ) + // InternalExpression.g:19431:2: rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 + { + pushFollow(FOLLOW_115); + rule__JvmWildcardTypeReference__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__1__Impl" + // InternalExpression.g:19438:1: rule__JvmWildcardTypeReference__Group__1__Impl : ( '?' ) ; + public final void rule__JvmWildcardTypeReference__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19442:1: ( ( '?' ) ) + // InternalExpression.g:19443:1: ( '?' ) + { + // InternalExpression.g:19443:1: ( '?' ) + // InternalExpression.g:19444:2: '?' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + match(input,69,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__2" + // InternalExpression.g:19453:1: rule__JvmWildcardTypeReference__Group__2 : rule__JvmWildcardTypeReference__Group__2__Impl ; + public final void rule__JvmWildcardTypeReference__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19457:1: ( rule__JvmWildcardTypeReference__Group__2__Impl ) + // InternalExpression.g:19458:2: rule__JvmWildcardTypeReference__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__2" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__2__Impl" + // InternalExpression.g:19464:1: rule__JvmWildcardTypeReference__Group__2__Impl : ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ; + public final void rule__JvmWildcardTypeReference__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19468:1: ( ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ) + // InternalExpression.g:19469:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) + { + // InternalExpression.g:19469:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) + // InternalExpression.g:19470:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); + } + // InternalExpression.g:19471:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==60||LA149_0==64) ) { + alt149=1; + } + switch (alt149) { + case 1 : + // InternalExpression.g:19471:3: rule__JvmWildcardTypeReference__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__2__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0" + // InternalExpression.g:19480:1: rule__JvmWildcardTypeReference__Group_2_0__0 : rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ; + public final void rule__JvmWildcardTypeReference__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19484:1: ( rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ) + // InternalExpression.g:19485:2: rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 + { + pushFollow(FOLLOW_116); + rule__JvmWildcardTypeReference__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" + // InternalExpression.g:19492:1: rule__JvmWildcardTypeReference__Group_2_0__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ; + public final void rule__JvmWildcardTypeReference__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19496:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ) + // InternalExpression.g:19497:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) + { + // InternalExpression.g:19497:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) + // InternalExpression.g:19498:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); + } + // InternalExpression.g:19499:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) + // InternalExpression.g:19499:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1" + // InternalExpression.g:19507:1: rule__JvmWildcardTypeReference__Group_2_0__1 : rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; + public final void rule__JvmWildcardTypeReference__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19511:1: ( rule__JvmWildcardTypeReference__Group_2_0__1__Impl ) + // InternalExpression.g:19512:2: rule__JvmWildcardTypeReference__Group_2_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" + // InternalExpression.g:19518:1: rule__JvmWildcardTypeReference__Group_2_0__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ; + public final void rule__JvmWildcardTypeReference__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19522:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ) + // InternalExpression.g:19523:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) + { + // InternalExpression.g:19523:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) + // InternalExpression.g:19524:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); + } + // InternalExpression.g:19525:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* + loop150: + do { + int alt150=2; + int LA150_0 = input.LA(1); + + if ( (LA150_0==100) ) { + alt150=1; + } + + + switch (alt150) { + case 1 : + // InternalExpression.g:19525:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 + { + pushFollow(FOLLOW_117); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop150; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0" + // InternalExpression.g:19534:1: rule__JvmWildcardTypeReference__Group_2_1__0 : rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ; + public final void rule__JvmWildcardTypeReference__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19538:1: ( rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ) + // InternalExpression.g:19539:2: rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 + { + pushFollow(FOLLOW_116); + rule__JvmWildcardTypeReference__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" + // InternalExpression.g:19546:1: rule__JvmWildcardTypeReference__Group_2_1__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ; + public final void rule__JvmWildcardTypeReference__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19550:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ) + // InternalExpression.g:19551:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) + { + // InternalExpression.g:19551:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) + // InternalExpression.g:19552:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); + } + // InternalExpression.g:19553:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) + // InternalExpression.g:19553:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1" + // InternalExpression.g:19561:1: rule__JvmWildcardTypeReference__Group_2_1__1 : rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; + public final void rule__JvmWildcardTypeReference__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19565:1: ( rule__JvmWildcardTypeReference__Group_2_1__1__Impl ) + // InternalExpression.g:19566:2: rule__JvmWildcardTypeReference__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" + // InternalExpression.g:19572:1: rule__JvmWildcardTypeReference__Group_2_1__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ; + public final void rule__JvmWildcardTypeReference__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19576:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ) + // InternalExpression.g:19577:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) + { + // InternalExpression.g:19577:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) + // InternalExpression.g:19578:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); + } + // InternalExpression.g:19579:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* + loop151: + do { + int alt151=2; + int LA151_0 = input.LA(1); + + if ( (LA151_0==100) ) { + alt151=1; + } + + + switch (alt151) { + case 1 : + // InternalExpression.g:19579:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 + { + pushFollow(FOLLOW_117); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop151; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" + + + // $ANTLR start "rule__JvmUpperBound__Group__0" + // InternalExpression.g:19588:1: rule__JvmUpperBound__Group__0 : rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ; + public final void rule__JvmUpperBound__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19592:1: ( rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ) + // InternalExpression.g:19593:2: rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 + { + pushFollow(FOLLOW_56); + rule__JvmUpperBound__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__0" + + + // $ANTLR start "rule__JvmUpperBound__Group__0__Impl" + // InternalExpression.g:19600:1: rule__JvmUpperBound__Group__0__Impl : ( 'extends' ) ; + public final void rule__JvmUpperBound__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19604:1: ( ( 'extends' ) ) + // InternalExpression.g:19605:1: ( 'extends' ) + { + // InternalExpression.g:19605:1: ( 'extends' ) + // InternalExpression.g:19606:2: 'extends' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + match(input,60,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__0__Impl" + + + // $ANTLR start "rule__JvmUpperBound__Group__1" + // InternalExpression.g:19615:1: rule__JvmUpperBound__Group__1 : rule__JvmUpperBound__Group__1__Impl ; + public final void rule__JvmUpperBound__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19619:1: ( rule__JvmUpperBound__Group__1__Impl ) + // InternalExpression.g:19620:2: rule__JvmUpperBound__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__1" + + + // $ANTLR start "rule__JvmUpperBound__Group__1__Impl" + // InternalExpression.g:19626:1: rule__JvmUpperBound__Group__1__Impl : ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmUpperBound__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19630:1: ( ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ) + // InternalExpression.g:19631:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) + { + // InternalExpression.g:19631:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) + // InternalExpression.g:19632:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); + } + // InternalExpression.g:19633:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) + // InternalExpression.g:19633:3: rule__JvmUpperBound__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__1__Impl" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__0" + // InternalExpression.g:19642:1: rule__JvmUpperBoundAnded__Group__0 : rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ; + public final void rule__JvmUpperBoundAnded__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19646:1: ( rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ) + // InternalExpression.g:19647:2: rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 + { + pushFollow(FOLLOW_56); + rule__JvmUpperBoundAnded__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__0" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__0__Impl" + // InternalExpression.g:19654:1: rule__JvmUpperBoundAnded__Group__0__Impl : ( '&' ) ; + public final void rule__JvmUpperBoundAnded__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19658:1: ( ( '&' ) ) + // InternalExpression.g:19659:1: ( '&' ) + { + // InternalExpression.g:19659:1: ( '&' ) + // InternalExpression.g:19660:2: '&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + match(input,100,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__0__Impl" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__1" + // InternalExpression.g:19669:1: rule__JvmUpperBoundAnded__Group__1 : rule__JvmUpperBoundAnded__Group__1__Impl ; + public final void rule__JvmUpperBoundAnded__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19673:1: ( rule__JvmUpperBoundAnded__Group__1__Impl ) + // InternalExpression.g:19674:2: rule__JvmUpperBoundAnded__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__1" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__1__Impl" + // InternalExpression.g:19680:1: rule__JvmUpperBoundAnded__Group__1__Impl : ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmUpperBoundAnded__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19684:1: ( ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ) + // InternalExpression.g:19685:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) + { + // InternalExpression.g:19685:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) + // InternalExpression.g:19686:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); + } + // InternalExpression.g:19687:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) + // InternalExpression.g:19687:3: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__1__Impl" + + + // $ANTLR start "rule__JvmLowerBound__Group__0" + // InternalExpression.g:19696:1: rule__JvmLowerBound__Group__0 : rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ; + public final void rule__JvmLowerBound__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19700:1: ( rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ) + // InternalExpression.g:19701:2: rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 + { + pushFollow(FOLLOW_56); + rule__JvmLowerBound__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__0" + + + // $ANTLR start "rule__JvmLowerBound__Group__0__Impl" + // InternalExpression.g:19708:1: rule__JvmLowerBound__Group__0__Impl : ( 'super' ) ; + public final void rule__JvmLowerBound__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19712:1: ( ( 'super' ) ) + // InternalExpression.g:19713:1: ( 'super' ) + { + // InternalExpression.g:19713:1: ( 'super' ) + // InternalExpression.g:19714:2: 'super' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + match(input,64,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__0__Impl" + + + // $ANTLR start "rule__JvmLowerBound__Group__1" + // InternalExpression.g:19723:1: rule__JvmLowerBound__Group__1 : rule__JvmLowerBound__Group__1__Impl ; + public final void rule__JvmLowerBound__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19727:1: ( rule__JvmLowerBound__Group__1__Impl ) + // InternalExpression.g:19728:2: rule__JvmLowerBound__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__1" + + + // $ANTLR start "rule__JvmLowerBound__Group__1__Impl" + // InternalExpression.g:19734:1: rule__JvmLowerBound__Group__1__Impl : ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmLowerBound__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19738:1: ( ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ) + // InternalExpression.g:19739:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) + { + // InternalExpression.g:19739:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) + // InternalExpression.g:19740:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); + } + // InternalExpression.g:19741:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) + // InternalExpression.g:19741:3: rule__JvmLowerBound__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__1__Impl" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__0" + // InternalExpression.g:19750:1: rule__JvmLowerBoundAnded__Group__0 : rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ; + public final void rule__JvmLowerBoundAnded__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19754:1: ( rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ) + // InternalExpression.g:19755:2: rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 + { + pushFollow(FOLLOW_56); + rule__JvmLowerBoundAnded__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__0" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__0__Impl" + // InternalExpression.g:19762:1: rule__JvmLowerBoundAnded__Group__0__Impl : ( '&' ) ; + public final void rule__JvmLowerBoundAnded__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19766:1: ( ( '&' ) ) + // InternalExpression.g:19767:1: ( '&' ) + { + // InternalExpression.g:19767:1: ( '&' ) + // InternalExpression.g:19768:2: '&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + match(input,100,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__0__Impl" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__1" + // InternalExpression.g:19777:1: rule__JvmLowerBoundAnded__Group__1 : rule__JvmLowerBoundAnded__Group__1__Impl ; + public final void rule__JvmLowerBoundAnded__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19781:1: ( rule__JvmLowerBoundAnded__Group__1__Impl ) + // InternalExpression.g:19782:2: rule__JvmLowerBoundAnded__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__1" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__1__Impl" + // InternalExpression.g:19788:1: rule__JvmLowerBoundAnded__Group__1__Impl : ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmLowerBoundAnded__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19792:1: ( ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ) + // InternalExpression.g:19793:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) + { + // InternalExpression.g:19793:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) + // InternalExpression.g:19794:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); + } + // InternalExpression.g:19795:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) + // InternalExpression.g:19795:3: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0" + // InternalExpression.g:19804:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ; + public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19808:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ) + // InternalExpression.g:19809:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 + { + pushFollow(FOLLOW_32); + rule__QualifiedNameWithWildcard__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl" + // InternalExpression.g:19816:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ; + public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19820:1: ( ( ruleQualifiedName ) ) + // InternalExpression.g:19821:1: ( ruleQualifiedName ) + { + // InternalExpression.g:19821:1: ( ruleQualifiedName ) + // InternalExpression.g:19822:2: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1" + // InternalExpression.g:19831:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ; + public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19835:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ) + // InternalExpression.g:19836:2: rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 + { + pushFollow(FOLLOW_118); + rule__QualifiedNameWithWildcard__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl" + // InternalExpression.g:19843:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( '.' ) ; + public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19847:1: ( ( '.' ) ) + // InternalExpression.g:19848:1: ( '.' ) + { + // InternalExpression.g:19848:1: ( '.' ) + // InternalExpression.g:19849:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2" + // InternalExpression.g:19858:1: rule__QualifiedNameWithWildcard__Group__2 : rule__QualifiedNameWithWildcard__Group__2__Impl ; + public final void rule__QualifiedNameWithWildcard__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19862:1: ( rule__QualifiedNameWithWildcard__Group__2__Impl ) + // InternalExpression.g:19863:2: rule__QualifiedNameWithWildcard__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2__Impl" + // InternalExpression.g:19869:1: rule__QualifiedNameWithWildcard__Group__2__Impl : ( '*' ) ; + public final void rule__QualifiedNameWithWildcard__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19873:1: ( ( '*' ) ) + // InternalExpression.g:19874:1: ( '*' ) + { + // InternalExpression.g:19874:1: ( '*' ) + // InternalExpression.g:19875:2: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__0" + // InternalExpression.g:19885:1: rule__XImportDeclaration__Group__0 : rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ; + public final void rule__XImportDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19889:1: ( rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ) + // InternalExpression.g:19890:2: rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 + { + pushFollow(FOLLOW_119); + rule__XImportDeclaration__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__0" + + + // $ANTLR start "rule__XImportDeclaration__Group__0__Impl" + // InternalExpression.g:19897:1: rule__XImportDeclaration__Group__0__Impl : ( 'import' ) ; + public final void rule__XImportDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19901:1: ( ( 'import' ) ) + // InternalExpression.g:19902:1: ( 'import' ) + { + // InternalExpression.g:19902:1: ( 'import' ) + // InternalExpression.g:19903:2: 'import' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + match(input,62,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__1" + // InternalExpression.g:19912:1: rule__XImportDeclaration__Group__1 : rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ; + public final void rule__XImportDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19916:1: ( rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ) + // InternalExpression.g:19917:2: rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 + { + pushFollow(FOLLOW_84); + rule__XImportDeclaration__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__1" + + + // $ANTLR start "rule__XImportDeclaration__Group__1__Impl" + // InternalExpression.g:19924:1: rule__XImportDeclaration__Group__1__Impl : ( ( rule__XImportDeclaration__Alternatives_1 ) ) ; + public final void rule__XImportDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19928:1: ( ( ( rule__XImportDeclaration__Alternatives_1 ) ) ) + // InternalExpression.g:19929:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) + { + // InternalExpression.g:19929:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) + // InternalExpression.g:19930:2: ( rule__XImportDeclaration__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); + } + // InternalExpression.g:19931:2: ( rule__XImportDeclaration__Alternatives_1 ) + // InternalExpression.g:19931:3: rule__XImportDeclaration__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__2" + // InternalExpression.g:19939:1: rule__XImportDeclaration__Group__2 : rule__XImportDeclaration__Group__2__Impl ; + public final void rule__XImportDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19943:1: ( rule__XImportDeclaration__Group__2__Impl ) + // InternalExpression.g:19944:2: rule__XImportDeclaration__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__2" + + + // $ANTLR start "rule__XImportDeclaration__Group__2__Impl" + // InternalExpression.g:19950:1: rule__XImportDeclaration__Group__2__Impl : ( ( ';' )? ) ; + public final void rule__XImportDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19954:1: ( ( ( ';' )? ) ) + // InternalExpression.g:19955:1: ( ( ';' )? ) + { + // InternalExpression.g:19955:1: ( ( ';' )? ) + // InternalExpression.g:19956:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + // InternalExpression.g:19957:2: ( ';' )? + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==88) ) { + alt152=1; + } + switch (alt152) { + case 1 : + // InternalExpression.g:19957:3: ';' + { + match(input,88,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__0" + // InternalExpression.g:19966:1: rule__XImportDeclaration__Group_1_0__0 : rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ; + public final void rule__XImportDeclaration__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19970:1: ( rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ) + // InternalExpression.g:19971:2: rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 + { + pushFollow(FOLLOW_120); + rule__XImportDeclaration__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__0" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__0__Impl" + // InternalExpression.g:19978:1: rule__XImportDeclaration__Group_1_0__0__Impl : ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19982:1: ( ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ) + // InternalExpression.g:19983:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) + { + // InternalExpression.g:19983:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) + // InternalExpression.g:19984:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); + } + // InternalExpression.g:19985:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) + // InternalExpression.g:19985:3: rule__XImportDeclaration__StaticAssignment_1_0_0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__StaticAssignment_1_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__1" + // InternalExpression.g:19993:1: rule__XImportDeclaration__Group_1_0__1 : rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ; + public final void rule__XImportDeclaration__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:19997:1: ( rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ) + // InternalExpression.g:19998:2: rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 + { + pushFollow(FOLLOW_120); + rule__XImportDeclaration__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__1" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__1__Impl" + // InternalExpression.g:20005:1: rule__XImportDeclaration__Group_1_0__1__Impl : ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ; + public final void rule__XImportDeclaration__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20009:1: ( ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ) + // InternalExpression.g:20010:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) + { + // InternalExpression.g:20010:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) + // InternalExpression.g:20011:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); + } + // InternalExpression.g:20012:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? + int alt153=2; + int LA153_0 = input.LA(1); + + if ( (LA153_0==63) ) { + alt153=1; + } + switch (alt153) { + case 1 : + // InternalExpression.g:20012:3: rule__XImportDeclaration__ExtensionAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ExtensionAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__2" + // InternalExpression.g:20020:1: rule__XImportDeclaration__Group_1_0__2 : rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ; + public final void rule__XImportDeclaration__Group_1_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20024:1: ( rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ) + // InternalExpression.g:20025:2: rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 + { + pushFollow(FOLLOW_121); + rule__XImportDeclaration__Group_1_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__2" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__2__Impl" + // InternalExpression.g:20032:1: rule__XImportDeclaration__Group_1_0__2__Impl : ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20036:1: ( ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ) + // InternalExpression.g:20037:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) + { + // InternalExpression.g:20037:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) + // InternalExpression.g:20038:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); + } + // InternalExpression.g:20039:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) + // InternalExpression.g:20039:3: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedTypeAssignment_1_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__3" + // InternalExpression.g:20047:1: rule__XImportDeclaration__Group_1_0__3 : rule__XImportDeclaration__Group_1_0__3__Impl ; + public final void rule__XImportDeclaration__Group_1_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20051:1: ( rule__XImportDeclaration__Group_1_0__3__Impl ) + // InternalExpression.g:20052:2: rule__XImportDeclaration__Group_1_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__3" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__3__Impl" + // InternalExpression.g:20058:1: rule__XImportDeclaration__Group_1_0__3__Impl : ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20062:1: ( ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ) + // InternalExpression.g:20063:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) + { + // InternalExpression.g:20063:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) + // InternalExpression.g:20064:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); + } + // InternalExpression.g:20065:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) + // InternalExpression.g:20065:3: rule__XImportDeclaration__Alternatives_1_0_3 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Alternatives_1_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__3__Impl" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0" + // InternalExpression.g:20074:1: rule__QualifiedNameInStaticImport__Group__0 : rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ; + public final void rule__QualifiedNameInStaticImport__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20078:1: ( rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ) + // InternalExpression.g:20079:2: rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 + { + pushFollow(FOLLOW_32); + rule__QualifiedNameInStaticImport__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameInStaticImport__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0__Impl" + // InternalExpression.g:20086:1: rule__QualifiedNameInStaticImport__Group__0__Impl : ( ruleValidID ) ; + public final void rule__QualifiedNameInStaticImport__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20090:1: ( ( ruleValidID ) ) + // InternalExpression.g:20091:1: ( ruleValidID ) + { + // InternalExpression.g:20091:1: ( ruleValidID ) + // InternalExpression.g:20092:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1" + // InternalExpression.g:20101:1: rule__QualifiedNameInStaticImport__Group__1 : rule__QualifiedNameInStaticImport__Group__1__Impl ; + public final void rule__QualifiedNameInStaticImport__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20105:1: ( rule__QualifiedNameInStaticImport__Group__1__Impl ) + // InternalExpression.g:20106:2: rule__QualifiedNameInStaticImport__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedNameInStaticImport__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1__Impl" + // InternalExpression.g:20112:1: rule__QualifiedNameInStaticImport__Group__1__Impl : ( '.' ) ; + public final void rule__QualifiedNameInStaticImport__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20116:1: ( ( '.' ) ) + // InternalExpression.g:20117:1: ( '.' ) + { + // InternalExpression.g:20117:1: ( '.' ) + // InternalExpression.g:20118:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1__Impl" + + + // $ANTLR start "rule__LetExpression__IdentifierAssignment_1" + // InternalExpression.g:20128:1: rule__LetExpression__IdentifierAssignment_1 : ( ruleIdentifier ) ; + public final void rule__LetExpression__IdentifierAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20132:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:20133:2: ( ruleIdentifier ) + { + // InternalExpression.g:20133:2: ( ruleIdentifier ) + // InternalExpression.g:20134:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__IdentifierAssignment_1" + + + // $ANTLR start "rule__LetExpression__VarExprAssignment_3" + // InternalExpression.g:20143:1: rule__LetExpression__VarExprAssignment_3 : ( ruleExpression ) ; + public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20147:1: ( ( ruleExpression ) ) + // InternalExpression.g:20148:2: ( ruleExpression ) + { + // InternalExpression.g:20148:2: ( ruleExpression ) + // InternalExpression.g:20149:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__VarExprAssignment_3" + + + // $ANTLR start "rule__LetExpression__TargetAssignment_5" + // InternalExpression.g:20158:1: rule__LetExpression__TargetAssignment_5 : ( ruleExpression ) ; + public final void rule__LetExpression__TargetAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20162:1: ( ( ruleExpression ) ) + // InternalExpression.g:20163:2: ( ruleExpression ) + { + // InternalExpression.g:20163:2: ( ruleExpression ) + // InternalExpression.g:20164:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__TargetAssignment_5" + + + // $ANTLR start "rule__CastedExpression__TypeAssignment_1" + // InternalExpression.g:20173:1: rule__CastedExpression__TypeAssignment_1 : ( ruleType ) ; + public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20177:1: ( ( ruleType ) ) + // InternalExpression.g:20178:2: ( ruleType ) + { + // InternalExpression.g:20178:2: ( ruleType ) + // InternalExpression.g:20179:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__TypeAssignment_1" + + + // $ANTLR start "rule__CastedExpression__TargetAssignment_3" + // InternalExpression.g:20188:1: rule__CastedExpression__TargetAssignment_3 : ( ruleExpression ) ; + public final void rule__CastedExpression__TargetAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20192:1: ( ( ruleExpression ) ) + // InternalExpression.g:20193:2: ( ruleExpression ) + { + // InternalExpression.g:20193:2: ( ruleExpression ) + // InternalExpression.g:20194:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__TargetAssignment_3" + + + // $ANTLR start "rule__ChainExpression__NextAssignment_1_2" + // InternalExpression.g:20203:1: rule__ChainExpression__NextAssignment_1_2 : ( ruleChainedExpression ) ; + public final void rule__ChainExpression__NextAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20207:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:20208:2: ( ruleChainedExpression ) + { + // InternalExpression.g:20208:2: ( ruleChainedExpression ) + // InternalExpression.g:20209:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ChainExpression__NextAssignment_1_2" + + + // $ANTLR start "rule__IfExpressionTri__ThenPartAssignment_1_2" + // InternalExpression.g:20218:1: rule__IfExpressionTri__ThenPartAssignment_1_2 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20222:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:20223:2: ( ruleChainedExpression ) + { + // InternalExpression.g:20223:2: ( ruleChainedExpression ) + // InternalExpression.g:20224:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__ThenPartAssignment_1_2" + + + // $ANTLR start "rule__IfExpressionTri__ElsePartAssignment_1_4" + // InternalExpression.g:20233:1: rule__IfExpressionTri__ElsePartAssignment_1_4 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20237:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:20238:2: ( ruleChainedExpression ) + { + // InternalExpression.g:20238:2: ( ruleChainedExpression ) + // InternalExpression.g:20239:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__ElsePartAssignment_1_4" + + + // $ANTLR start "rule__IfExpressionKw__ConditionAssignment_1" + // InternalExpression.g:20248:1: rule__IfExpressionKw__ConditionAssignment_1 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ConditionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20252:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:20253:2: ( ruleChainedExpression ) + { + // InternalExpression.g:20253:2: ( ruleChainedExpression ) + // InternalExpression.g:20254:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ConditionAssignment_1" + + + // $ANTLR start "rule__IfExpressionKw__ThenPartAssignment_3" + // InternalExpression.g:20263:1: rule__IfExpressionKw__ThenPartAssignment_3 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ThenPartAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20267:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:20268:2: ( ruleChainedExpression ) + { + // InternalExpression.g:20268:2: ( ruleChainedExpression ) + // InternalExpression.g:20269:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ThenPartAssignment_3" + + + // $ANTLR start "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + // InternalExpression.g:20278:1: rule__IfExpressionKw__ElsePartAssignment_4_0_1 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20282:1: ( ( ruleChainedExpression ) ) + // InternalExpression.g:20283:2: ( ruleChainedExpression ) + { + // InternalExpression.g:20283:2: ( ruleChainedExpression ) + // InternalExpression.g:20284:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + + + // $ANTLR start "rule__SwitchExpression__SwitchExprAssignment_1_1" + // InternalExpression.g:20293:1: rule__SwitchExpression__SwitchExprAssignment_1_1 : ( ruleOrExpression ) ; + public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20297:1: ( ( ruleOrExpression ) ) + // InternalExpression.g:20298:2: ( ruleOrExpression ) + { + // InternalExpression.g:20298:2: ( ruleOrExpression ) + // InternalExpression.g:20299:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__SwitchExprAssignment_1_1" + + + // $ANTLR start "rule__SwitchExpression__CaseAssignment_3" + // InternalExpression.g:20308:1: rule__SwitchExpression__CaseAssignment_3 : ( ruleCase ) ; + public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20312:1: ( ( ruleCase ) ) + // InternalExpression.g:20313:2: ( ruleCase ) + { + // InternalExpression.g:20313:2: ( ruleCase ) + // InternalExpression.g:20314:3: ruleCase + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleCase(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__CaseAssignment_3" + + + // $ANTLR start "rule__SwitchExpression__DefaultExprAssignment_6" + // InternalExpression.g:20323:1: rule__SwitchExpression__DefaultExprAssignment_6 : ( ruleOrExpression ) ; + public final void rule__SwitchExpression__DefaultExprAssignment_6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20327:1: ( ( ruleOrExpression ) ) + // InternalExpression.g:20328:2: ( ruleOrExpression ) + { + // InternalExpression.g:20328:2: ( ruleOrExpression ) + // InternalExpression.g:20329:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__DefaultExprAssignment_6" + + + // $ANTLR start "rule__Case__ConditionAssignment_1" + // InternalExpression.g:20338:1: rule__Case__ConditionAssignment_1 : ( ruleOrExpression ) ; + public final void rule__Case__ConditionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20342:1: ( ( ruleOrExpression ) ) + // InternalExpression.g:20343:2: ( ruleOrExpression ) + { + // InternalExpression.g:20343:2: ( ruleOrExpression ) + // InternalExpression.g:20344:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Case__ConditionAssignment_1" + + + // $ANTLR start "rule__Case__ThenParAssignment_3" + // InternalExpression.g:20353:1: rule__Case__ThenParAssignment_3 : ( ruleOrExpression ) ; + public final void rule__Case__ThenParAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20357:1: ( ( ruleOrExpression ) ) + // InternalExpression.g:20358:2: ( ruleOrExpression ) + { + // InternalExpression.g:20358:2: ( ruleOrExpression ) + // InternalExpression.g:20359:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Case__ThenParAssignment_3" + + + // $ANTLR start "rule__OrExpression__OperatorAssignment_1_1" + // InternalExpression.g:20368:1: rule__OrExpression__OperatorAssignment_1_1 : ( ( '||' ) ) ; + public final void rule__OrExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20372:1: ( ( ( '||' ) ) ) + // InternalExpression.g:20373:2: ( ( '||' ) ) + { + // InternalExpression.g:20373:2: ( ( '||' ) ) + // InternalExpression.g:20374:3: ( '||' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + // InternalExpression.g:20375:3: ( '||' ) + // InternalExpression.g:20376:4: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + match(input,15,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OrExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__OrExpression__RightAssignment_1_2" + // InternalExpression.g:20387:1: rule__OrExpression__RightAssignment_1_2 : ( ruleAndExpression ) ; + public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20391:1: ( ( ruleAndExpression ) ) + // InternalExpression.g:20392:2: ( ruleAndExpression ) + { + // InternalExpression.g:20392:2: ( ruleAndExpression ) + // InternalExpression.g:20393:3: ruleAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OrExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__AndExpression__OperatorAssignment_1_1" + // InternalExpression.g:20402:1: rule__AndExpression__OperatorAssignment_1_1 : ( ( '&&' ) ) ; + public final void rule__AndExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20406:1: ( ( ( '&&' ) ) ) + // InternalExpression.g:20407:2: ( ( '&&' ) ) + { + // InternalExpression.g:20407:2: ( ( '&&' ) ) + // InternalExpression.g:20408:3: ( '&&' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + // InternalExpression.g:20409:3: ( '&&' ) + // InternalExpression.g:20410:4: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + match(input,16,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AndExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__AndExpression__RightAssignment_1_2" + // InternalExpression.g:20421:1: rule__AndExpression__RightAssignment_1_2 : ( ruleImpliesExpression ) ; + public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20425:1: ( ( ruleImpliesExpression ) ) + // InternalExpression.g:20426:2: ( ruleImpliesExpression ) + { + // InternalExpression.g:20426:2: ( ruleImpliesExpression ) + // InternalExpression.g:20427:3: ruleImpliesExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleImpliesExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AndExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__ImpliesExpression__OperatorAssignment_1_1" + // InternalExpression.g:20436:1: rule__ImpliesExpression__OperatorAssignment_1_1 : ( ( 'implies' ) ) ; + public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20440:1: ( ( ( 'implies' ) ) ) + // InternalExpression.g:20441:2: ( ( 'implies' ) ) + { + // InternalExpression.g:20441:2: ( ( 'implies' ) ) + // InternalExpression.g:20442:3: ( 'implies' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + // InternalExpression.g:20443:3: ( 'implies' ) + // InternalExpression.g:20444:4: 'implies' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + match(input,101,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ImpliesExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__ImpliesExpression__RightAssignment_1_2" + // InternalExpression.g:20455:1: rule__ImpliesExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; + public final void rule__ImpliesExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20459:1: ( ( ruleRelationalExpression ) ) + // InternalExpression.g:20460:2: ( ruleRelationalExpression ) + { + // InternalExpression.g:20460:2: ( ruleRelationalExpression ) + // InternalExpression.g:20461:3: ruleRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ImpliesExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" + // InternalExpression.g:20470:1: rule__RelationalExpression__OperatorAssignment_1_1 : ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ; + public final void rule__RelationalExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20474:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) + // InternalExpression.g:20475:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + { + // InternalExpression.g:20475:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalExpression.g:20476:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + } + // InternalExpression.g:20477:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalExpression.g:20477:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__RelationalExpression__OperatorAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" + // InternalExpression.g:20485:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; + public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20489:1: ( ( ruleAdditiveExpression ) ) + // InternalExpression.g:20490:2: ( ruleAdditiveExpression ) + { + // InternalExpression.g:20490:2: ( ruleAdditiveExpression ) + // InternalExpression.g:20491:3: ruleAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__AdditiveExpression__NameAssignment_1_1" + // InternalExpression.g:20500:1: rule__AdditiveExpression__NameAssignment_1_1 : ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ; + public final void rule__AdditiveExpression__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20504:1: ( ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ) + // InternalExpression.g:20505:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + { + // InternalExpression.g:20505:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + // InternalExpression.g:20506:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + } + // InternalExpression.g:20507:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + // InternalExpression.g:20507:4: rule__AdditiveExpression__NameAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__AdditiveExpression__NameAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__NameAssignment_1_1" + + + // $ANTLR start "rule__AdditiveExpression__ParamsAssignment_1_2" + // InternalExpression.g:20515:1: rule__AdditiveExpression__ParamsAssignment_1_2 : ( ruleMultiplicativeExpression ) ; + public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20519:1: ( ( ruleMultiplicativeExpression ) ) + // InternalExpression.g:20520:2: ( ruleMultiplicativeExpression ) + { + // InternalExpression.g:20520:2: ( ruleMultiplicativeExpression ) + // InternalExpression.g:20521:3: ruleMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__ParamsAssignment_1_2" + + + // $ANTLR start "rule__MultiplicativeExpression__NameAssignment_1_1" + // InternalExpression.g:20530:1: rule__MultiplicativeExpression__NameAssignment_1_1 : ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ; + public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20534:1: ( ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ) + // InternalExpression.g:20535:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + { + // InternalExpression.g:20535:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + // InternalExpression.g:20536:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + } + // InternalExpression.g:20537:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + // InternalExpression.g:20537:4: rule__MultiplicativeExpression__NameAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__NameAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__NameAssignment_1_1" + + + // $ANTLR start "rule__MultiplicativeExpression__ParamsAssignment_1_2" + // InternalExpression.g:20545:1: rule__MultiplicativeExpression__ParamsAssignment_1_2 : ( ruleUnaryOrInfixExpression ) ; + public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20549:1: ( ( ruleUnaryOrInfixExpression ) ) + // InternalExpression.g:20550:2: ( ruleUnaryOrInfixExpression ) + { + // InternalExpression.g:20550:2: ( ruleUnaryOrInfixExpression ) + // InternalExpression.g:20551:3: ruleUnaryOrInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleUnaryOrInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__ParamsAssignment_1_2" + + + // $ANTLR start "rule__UnaryExpression__NameAssignment_0" + // InternalExpression.g:20560:1: rule__UnaryExpression__NameAssignment_0 : ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ; + public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20564:1: ( ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ) + // InternalExpression.g:20565:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + { + // InternalExpression.g:20565:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + // InternalExpression.g:20566:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + } + // InternalExpression.g:20567:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + // InternalExpression.g:20567:4: rule__UnaryExpression__NameAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__UnaryExpression__NameAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__NameAssignment_0" + + + // $ANTLR start "rule__UnaryExpression__ParamsAssignment_1" + // InternalExpression.g:20575:1: rule__UnaryExpression__ParamsAssignment_1 : ( ruleInfixExpression ) ; + public final void rule__UnaryExpression__ParamsAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20579:1: ( ( ruleInfixExpression ) ) + // InternalExpression.g:20580:2: ( ruleInfixExpression ) + { + // InternalExpression.g:20580:2: ( ruleInfixExpression ) + // InternalExpression.g:20581:3: ruleInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__ParamsAssignment_1" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_0_2" + // InternalExpression.g:20590:1: rule__InfixExpression__NameAssignment_1_0_2 : ( ruleIdentifier ) ; + public final void rule__InfixExpression__NameAssignment_1_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20594:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:20595:2: ( ruleIdentifier ) + { + // InternalExpression.g:20595:2: ( ruleIdentifier ) + // InternalExpression.g:20596:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_0_2" + + + // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_0" + // InternalExpression.g:20605:1: rule__InfixExpression__ParamsAssignment_1_0_4_0 : ( ruleExpression ) ; + public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20609:1: ( ( ruleExpression ) ) + // InternalExpression.g:20610:2: ( ruleExpression ) + { + // InternalExpression.g:20610:2: ( ruleExpression ) + // InternalExpression.g:20611:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_0" + + + // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + // InternalExpression.g:20620:1: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 : ( ruleExpression ) ; + public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20624:1: ( ( ruleExpression ) ) + // InternalExpression.g:20625:2: ( ruleExpression ) + { + // InternalExpression.g:20625:2: ( ruleExpression ) + // InternalExpression.g:20626:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + + + // $ANTLR start "rule__InfixExpression__TypeAssignment_1_1_2" + // InternalExpression.g:20635:1: rule__InfixExpression__TypeAssignment_1_1_2 : ( ruleType ) ; + public final void rule__InfixExpression__TypeAssignment_1_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20639:1: ( ( ruleType ) ) + // InternalExpression.g:20640:2: ( ruleType ) + { + // InternalExpression.g:20640:2: ( ruleType ) + // InternalExpression.g:20641:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__TypeAssignment_1_1_2" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_2_2" + // InternalExpression.g:20650:1: rule__InfixExpression__NameAssignment_1_2_2 : ( ( 'typeSelect' ) ) ; + public final void rule__InfixExpression__NameAssignment_1_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20654:1: ( ( ( 'typeSelect' ) ) ) + // InternalExpression.g:20655:2: ( ( 'typeSelect' ) ) + { + // InternalExpression.g:20655:2: ( ( 'typeSelect' ) ) + // InternalExpression.g:20656:3: ( 'typeSelect' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + // InternalExpression.g:20657:3: ( 'typeSelect' ) + // InternalExpression.g:20658:4: 'typeSelect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + match(input,102,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_2_2" + + + // $ANTLR start "rule__InfixExpression__TypeAssignment_1_2_4" + // InternalExpression.g:20669:1: rule__InfixExpression__TypeAssignment_1_2_4 : ( ruleType ) ; + public final void rule__InfixExpression__TypeAssignment_1_2_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20673:1: ( ( ruleType ) ) + // InternalExpression.g:20674:2: ( ruleType ) + { + // InternalExpression.g:20674:2: ( ruleType ) + // InternalExpression.g:20675:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__TypeAssignment_1_2_4" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_3_2" + // InternalExpression.g:20684:1: rule__InfixExpression__NameAssignment_1_3_2 : ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ; + public final void rule__InfixExpression__NameAssignment_1_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20688:1: ( ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ) + // InternalExpression.g:20689:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + { + // InternalExpression.g:20689:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + // InternalExpression.g:20690:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + } + // InternalExpression.g:20691:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + // InternalExpression.g:20691:4: rule__InfixExpression__NameAlternatives_1_3_2_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAlternatives_1_3_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_3_2" + + + // $ANTLR start "rule__InfixExpression__VarAssignment_1_3_4_0" + // InternalExpression.g:20699:1: rule__InfixExpression__VarAssignment_1_3_4_0 : ( ruleIdentifier ) ; + public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20703:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:20704:2: ( ruleIdentifier ) + { + // InternalExpression.g:20704:2: ( ruleIdentifier ) + // InternalExpression.g:20705:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__VarAssignment_1_3_4_0" + + + // $ANTLR start "rule__InfixExpression__ExpAssignment_1_3_5" + // InternalExpression.g:20714:1: rule__InfixExpression__ExpAssignment_1_3_5 : ( ruleExpression ) ; + public final void rule__InfixExpression__ExpAssignment_1_3_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20718:1: ( ( ruleExpression ) ) + // InternalExpression.g:20719:2: ( ruleExpression ) + { + // InternalExpression.g:20719:2: ( ruleExpression ) + // InternalExpression.g:20720:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ExpAssignment_1_3_5" + + + // $ANTLR start "rule__BooleanLiteral__ValAssignment" + // InternalExpression.g:20729:1: rule__BooleanLiteral__ValAssignment : ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ; + public final void rule__BooleanLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20733:1: ( ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ) + // InternalExpression.g:20734:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + { + // InternalExpression.g:20734:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + // InternalExpression.g:20735:3: ( rule__BooleanLiteral__ValAlternatives_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); + } + // InternalExpression.g:20736:3: ( rule__BooleanLiteral__ValAlternatives_0 ) + // InternalExpression.g:20736:4: rule__BooleanLiteral__ValAlternatives_0 + { + pushFollow(FOLLOW_2); + rule__BooleanLiteral__ValAlternatives_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BooleanLiteral__ValAssignment" + + + // $ANTLR start "rule__IntegerLiteral__ValAssignment" + // InternalExpression.g:20744:1: rule__IntegerLiteral__ValAssignment : ( RULE_INT ) ; + public final void rule__IntegerLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20748:1: ( ( RULE_INT ) ) + // InternalExpression.g:20749:2: ( RULE_INT ) + { + // InternalExpression.g:20749:2: ( RULE_INT ) + // InternalExpression.g:20750:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IntegerLiteral__ValAssignment" + + + // $ANTLR start "rule__NullLiteral__ValAssignment" + // InternalExpression.g:20759:1: rule__NullLiteral__ValAssignment : ( ( 'null' ) ) ; + public final void rule__NullLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20763:1: ( ( ( 'null' ) ) ) + // InternalExpression.g:20764:2: ( ( 'null' ) ) + { + // InternalExpression.g:20764:2: ( ( 'null' ) ) + // InternalExpression.g:20765:3: ( 'null' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + // InternalExpression.g:20766:3: ( 'null' ) + // InternalExpression.g:20767:4: 'null' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NullLiteral__ValAssignment" + + + // $ANTLR start "rule__RealLiteral__ValAssignment" + // InternalExpression.g:20778:1: rule__RealLiteral__ValAssignment : ( RULE_REAL ) ; + public final void rule__RealLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20782:1: ( ( RULE_REAL ) ) + // InternalExpression.g:20783:2: ( RULE_REAL ) + { + // InternalExpression.g:20783:2: ( RULE_REAL ) + // InternalExpression.g:20784:3: RULE_REAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + } + match(input,RULE_REAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RealLiteral__ValAssignment" + + + // $ANTLR start "rule__StringLiteral__ValAssignment" + // InternalExpression.g:20793:1: rule__StringLiteral__ValAssignment : ( RULE_STRING ) ; + public final void rule__StringLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20797:1: ( ( RULE_STRING ) ) + // InternalExpression.g:20798:2: ( RULE_STRING ) + { + // InternalExpression.g:20798:2: ( RULE_STRING ) + // InternalExpression.g:20799:3: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__StringLiteral__ValAssignment" + + + // $ANTLR start "rule__GlobalVarExpression__NameAssignment_1" + // InternalExpression.g:20808:1: rule__GlobalVarExpression__NameAssignment_1 : ( ruleIdentifier ) ; + public final void rule__GlobalVarExpression__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20812:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:20813:2: ( ruleIdentifier ) + { + // InternalExpression.g:20813:2: ( ruleIdentifier ) + // InternalExpression.g:20814:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__NameAssignment_1" + + + // $ANTLR start "rule__FeatureCall__TypeAssignment_1" + // InternalExpression.g:20823:1: rule__FeatureCall__TypeAssignment_1 : ( ruleType ) ; + public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20827:1: ( ( ruleType ) ) + // InternalExpression.g:20828:2: ( ruleType ) + { + // InternalExpression.g:20828:2: ( ruleType ) + // InternalExpression.g:20829:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FeatureCall__TypeAssignment_1" + + + // $ANTLR start "rule__OperationCall__NameAssignment_0" + // InternalExpression.g:20838:1: rule__OperationCall__NameAssignment_0 : ( ruleIdentifier ) ; + public final void rule__OperationCall__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20842:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:20843:2: ( ruleIdentifier ) + { + // InternalExpression.g:20843:2: ( ruleIdentifier ) + // InternalExpression.g:20844:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__NameAssignment_0" + + + // $ANTLR start "rule__OperationCall__ParamsAssignment_2_0" + // InternalExpression.g:20853:1: rule__OperationCall__ParamsAssignment_2_0 : ( ruleExpression ) ; + public final void rule__OperationCall__ParamsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20857:1: ( ( ruleExpression ) ) + // InternalExpression.g:20858:2: ( ruleExpression ) + { + // InternalExpression.g:20858:2: ( ruleExpression ) + // InternalExpression.g:20859:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__ParamsAssignment_2_0" + + + // $ANTLR start "rule__OperationCall__ParamsAssignment_2_1_1" + // InternalExpression.g:20868:1: rule__OperationCall__ParamsAssignment_2_1_1 : ( ruleExpression ) ; + public final void rule__OperationCall__ParamsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20872:1: ( ( ruleExpression ) ) + // InternalExpression.g:20873:2: ( ruleExpression ) + { + // InternalExpression.g:20873:2: ( ruleExpression ) + // InternalExpression.g:20874:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__ParamsAssignment_2_1_1" + + + // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_0" + // InternalExpression.g:20883:1: rule__ListLiteral__ElementsAssignment_2_0 : ( ruleExpression ) ; + public final void rule__ListLiteral__ElementsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20887:1: ( ( ruleExpression ) ) + // InternalExpression.g:20888:2: ( ruleExpression ) + { + // InternalExpression.g:20888:2: ( ruleExpression ) + // InternalExpression.g:20889:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_0" + + + // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_1_1" + // InternalExpression.g:20898:1: rule__ListLiteral__ElementsAssignment_2_1_1 : ( ruleExpression ) ; + public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20902:1: ( ( ruleExpression ) ) + // InternalExpression.g:20903:2: ( ruleExpression ) + { + // InternalExpression.g:20903:2: ( ruleExpression ) + // InternalExpression.g:20904:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_1_1" + + + // $ANTLR start "rule__ConstructorCallExpression__TypeAssignment_1" + // InternalExpression.g:20913:1: rule__ConstructorCallExpression__TypeAssignment_1 : ( ruleSimpleType ) ; + public final void rule__ConstructorCallExpression__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20917:1: ( ( ruleSimpleType ) ) + // InternalExpression.g:20918:2: ( ruleSimpleType ) + { + // InternalExpression.g:20918:2: ( ruleSimpleType ) + // InternalExpression.g:20919:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__TypeAssignment_1" + + + // $ANTLR start "rule__TypeSelectExpression__NameAssignment_0" + // InternalExpression.g:20928:1: rule__TypeSelectExpression__NameAssignment_0 : ( ( 'typeSelect' ) ) ; + public final void rule__TypeSelectExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20932:1: ( ( ( 'typeSelect' ) ) ) + // InternalExpression.g:20933:2: ( ( 'typeSelect' ) ) + { + // InternalExpression.g:20933:2: ( ( 'typeSelect' ) ) + // InternalExpression.g:20934:3: ( 'typeSelect' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + // InternalExpression.g:20935:3: ( 'typeSelect' ) + // InternalExpression.g:20936:4: 'typeSelect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + match(input,102,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__NameAssignment_0" + + + // $ANTLR start "rule__TypeSelectExpression__TypeAssignment_2" + // InternalExpression.g:20947:1: rule__TypeSelectExpression__TypeAssignment_2 : ( ruleType ) ; + public final void rule__TypeSelectExpression__TypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20951:1: ( ( ruleType ) ) + // InternalExpression.g:20952:2: ( ruleType ) + { + // InternalExpression.g:20952:2: ( ruleType ) + // InternalExpression.g:20953:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__TypeAssignment_2" + + + // $ANTLR start "rule__CollectionExpression__NameAssignment_0" + // InternalExpression.g:20962:1: rule__CollectionExpression__NameAssignment_0 : ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ; + public final void rule__CollectionExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20966:1: ( ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ) + // InternalExpression.g:20967:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + { + // InternalExpression.g:20967:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + // InternalExpression.g:20968:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + } + // InternalExpression.g:20969:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + // InternalExpression.g:20969:4: rule__CollectionExpression__NameAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__NameAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__NameAssignment_0" + + + // $ANTLR start "rule__CollectionExpression__VarAssignment_2_0" + // InternalExpression.g:20977:1: rule__CollectionExpression__VarAssignment_2_0 : ( ruleIdentifier ) ; + public final void rule__CollectionExpression__VarAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20981:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:20982:2: ( ruleIdentifier ) + { + // InternalExpression.g:20982:2: ( ruleIdentifier ) + // InternalExpression.g:20983:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__VarAssignment_2_0" + + + // $ANTLR start "rule__CollectionExpression__ExpAssignment_3" + // InternalExpression.g:20992:1: rule__CollectionExpression__ExpAssignment_3 : ( ruleExpression ) ; + public final void rule__CollectionExpression__ExpAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:20996:1: ( ( ruleExpression ) ) + // InternalExpression.g:20997:2: ( ruleExpression ) + { + // InternalExpression.g:20997:2: ( ruleExpression ) + // InternalExpression.g:20998:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__ExpAssignment_3" + + + // $ANTLR start "rule__CollectionType__ClAssignment_0" + // InternalExpression.g:21007:1: rule__CollectionType__ClAssignment_0 : ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ; + public final void rule__CollectionType__ClAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21011:1: ( ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ) + // InternalExpression.g:21012:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) + { + // InternalExpression.g:21012:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) + // InternalExpression.g:21013:3: ( rule__CollectionType__ClAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); + } + // InternalExpression.g:21014:3: ( rule__CollectionType__ClAlternatives_0_0 ) + // InternalExpression.g:21014:4: rule__CollectionType__ClAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__CollectionType__ClAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__ClAssignment_0" + + + // $ANTLR start "rule__CollectionType__Id1Assignment_2" + // InternalExpression.g:21022:1: rule__CollectionType__Id1Assignment_2 : ( ruleSimpleType ) ; + public final void rule__CollectionType__Id1Assignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21026:1: ( ( ruleSimpleType ) ) + // InternalExpression.g:21027:2: ( ruleSimpleType ) + { + // InternalExpression.g:21027:2: ( ruleSimpleType ) + // InternalExpression.g:21028:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Id1Assignment_2" + + + // $ANTLR start "rule__SimpleType__IdAssignment_0" + // InternalExpression.g:21037:1: rule__SimpleType__IdAssignment_0 : ( ruleIdentifier ) ; + public final void rule__SimpleType__IdAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21041:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:21042:2: ( ruleIdentifier ) + { + // InternalExpression.g:21042:2: ( ruleIdentifier ) + // InternalExpression.g:21043:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__IdAssignment_0" + + + // $ANTLR start "rule__SimpleType__IdAssignment_1_1" + // InternalExpression.g:21052:1: rule__SimpleType__IdAssignment_1_1 : ( ruleIdentifier ) ; + public final void rule__SimpleType__IdAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21056:1: ( ( ruleIdentifier ) ) + // InternalExpression.g:21057:2: ( ruleIdentifier ) + { + // InternalExpression.g:21057:2: ( ruleIdentifier ) + // InternalExpression.g:21058:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__IdAssignment_1_1" + + + // $ANTLR start "rule__XAssignment__FeatureAssignment_0_1" + // InternalExpression.g:21067:1: rule__XAssignment__FeatureAssignment_0_1 : ( ( ruleFeatureCallID ) ) ; + public final void rule__XAssignment__FeatureAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21071:1: ( ( ( ruleFeatureCallID ) ) ) + // InternalExpression.g:21072:2: ( ( ruleFeatureCallID ) ) + { + // InternalExpression.g:21072:2: ( ( ruleFeatureCallID ) ) + // InternalExpression.g:21073:3: ( ruleFeatureCallID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + // InternalExpression.g:21074:3: ( ruleFeatureCallID ) + // InternalExpression.g:21075:4: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__FeatureAssignment_0_1" + + + // $ANTLR start "rule__XAssignment__ValueAssignment_0_3" + // InternalExpression.g:21086:1: rule__XAssignment__ValueAssignment_0_3 : ( ruleXAssignment ) ; + public final void rule__XAssignment__ValueAssignment_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21090:1: ( ( ruleXAssignment ) ) + // InternalExpression.g:21091:2: ( ruleXAssignment ) + { + // InternalExpression.g:21091:2: ( ruleXAssignment ) + // InternalExpression.g:21092:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__ValueAssignment_0_3" + + + // $ANTLR start "rule__XAssignment__FeatureAssignment_1_1_0_0_1" + // InternalExpression.g:21101:1: rule__XAssignment__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpMultiAssign ) ) ; + public final void rule__XAssignment__FeatureAssignment_1_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21105:1: ( ( ( ruleOpMultiAssign ) ) ) + // InternalExpression.g:21106:2: ( ( ruleOpMultiAssign ) ) + { + // InternalExpression.g:21106:2: ( ( ruleOpMultiAssign ) ) + // InternalExpression.g:21107:3: ( ruleOpMultiAssign ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + // InternalExpression.g:21108:3: ( ruleOpMultiAssign ) + // InternalExpression.g:21109:4: ruleOpMultiAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__FeatureAssignment_1_1_0_0_1" + + + // $ANTLR start "rule__XAssignment__RightOperandAssignment_1_1_1" + // InternalExpression.g:21120:1: rule__XAssignment__RightOperandAssignment_1_1_1 : ( ruleXAssignment ) ; + public final void rule__XAssignment__RightOperandAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21124:1: ( ( ruleXAssignment ) ) + // InternalExpression.g:21125:2: ( ruleXAssignment ) + { + // InternalExpression.g:21125:2: ( ruleXAssignment ) + // InternalExpression.g:21126:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__RightOperandAssignment_1_1_1" + + + // $ANTLR start "rule__XOrExpression__FeatureAssignment_1_0_0_1" + // InternalExpression.g:21135:1: rule__XOrExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOr ) ) ; + public final void rule__XOrExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21139:1: ( ( ( ruleOpOr ) ) ) + // InternalExpression.g:21140:2: ( ( ruleOpOr ) ) + { + // InternalExpression.g:21140:2: ( ( ruleOpOr ) ) + // InternalExpression.g:21141:3: ( ruleOpOr ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExpression.g:21142:3: ( ruleOpOr ) + // InternalExpression.g:21143:4: ruleOpOr + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XOrExpression__RightOperandAssignment_1_1" + // InternalExpression.g:21154:1: rule__XOrExpression__RightOperandAssignment_1_1 : ( ruleXAndExpression ) ; + public final void rule__XOrExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21158:1: ( ( ruleXAndExpression ) ) + // InternalExpression.g:21159:2: ( ruleXAndExpression ) + { + // InternalExpression.g:21159:2: ( ruleXAndExpression ) + // InternalExpression.g:21160:3: ruleXAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XAndExpression__FeatureAssignment_1_0_0_1" + // InternalExpression.g:21169:1: rule__XAndExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAnd ) ) ; + public final void rule__XAndExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21173:1: ( ( ( ruleOpAnd ) ) ) + // InternalExpression.g:21174:2: ( ( ruleOpAnd ) ) + { + // InternalExpression.g:21174:2: ( ( ruleOpAnd ) ) + // InternalExpression.g:21175:3: ( ruleOpAnd ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExpression.g:21176:3: ( ruleOpAnd ) + // InternalExpression.g:21177:4: ruleOpAnd + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XAndExpression__RightOperandAssignment_1_1" + // InternalExpression.g:21188:1: rule__XAndExpression__RightOperandAssignment_1_1 : ( ruleXEqualityExpression ) ; + public final void rule__XAndExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21192:1: ( ( ruleXEqualityExpression ) ) + // InternalExpression.g:21193:2: ( ruleXEqualityExpression ) + { + // InternalExpression.g:21193:2: ( ruleXEqualityExpression ) + // InternalExpression.g:21194:3: ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XEqualityExpression__FeatureAssignment_1_0_0_1" + // InternalExpression.g:21203:1: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpEquality ) ) ; + public final void rule__XEqualityExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21207:1: ( ( ( ruleOpEquality ) ) ) + // InternalExpression.g:21208:2: ( ( ruleOpEquality ) ) + { + // InternalExpression.g:21208:2: ( ( ruleOpEquality ) ) + // InternalExpression.g:21209:3: ( ruleOpEquality ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExpression.g:21210:3: ( ruleOpEquality ) + // InternalExpression.g:21211:4: ruleOpEquality + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XEqualityExpression__RightOperandAssignment_1_1" + // InternalExpression.g:21222:1: rule__XEqualityExpression__RightOperandAssignment_1_1 : ( ruleXRelationalExpression ) ; + public final void rule__XEqualityExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21226:1: ( ( ruleXRelationalExpression ) ) + // InternalExpression.g:21227:2: ( ruleXRelationalExpression ) + { + // InternalExpression.g:21227:2: ( ruleXRelationalExpression ) + // InternalExpression.g:21228:3: ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XRelationalExpression__TypeAssignment_1_0_1" + // InternalExpression.g:21237:1: rule__XRelationalExpression__TypeAssignment_1_0_1 : ( ruleJvmTypeReference ) ; + public final void rule__XRelationalExpression__TypeAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21241:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:21242:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:21242:2: ( ruleJvmTypeReference ) + // InternalExpression.g:21243:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__TypeAssignment_1_0_1" + + + // $ANTLR start "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1" + // InternalExpression.g:21252:1: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpCompare ) ) ; + public final void rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21256:1: ( ( ( ruleOpCompare ) ) ) + // InternalExpression.g:21257:2: ( ( ruleOpCompare ) ) + { + // InternalExpression.g:21257:2: ( ( ruleOpCompare ) ) + // InternalExpression.g:21258:3: ( ruleOpCompare ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + // InternalExpression.g:21259:3: ( ruleOpCompare ) + // InternalExpression.g:21260:4: ruleOpCompare + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1" + + + // $ANTLR start "rule__XRelationalExpression__RightOperandAssignment_1_1_1" + // InternalExpression.g:21271:1: rule__XRelationalExpression__RightOperandAssignment_1_1_1 : ( ruleXOtherOperatorExpression ) ; + public final void rule__XRelationalExpression__RightOperandAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21275:1: ( ( ruleXOtherOperatorExpression ) ) + // InternalExpression.g:21276:2: ( ruleXOtherOperatorExpression ) + { + // InternalExpression.g:21276:2: ( ruleXOtherOperatorExpression ) + // InternalExpression.g:21277:3: ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__RightOperandAssignment_1_1_1" + + + // $ANTLR start "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1" + // InternalExpression.g:21286:1: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOther ) ) ; + public final void rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21290:1: ( ( ( ruleOpOther ) ) ) + // InternalExpression.g:21291:2: ( ( ruleOpOther ) ) + { + // InternalExpression.g:21291:2: ( ( ruleOpOther ) ) + // InternalExpression.g:21292:3: ( ruleOpOther ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExpression.g:21293:3: ( ruleOpOther ) + // InternalExpression.g:21294:4: ruleOpOther + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XOtherOperatorExpression__RightOperandAssignment_1_1" + // InternalExpression.g:21305:1: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 : ( ruleXAdditiveExpression ) ; + public final void rule__XOtherOperatorExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21309:1: ( ( ruleXAdditiveExpression ) ) + // InternalExpression.g:21310:2: ( ruleXAdditiveExpression ) + { + // InternalExpression.g:21310:2: ( ruleXAdditiveExpression ) + // InternalExpression.g:21311:3: ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1" + // InternalExpression.g:21320:1: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAdd ) ) ; + public final void rule__XAdditiveExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21324:1: ( ( ( ruleOpAdd ) ) ) + // InternalExpression.g:21325:2: ( ( ruleOpAdd ) ) + { + // InternalExpression.g:21325:2: ( ( ruleOpAdd ) ) + // InternalExpression.g:21326:3: ( ruleOpAdd ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExpression.g:21327:3: ( ruleOpAdd ) + // InternalExpression.g:21328:4: ruleOpAdd + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XAdditiveExpression__RightOperandAssignment_1_1" + // InternalExpression.g:21339:1: rule__XAdditiveExpression__RightOperandAssignment_1_1 : ( ruleXMultiplicativeExpression ) ; + public final void rule__XAdditiveExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21343:1: ( ( ruleXMultiplicativeExpression ) ) + // InternalExpression.g:21344:2: ( ruleXMultiplicativeExpression ) + { + // InternalExpression.g:21344:2: ( ruleXMultiplicativeExpression ) + // InternalExpression.g:21345:3: ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1" + // InternalExpression.g:21354:1: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpMulti ) ) ; + public final void rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21358:1: ( ( ( ruleOpMulti ) ) ) + // InternalExpression.g:21359:2: ( ( ruleOpMulti ) ) + { + // InternalExpression.g:21359:2: ( ( ruleOpMulti ) ) + // InternalExpression.g:21360:3: ( ruleOpMulti ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalExpression.g:21361:3: ( ruleOpMulti ) + // InternalExpression.g:21362:4: ruleOpMulti + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XMultiplicativeExpression__RightOperandAssignment_1_1" + // InternalExpression.g:21373:1: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 : ( ruleXUnaryOperation ) ; + public final void rule__XMultiplicativeExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21377:1: ( ( ruleXUnaryOperation ) ) + // InternalExpression.g:21378:2: ( ruleXUnaryOperation ) + { + // InternalExpression.g:21378:2: ( ruleXUnaryOperation ) + // InternalExpression.g:21379:3: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XUnaryOperation__FeatureAssignment_0_1" + // InternalExpression.g:21388:1: rule__XUnaryOperation__FeatureAssignment_0_1 : ( ( ruleOpUnary ) ) ; + public final void rule__XUnaryOperation__FeatureAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21392:1: ( ( ( ruleOpUnary ) ) ) + // InternalExpression.g:21393:2: ( ( ruleOpUnary ) ) + { + // InternalExpression.g:21393:2: ( ( ruleOpUnary ) ) + // InternalExpression.g:21394:3: ( ruleOpUnary ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + // InternalExpression.g:21395:3: ( ruleOpUnary ) + // InternalExpression.g:21396:4: ruleOpUnary + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__FeatureAssignment_0_1" + + + // $ANTLR start "rule__XUnaryOperation__OperandAssignment_0_2" + // InternalExpression.g:21407:1: rule__XUnaryOperation__OperandAssignment_0_2 : ( ruleXUnaryOperation ) ; + public final void rule__XUnaryOperation__OperandAssignment_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21411:1: ( ( ruleXUnaryOperation ) ) + // InternalExpression.g:21412:2: ( ruleXUnaryOperation ) + { + // InternalExpression.g:21412:2: ( ruleXUnaryOperation ) + // InternalExpression.g:21413:3: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__OperandAssignment_0_2" + + + // $ANTLR start "rule__XCastedExpression__TypeAssignment_1_1" + // InternalExpression.g:21422:1: rule__XCastedExpression__TypeAssignment_1_1 : ( ruleJvmTypeReference ) ; + public final void rule__XCastedExpression__TypeAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21426:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:21427:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:21427:2: ( ruleJvmTypeReference ) + // InternalExpression.g:21428:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__TypeAssignment_1_1" + + + // $ANTLR start "rule__XPostfixOperation__FeatureAssignment_1_0_1" + // InternalExpression.g:21437:1: rule__XPostfixOperation__FeatureAssignment_1_0_1 : ( ( ruleOpPostfix ) ) ; + public final void rule__XPostfixOperation__FeatureAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21441:1: ( ( ( ruleOpPostfix ) ) ) + // InternalExpression.g:21442:2: ( ( ruleOpPostfix ) ) + { + // InternalExpression.g:21442:2: ( ( ruleOpPostfix ) ) + // InternalExpression.g:21443:3: ( ruleOpPostfix ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + // InternalExpression.g:21444:3: ( ruleOpPostfix ) + // InternalExpression.g:21445:4: ruleOpPostfix + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__FeatureAssignment_1_0_1" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1" + // InternalExpression.g:21456:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 : ( ( '::' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21460:1: ( ( ( '::' ) ) ) + // InternalExpression.g:21461:2: ( ( '::' ) ) + { + // InternalExpression.g:21461:2: ( ( '::' ) ) + // InternalExpression.g:21462:3: ( '::' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + // InternalExpression.g:21463:3: ( '::' ) + // InternalExpression.g:21464:4: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + match(input,84,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2" + // InternalExpression.g:21475:1: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 : ( ( ruleFeatureCallID ) ) ; + public final void rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21479:1: ( ( ( ruleFeatureCallID ) ) ) + // InternalExpression.g:21480:2: ( ( ruleFeatureCallID ) ) + { + // InternalExpression.g:21480:2: ( ( ruleFeatureCallID ) ) + // InternalExpression.g:21481:3: ( ruleFeatureCallID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + // InternalExpression.g:21482:3: ( ruleFeatureCallID ) + // InternalExpression.g:21483:4: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2" + + + // $ANTLR start "rule__XMemberFeatureCall__ValueAssignment_1_0_1" + // InternalExpression.g:21494:1: rule__XMemberFeatureCall__ValueAssignment_1_0_1 : ( ruleXAssignment ) ; + public final void rule__XMemberFeatureCall__ValueAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21498:1: ( ( ruleXAssignment ) ) + // InternalExpression.g:21499:2: ( ruleXAssignment ) + { + // InternalExpression.g:21499:2: ( ruleXAssignment ) + // InternalExpression.g:21500:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ValueAssignment_1_0_1" + + + // $ANTLR start "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1" + // InternalExpression.g:21509:1: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 : ( ( '?.' ) ) ; + public final void rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21513:1: ( ( ( '?.' ) ) ) + // InternalExpression.g:21514:2: ( ( '?.' ) ) + { + // InternalExpression.g:21514:2: ( ( '?.' ) ) + // InternalExpression.g:21515:3: ( '?.' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + // InternalExpression.g:21516:3: ( '?.' ) + // InternalExpression.g:21517:4: '?.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + match(input,103,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2" + // InternalExpression.g:21528:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 : ( ( '::' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21532:1: ( ( ( '::' ) ) ) + // InternalExpression.g:21533:2: ( ( '::' ) ) + { + // InternalExpression.g:21533:2: ( ( '::' ) ) + // InternalExpression.g:21534:3: ( '::' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + // InternalExpression.g:21535:3: ( '::' ) + // InternalExpression.g:21536:4: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + match(input,84,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2" + + + // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1" + // InternalExpression.g:21547:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21551:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:21552:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:21552:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:21553:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1" + // InternalExpression.g:21562:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21566:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:21567:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:21567:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:21568:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1" + + + // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_1_2" + // InternalExpression.g:21577:1: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 : ( ( ruleIdOrSuper ) ) ; + public final void rule__XMemberFeatureCall__FeatureAssignment_1_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21581:1: ( ( ( ruleIdOrSuper ) ) ) + // InternalExpression.g:21582:2: ( ( ruleIdOrSuper ) ) + { + // InternalExpression.g:21582:2: ( ( ruleIdOrSuper ) ) + // InternalExpression.g:21583:3: ( ruleIdOrSuper ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + // InternalExpression.g:21584:3: ( ruleIdOrSuper ) + // InternalExpression.g:21585:4: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_1_2" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0" + // InternalExpression.g:21596:1: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 : ( ( '(' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21600:1: ( ( ( '(' ) ) ) + // InternalExpression.g:21601:2: ( ( '(' ) ) + { + // InternalExpression.g:21601:2: ( ( '(' ) ) + // InternalExpression.g:21602:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + // InternalExpression.g:21603:3: ( '(' ) + // InternalExpression.g:21604:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0" + // InternalExpression.g:21615:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 : ( ruleXShortClosure ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21619:1: ( ( ruleXShortClosure ) ) + // InternalExpression.g:21620:2: ( ruleXShortClosure ) + { + // InternalExpression.g:21620:2: ( ruleXShortClosure ) + // InternalExpression.g:21621:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0" + // InternalExpression.g:21630:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 : ( ruleXExpression ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21634:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21635:2: ( ruleXExpression ) + { + // InternalExpression.g:21635:2: ( ruleXExpression ) + // InternalExpression.g:21636:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1" + // InternalExpression.g:21645:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21649:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21650:2: ( ruleXExpression ) + { + // InternalExpression.g:21650:2: ( ruleXExpression ) + // InternalExpression.g:21651:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4" + // InternalExpression.g:21660:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 : ( ruleXClosure ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21664:1: ( ( ruleXClosure ) ) + // InternalExpression.g:21665:2: ( ruleXClosure ) + { + // InternalExpression.g:21665:2: ( ruleXClosure ) + // InternalExpression.g:21666:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4" + + + // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_0" + // InternalExpression.g:21675:1: rule__XSetLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ; + public final void rule__XSetLiteral__ElementsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21679:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21680:2: ( ruleXExpression ) + { + // InternalExpression.g:21680:2: ( ruleXExpression ) + // InternalExpression.g:21681:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_0" + + + // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_1_1" + // InternalExpression.g:21690:1: rule__XSetLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XSetLiteral__ElementsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21694:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21695:2: ( ruleXExpression ) + { + // InternalExpression.g:21695:2: ( ruleXExpression ) + // InternalExpression.g:21696:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_1_1" + + + // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_0" + // InternalExpression.g:21705:1: rule__XListLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ; + public final void rule__XListLiteral__ElementsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21709:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21710:2: ( ruleXExpression ) + { + // InternalExpression.g:21710:2: ( ruleXExpression ) + // InternalExpression.g:21711:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_0" + + + // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_1_1" + // InternalExpression.g:21720:1: rule__XListLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XListLiteral__ElementsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21724:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21725:2: ( ruleXExpression ) + { + // InternalExpression.g:21725:2: ( ruleXExpression ) + // InternalExpression.g:21726:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_1_1" + + + // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0" + // InternalExpression.g:21735:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21739:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:21740:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:21740:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:21741:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0" + + + // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1" + // InternalExpression.g:21750:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21754:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:21755:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:21755:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:21756:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1" + + + // $ANTLR start "rule__XClosure__ExplicitSyntaxAssignment_1_0_1" + // InternalExpression.g:21765:1: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 : ( ( '|' ) ) ; + public final void rule__XClosure__ExplicitSyntaxAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21769:1: ( ( ( '|' ) ) ) + // InternalExpression.g:21770:2: ( ( '|' ) ) + { + // InternalExpression.g:21770:2: ( ( '|' ) ) + // InternalExpression.g:21771:3: ( '|' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + // InternalExpression.g:21772:3: ( '|' ) + // InternalExpression.g:21773:4: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + match(input,79,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__ExplicitSyntaxAssignment_1_0_1" + + + // $ANTLR start "rule__XClosure__ExpressionAssignment_2" + // InternalExpression.g:21784:1: rule__XClosure__ExpressionAssignment_2 : ( ruleXExpressionInClosure ) ; + public final void rule__XClosure__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21788:1: ( ( ruleXExpressionInClosure ) ) + // InternalExpression.g:21789:2: ( ruleXExpressionInClosure ) + { + // InternalExpression.g:21789:2: ( ruleXExpressionInClosure ) + // InternalExpression.g:21790:3: ruleXExpressionInClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__ExpressionAssignment_2" + + + // $ANTLR start "rule__XExpressionInClosure__ExpressionsAssignment_1_0" + // InternalExpression.g:21799:1: rule__XExpressionInClosure__ExpressionsAssignment_1_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XExpressionInClosure__ExpressionsAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21803:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:21804:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:21804:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:21805:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__ExpressionsAssignment_1_0" + + + // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0" + // InternalExpression.g:21814:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21818:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:21819:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:21819:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:21820:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0" + + + // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1" + // InternalExpression.g:21829:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21833:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:21834:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:21834:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:21835:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1" + + + // $ANTLR start "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2" + // InternalExpression.g:21844:1: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 : ( ( '|' ) ) ; + public final void rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21848:1: ( ( ( '|' ) ) ) + // InternalExpression.g:21849:2: ( ( '|' ) ) + { + // InternalExpression.g:21849:2: ( ( '|' ) ) + // InternalExpression.g:21850:3: ( '|' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + // InternalExpression.g:21851:3: ( '|' ) + // InternalExpression.g:21852:4: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + match(input,79,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2" + + + // $ANTLR start "rule__XShortClosure__ExpressionAssignment_1" + // InternalExpression.g:21863:1: rule__XShortClosure__ExpressionAssignment_1 : ( ruleXExpression ) ; + public final void rule__XShortClosure__ExpressionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21867:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21868:2: ( ruleXExpression ) + { + // InternalExpression.g:21868:2: ( ruleXExpression ) + // InternalExpression.g:21869:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__ExpressionAssignment_1" + + + // $ANTLR start "rule__XIfExpression__IfAssignment_3" + // InternalExpression.g:21878:1: rule__XIfExpression__IfAssignment_3 : ( ruleXExpression ) ; + public final void rule__XIfExpression__IfAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21882:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21883:2: ( ruleXExpression ) + { + // InternalExpression.g:21883:2: ( ruleXExpression ) + // InternalExpression.g:21884:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__IfAssignment_3" + + + // $ANTLR start "rule__XIfExpression__ThenAssignment_5" + // InternalExpression.g:21893:1: rule__XIfExpression__ThenAssignment_5 : ( ruleXExpression ) ; + public final void rule__XIfExpression__ThenAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21897:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21898:2: ( ruleXExpression ) + { + // InternalExpression.g:21898:2: ( ruleXExpression ) + // InternalExpression.g:21899:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__ThenAssignment_5" + + + // $ANTLR start "rule__XIfExpression__ElseAssignment_6_1" + // InternalExpression.g:21908:1: rule__XIfExpression__ElseAssignment_6_1 : ( ruleXExpression ) ; + public final void rule__XIfExpression__ElseAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21912:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21913:2: ( ruleXExpression ) + { + // InternalExpression.g:21913:2: ( ruleXExpression ) + // InternalExpression.g:21914:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__ElseAssignment_6_1" + + + // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1" + // InternalExpression.g:21923:1: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21927:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:21928:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:21928:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:21929:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1" + + + // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_0_1" + // InternalExpression.g:21938:1: rule__XSwitchExpression__SwitchAssignment_2_0_1 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__SwitchAssignment_2_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21942:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21943:2: ( ruleXExpression ) + { + // InternalExpression.g:21943:2: ( ruleXExpression ) + // InternalExpression.g:21944:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_0_1" + + + // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0" + // InternalExpression.g:21953:1: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21957:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:21958:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:21958:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:21959:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0" + + + // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_1_1" + // InternalExpression.g:21968:1: rule__XSwitchExpression__SwitchAssignment_2_1_1 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__SwitchAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21972:1: ( ( ruleXExpression ) ) + // InternalExpression.g:21973:2: ( ruleXExpression ) + { + // InternalExpression.g:21973:2: ( ruleXExpression ) + // InternalExpression.g:21974:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_1_1" + + + // $ANTLR start "rule__XSwitchExpression__CasesAssignment_4" + // InternalExpression.g:21983:1: rule__XSwitchExpression__CasesAssignment_4 : ( ruleXCasePart ) ; + public final void rule__XSwitchExpression__CasesAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:21987:1: ( ( ruleXCasePart ) ) + // InternalExpression.g:21988:2: ( ruleXCasePart ) + { + // InternalExpression.g:21988:2: ( ruleXCasePart ) + // InternalExpression.g:21989:3: ruleXCasePart + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXCasePart(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__CasesAssignment_4" + + + // $ANTLR start "rule__XSwitchExpression__DefaultAssignment_5_2" + // InternalExpression.g:21998:1: rule__XSwitchExpression__DefaultAssignment_5_2 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__DefaultAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22002:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22003:2: ( ruleXExpression ) + { + // InternalExpression.g:22003:2: ( ruleXExpression ) + // InternalExpression.g:22004:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DefaultAssignment_5_2" + + + // $ANTLR start "rule__XCasePart__TypeGuardAssignment_1" + // InternalExpression.g:22013:1: rule__XCasePart__TypeGuardAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__XCasePart__TypeGuardAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22017:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22018:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22018:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22019:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__TypeGuardAssignment_1" + + + // $ANTLR start "rule__XCasePart__CaseAssignment_2_1" + // InternalExpression.g:22028:1: rule__XCasePart__CaseAssignment_2_1 : ( ruleXExpression ) ; + public final void rule__XCasePart__CaseAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22032:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22033:2: ( ruleXExpression ) + { + // InternalExpression.g:22033:2: ( ruleXExpression ) + // InternalExpression.g:22034:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__CaseAssignment_2_1" + + + // $ANTLR start "rule__XCasePart__ThenAssignment_3_0_1" + // InternalExpression.g:22043:1: rule__XCasePart__ThenAssignment_3_0_1 : ( ruleXExpression ) ; + public final void rule__XCasePart__ThenAssignment_3_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22047:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22048:2: ( ruleXExpression ) + { + // InternalExpression.g:22048:2: ( ruleXExpression ) + // InternalExpression.g:22049:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__ThenAssignment_3_0_1" + + + // $ANTLR start "rule__XCasePart__FallThroughAssignment_3_1" + // InternalExpression.g:22058:1: rule__XCasePart__FallThroughAssignment_3_1 : ( ( ',' ) ) ; + public final void rule__XCasePart__FallThroughAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22062:1: ( ( ( ',' ) ) ) + // InternalExpression.g:22063:2: ( ( ',' ) ) + { + // InternalExpression.g:22063:2: ( ( ',' ) ) + // InternalExpression.g:22064:3: ( ',' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + // InternalExpression.g:22065:3: ( ',' ) + // InternalExpression.g:22066:4: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__FallThroughAssignment_3_1" + + + // $ANTLR start "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3" + // InternalExpression.g:22077:1: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 : ( ruleJvmFormalParameter ) ; + public final void rule__XForLoopExpression__DeclaredParamAssignment_0_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22081:1: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:22082:2: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:22082:2: ( ruleJvmFormalParameter ) + // InternalExpression.g:22083:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3" + + + // $ANTLR start "rule__XForLoopExpression__ForExpressionAssignment_1" + // InternalExpression.g:22092:1: rule__XForLoopExpression__ForExpressionAssignment_1 : ( ruleXExpression ) ; + public final void rule__XForLoopExpression__ForExpressionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22096:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22097:2: ( ruleXExpression ) + { + // InternalExpression.g:22097:2: ( ruleXExpression ) + // InternalExpression.g:22098:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__ForExpressionAssignment_1" + + + // $ANTLR start "rule__XForLoopExpression__EachExpressionAssignment_3" + // InternalExpression.g:22107:1: rule__XForLoopExpression__EachExpressionAssignment_3 : ( ruleXExpression ) ; + public final void rule__XForLoopExpression__EachExpressionAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22111:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22112:2: ( ruleXExpression ) + { + // InternalExpression.g:22112:2: ( ruleXExpression ) + // InternalExpression.g:22113:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__EachExpressionAssignment_3" + + + // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0" + // InternalExpression.g:22122:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22126:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:22127:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:22127:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:22128:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0" + + + // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1" + // InternalExpression.g:22137:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22141:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:22142:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:22142:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:22143:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1" + + + // $ANTLR start "rule__XBasicForLoopExpression__ExpressionAssignment_5" + // InternalExpression.g:22152:1: rule__XBasicForLoopExpression__ExpressionAssignment_5 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__ExpressionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22156:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22157:2: ( ruleXExpression ) + { + // InternalExpression.g:22157:2: ( ruleXExpression ) + // InternalExpression.g:22158:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__ExpressionAssignment_5" + + + // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0" + // InternalExpression.g:22167:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22171:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22172:2: ( ruleXExpression ) + { + // InternalExpression.g:22172:2: ( ruleXExpression ) + // InternalExpression.g:22173:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0" + + + // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1" + // InternalExpression.g:22182:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22186:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22187:2: ( ruleXExpression ) + { + // InternalExpression.g:22187:2: ( ruleXExpression ) + // InternalExpression.g:22188:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1" + + + // $ANTLR start "rule__XBasicForLoopExpression__EachExpressionAssignment_9" + // InternalExpression.g:22197:1: rule__XBasicForLoopExpression__EachExpressionAssignment_9 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__EachExpressionAssignment_9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22201:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22202:2: ( ruleXExpression ) + { + // InternalExpression.g:22202:2: ( ruleXExpression ) + // InternalExpression.g:22203:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__EachExpressionAssignment_9" + + + // $ANTLR start "rule__XWhileExpression__PredicateAssignment_3" + // InternalExpression.g:22212:1: rule__XWhileExpression__PredicateAssignment_3 : ( ruleXExpression ) ; + public final void rule__XWhileExpression__PredicateAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22216:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22217:2: ( ruleXExpression ) + { + // InternalExpression.g:22217:2: ( ruleXExpression ) + // InternalExpression.g:22218:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__PredicateAssignment_3" + + + // $ANTLR start "rule__XWhileExpression__BodyAssignment_5" + // InternalExpression.g:22227:1: rule__XWhileExpression__BodyAssignment_5 : ( ruleXExpression ) ; + public final void rule__XWhileExpression__BodyAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22231:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22232:2: ( ruleXExpression ) + { + // InternalExpression.g:22232:2: ( ruleXExpression ) + // InternalExpression.g:22233:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__BodyAssignment_5" + + + // $ANTLR start "rule__XDoWhileExpression__BodyAssignment_2" + // InternalExpression.g:22242:1: rule__XDoWhileExpression__BodyAssignment_2 : ( ruleXExpression ) ; + public final void rule__XDoWhileExpression__BodyAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22246:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22247:2: ( ruleXExpression ) + { + // InternalExpression.g:22247:2: ( ruleXExpression ) + // InternalExpression.g:22248:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__BodyAssignment_2" + + + // $ANTLR start "rule__XDoWhileExpression__PredicateAssignment_5" + // InternalExpression.g:22257:1: rule__XDoWhileExpression__PredicateAssignment_5 : ( ruleXExpression ) ; + public final void rule__XDoWhileExpression__PredicateAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22261:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22262:2: ( ruleXExpression ) + { + // InternalExpression.g:22262:2: ( ruleXExpression ) + // InternalExpression.g:22263:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__PredicateAssignment_5" + + + // $ANTLR start "rule__XBlockExpression__ExpressionsAssignment_2_0" + // InternalExpression.g:22272:1: rule__XBlockExpression__ExpressionsAssignment_2_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBlockExpression__ExpressionsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22276:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:22277:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:22277:2: ( ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:22278:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__ExpressionsAssignment_2_0" + + + // $ANTLR start "rule__XVariableDeclaration__WriteableAssignment_1_0" + // InternalExpression.g:22287:1: rule__XVariableDeclaration__WriteableAssignment_1_0 : ( ( 'var' ) ) ; + public final void rule__XVariableDeclaration__WriteableAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22291:1: ( ( ( 'var' ) ) ) + // InternalExpression.g:22292:2: ( ( 'var' ) ) + { + // InternalExpression.g:22292:2: ( ( 'var' ) ) + // InternalExpression.g:22293:3: ( 'var' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + // InternalExpression.g:22294:3: ( 'var' ) + // InternalExpression.g:22295:4: 'var' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + match(input,104,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__WriteableAssignment_1_0" + + + // $ANTLR start "rule__XVariableDeclaration__TypeAssignment_2_0_0_0" + // InternalExpression.g:22306:1: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 : ( ruleJvmTypeReference ) ; + public final void rule__XVariableDeclaration__TypeAssignment_2_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22310:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22311:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22311:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22312:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__TypeAssignment_2_0_0_0" + + + // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_0_0_1" + // InternalExpression.g:22321:1: rule__XVariableDeclaration__NameAssignment_2_0_0_1 : ( ruleValidID ) ; + public final void rule__XVariableDeclaration__NameAssignment_2_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22325:1: ( ( ruleValidID ) ) + // InternalExpression.g:22326:2: ( ruleValidID ) + { + // InternalExpression.g:22326:2: ( ruleValidID ) + // InternalExpression.g:22327:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_0_0_1" + + + // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_1" + // InternalExpression.g:22336:1: rule__XVariableDeclaration__NameAssignment_2_1 : ( ruleValidID ) ; + public final void rule__XVariableDeclaration__NameAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22340:1: ( ( ruleValidID ) ) + // InternalExpression.g:22341:2: ( ruleValidID ) + { + // InternalExpression.g:22341:2: ( ruleValidID ) + // InternalExpression.g:22342:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_1" + + + // $ANTLR start "rule__XVariableDeclaration__RightAssignment_3_1" + // InternalExpression.g:22351:1: rule__XVariableDeclaration__RightAssignment_3_1 : ( ruleXExpression ) ; + public final void rule__XVariableDeclaration__RightAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22355:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22356:2: ( ruleXExpression ) + { + // InternalExpression.g:22356:2: ( ruleXExpression ) + // InternalExpression.g:22357:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__RightAssignment_3_1" + + + // $ANTLR start "rule__JvmFormalParameter__ParameterTypeAssignment_0" + // InternalExpression.g:22366:1: rule__JvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ; + public final void rule__JvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22370:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22371:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22371:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22372:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__JvmFormalParameter__NameAssignment_1" + // InternalExpression.g:22381:1: rule__JvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ; + public final void rule__JvmFormalParameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22385:1: ( ( ruleValidID ) ) + // InternalExpression.g:22386:2: ( ruleValidID ) + { + // InternalExpression.g:22386:2: ( ruleValidID ) + // InternalExpression.g:22387:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__NameAssignment_1" + + + // $ANTLR start "rule__FullJvmFormalParameter__ParameterTypeAssignment_0" + // InternalExpression.g:22396:1: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ; + public final void rule__FullJvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22400:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22401:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22401:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22402:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__FullJvmFormalParameter__NameAssignment_1" + // InternalExpression.g:22411:1: rule__FullJvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ; + public final void rule__FullJvmFormalParameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22415:1: ( ( ruleValidID ) ) + // InternalExpression.g:22416:2: ( ruleValidID ) + { + // InternalExpression.g:22416:2: ( ruleValidID ) + // InternalExpression.g:22417:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__NameAssignment_1" + + + // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_1" + // InternalExpression.g:22426:1: rule__XFeatureCall__TypeArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XFeatureCall__TypeArgumentsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22430:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:22431:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:22431:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:22432:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_1" + + + // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1" + // InternalExpression.g:22441:1: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XFeatureCall__TypeArgumentsAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22445:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:22446:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:22446:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:22447:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1" + + + // $ANTLR start "rule__XFeatureCall__FeatureAssignment_2" + // InternalExpression.g:22456:1: rule__XFeatureCall__FeatureAssignment_2 : ( ( ruleIdOrSuper ) ) ; + public final void rule__XFeatureCall__FeatureAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22460:1: ( ( ( ruleIdOrSuper ) ) ) + // InternalExpression.g:22461:2: ( ( ruleIdOrSuper ) ) + { + // InternalExpression.g:22461:2: ( ( ruleIdOrSuper ) ) + // InternalExpression.g:22462:3: ( ruleIdOrSuper ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + // InternalExpression.g:22463:3: ( ruleIdOrSuper ) + // InternalExpression.g:22464:4: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureAssignment_2" + + + // $ANTLR start "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0" + // InternalExpression.g:22475:1: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 : ( ( '(' ) ) ; + public final void rule__XFeatureCall__ExplicitOperationCallAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22479:1: ( ( ( '(' ) ) ) + // InternalExpression.g:22480:2: ( ( '(' ) ) + { + // InternalExpression.g:22480:2: ( ( '(' ) ) + // InternalExpression.g:22481:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + // InternalExpression.g:22482:3: ( '(' ) + // InternalExpression.g:22483:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0" + // InternalExpression.g:22494:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 : ( ruleXShortClosure ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22498:1: ( ( ruleXShortClosure ) ) + // InternalExpression.g:22499:2: ( ruleXShortClosure ) + { + // InternalExpression.g:22499:2: ( ruleXShortClosure ) + // InternalExpression.g:22500:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0" + // InternalExpression.g:22509:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 : ( ruleXExpression ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22513:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22514:2: ( ruleXExpression ) + { + // InternalExpression.g:22514:2: ( ruleXExpression ) + // InternalExpression.g:22515:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1" + // InternalExpression.g:22524:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22528:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22529:2: ( ruleXExpression ) + { + // InternalExpression.g:22529:2: ( ruleXExpression ) + // InternalExpression.g:22530:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_4" + // InternalExpression.g:22539:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 : ( ruleXClosure ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22543:1: ( ( ruleXClosure ) ) + // InternalExpression.g:22544:2: ( ruleXClosure ) + { + // InternalExpression.g:22544:2: ( ruleXClosure ) + // InternalExpression.g:22545:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_4" + + + // $ANTLR start "rule__XConstructorCall__ConstructorAssignment_2" + // InternalExpression.g:22554:1: rule__XConstructorCall__ConstructorAssignment_2 : ( ( ruleQualifiedName ) ) ; + public final void rule__XConstructorCall__ConstructorAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22558:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExpression.g:22559:2: ( ( ruleQualifiedName ) ) + { + // InternalExpression.g:22559:2: ( ( ruleQualifiedName ) ) + // InternalExpression.g:22560:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + // InternalExpression.g:22561:3: ( ruleQualifiedName ) + // InternalExpression.g:22562:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ConstructorAssignment_2" + + + // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_1" + // InternalExpression.g:22573:1: rule__XConstructorCall__TypeArgumentsAssignment_3_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XConstructorCall__TypeArgumentsAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22577:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:22578:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:22578:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:22579:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_1" + + + // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1" + // InternalExpression.g:22588:1: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XConstructorCall__TypeArgumentsAssignment_3_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22592:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:22593:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:22593:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:22594:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1" + + + // $ANTLR start "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0" + // InternalExpression.g:22603:1: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 : ( ( '(' ) ) ; + public final void rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22607:1: ( ( ( '(' ) ) ) + // InternalExpression.g:22608:2: ( ( '(' ) ) + { + // InternalExpression.g:22608:2: ( ( '(' ) ) + // InternalExpression.g:22609:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + // InternalExpression.g:22610:3: ( '(' ) + // InternalExpression.g:22611:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_0" + // InternalExpression.g:22622:1: rule__XConstructorCall__ArgumentsAssignment_4_1_0 : ( ruleXShortClosure ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22626:1: ( ( ruleXShortClosure ) ) + // InternalExpression.g:22627:2: ( ruleXShortClosure ) + { + // InternalExpression.g:22627:2: ( ruleXShortClosure ) + // InternalExpression.g:22628:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0" + // InternalExpression.g:22637:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 : ( ruleXExpression ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22641:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22642:2: ( ruleXExpression ) + { + // InternalExpression.g:22642:2: ( ruleXExpression ) + // InternalExpression.g:22643:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1" + // InternalExpression.g:22652:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22656:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22657:2: ( ruleXExpression ) + { + // InternalExpression.g:22657:2: ( ruleXExpression ) + // InternalExpression.g:22658:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_5" + // InternalExpression.g:22667:1: rule__XConstructorCall__ArgumentsAssignment_5 : ( ruleXClosure ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22671:1: ( ( ruleXClosure ) ) + // InternalExpression.g:22672:2: ( ruleXClosure ) + { + // InternalExpression.g:22672:2: ( ruleXClosure ) + // InternalExpression.g:22673:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_5" + + + // $ANTLR start "rule__XBooleanLiteral__IsTrueAssignment_1_1" + // InternalExpression.g:22682:1: rule__XBooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ; + public final void rule__XBooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22686:1: ( ( ( 'true' ) ) ) + // InternalExpression.g:22687:2: ( ( 'true' ) ) + { + // InternalExpression.g:22687:2: ( ( 'true' ) ) + // InternalExpression.g:22688:3: ( 'true' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + // InternalExpression.g:22689:3: ( 'true' ) + // InternalExpression.g:22690:4: 'true' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + match(input,36,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__IsTrueAssignment_1_1" + + + // $ANTLR start "rule__XNumberLiteral__ValueAssignment_1" + // InternalExpression.g:22701:1: rule__XNumberLiteral__ValueAssignment_1 : ( ruleNumber ) ; + public final void rule__XNumberLiteral__ValueAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22705:1: ( ( ruleNumber ) ) + // InternalExpression.g:22706:2: ( ruleNumber ) + { + // InternalExpression.g:22706:2: ( ruleNumber ) + // InternalExpression.g:22707:3: ruleNumber + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleNumber(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__ValueAssignment_1" + + + // $ANTLR start "rule__XStringLiteral__ValueAssignment_1" + // InternalExpression.g:22716:1: rule__XStringLiteral__ValueAssignment_1 : ( RULE_STRING ) ; + public final void rule__XStringLiteral__ValueAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22720:1: ( ( RULE_STRING ) ) + // InternalExpression.g:22721:2: ( RULE_STRING ) + { + // InternalExpression.g:22721:2: ( RULE_STRING ) + // InternalExpression.g:22722:3: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__ValueAssignment_1" + + + // $ANTLR start "rule__XTypeLiteral__TypeAssignment_3" + // InternalExpression.g:22731:1: rule__XTypeLiteral__TypeAssignment_3 : ( ( ruleQualifiedName ) ) ; + public final void rule__XTypeLiteral__TypeAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22735:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExpression.g:22736:2: ( ( ruleQualifiedName ) ) + { + // InternalExpression.g:22736:2: ( ( ruleQualifiedName ) ) + // InternalExpression.g:22737:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + // InternalExpression.g:22738:3: ( ruleQualifiedName ) + // InternalExpression.g:22739:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__TypeAssignment_3" + + + // $ANTLR start "rule__XTypeLiteral__ArrayDimensionsAssignment_4" + // InternalExpression.g:22750:1: rule__XTypeLiteral__ArrayDimensionsAssignment_4 : ( ruleArrayBrackets ) ; + public final void rule__XTypeLiteral__ArrayDimensionsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22754:1: ( ( ruleArrayBrackets ) ) + // InternalExpression.g:22755:2: ( ruleArrayBrackets ) + { + // InternalExpression.g:22755:2: ( ruleArrayBrackets ) + // InternalExpression.g:22756:3: ruleArrayBrackets + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__ArrayDimensionsAssignment_4" + + + // $ANTLR start "rule__XThrowExpression__ExpressionAssignment_2" + // InternalExpression.g:22765:1: rule__XThrowExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XThrowExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22769:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22770:2: ( ruleXExpression ) + { + // InternalExpression.g:22770:2: ( ruleXExpression ) + // InternalExpression.g:22771:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XReturnExpression__ExpressionAssignment_2" + // InternalExpression.g:22780:1: rule__XReturnExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XReturnExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22784:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22785:2: ( ruleXExpression ) + { + // InternalExpression.g:22785:2: ( ruleXExpression ) + // InternalExpression.g:22786:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__ExpressionAssignment_2" + // InternalExpression.g:22795:1: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22799:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22800:2: ( ruleXExpression ) + { + // InternalExpression.g:22800:2: ( ruleXExpression ) + // InternalExpression.g:22801:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0" + // InternalExpression.g:22810:1: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 : ( ruleXCatchClause ) ; + public final void rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22814:1: ( ( ruleXCatchClause ) ) + // InternalExpression.g:22815:2: ( ruleXCatchClause ) + { + // InternalExpression.g:22815:2: ( ruleXCatchClause ) + // InternalExpression.g:22816:3: ruleXCatchClause + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleXCatchClause(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1" + // InternalExpression.g:22825:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22829:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22830:2: ( ruleXExpression ) + { + // InternalExpression.g:22830:2: ( ruleXExpression ) + // InternalExpression.g:22831:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1" + // InternalExpression.g:22840:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22844:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22845:2: ( ruleXExpression ) + { + // InternalExpression.g:22845:2: ( ruleXExpression ) + // InternalExpression.g:22846:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1" + + + // $ANTLR start "rule__XSynchronizedExpression__ParamAssignment_1" + // InternalExpression.g:22855:1: rule__XSynchronizedExpression__ParamAssignment_1 : ( ruleXExpression ) ; + public final void rule__XSynchronizedExpression__ParamAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22859:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22860:2: ( ruleXExpression ) + { + // InternalExpression.g:22860:2: ( ruleXExpression ) + // InternalExpression.g:22861:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__ParamAssignment_1" + + + // $ANTLR start "rule__XSynchronizedExpression__ExpressionAssignment_3" + // InternalExpression.g:22870:1: rule__XSynchronizedExpression__ExpressionAssignment_3 : ( ruleXExpression ) ; + public final void rule__XSynchronizedExpression__ExpressionAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22874:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22875:2: ( ruleXExpression ) + { + // InternalExpression.g:22875:2: ( ruleXExpression ) + // InternalExpression.g:22876:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__ExpressionAssignment_3" + + + // $ANTLR start "rule__XCatchClause__DeclaredParamAssignment_2" + // InternalExpression.g:22885:1: rule__XCatchClause__DeclaredParamAssignment_2 : ( ruleFullJvmFormalParameter ) ; + public final void rule__XCatchClause__DeclaredParamAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22889:1: ( ( ruleFullJvmFormalParameter ) ) + // InternalExpression.g:22890:2: ( ruleFullJvmFormalParameter ) + { + // InternalExpression.g:22890:2: ( ruleFullJvmFormalParameter ) + // InternalExpression.g:22891:3: ruleFullJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__DeclaredParamAssignment_2" + + + // $ANTLR start "rule__XCatchClause__ExpressionAssignment_4" + // InternalExpression.g:22900:1: rule__XCatchClause__ExpressionAssignment_4 : ( ruleXExpression ) ; + public final void rule__XCatchClause__ExpressionAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22904:1: ( ( ruleXExpression ) ) + // InternalExpression.g:22905:2: ( ruleXExpression ) + { + // InternalExpression.g:22905:2: ( ruleXExpression ) + // InternalExpression.g:22906:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__ExpressionAssignment_4" + + + // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" + // InternalExpression.g:22915:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22919:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22920:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22920:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22921:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" + + + // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" + // InternalExpression.g:22930:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22934:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22935:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22935:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22936:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" + + + // $ANTLR start "rule__XFunctionTypeRef__ReturnTypeAssignment_2" + // InternalExpression.g:22945:1: rule__XFunctionTypeRef__ReturnTypeAssignment_2 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ReturnTypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22949:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:22950:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:22950:2: ( ruleJvmTypeReference ) + // InternalExpression.g:22951:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ReturnTypeAssignment_2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_0" + // InternalExpression.g:22960:1: rule__JvmParameterizedTypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__JvmParameterizedTypeReference__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22964:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExpression.g:22965:2: ( ( ruleQualifiedName ) ) + { + // InternalExpression.g:22965:2: ( ( ruleQualifiedName ) ) + // InternalExpression.g:22966:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + // InternalExpression.g:22967:3: ( ruleQualifiedName ) + // InternalExpression.g:22968:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" + // InternalExpression.g:22979:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22983:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:22984:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:22984:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:22985:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" + // InternalExpression.g:22994:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:22998:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:22999:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:22999:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:23000:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" + // InternalExpression.g:23009:1: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 : ( ( ruleValidID ) ) ; + public final void rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23013:1: ( ( ( ruleValidID ) ) ) + // InternalExpression.g:23014:2: ( ( ruleValidID ) ) + { + // InternalExpression.g:23014:2: ( ( ruleValidID ) ) + // InternalExpression.g:23015:3: ( ruleValidID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + // InternalExpression.g:23016:3: ( ruleValidID ) + // InternalExpression.g:23017:4: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" + // InternalExpression.g:23028:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23032:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:23033:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:23033:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:23034:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" + // InternalExpression.g:23043:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23047:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:23048:2: ( ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:23048:2: ( ruleJvmArgumentTypeReference ) + // InternalExpression.g:23049:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" + // InternalExpression.g:23058:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 : ( ruleJvmUpperBound ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23062:1: ( ( ruleJvmUpperBound ) ) + // InternalExpression.g:23063:2: ( ruleJvmUpperBound ) + { + // InternalExpression.g:23063:2: ( ruleJvmUpperBound ) + // InternalExpression.g:23064:3: ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" + // InternalExpression.g:23073:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 : ( ruleJvmUpperBoundAnded ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23077:1: ( ( ruleJvmUpperBoundAnded ) ) + // InternalExpression.g:23078:2: ( ruleJvmUpperBoundAnded ) + { + // InternalExpression.g:23078:2: ( ruleJvmUpperBoundAnded ) + // InternalExpression.g:23079:3: ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" + // InternalExpression.g:23088:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 : ( ruleJvmLowerBound ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23092:1: ( ( ruleJvmLowerBound ) ) + // InternalExpression.g:23093:2: ( ruleJvmLowerBound ) + { + // InternalExpression.g:23093:2: ( ruleJvmLowerBound ) + // InternalExpression.g:23094:3: ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" + // InternalExpression.g:23103:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 : ( ruleJvmLowerBoundAnded ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23107:1: ( ( ruleJvmLowerBoundAnded ) ) + // InternalExpression.g:23108:2: ( ruleJvmLowerBoundAnded ) + { + // InternalExpression.g:23108:2: ( ruleJvmLowerBoundAnded ) + // InternalExpression.g:23109:3: ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" + + + // $ANTLR start "rule__JvmUpperBound__TypeReferenceAssignment_1" + // InternalExpression.g:23118:1: rule__JvmUpperBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmUpperBound__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23122:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:23123:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:23123:2: ( ruleJvmTypeReference ) + // InternalExpression.g:23124:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" + // InternalExpression.g:23133:1: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmUpperBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23137:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:23138:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:23138:2: ( ruleJvmTypeReference ) + // InternalExpression.g:23139:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmLowerBound__TypeReferenceAssignment_1" + // InternalExpression.g:23148:1: rule__JvmLowerBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmLowerBound__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23152:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:23153:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:23153:2: ( ruleJvmTypeReference ) + // InternalExpression.g:23154:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" + // InternalExpression.g:23163:1: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmLowerBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23167:1: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:23168:2: ( ruleJvmTypeReference ) + { + // InternalExpression.g:23168:2: ( ruleJvmTypeReference ) + // InternalExpression.g:23169:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__XImportDeclaration__StaticAssignment_1_0_0" + // InternalExpression.g:23178:1: rule__XImportDeclaration__StaticAssignment_1_0_0 : ( ( 'static' ) ) ; + public final void rule__XImportDeclaration__StaticAssignment_1_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23182:1: ( ( ( 'static' ) ) ) + // InternalExpression.g:23183:2: ( ( 'static' ) ) + { + // InternalExpression.g:23183:2: ( ( 'static' ) ) + // InternalExpression.g:23184:3: ( 'static' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + // InternalExpression.g:23185:3: ( 'static' ) + // InternalExpression.g:23186:4: 'static' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + match(input,61,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__StaticAssignment_1_0_0" + + + // $ANTLR start "rule__XImportDeclaration__ExtensionAssignment_1_0_1" + // InternalExpression.g:23197:1: rule__XImportDeclaration__ExtensionAssignment_1_0_1 : ( ( 'extension' ) ) ; + public final void rule__XImportDeclaration__ExtensionAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23201:1: ( ( ( 'extension' ) ) ) + // InternalExpression.g:23202:2: ( ( 'extension' ) ) + { + // InternalExpression.g:23202:2: ( ( 'extension' ) ) + // InternalExpression.g:23203:3: ( 'extension' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + // InternalExpression.g:23204:3: ( 'extension' ) + // InternalExpression.g:23205:4: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ExtensionAssignment_1_0_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" + // InternalExpression.g:23216:1: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 : ( ( ruleQualifiedNameInStaticImport ) ) ; + public final void rule__XImportDeclaration__ImportedTypeAssignment_1_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23220:1: ( ( ( ruleQualifiedNameInStaticImport ) ) ) + // InternalExpression.g:23221:2: ( ( ruleQualifiedNameInStaticImport ) ) + { + // InternalExpression.g:23221:2: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalExpression.g:23222:3: ( ruleQualifiedNameInStaticImport ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + // InternalExpression.g:23223:3: ( ruleQualifiedNameInStaticImport ) + // InternalExpression.g:23224:4: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" + + + // $ANTLR start "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" + // InternalExpression.g:23235:1: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 : ( ( '*' ) ) ; + public final void rule__XImportDeclaration__WildcardAssignment_1_0_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23239:1: ( ( ( '*' ) ) ) + // InternalExpression.g:23240:2: ( ( '*' ) ) + { + // InternalExpression.g:23240:2: ( ( '*' ) ) + // InternalExpression.g:23241:3: ( '*' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + // InternalExpression.g:23242:3: ( '*' ) + // InternalExpression.g:23243:4: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" + + + // $ANTLR start "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" + // InternalExpression.g:23254:1: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 : ( ruleValidID ) ; + public final void rule__XImportDeclaration__MemberNameAssignment_1_0_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23258:1: ( ( ruleValidID ) ) + // InternalExpression.g:23259:2: ( ruleValidID ) + { + // InternalExpression.g:23259:2: ( ruleValidID ) + // InternalExpression.g:23260:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_1" + // InternalExpression.g:23269:1: rule__XImportDeclaration__ImportedTypeAssignment_1_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__XImportDeclaration__ImportedTypeAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23273:1: ( ( ( ruleQualifiedName ) ) ) + // InternalExpression.g:23274:2: ( ( ruleQualifiedName ) ) + { + // InternalExpression.g:23274:2: ( ( ruleQualifiedName ) ) + // InternalExpression.g:23275:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + // InternalExpression.g:23276:3: ( ruleQualifiedName ) + // InternalExpression.g:23277:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" + // InternalExpression.g:23288:1: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 : ( ruleQualifiedNameWithWildcard ) ; + public final void rule__XImportDeclaration__ImportedNamespaceAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalExpression.g:23292:1: ( ( ruleQualifiedNameWithWildcard ) ) + // InternalExpression.g:23293:2: ( ruleQualifiedNameWithWildcard ) + { + // InternalExpression.g:23293:2: ( ruleQualifiedNameWithWildcard ) + // InternalExpression.g:23294:3: ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" + + // $ANTLR start synpred3_InternalExpression + public final void synpred3_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:2879:2: ( ( ( ruleCastedExpression ) ) ) + // InternalExpression.g:2879:2: ( ( ruleCastedExpression ) ) + { + // InternalExpression.g:2879:2: ( ( ruleCastedExpression ) ) + // InternalExpression.g:2880:3: ( ruleCastedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } + // InternalExpression.g:2881:3: ( ruleCastedExpression ) + // InternalExpression.g:2881:4: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred3_InternalExpression + + // $ANTLR start synpred71_InternalExpression + public final void synpred71_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3632:2: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) ) + // InternalExpression.g:3632:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // InternalExpression.g:3632:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // InternalExpression.g:3633:3: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // InternalExpression.g:3634:3: ( rule__OpOther__Group_6_1_0__0 ) + // InternalExpression.g:3634:4: rule__OpOther__Group_6_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred71_InternalExpression + + // $ANTLR start synpred72_InternalExpression + public final void synpred72_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3638:2: ( ( '<' ) ) + // InternalExpression.g:3638:2: ( '<' ) + { + // InternalExpression.g:3638:2: ( '<' ) + // InternalExpression.g:3639:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred72_InternalExpression + + // $ANTLR start synpred85_InternalExpression + public final void synpred85_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3851:2: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) ) + // InternalExpression.g:3851:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + { + // InternalExpression.g:3851:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + // InternalExpression.g:3852:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + // InternalExpression.g:3853:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + // InternalExpression.g:3853:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred85_InternalExpression + + // $ANTLR start synpred93_InternalExpression + public final void synpred93_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3914:2: ( ( ( ruleXForLoopExpression ) ) ) + // InternalExpression.g:3914:2: ( ( ruleXForLoopExpression ) ) + { + // InternalExpression.g:3914:2: ( ( ruleXForLoopExpression ) ) + // InternalExpression.g:3915:3: ( ruleXForLoopExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + // InternalExpression.g:3916:3: ( ruleXForLoopExpression ) + // InternalExpression.g:3916:4: ruleXForLoopExpression + { + pushFollow(FOLLOW_2); + ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred93_InternalExpression + + // $ANTLR start synpred94_InternalExpression + public final void synpred94_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3920:2: ( ( ruleXBasicForLoopExpression ) ) + // InternalExpression.g:3920:2: ( ruleXBasicForLoopExpression ) + { + // InternalExpression.g:3920:2: ( ruleXBasicForLoopExpression ) + // InternalExpression.g:3921:3: ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + pushFollow(FOLLOW_2); + ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred94_InternalExpression + + // $ANTLR start synpred107_InternalExpression + public final void synpred107_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4043:2: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) ) + // InternalExpression.g:4043:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + { + // InternalExpression.g:4043:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + // InternalExpression.g:4044:3: ( rule__XSwitchExpression__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + // InternalExpression.g:4045:3: ( rule__XSwitchExpression__Group_2_0__0 ) + // InternalExpression.g:4045:4: rule__XSwitchExpression__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred107_InternalExpression + + // $ANTLR start synpred111_InternalExpression + public final void synpred111_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4127:2: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) ) + // InternalExpression.g:4127:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + { + // InternalExpression.g:4127:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + // InternalExpression.g:4128:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + // InternalExpression.g:4129:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + // InternalExpression.g:4129:4: rule__XVariableDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred111_InternalExpression + + // $ANTLR start synpred112_InternalExpression + public final void synpred112_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4148:2: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) ) + // InternalExpression.g:4148:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + { + // InternalExpression.g:4148:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + // InternalExpression.g:4149:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + // InternalExpression.g:4150:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + // InternalExpression.g:4150:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred112_InternalExpression + + // $ANTLR start synpred118_InternalExpression + public final void synpred118_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4229:2: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) ) + // InternalExpression.g:4229:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + { + // InternalExpression.g:4229:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + // InternalExpression.g:4230:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + // InternalExpression.g:4231:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + // InternalExpression.g:4231:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred118_InternalExpression + + // $ANTLR start synpred132_InternalExpression + public final void synpred132_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:5181:3: ( rule__IfExpressionKw__Group_4__0 ) + // InternalExpression.g:5181:3: rule__IfExpressionKw__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred132_InternalExpression + + // $ANTLR start synpred151_InternalExpression + public final void synpred151_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8637:3: ( rule__XAssignment__Group_1_1__0 ) + // InternalExpression.g:8637:3: rule__XAssignment__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred151_InternalExpression + + // $ANTLR start synpred153_InternalExpression + public final void synpred153_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8988:3: ( rule__XOrExpression__Group_1__0 ) + // InternalExpression.g:8988:3: rule__XOrExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred153_InternalExpression + + // $ANTLR start synpred154_InternalExpression + public final void synpred154_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:9177:3: ( rule__XAndExpression__Group_1__0 ) + // InternalExpression.g:9177:3: rule__XAndExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred154_InternalExpression + + // $ANTLR start synpred155_InternalExpression + public final void synpred155_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:9366:3: ( rule__XEqualityExpression__Group_1__0 ) + // InternalExpression.g:9366:3: rule__XEqualityExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred155_InternalExpression + + // $ANTLR start synpred156_InternalExpression + public final void synpred156_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:9555:3: ( rule__XRelationalExpression__Alternatives_1 ) + // InternalExpression.g:9555:3: rule__XRelationalExpression__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred156_InternalExpression + + // $ANTLR start synpred157_InternalExpression + public final void synpred157_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:9933:3: ( rule__XOtherOperatorExpression__Group_1__0 ) + // InternalExpression.g:9933:3: rule__XOtherOperatorExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred157_InternalExpression + + // $ANTLR start synpred158_InternalExpression + public final void synpred158_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:10446:3: ( rule__XAdditiveExpression__Group_1__0 ) + // InternalExpression.g:10446:3: rule__XAdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred158_InternalExpression + + // $ANTLR start synpred159_InternalExpression + public final void synpred159_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:10635:3: ( rule__XMultiplicativeExpression__Group_1__0 ) + // InternalExpression.g:10635:3: rule__XMultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred159_InternalExpression + + // $ANTLR start synpred160_InternalExpression + public final void synpred160_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:10905:3: ( rule__XCastedExpression__Group_1__0 ) + // InternalExpression.g:10905:3: rule__XCastedExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred160_InternalExpression + + // $ANTLR start synpred161_InternalExpression + public final void synpred161_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:11094:3: ( rule__XPostfixOperation__Group_1__0 ) + // InternalExpression.g:11094:3: rule__XPostfixOperation__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred161_InternalExpression + + // $ANTLR start synpred162_InternalExpression + public final void synpred162_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:11229:3: ( rule__XMemberFeatureCall__Alternatives_1 ) + // InternalExpression.g:11229:3: rule__XMemberFeatureCall__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred162_InternalExpression + + // $ANTLR start synpred164_InternalExpression + public final void synpred164_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:11527:3: ( rule__XMemberFeatureCall__Group_1_1_3__0 ) + // InternalExpression.g:11527:3: rule__XMemberFeatureCall__Group_1_1_3__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred164_InternalExpression + + // $ANTLR start synpred165_InternalExpression + public final void synpred165_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:11553:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 ) + // InternalExpression.g:11553:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred165_InternalExpression + + // $ANTLR start synpred173_InternalExpression + public final void synpred173_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:12526:3: ( rule__XClosure__Group_1__0 ) + // InternalExpression.g:12526:3: rule__XClosure__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred173_InternalExpression + + // $ANTLR start synpred180_InternalExpression + public final void synpred180_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:13497:3: ( rule__XIfExpression__Group_6__0 ) + // InternalExpression.g:13497:3: rule__XIfExpression__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred180_InternalExpression + + // $ANTLR start synpred183_InternalExpression + public final void synpred183_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:13957:3: ( rule__XSwitchExpression__Group_2_1_0__0 ) + // InternalExpression.g:13957:3: rule__XSwitchExpression__Group_2_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred183_InternalExpression + + // $ANTLR start synpred196_InternalExpression + public final void synpred196_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:16090:3: ( rule__XFeatureCall__Group_3__0 ) + // InternalExpression.g:16090:3: rule__XFeatureCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred196_InternalExpression + + // $ANTLR start synpred197_InternalExpression + public final void synpred197_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:16116:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 ) + // InternalExpression.g:16116:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred197_InternalExpression + + // $ANTLR start synpred201_InternalExpression + public final void synpred201_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:16576:3: ( rule__XConstructorCall__Group_3__0 ) + // InternalExpression.g:16576:3: rule__XConstructorCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred201_InternalExpression + + // $ANTLR start synpred202_InternalExpression + public final void synpred202_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:16603:3: ( rule__XConstructorCall__Group_4__0 ) + // InternalExpression.g:16603:3: rule__XConstructorCall__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred202_InternalExpression + + // $ANTLR start synpred203_InternalExpression + public final void synpred203_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:16629:3: ( rule__XConstructorCall__ArgumentsAssignment_5 ) + // InternalExpression.g:16629:3: rule__XConstructorCall__ArgumentsAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred203_InternalExpression + + // $ANTLR start synpred208_InternalExpression + public final void synpred208_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:17520:3: ( rule__XReturnExpression__ExpressionAssignment_2 ) + // InternalExpression.g:17520:3: rule__XReturnExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred208_InternalExpression + + // $ANTLR start synpred209_InternalExpression + public final void synpred209_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:17662:4: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + // InternalExpression.g:17662:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred209_InternalExpression + + // $ANTLR start synpred210_InternalExpression + public final void synpred210_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:17689:3: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 ) + // InternalExpression.g:17689:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred210_InternalExpression + + // $ANTLR start synpred211_InternalExpression + public final void synpred211_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:18202:3: ( rule__QualifiedName__Group_1__0 ) + // InternalExpression.g:18202:3: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred211_InternalExpression + + // $ANTLR start synpred213_InternalExpression + public final void synpred213_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:18418:3: ( rule__JvmTypeReference__Group_0_1__0 ) + // InternalExpression.g:18418:3: rule__JvmTypeReference__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred213_InternalExpression + + // $ANTLR start synpred217_InternalExpression + public final void synpred217_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:18877:3: ( rule__JvmParameterizedTypeReference__Group_1__0 ) + // InternalExpression.g:18877:3: rule__JvmParameterizedTypeReference__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred217_InternalExpression + + // $ANTLR start synpred219_InternalExpression + public final void synpred219_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:19012:3: ( rule__JvmParameterizedTypeReference__Group_1_4__0 ) + // InternalExpression.g:19012:3: rule__JvmParameterizedTypeReference__Group_1_4__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred219_InternalExpression + + // $ANTLR start synpred220_InternalExpression + public final void synpred220_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:19147:3: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 ) + // InternalExpression.g:19147:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred220_InternalExpression + + // Delegated rules + + public final boolean synpred173_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred173_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred3_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred118_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred118_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred197_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred197_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred196_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred196_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred201_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred201_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred151_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred151_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred202_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred202_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred203_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred203_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred153_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred153_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred209_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred209_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred154_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred154_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred208_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred208_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred210_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred210_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred211_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred211_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred85_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred85_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred159_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred159_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred161_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred161_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred217_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred217_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred160_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred160_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred71_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred71_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred162_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred162_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred72_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred72_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred132_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred132_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred156_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred156_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred219_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred219_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred213_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred213_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred107_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred107_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred155_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred155_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred158_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred158_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred157_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred157_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred112_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred112_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred164_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred164_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred165_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred165_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred180_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred180_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred183_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred183_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred111_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred111_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred93_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred93_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred94_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred94_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred220_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred220_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA2 dfa2 = new DFA2(this); + protected DFA23 dfa23 = new DFA23(this); + protected DFA31 dfa31 = new DFA31(this); + protected DFA34 dfa34 = new DFA34(this); + protected DFA35 dfa35 = new DFA35(this); + protected DFA38 dfa38 = new DFA38(this); + protected DFA43 dfa43 = new DFA43(this); + protected DFA46 dfa46 = new DFA46(this); + protected DFA55 dfa55 = new DFA55(this); + protected DFA78 dfa78 = new DFA78(this); + protected DFA84 dfa84 = new DFA84(this); + protected DFA91 dfa91 = new DFA91(this); + protected DFA92 dfa92 = new DFA92(this); + protected DFA100 dfa100 = new DFA100(this); + protected DFA110 dfa110 = new DFA110(this); + protected DFA123 dfa123 = new DFA123(this); + protected DFA124 dfa124 = new DFA124(this); + protected DFA128 dfa128 = new DFA128(this); + protected DFA129 dfa129 = new DFA129(this); + protected DFA130 dfa130 = new DFA130(this); + protected DFA135 dfa135 = new DFA135(this); + protected DFA144 dfa144 = new DFA144(this); + protected DFA147 dfa147 = new DFA147(this); + static final String dfa_1s = "\36\uffff"; + static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; + static final String dfa_3s = "\1\146\1\uffff\1\0\33\uffff"; + static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; + static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; + static final String[] dfa_6s = { + "\1\3\1\uffff\1\3\1\uffff\2\3\16\uffff\1\3\2\uffff\16\3\30\uffff\1\1\1\uffff\1\2\2\uffff\1\3\2\uffff\2\3\5\uffff\2\3\12\uffff\1\3\11\uffff\1\3", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA2 extends DFA { + + public DFA2(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 2; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "2868:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA2_2 = input.LA(1); + + + int index2_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 29;} + + else if ( (true) ) {s = 3;} + + + input.seek(index2_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 2, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_7s = "\13\uffff"; + static final String dfa_8s = "\1\25\2\uffff\1\25\7\uffff"; + static final String dfa_9s = "\1\65\2\uffff\1\62\7\uffff"; + static final String dfa_10s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\6\1\3"; + static final String dfa_11s = "\13\uffff}>"; + static final String[] dfa_12s = { + "\1\3\1\6\31\uffff\1\1\1\2\1\4\1\5\1\7\1\10", + "", + "", + "\1\11\34\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); + static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); + static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); + static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); + static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); + static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); + + class DFA23 extends DFA { + + public DFA23(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 23; + this.eot = dfa_7; + this.eof = dfa_7; + this.min = dfa_8; + this.max = dfa_9; + this.accept = dfa_10; + this.special = dfa_11; + this.transition = dfa_12; + } + public String getDescription() { + return "3543:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );"; + } + } + static final String dfa_13s = "\12\uffff"; + static final String dfa_14s = "\4\uffff\5\3\1\uffff"; + static final String dfa_15s = "\1\72\2\4\1\uffff\5\4\1\uffff"; + static final String dfa_16s = "\1\147\2\100\1\uffff\5\150\1\uffff"; + static final String dfa_17s = "\3\uffff\1\2\5\uffff\1\1"; + static final String dfa_18s = "\12\uffff}>"; + static final String[] dfa_19s = { + "\1\1\31\uffff\1\2\22\uffff\1\3", + "\1\4\21\uffff\1\3\45\uffff\1\5\1\6\1\7\1\10\1\3", + "\1\4\21\uffff\1\3\45\uffff\1\5\1\6\1\7\1\10\1\3", + "", + "\4\3\1\uffff\1\3\4\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\3\3\1\uffff\1\3\1\uffff\7\3\2\uffff\23\3\3\uffff\2\3", + "\4\3\1\uffff\1\3\4\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\3\3\1\uffff\1\3\1\uffff\7\3\2\uffff\23\3\3\uffff\2\3", + "\4\3\1\uffff\1\3\4\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\3\3\1\uffff\1\3\1\uffff\7\3\2\uffff\23\3\3\uffff\2\3", + "\4\3\1\uffff\1\3\4\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\3\3\1\uffff\1\3\1\uffff\7\3\2\uffff\23\3\3\uffff\2\3", + "\4\3\1\uffff\1\3\4\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\1\uffff\3\3\1\uffff\1\3\1\uffff\7\3\2\uffff\23\3\3\uffff\2\3", + "" + }; + + static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); + static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); + static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); + static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); + static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); + static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); + static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s); + + class DFA31 extends DFA { + + public DFA31(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 31; + this.eot = dfa_13; + this.eof = dfa_14; + this.min = dfa_15; + this.max = dfa_16; + this.accept = dfa_17; + this.special = dfa_18; + this.transition = dfa_19; + } + public String getDescription() { + return "3777:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );"; + } + } + static final String dfa_20s = "\43\uffff"; + static final String dfa_21s = "\1\4\2\0\40\uffff"; + static final String dfa_22s = "\1\142\2\0\40\uffff"; + static final String dfa_23s = "\3\uffff\1\1\1\uffff\1\2\35\uffff"; + static final String dfa_24s = "\1\uffff\1\0\1\1\40\uffff}>"; + static final String[] dfa_25s = { + "\1\1\3\5\1\uffff\1\5\14\uffff\3\5\2\uffff\1\5\10\uffff\2\5\15\uffff\1\3\10\uffff\5\5\2\uffff\1\2\2\uffff\1\5\2\uffff\2\5\4\uffff\1\3\1\uffff\2\5\4\uffff\1\5\1\uffff\10\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); + static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); + static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); + static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); + static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); + static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); + + class DFA34 extends DFA { + + public DFA34(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 34; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "3846:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA34_1 = input.LA(1); + + + int index34_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred85_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index34_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA34_2 = input.LA(1); + + + int index34_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred85_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index34_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 34, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_26s = "\40\uffff"; + static final String dfa_27s = "\1\4\26\uffff\1\0\10\uffff"; + static final String dfa_28s = "\1\142\26\uffff\1\0\10\uffff"; + static final String dfa_29s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11"; + static final String dfa_30s = "\27\uffff\1\0\10\uffff}>"; + static final String[] dfa_31s = { + "\1\5\3\14\1\uffff\1\14\14\uffff\1\5\15\uffff\2\14\26\uffff\5\5\2\uffff\1\35\2\uffff\1\26\2\uffff\1\3\1\2\6\uffff\1\1\1\14\4\uffff\1\14\1\uffff\1\27\1\30\1\31\2\14\1\32\1\33\1\34\1\uffff\1\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s); + static final char[] dfa_27 = DFA.unpackEncodedStringToUnsignedChars(dfa_27s); + static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s); + static final short[] dfa_29 = DFA.unpackEncodedString(dfa_29s); + static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s); + static final short[][] dfa_31 = unpackEncodedStringArray(dfa_31s); + + class DFA35 extends DFA { + + public DFA35(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 35; + this.eot = dfa_26; + this.eof = dfa_26; + this.min = dfa_27; + this.max = dfa_28; + this.accept = dfa_29; + this.special = dfa_30; + this.transition = dfa_31; + } + public String getDescription() { + return "3867:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA35_23 = input.LA(1); + + + int index35_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred93_InternalExpression()) ) {s = 30;} + + else if ( (synpred94_InternalExpression()) ) {s = 31;} + + + input.seek(index35_23); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 35, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_32s = "\1\4\1\0\41\uffff"; + static final String dfa_33s = "\1\142\1\0\41\uffff"; + static final String dfa_34s = "\2\uffff\1\2\37\uffff\1\1"; + static final String dfa_35s = "\1\uffff\1\0\41\uffff}>"; + static final String[] dfa_36s = { + "\4\2\1\uffff\1\2\14\uffff\3\2\2\uffff\1\2\10\uffff\2\2\15\uffff\1\2\10\uffff\5\2\2\uffff\1\1\2\uffff\1\2\2\uffff\2\2\6\uffff\2\2\4\uffff\1\2\1\uffff\10\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_32 = DFA.unpackEncodedStringToUnsignedChars(dfa_32s); + static final char[] dfa_33 = DFA.unpackEncodedStringToUnsignedChars(dfa_33s); + static final short[] dfa_34 = DFA.unpackEncodedString(dfa_34s); + static final short[] dfa_35 = DFA.unpackEncodedString(dfa_35s); + static final short[][] dfa_36 = unpackEncodedStringArray(dfa_36s); + + class DFA38 extends DFA { + + public DFA38(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 38; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_32; + this.max = dfa_33; + this.accept = dfa_34; + this.special = dfa_35; + this.transition = dfa_36; + } + public String getDescription() { + return "4038:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA38_1 = input.LA(1); + + + int index38_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred107_InternalExpression()) ) {s = 34;} + + else if ( (true) ) {s = 2;} + + + input.seek(index38_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 38, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA43 extends DFA { + + public DFA43(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 43; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4143:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA43_1 = input.LA(1); + + + int index43_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred112_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index43_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA43_2 = input.LA(1); + + + int index43_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred112_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index43_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 43, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA46 extends DFA { + + public DFA46(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 46; + this.eot = dfa_20; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4224:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA46_1 = input.LA(1); + + + int index46_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred118_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index46_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA46_2 = input.LA(1); + + + int index46_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred118_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index46_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 46, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_37s = "\7\uffff"; + static final String dfa_38s = "\2\uffff\1\4\2\uffff\1\4\1\uffff"; + static final String dfa_39s = "\1\4\1\uffff\1\72\1\4\1\uffff\1\72\1\uffff"; + static final String dfa_40s = "\1\75\1\uffff\1\130\1\31\1\uffff\1\130\1\uffff"; + static final String dfa_41s = "\1\uffff\1\1\2\uffff\1\2\1\uffff\1\3"; + static final String dfa_42s = "\7\uffff}>"; + static final String[] dfa_43s = { + "\1\2\70\uffff\1\1", + "", + "\1\3\35\uffff\1\4", + "\1\5\24\uffff\1\6", + "", + "\1\3\35\uffff\1\4", + "" + }; + + static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s); + static final short[] dfa_38 = DFA.unpackEncodedString(dfa_38s); + static final char[] dfa_39 = DFA.unpackEncodedStringToUnsignedChars(dfa_39s); + static final char[] dfa_40 = DFA.unpackEncodedStringToUnsignedChars(dfa_40s); + static final short[] dfa_41 = DFA.unpackEncodedString(dfa_41s); + static final short[] dfa_42 = DFA.unpackEncodedString(dfa_42s); + static final short[][] dfa_43 = unpackEncodedStringArray(dfa_43s); + + class DFA55 extends DFA { + + public DFA55(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 55; + this.eot = dfa_37; + this.eof = dfa_38; + this.min = dfa_39; + this.max = dfa_40; + this.accept = dfa_41; + this.special = dfa_42; + this.transition = dfa_43; + } + public String getDescription() { + return "4413:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) );"; + } + } + static final String dfa_44s = "\1\10\11\uffff"; + static final String dfa_45s = "\1\4\7\0\2\uffff"; + static final String dfa_46s = "\1\150\7\0\2\uffff"; + static final String dfa_47s = "\10\uffff\1\2\1\1"; + static final String dfa_48s = "\1\uffff\1\1\1\4\1\6\1\0\1\2\1\5\1\3\2\uffff}>"; + static final String[] dfa_49s = { + "\4\10\1\uffff\1\10\5\uffff\5\10\1\uffff\1\7\1\6\5\10\10\uffff\2\10\3\uffff\1\1\1\2\1\3\1\4\1\5\23\10\1\uffff\3\10\1\uffff\1\10\1\uffff\7\10\2\uffff\23\10\3\uffff\2\10", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s); + static final char[] dfa_45 = DFA.unpackEncodedStringToUnsignedChars(dfa_45s); + static final char[] dfa_46 = DFA.unpackEncodedStringToUnsignedChars(dfa_46s); + static final short[] dfa_47 = DFA.unpackEncodedString(dfa_47s); + static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s); + static final short[][] dfa_49 = unpackEncodedStringArray(dfa_49s); + + class DFA78 extends DFA { + + public DFA78(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 78; + this.eot = dfa_13; + this.eof = dfa_44; + this.min = dfa_45; + this.max = dfa_46; + this.accept = dfa_47; + this.special = dfa_48; + this.transition = dfa_49; + } + public String getDescription() { + return "8637:2: ( rule__XAssignment__Group_1_1__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA78_4 = input.LA(1); + + + int index78_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_4); + if ( s>=0 ) return s; + break; + case 1 : + int LA78_1 = input.LA(1); + + + int index78_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA78_5 = input.LA(1); + + + int index78_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_5); + if ( s>=0 ) return s; + break; + case 3 : + int LA78_7 = input.LA(1); + + + int index78_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_7); + if ( s>=0 ) return s; + break; + case 4 : + int LA78_2 = input.LA(1); + + + int index78_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_2); + if ( s>=0 ) return s; + break; + case 5 : + int LA78_6 = input.LA(1); + + + int index78_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA78_3 = input.LA(1); + + + int index78_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred151_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index78_3); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 78, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_50s = "\1\1\12\uffff"; + static final String dfa_51s = "\1\4\1\uffff\10\0\1\uffff"; + static final String dfa_52s = "\1\150\1\uffff\10\0\1\uffff"; + static final String dfa_53s = "\1\uffff\1\2\10\uffff\1\1"; + static final String dfa_54s = "\2\uffff\1\1\1\2\1\6\1\4\1\0\1\3\1\7\1\5\1\uffff}>"; + static final String[] dfa_55s = { + "\4\1\1\uffff\1\1\5\uffff\5\1\1\uffff\1\3\1\2\5\1\10\uffff\2\1\3\uffff\7\1\1\4\1\5\1\6\1\7\1\10\1\11\13\1\1\uffff\3\1\1\uffff\1\1\1\uffff\7\1\2\uffff\23\1\3\uffff\2\1", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "" + }; + static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s); + static final char[] dfa_51 = DFA.unpackEncodedStringToUnsignedChars(dfa_51s); + static final char[] dfa_52 = DFA.unpackEncodedStringToUnsignedChars(dfa_52s); + static final short[] dfa_53 = DFA.unpackEncodedString(dfa_53s); + static final short[] dfa_54 = DFA.unpackEncodedString(dfa_54s); + static final short[][] dfa_55 = unpackEncodedStringArray(dfa_55s); + + class DFA84 extends DFA { + + public DFA84(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 84; + this.eot = dfa_7; + this.eof = dfa_50; + this.min = dfa_51; + this.max = dfa_52; + this.accept = dfa_53; + this.special = dfa_54; + this.transition = dfa_55; + } + public String getDescription() { + return "()* loopback of 9933:2: ( rule__XOtherOperatorExpression__Group_1__0 )*"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA84_6 = input.LA(1); + + + int index84_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_6); + if ( s>=0 ) return s; + break; + case 1 : + int LA84_2 = input.LA(1); + + + int index84_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA84_3 = input.LA(1); + + + int index84_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA84_7 = input.LA(1); + + + int index84_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_7); + if ( s>=0 ) return s; + break; + case 4 : + int LA84_5 = input.LA(1); + + + int index84_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA84_9 = input.LA(1); + + + int index84_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_9); + if ( s>=0 ) return s; + break; + case 6 : + int LA84_4 = input.LA(1); + + + int index84_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_4); + if ( s>=0 ) return s; + break; + case 7 : + int LA84_8 = input.LA(1); + + + int index84_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred157_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index84_8); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 84, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_56s = "\116\uffff"; + static final String dfa_57s = "\1\2\115\uffff"; + static final String dfa_58s = "\1\4\1\0\114\uffff"; + static final String dfa_59s = "\1\150\1\0\114\uffff"; + static final String dfa_60s = "\2\uffff\1\2\112\uffff\1\1"; + static final String dfa_61s = "\1\uffff\1\0\114\uffff}>"; + static final String[] dfa_62s = { + "\4\2\1\uffff\1\2\5\uffff\5\2\1\uffff\7\2\10\uffff\2\2\3\uffff\30\2\1\uffff\1\2\1\1\1\2\1\uffff\1\2\1\uffff\7\2\2\uffff\23\2\3\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s); + static final short[] dfa_57 = DFA.unpackEncodedString(dfa_57s); + static final char[] dfa_58 = DFA.unpackEncodedStringToUnsignedChars(dfa_58s); + static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s); + static final short[] dfa_60 = DFA.unpackEncodedString(dfa_60s); + static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); + static final short[][] dfa_62 = unpackEncodedStringArray(dfa_62s); + + class DFA91 extends DFA { + + public DFA91(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 91; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "11527:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA91_1 = input.LA(1); + + + int index91_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred164_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index91_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 91, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_63s = { + "\4\2\1\uffff\1\2\5\uffff\5\2\1\uffff\7\2\10\uffff\2\2\3\uffff\30\2\1\uffff\3\2\1\uffff\1\2\1\uffff\7\2\2\uffff\1\2\1\1\21\2\3\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_63 = unpackEncodedStringArray(dfa_63s); + + class DFA92 extends DFA { + + public DFA92(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 92; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_63; + } + public String getDescription() { + return "11553:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA92_1 = input.LA(1); + + + int index92_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred165_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index92_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 92, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_64s = "\46\uffff"; + static final String dfa_65s = "\1\4\2\0\43\uffff"; + static final String dfa_66s = "\1\150\2\0\43\uffff"; + static final String dfa_67s = "\3\uffff\1\1\1\uffff\1\2\40\uffff"; + static final String dfa_68s = "\1\uffff\1\0\1\1\43\uffff}>"; + static final String[] dfa_69s = { + "\1\1\3\5\1\uffff\1\5\14\uffff\3\5\2\uffff\1\5\10\uffff\2\5\15\uffff\1\3\7\uffff\6\5\2\uffff\1\2\2\uffff\1\5\2\uffff\2\5\4\uffff\1\3\1\uffff\3\5\3\uffff\1\5\1\uffff\10\5\1\uffff\1\5\5\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_64 = DFA.unpackEncodedString(dfa_64s); + static final char[] dfa_65 = DFA.unpackEncodedStringToUnsignedChars(dfa_65s); + static final char[] dfa_66 = DFA.unpackEncodedStringToUnsignedChars(dfa_66s); + static final short[] dfa_67 = DFA.unpackEncodedString(dfa_67s); + static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s); + static final short[][] dfa_69 = unpackEncodedStringArray(dfa_69s); + + class DFA100 extends DFA { + + public DFA100(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 100; + this.eot = dfa_64; + this.eof = dfa_64; + this.min = dfa_65; + this.max = dfa_66; + this.accept = dfa_67; + this.special = dfa_68; + this.transition = dfa_69; + } + public String getDescription() { + return "12526:2: ( rule__XClosure__Group_1__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA100_1 = input.LA(1); + + + int index100_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred173_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index100_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA100_2 = input.LA(1); + + + int index100_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred173_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index100_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 100, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_70s = "\42\uffff"; + static final String dfa_71s = "\1\4\2\0\37\uffff"; + static final String dfa_72s = "\1\142\2\0\37\uffff"; + static final String dfa_73s = "\3\uffff\1\1\1\2\35\uffff"; + static final String dfa_74s = "\1\uffff\1\0\1\1\37\uffff}>"; + static final String[] dfa_75s = { + "\1\1\3\4\1\uffff\1\4\14\uffff\3\4\2\uffff\1\4\10\uffff\2\4\15\uffff\1\3\10\uffff\5\4\2\uffff\1\2\2\uffff\1\4\2\uffff\2\4\6\uffff\2\4\4\uffff\1\4\1\uffff\10\4\1\uffff\1\4", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_70 = DFA.unpackEncodedString(dfa_70s); + static final char[] dfa_71 = DFA.unpackEncodedStringToUnsignedChars(dfa_71s); + static final char[] dfa_72 = DFA.unpackEncodedStringToUnsignedChars(dfa_72s); + static final short[] dfa_73 = DFA.unpackEncodedString(dfa_73s); + static final short[] dfa_74 = DFA.unpackEncodedString(dfa_74s); + static final short[][] dfa_75 = unpackEncodedStringArray(dfa_75s); + + class DFA110 extends DFA { + + public DFA110(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 110; + this.eot = dfa_70; + this.eof = dfa_70; + this.min = dfa_71; + this.max = dfa_72; + this.accept = dfa_73; + this.special = dfa_74; + this.transition = dfa_75; + } + public String getDescription() { + return "13957:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA110_1 = input.LA(1); + + + int index110_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred183_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index110_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA110_2 = input.LA(1); + + + int index110_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred183_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index110_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 110, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA123 extends DFA { + + public DFA123(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 123; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "16090:2: ( rule__XFeatureCall__Group_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA123_1 = input.LA(1); + + + int index123_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index123_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 123, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA124 extends DFA { + + public DFA124(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 124; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_63; + } + public String getDescription() { + return "16116:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA124_1 = input.LA(1); + + + int index124_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred197_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index124_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 124, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_76s = { + "\4\2\1\uffff\1\2\5\uffff\5\2\1\uffff\1\2\1\1\5\2\10\uffff\2\2\3\uffff\30\2\1\uffff\3\2\1\uffff\1\2\1\uffff\7\2\2\uffff\23\2\3\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_76 = unpackEncodedStringArray(dfa_76s); + + class DFA128 extends DFA { + + public DFA128(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 128; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_76; + } + public String getDescription() { + return "16576:2: ( rule__XConstructorCall__Group_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA128_1 = input.LA(1); + + + int index128_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred201_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index128_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 128, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA129 extends DFA { + + public DFA129(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 129; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "16603:2: ( rule__XConstructorCall__Group_4__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA129_1 = input.LA(1); + + + int index129_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred202_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index129_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 129, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA130 extends DFA { + + public DFA130(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 130; + this.eot = dfa_56; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_63; + } + public String getDescription() { + return "16629:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA130_1 = input.LA(1); + + + int index130_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred203_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index130_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 130, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_77s = "\1\41\115\uffff"; + static final String dfa_78s = "\1\4\40\0\55\uffff"; + static final String dfa_79s = "\1\150\40\0\55\uffff"; + static final String dfa_80s = "\41\uffff\1\2\53\uffff\1\1"; + static final String dfa_81s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>"; + static final String[] dfa_82s = { + "\1\1\1\23\1\24\1\25\1\uffff\1\27\5\uffff\5\41\1\uffff\1\41\1\15\1\10\1\7\2\41\1\6\10\uffff\1\22\1\21\3\uffff\23\41\1\2\1\3\1\4\1\5\1\16\1\uffff\1\41\1\40\1\41\1\uffff\1\31\1\uffff\1\41\1\13\1\12\4\41\2\uffff\1\11\1\20\4\41\1\17\1\41\1\32\1\33\1\34\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41\3\uffff\2\41", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[] dfa_77 = DFA.unpackEncodedString(dfa_77s); + static final char[] dfa_78 = DFA.unpackEncodedStringToUnsignedChars(dfa_78s); + static final char[] dfa_79 = DFA.unpackEncodedStringToUnsignedChars(dfa_79s); + static final short[] dfa_80 = DFA.unpackEncodedString(dfa_80s); + static final short[] dfa_81 = DFA.unpackEncodedString(dfa_81s); + static final short[][] dfa_82 = unpackEncodedStringArray(dfa_82s); + + class DFA135 extends DFA { + + public DFA135(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 135; + this.eot = dfa_56; + this.eof = dfa_77; + this.min = dfa_78; + this.max = dfa_79; + this.accept = dfa_80; + this.special = dfa_81; + this.transition = dfa_82; + } + public String getDescription() { + return "17520:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA135_1 = input.LA(1); + + + int index135_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index135_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA135_2 = input.LA(1); + + + int index135_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index135_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA135_3 = input.LA(1); + + + int index135_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index135_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA135_4 = input.LA(1); + + + int index135_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index135_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA135_5 = input.LA(1); + + + int index135_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index135_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA135_6 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); - } + + int index135_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index135_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA135_7 = input.LA(1); - } + + int index135_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index135_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA135_8 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CollectionExpression__NameAssignment_0" + + int index135_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + else if ( (true) ) {s = 33;} - // $ANTLR start "rule__CollectionExpression__VarAssignment_2_0" - // InternalExpression.g:6366:1: rule__CollectionExpression__VarAssignment_2_0 : ( ruleIdentifier ) ; - public final void rule__CollectionExpression__VarAssignment_2_0() throws RecognitionException { + + input.seek(index135_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA135_9 = input.LA(1); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:6370:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:6371:2: ( ruleIdentifier ) - { - // InternalExpression.g:6371:2: ( ruleIdentifier ) - // InternalExpression.g:6372:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + + int index135_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); - } + else if ( (true) ) {s = 33;} - } + + input.seek(index135_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA135_10 = input.LA(1); + + int index135_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + input.seek(index135_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA135_11 = input.LA(1); - restoreStackSize(stackSize); + + int index135_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } - return ; - } - // $ANTLR end "rule__CollectionExpression__VarAssignment_2_0" + else if ( (true) ) {s = 33;} + + input.seek(index135_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA135_12 = input.LA(1); - // $ANTLR start "rule__CollectionExpression__ExpAssignment_3" - // InternalExpression.g:6381:1: rule__CollectionExpression__ExpAssignment_3 : ( ruleExpression ) ; - public final void rule__CollectionExpression__ExpAssignment_3() throws RecognitionException { + + int index135_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:6385:1: ( ( ruleExpression ) ) - // InternalExpression.g:6386:2: ( ruleExpression ) - { - // InternalExpression.g:6386:2: ( ruleExpression ) - // InternalExpression.g:6387:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); - } + + input.seek(index135_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA135_13 = input.LA(1); - } + + int index135_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index135_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA135_14 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index135_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__CollectionExpression__ExpAssignment_3" + + input.seek(index135_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA135_15 = input.LA(1); + + int index135_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - // $ANTLR start "rule__CollectionType__ClAssignment_0" - // InternalExpression.g:6396:1: rule__CollectionType__ClAssignment_0 : ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ; - public final void rule__CollectionType__ClAssignment_0() throws RecognitionException { + else if ( (true) ) {s = 33;} - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:6400:1: ( ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ) - // InternalExpression.g:6401:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) - { - // InternalExpression.g:6401:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) - // InternalExpression.g:6402:3: ( rule__CollectionType__ClAlternatives_0_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); - } - // InternalExpression.g:6403:3: ( rule__CollectionType__ClAlternatives_0_0 ) - // InternalExpression.g:6403:4: rule__CollectionType__ClAlternatives_0_0 - { - pushFollow(FOLLOW_2); - rule__CollectionType__ClAlternatives_0_0(); + + input.seek(index135_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA135_16 = input.LA(1); - state._fsp--; - if (state.failed) return ; + + int index135_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); - } + + input.seek(index135_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA135_17 = input.LA(1); - } + + int index135_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index135_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA135_18 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index135_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__CollectionType__ClAssignment_0" + + input.seek(index135_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA135_19 = input.LA(1); + + int index135_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - // $ANTLR start "rule__CollectionType__Id1Assignment_2" - // InternalExpression.g:6411:1: rule__CollectionType__Id1Assignment_2 : ( ruleSimpleType ) ; - public final void rule__CollectionType__Id1Assignment_2() throws RecognitionException { + else if ( (true) ) {s = 33;} - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:6415:1: ( ( ruleSimpleType ) ) - // InternalExpression.g:6416:2: ( ruleSimpleType ) - { - // InternalExpression.g:6416:2: ( ruleSimpleType ) - // InternalExpression.g:6417:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); + + input.seek(index135_19); + if ( s>=0 ) return s; + break; + case 19 : + int LA135_20 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); - } + + int index135_20 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index135_20); + if ( s>=0 ) return s; + break; + case 20 : + int LA135_21 = input.LA(1); - } + + int index135_21 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index135_21); + if ( s>=0 ) return s; + break; + case 21 : + int LA135_22 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CollectionType__Id1Assignment_2" + + int index135_22 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + else if ( (true) ) {s = 33;} - // $ANTLR start "rule__SimpleType__IdAssignment_0" - // InternalExpression.g:6426:1: rule__SimpleType__IdAssignment_0 : ( ruleIdentifier ) ; - public final void rule__SimpleType__IdAssignment_0() throws RecognitionException { + + input.seek(index135_22); + if ( s>=0 ) return s; + break; + case 22 : + int LA135_23 = input.LA(1); - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:6430:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:6431:2: ( ruleIdentifier ) - { - // InternalExpression.g:6431:2: ( ruleIdentifier ) - // InternalExpression.g:6432:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + + int index135_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); - } + else if ( (true) ) {s = 33;} - } + + input.seek(index135_23); + if ( s>=0 ) return s; + break; + case 23 : + int LA135_24 = input.LA(1); + + int index135_24 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + input.seek(index135_24); + if ( s>=0 ) return s; + break; + case 24 : + int LA135_25 = input.LA(1); - restoreStackSize(stackSize); + + int index135_25 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } - return ; - } - // $ANTLR end "rule__SimpleType__IdAssignment_0" + else if ( (true) ) {s = 33;} + + input.seek(index135_25); + if ( s>=0 ) return s; + break; + case 25 : + int LA135_26 = input.LA(1); - // $ANTLR start "rule__SimpleType__IdAssignment_1_1" - // InternalExpression.g:6441:1: rule__SimpleType__IdAssignment_1_1 : ( ruleIdentifier ) ; - public final void rule__SimpleType__IdAssignment_1_1() throws RecognitionException { + + int index135_26 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - int stackSize = keepStackSize(); - - try { - // InternalExpression.g:6445:1: ( ( ruleIdentifier ) ) - // InternalExpression.g:6446:2: ( ruleIdentifier ) - { - // InternalExpression.g:6446:2: ( ruleIdentifier ) - // InternalExpression.g:6447:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); - } + + input.seek(index135_26); + if ( s>=0 ) return s; + break; + case 26 : + int LA135_27 = input.LA(1); - } + + int index135_27 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index135_27); + if ( s>=0 ) return s; + break; + case 27 : + int LA135_28 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index135_28 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__SimpleType__IdAssignment_1_1" + + input.seek(index135_28); + if ( s>=0 ) return s; + break; + case 28 : + int LA135_29 = input.LA(1); - // $ANTLR start synpred2_InternalExpression - public final void synpred2_InternalExpression_fragment() throws RecognitionException { - // InternalExpression.g:989:2: ( ( ( ruleCastedExpression ) ) ) - // InternalExpression.g:989:2: ( ( ruleCastedExpression ) ) - { - // InternalExpression.g:989:2: ( ( ruleCastedExpression ) ) - // InternalExpression.g:990:3: ( ruleCastedExpression ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - // InternalExpression.g:991:3: ( ruleCastedExpression ) - // InternalExpression.g:991:4: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + + int index135_29 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; + else if ( (true) ) {s = 33;} - } + + input.seek(index135_29); + if ( s>=0 ) return s; + break; + case 29 : + int LA135_30 = input.LA(1); + + int index135_30 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index135_30); + if ( s>=0 ) return s; + break; + case 30 : + int LA135_31 = input.LA(1); - } - } - // $ANTLR end synpred2_InternalExpression + + int index135_31 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - // $ANTLR start synpred49_InternalExpression - public final void synpred49_InternalExpression_fragment() throws RecognitionException { - // InternalExpression.g:2214:3: ( rule__IfExpressionKw__Group_4__0 ) - // InternalExpression.g:2214:3: rule__IfExpressionKw__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; + + input.seek(index135_31); + if ( s>=0 ) return s; + break; + case 31 : + int LA135_32 = input.LA(1); - } - } - // $ANTLR end synpred49_InternalExpression + + int index135_32 = input.index(); + input.rewind(); + s = -1; + if ( (synpred208_InternalExpression()) ) {s = 77;} - // Delegated rules + else if ( (true) ) {s = 33;} - public final boolean synpred2_InternalExpression() { - state.backtracking++; - int start = input.mark(); - try { - synpred2_InternalExpression_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred49_InternalExpression() { - state.backtracking++; - int start = input.mark(); - try { - synpred49_InternalExpression_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); + + input.seek(index135_32); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 135, _s, input); + error(nvae); + throw nvae; } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; } - - - protected DFA1 dfa1 = new DFA1(this); - static final String dfa_1s = "\36\uffff"; - static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; - static final String dfa_3s = "\1\77\1\uffff\1\0\33\uffff"; - static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; - static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; - static final String[] dfa_6s = { - "\4\3\13\uffff\1\3\2\uffff\16\3\1\1\2\uffff\1\2\3\uffff\1\3\2\uffff\2\3\6\uffff\2\3\6\uffff\2\3", - "", + static final String dfa_83s = "\117\uffff"; + static final String dfa_84s = "\1\2\116\uffff"; + static final String dfa_85s = "\1\4\1\0\115\uffff"; + static final String dfa_86s = "\1\150\1\0\115\uffff"; + static final String dfa_87s = "\2\uffff\1\2\113\uffff\1\1"; + static final String dfa_88s = "\1\uffff\1\0\115\uffff}>"; + static final String[] dfa_89s = { + "\4\2\1\uffff\1\2\5\uffff\5\2\1\uffff\1\2\1\1\5\2\10\uffff\2\2\3\uffff\30\2\1\uffff\3\2\1\uffff\1\2\1\uffff\7\2\2\uffff\24\2\2\uffff\2\2", "\1\uffff", "", "", @@ -21131,55 +79545,150 @@ public final boolean synpred49_InternalExpression() { "", "", "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", "" }; - static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); - static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); - static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); - static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); - static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); - static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s); + static final short[] dfa_84 = DFA.unpackEncodedString(dfa_84s); + static final char[] dfa_85 = DFA.unpackEncodedStringToUnsignedChars(dfa_85s); + static final char[] dfa_86 = DFA.unpackEncodedStringToUnsignedChars(dfa_86s); + static final short[] dfa_87 = DFA.unpackEncodedString(dfa_87s); + static final short[] dfa_88 = DFA.unpackEncodedString(dfa_88s); + static final short[][] dfa_89 = unpackEncodedStringArray(dfa_89s); - class DFA1 extends DFA { + class DFA144 extends DFA { - public DFA1(BaseRecognizer recognizer) { + public DFA144(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 1; - this.eot = dfa_1; - this.eof = dfa_1; - this.min = dfa_2; - this.max = dfa_3; - this.accept = dfa_4; - this.special = dfa_5; - this.transition = dfa_6; + this.decisionNumber = 144; + this.eot = dfa_83; + this.eof = dfa_84; + this.min = dfa_85; + this.max = dfa_86; + this.accept = dfa_87; + this.special = dfa_88; + this.transition = dfa_89; } public String getDescription() { - return "978:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) );"; + return "18877:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA1_2 = input.LA(1); + int LA144_1 = input.LA(1); - int index1_2 = input.index(); + int index144_1 = input.index(); input.rewind(); s = -1; - if ( (synpred2_InternalExpression()) ) {s = 29;} + if ( (synpred217_InternalExpression()) ) {s = 78;} - else if ( (true) ) {s = 3;} + else if ( (true) ) {s = 2;} + + + input.seek(index144_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 144, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA147 extends DFA { + + public DFA147(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 147; + this.eot = dfa_83; + this.eof = dfa_84; + this.min = dfa_85; + this.max = dfa_86; + this.accept = dfa_87; + this.special = dfa_88; + this.transition = dfa_89; + } + public String getDescription() { + return "19147:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA147_1 = input.LA(1); + + + int index147_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred220_InternalExpression()) ) {s = 78;} + + else if ( (true) ) {s = 2;} - input.seek(index1_2); + input.seek(index147_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 1, _s, input); + new NoViableAltException(getDescription(), 147, _s, input); error(nvae); throw nvae; } @@ -21188,48 +79697,124 @@ public int specialStateTransition(int s, IntStream _input) throws NoViableAltExc public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000002000000000L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0xC0C0C89FFFC800F0L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000004000000000L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000E00000010L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000010000000000L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000020000000000L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000020000000002L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000040000000000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000808000000000L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0005000000000000L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0004000000000002L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0xC0C0808FFFC800F0L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0002000000000000L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0800000000000000L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0800000000000002L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x1000000000000000L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x1000000000000002L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x2000000000000000L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x2000000000000002L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x000000000003F000L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x000000000003F002L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x00000000000C0000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x00000000000C0002L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000300000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000300002L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0008000000000000L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0008000000000002L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000008000000000L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0xC0C0C99FFFC800F0L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0010000000000000L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0010000000000002L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x4000000000000000L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x000000007F800000L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0020000000000000L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000800000000000L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0xC0C2C89FFFC800F0L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0100000000000000L}); - public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0200000000000000L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0400000000000000L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0400000000000002L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000012L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000004000L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x000001FFF9000350L,0x000000401003064AL}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x000001C000000010L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0001000000000000L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0001000000000002L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000408L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002800L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000002L,0x0000000000002000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x000001FFF9000350L,0x0000004010030408L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000008002L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000010002L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000000002L,0x0000002000000000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x00000000007E0000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x00000000007E0002L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000001800000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000001800002L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000006000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000006000002L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0400000000000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0400000000000002L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x000001FFF9000350L,0x000000401003065AL}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000000L,0x0000004000000000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000FF0000000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x000001FFF9000350L,0x000000401003164AL}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000002L,0x0000000000100000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0xF000000000000010L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0xF000003009C002F0L,0x00000005FE860649L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x00003E0000600000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000280000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000C00000060000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000C00000060002L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000680000L,0x0000000000200000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000680002L,0x0000000000200000L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0008000000000010L,0x0000000000000008L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x003F000000600000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x003F000000600002L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0004000000000000L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0008000000400000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x00C0000006000000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x00C0000006000002L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000009800000L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0300000000000000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0400000000000000L,0x0000008000100000L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0400000000000002L,0x0000008000100000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0400000000000000L,0x0000000000100000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0xF000000000400010L,0x0000000000000001L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040008L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0008000000000010L,0x0000000000000028L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000200000L,0x0000000000004000L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xF008003009C002F0L,0x00000005FE868659L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0xF008003009C002F0L,0x00000005FE868649L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0xF008003009C002F0L,0x00000005FE869649L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0xF008003009C002F0L,0x00000005FE8E8649L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0xF808003009C002F0L,0x00000105FE868649L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0008000000000010L,0x0000000000008008L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0xF808003009C002F2L,0x00000105FE868649L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0008000000000010L,0x000000000000780CL}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0008000000000012L,0x000000000000600CL}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0008000000000010L,0x000000000000600CL}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0xF808003009C002F0L,0x00000105FF868649L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0xF008003009C002F0L,0x00000005FF868649L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0xF808003009C002F0L,0x00000105FE869649L}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0800000000000000L,0x0000010000000000L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000400000L,0x0000000000040008L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000003000000000L}); + public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x00000000000000E0L}); + public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000200L}); + public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x00000030000002E0L,0x0000000030840000L}); + public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040010L}); + public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); + public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x0000000000000000L,0x0000000040000000L}); + public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L}); + public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); + public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000000000000000L,0x0000000A00000000L}); + public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); + public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000000000000002L,0x0000000800000000L}); + public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); + public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x00000000000000C0L}); + public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0008000000000010L,0x0000000000000018L}); + public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x1000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000000002L,0x0000001000000000L}); + public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x2000000000000010L}); + public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x8000000000000010L}); + public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000000002000010L}); } \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.expression.ui/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.expression.ui/META-INF/MANIFEST.MF index f3e0514782..9229946b6b 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ui/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.expression.ui/META-INF/MANIFEST.MF @@ -15,8 +15,12 @@ Require-Bundle: org.eclipse.xtext.ui, org.antlr.runtime, com.avaloq.tools.ddk.xtext.expression, com.avaloq.tools.ddk.xtext.expression.ide, - org.eclipse.emf.codegen.ecore + org.eclipse.emf.codegen.ecore, + org.eclipse.xtext.xbase.ui, + org.eclipse.jdt.debug.ui, + org.eclipse.xtext.common.types.ui Export-Package: com.avaloq.tools.ddk.xtext.expression.ui.contentassist, - com.avaloq.tools.ddk.xtext.expression.ui.quickfix + com.avaloq.tools.ddk.xtext.expression.ui.quickfix, + com.avaloq.tools.ddk.xtext.expression.ui.editor Import-Package: org.apache.log4j Automatic-Module-Name: com.avaloq.tools.ddk.xtext.expression.ui diff --git a/com.avaloq.tools.ddk.xtext.expression.ui/plugin.xml_gen b/com.avaloq.tools.ddk.xtext.expression.ui/plugin.xml_gen index 1e8021cd06..bce22bfd03 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ui/plugin.xml_gen +++ b/com.avaloq.tools.ddk.xtext.expression.ui/plugin.xml_gen @@ -9,6 +9,7 @@ default="true" extensions="expression" id="com.avaloq.tools.ddk.xtext.expression.Expression" + matchingStrategy="com.avaloq.tools.ddk.xtext.expression.ui.ExpressionExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher" name="Expression Editor"> @@ -277,4 +278,162 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/AbstractExpressionUiModule.java b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/AbstractExpressionUiModule.java index 7f7503854e..f5c1c7ae25 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/AbstractExpressionUiModule.java +++ b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/AbstractExpressionUiModule.java @@ -6,16 +6,22 @@ import com.avaloq.tools.ddk.xtext.expression.ide.contentassist.antlr.ExpressionParser; import com.avaloq.tools.ddk.xtext.expression.ide.contentassist.antlr.internal.InternalExpressionLexer; import com.avaloq.tools.ddk.xtext.expression.ui.contentassist.ExpressionProposalProvider; +import com.avaloq.tools.ddk.xtext.expression.ui.editor.ExpressionEditor; import com.avaloq.tools.ddk.xtext.expression.ui.quickfix.ExpressionQuickfixProvider; import com.google.inject.Binder; import com.google.inject.Provider; import com.google.inject.name.Names; +import org.eclipse.ui.PlatformUI; import org.eclipse.ui.plugin.AbstractUIPlugin; import org.eclipse.xtext.builder.EclipseOutputConfigurationProvider; import org.eclipse.xtext.builder.builderState.IBuilderState; import org.eclipse.xtext.builder.clustering.CurrentDescriptions; import org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource; import org.eclipse.xtext.builder.nature.NatureAddingEditorCallback; +import org.eclipse.xtext.common.types.ui.navigation.GlobalDerivedMemberAwareURIEditorOpener; +import org.eclipse.xtext.common.types.ui.navigation.IDerivedMemberAwareEditorOpener; +import org.eclipse.xtext.common.types.ui.query.IJavaSearchParticipation; +import org.eclipse.xtext.common.types.ui.refactoring.participant.JdtRenameParticipant; import org.eclipse.xtext.generator.IContextualOutputConfigurationProvider; import org.eclipse.xtext.ide.LexerIdeBindings; import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; @@ -26,24 +32,52 @@ import org.eclipse.xtext.resource.IResourceDescriptions; import org.eclipse.xtext.resource.containers.IAllContainersState; import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider; -import org.eclipse.xtext.ui.DefaultUiModule; +import org.eclipse.xtext.ui.LanguageSpecific; import org.eclipse.xtext.ui.editor.DocumentBasedDirtyResource; +import org.eclipse.xtext.ui.editor.GlobalURIEditorOpener; +import org.eclipse.xtext.ui.editor.IURIEditorOpener; import org.eclipse.xtext.ui.editor.IXtextEditorCallback; +import org.eclipse.xtext.ui.editor.XtextEditor; import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; +import org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher; import org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider; import org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper; +import org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher; import org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper; import org.eclipse.xtext.ui.editor.contentassist.antlr.DelegatingContentAssistContextFactory; +import org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler; +import org.eclipse.xtext.ui.editor.findrefs.ReferenceQueryExecutor; +import org.eclipse.xtext.ui.editor.model.XtextDocumentProvider; +import org.eclipse.xtext.ui.editor.outline.impl.OutlineNodeElementOpener; import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider; +import org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler; import org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator; -import org.eclipse.xtext.ui.refactoring.impl.DefaultDependentElementsCalculator; +import org.eclipse.xtext.ui.refactoring.IReferenceUpdater; +import org.eclipse.xtext.ui.refactoring.IRenameRefactoringProvider; +import org.eclipse.xtext.ui.refactoring.IRenameStrategy; +import org.eclipse.xtext.ui.refactoring.ui.IRenameContextFactory; import org.eclipse.xtext.ui.shared.Access; +import org.eclipse.xtext.xbase.ui.DefaultXbaseUiModule; +import org.eclipse.xtext.xbase.ui.editor.XbaseDocumentProvider; +import org.eclipse.xtext.xbase.ui.generator.trace.XbaseOpenGeneratedFileHandler; +import org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelFindReferenceHandler; +import org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelReferenceQueryExecutor; +import org.eclipse.xtext.xbase.ui.jvmmodel.navigation.DerivedMemberAwareEditorOpener; +import org.eclipse.xtext.xbase.ui.jvmmodel.outline.JvmOutlineNodeElementOpener; +import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.DefaultJvmModelRenameStrategy; +import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelDependentElementsCalculator; +import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelJdtRenameParticipantContext; +import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameContextFactory; +import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameRefactoringProvider; +import org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixes; +import org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixesNoImportSection; +import org.eclipse.xtext.xbase.ui.refactoring.XbaseReferenceUpdater; /** * Manual modifications go to {@link ExpressionUiModule}. */ @SuppressWarnings("all") -public abstract class AbstractExpressionUiModule extends DefaultUiModule { +public abstract class AbstractExpressionUiModule extends DefaultXbaseUiModule { public AbstractExpressionUiModule(AbstractUIPlugin plugin) { super(plugin); @@ -54,6 +88,16 @@ public Provider provideIAllContainersState() { return Access.getJavaProjectsState(); } + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Class bindXtextDocumentProvider() { + return XbaseDocumentProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Class bindOpenGeneratedFileHandler() { + return XbaseOpenGeneratedFileHandler.class; + } + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 public Class bindIProposalConflictHelper() { return AntlrProposalConflictHelper.class; @@ -95,11 +139,6 @@ public void configureContentAssistLexerProvider(Binder binder) { binder.bind(InternalExpressionLexer.class).toProvider(LexerProvider.create(InternalExpressionLexer.class)); } - // contributed by org.eclipse.xtext.xtext.generator.exporting.SimpleNamesFragment2 - public Class bindIDependentElementsCalculator() { - return DefaultDependentElementsCalculator.class; - } - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 public void configureIResourceDescriptionsBuilderScope(Binder binder) { binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(CurrentDescriptions.ResourceSetAware.class); @@ -135,4 +174,82 @@ public Class bindIContentProposalProvider() return ExpressionProposalProvider.class; } + // contributed by org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 + public Class bindPrefixMatcher() { + return FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindFindReferencesHandler() { + return JvmModelFindReferenceHandler.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindReferenceQueryExecutor() { + return JvmModelReferenceQueryExecutor.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIDependentElementsCalculator() { + return JvmModelDependentElementsCalculator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameRefactoringProvider() { + return CombinedJvmJdtRenameRefactoringProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIReferenceUpdater() { + return XbaseReferenceUpdater.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameContextFactory() { + return CombinedJvmJdtRenameContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameStrategy() { + return DefaultJvmModelRenameStrategy.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindJdtRenameParticipant$ContextFactory() { + return JvmModelJdtRenameParticipantContext.ContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindOutlineNodeElementOpener() { + return JvmOutlineNodeElementOpener.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindGlobalURIEditorOpener() { + return GlobalDerivedMemberAwareURIEditorOpener.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIJavaSearchParticipation() { + return IJavaSearchParticipation.No.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public void configureLanguageSpecificURIEditorOpener(Binder binder) { + if (PlatformUI.isWorkbenchRunning()) { + binder.bind(IURIEditorOpener.class).annotatedWith(LanguageSpecific.class).to(DerivedMemberAwareEditorOpener.class); + binder.bind(IDerivedMemberAwareEditorOpener.class).to(DerivedMemberAwareEditorOpener.class); + } + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindJavaTypeQuickfixes() { + return JavaTypeQuickfixesNoImportSection.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindXtextEditor() { + return ExpressionEditor.class; + } + } diff --git a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/contentassist/AbstractExpressionProposalProvider.java b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/contentassist/AbstractExpressionProposalProvider.java index 7a2df94b23..0cc90612c4 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/contentassist/AbstractExpressionProposalProvider.java +++ b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/contentassist/AbstractExpressionProposalProvider.java @@ -8,16 +8,16 @@ import org.eclipse.xtext.Assignment; import org.eclipse.xtext.Keyword; import org.eclipse.xtext.RuleCall; -import org.eclipse.xtext.common.ui.contentassist.TerminalsProposalProvider; import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext; import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor; +import org.eclipse.xtext.xbase.ui.contentassist.XbaseProposalProvider; /** - * Represents a generated, default implementation of superclass {@link TerminalsProposalProvider}. + * Represents a generated, default implementation of superclass {@link XbaseProposalProvider}. * Methods are dynamically dispatched on the first parameter, i.e., you can override them * with a more concrete subtype. */ -public abstract class AbstractExpressionProposalProvider extends TerminalsProposalProvider { +public abstract class AbstractExpressionProposalProvider extends XbaseProposalProvider { public void completeLetExpression_Identifier(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) { completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor); diff --git a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/editor/ExpressionEditor.java b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/editor/ExpressionEditor.java new file mode 100644 index 0000000000..55508cb359 --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/editor/ExpressionEditor.java @@ -0,0 +1,13 @@ +/* + * generated by Xtext + */ +package com.avaloq.tools.ddk.xtext.expression.ui.editor; + +import org.eclipse.xtext.xbase.ui.editor.XbaseEditor; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class ExpressionEditor extends XbaseEditor { +} diff --git a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/internal/ExpressionActivator.java b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/internal/ExpressionActivator.java index 74eb087969..04fe26d6e3 100644 --- a/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/internal/ExpressionActivator.java +++ b/com.avaloq.tools.ddk.xtext.expression.ui/src-gen/com/avaloq/tools/ddk/xtext/expression/ui/internal/ExpressionActivator.java @@ -5,10 +5,10 @@ import com.avaloq.tools.ddk.xtext.expression.ExpressionRuntimeModule; import com.avaloq.tools.ddk.xtext.expression.ui.ExpressionUiModule; -import com.google.common.collect.Maps; import com.google.inject.Guice; import com.google.inject.Injector; import java.util.Collections; +import java.util.HashMap; import java.util.Map; import org.apache.log4j.Logger; import org.eclipse.ui.plugin.AbstractUIPlugin; @@ -29,7 +29,7 @@ public class ExpressionActivator extends AbstractUIPlugin { private static ExpressionActivator INSTANCE; - private Map injectors = Collections.synchronizedMap(Maps. newHashMapWithExpectedSize(1)); + private Map injectors = Collections.synchronizedMap(new HashMap<>(2)); @Override public void start(BundleContext context) throws Exception { diff --git a/com.avaloq.tools.ddk.xtext.expression/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.expression/META-INF/MANIFEST.MF index 9b40ba377a..8a9d12bcb7 100644 --- a/com.avaloq.tools.ddk.xtext.expression/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.expression/META-INF/MANIFEST.MF @@ -6,8 +6,8 @@ Bundle-Version: 17.3.1.qualifier Bundle-Vendor: Avaloq Group AG Bundle-RequiredExecutionEnvironment: JavaSE-21 Require-Bundle: org.eclipse.xtext, - org.eclipse.xtend, - org.eclipse.xtend.typesystem.emf, + org.eclipse.xtext.xbase, + org.eclipse.xtext.common.types, org.eclipse.xtext.xtext.generator, org.apache.commons.logging;resolution:=optional, org.eclipse.emf.codegen.ecore;resolution:=optional, @@ -23,8 +23,10 @@ Require-Bundle: org.eclipse.xtext, org.eclipse.jdt.launching, org.eclipse.core.resources, org.eclipse.core.runtime, - org.eclipse.xtext.xbase.lib;bundle-version="2.14.0" -Import-Package: org.apache.logging.log4j + org.eclipse.xtext.xbase.lib;bundle-version="2.14.0", + org.objectweb.asm +Import-Package: org.apache.logging.log4j, + org.apache.log4j Export-Package: com.avaloq.tools.ddk.xtext.expression, com.avaloq.tools.ddk.xtext.expression.conversion, com.avaloq.tools.ddk.xtext.expression.expression, @@ -37,5 +39,6 @@ Export-Package: com.avaloq.tools.ddk.xtext.expression, com.avaloq.tools.ddk.xtext.expression.scoping, com.avaloq.tools.ddk.xtext.expression.serializer, com.avaloq.tools.ddk.xtext.expression.services, - com.avaloq.tools.ddk.xtext.expression.validation + com.avaloq.tools.ddk.xtext.expression.validation, + com.avaloq.tools.ddk.xtext.expression.jvmmodel Automatic-Module-Name: com.avaloq.tools.ddk.xtext.expression diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/AbstractExpressionRuntimeModule.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/AbstractExpressionRuntimeModule.java index 25ba3cbefd..fc4fd82a4d 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/AbstractExpressionRuntimeModule.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/AbstractExpressionRuntimeModule.java @@ -3,6 +3,7 @@ */ package com.avaloq.tools.ddk.xtext.expression; +import com.avaloq.tools.ddk.xtext.expression.jvmmodel.ExpressionJvmModelInferrer; import com.avaloq.tools.ddk.xtext.expression.parser.antlr.ExpressionAntlrTokenFileProvider; import com.avaloq.tools.ddk.xtext.expression.parser.antlr.ExpressionParser; import com.avaloq.tools.ddk.xtext.expression.parser.antlr.internal.InternalExpressionLexer; @@ -17,6 +18,7 @@ import java.util.Properties; import org.eclipse.xtext.Constants; import org.eclipse.xtext.IGrammarAccess; +import org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider; import org.eclipse.xtext.naming.IQualifiedNameProvider; import org.eclipse.xtext.naming.SimpleNameProvider; import org.eclipse.xtext.parser.IParser; @@ -29,6 +31,7 @@ import org.eclipse.xtext.parser.antlr.LexerBindings; import org.eclipse.xtext.parser.antlr.LexerProvider; import org.eclipse.xtext.resource.IContainer; +import org.eclipse.xtext.resource.ILocationInFileProvider; import org.eclipse.xtext.resource.IResourceDescriptions; import org.eclipse.xtext.resource.containers.IAllContainersState; import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; @@ -39,20 +42,31 @@ import org.eclipse.xtext.scoping.IScopeProvider; import org.eclipse.xtext.scoping.IgnoreCaseLinking; import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; -import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider; -import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; import org.eclipse.xtext.serializer.ISerializer; import org.eclipse.xtext.serializer.impl.Serializer; import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; -import org.eclipse.xtext.service.DefaultRuntimeModule; import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.validation.IResourceValidator; +import org.eclipse.xtext.xbase.DefaultXbaseRuntimeModule; +import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator; +import org.eclipse.xtext.xbase.imports.RewritableImportSection; +import org.eclipse.xtext.xbase.jvmmodel.IJvmModelInferrer; +import org.eclipse.xtext.xbase.jvmmodel.JvmLocationInFileProvider; +import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider; +import org.eclipse.xtext.xbase.scoping.batch.IBatchScopeProvider; +import org.eclipse.xtext.xbase.typesystem.internal.DefaultBatchTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.DefaultReentrantTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareBatchTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareReentrantTypeResolver; +import org.eclipse.xtext.xbase.validation.FeatureNameValidator; +import org.eclipse.xtext.xbase.validation.LogicalContainerAwareFeatureNameValidator; /** * Manual modifications go to {@link ExpressionRuntimeModule}. */ @SuppressWarnings("all") -public abstract class AbstractExpressionRuntimeModule extends DefaultRuntimeModule { +public abstract class AbstractExpressionRuntimeModule extends DefaultXbaseRuntimeModule { protected Properties properties = null; @@ -140,18 +154,13 @@ public Class bindExpressionValidator() { } // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public Class bindIScopeProvider() { + public Class bindIBatchScopeProvider() { return ExpressionScopeProvider.class; } // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 public void configureIScopeProviderDelegate(Binder binder) { - binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public Class bindIGlobalScopeProvider() { - return DefaultGlobalScopeProvider.class; + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(XImportSectionNamespaceScopeProvider.class); } // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 @@ -184,4 +193,46 @@ public void configureIResourceDescriptionsPersisted(Binder binder) { binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); } + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public void configureRewritableImportSectionEnablement(Binder binder) { + binder.bind(Boolean.TYPE) + .annotatedWith(Names.named(RewritableImportSection.Factory.REWRITABLEIMPORTSECTION_ENABLEMENT)) + .toInstance(Boolean.FALSE); + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindILocationInFileProvider() { + return JvmLocationInFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIGlobalScopeProvider() { + return TypesAwareDefaultGlobalScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindFeatureNameValidator() { + return LogicalContainerAwareFeatureNameValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindDefaultBatchTypeResolver() { + return LogicalContainerAwareBatchTypeResolver.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindDefaultReentrantTypeResolver() { + return LogicalContainerAwareReentrantTypeResolver.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIResourceValidator() { + return DerivedStateAwareResourceValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIJvmModelInferrer() { + return ExpressionJvmModelInferrer.class; + } + } diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/Expression.xtextbin b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/Expression.xtextbin index 65b9ee2f3144966e25c0802d4e69100c94e6cf69..d7cde0ec1ba3bba4ae82e0ea163d08ca5a808f1b 100644 GIT binary patch literal 21273 zcma)Ed4L>6^-fLC%-)+Dk^td8a_xr584}W0by!HUF&mP_0AaG*n+%!EE;F+^2)6>F zqJkWX{!|o1ML`rrb{)wwF% zHq_cNt93$JsYA9@DkF=#yLar^(G?C9@+0N2Yq+$zd(py$Cv^8$!kv}>fh5(fnwOVy z+qUIOsZ24qEj)T)cw1L)d#*5iURPy!xKQpI9NgNqlj6FKHAD zgGNR-qHQ`XIbz4};Z5tj83t5$(h9_Yu zEDnT&E91whmT+}$U~6u3*pxbA4~~WJ>D)!#dSJK|{;y=+szn>o6H=*eE1N6ibLDJE z8OmxKDCFSLp?p|sPNiD4pR42udP1tTyIc2FO8MeumF~zDDq*RZtK_$bt_dbx=x8u;%O` z3M8JpC7#jC&{XI`2ZQMlFr^pnl?h#I+ib$~FgWpG>+qD-q&>#Zg!I(z?ncsvusMRBI}%Q}j#6zcRN>_c zg-nLZ=cv}yZ16)ph5)o;{(Lk<)OU>DxuSAj%9@ZqNObL)R;A}t%>vcl<{-8=7a5J2 z=AkfG87+mX_)2hRfw@2h9j|x9DC--RKp@PL-|l9j)3j zi(o?M>qpTE(3b{R!3^tlU^@ma(`3cH4dHw&p&bW?dPICQ}H9Dz?oK%c*R(l;6Ci zVmrJ&Un$#Fof+HX9Uj>}FW!L1niq#DJK*m|JXo$Wsnpy|);@&{J$wvl_Nly}oYVMt z1@9MLq2z&Xn`_N&a!?M?^tks4=eK0@3z6aG^ z%06AZqg19nS1b-!qK=WW*QtqZPW3@F*tYa;4@;%|U>M0=Pr1v0y&rNRY>BeZQ0vYumD*XIj^ z9QztrbHZwGV!Z4p@iHzUL=UiG?LjrE$r)hxkHXEyxQy;)Z-QHg=(uId-pp3Puwrjv z{MdO|)jojnqEgD`G1NwOol9_A8Hlj!^bth3J3Lw(wCqA8a2pX#5=6DPfKe2g!%)?X zX*MhlmX$pM4V{%_7tEro*yo8GB5#*ed;JhMcN|P*VyXbs)H+N~aWDk1Q3DJhwhM?I zwD$;Q?;KzKu9|vfpD!G{$92U8RC}Ru#fsq_RaaaTX}q}RirQPCxI|=L3KZG$C>*Hl z%f?6Y#u^g)O>hLld2EARP83%d<7;}1@mCrsQ2S<4dzCT%E#s?vYfWX;kMOVkwzw-@ zP3HN^emj^O1O6Svv4Q08B-P2vz9wQz+t;e5h8}3YOTb*GCS~mFBZxQ9TQekZdWyxc zR2T4=c2V`a0W2DP8A$I@9U1#35zhhQy+C+8soocL;f(!% z)h_)0aV+|PvB>^lZ2!&1{tt~q{o$(pw?y_s6P4X6%p57~kBHH?(ddsxMt_V(A1FpI z4`FnEz$uk-yBcio#H2bhT*M5+7fq?9%KkXD-Okt(1{Y)W*055x>`y?jjPmv;McW+& zvq9N+^7pI=ld?ZW_PfA7xjz^!%D7;3TK1ybL#_avt02Qbsq82B)N{W^ii$Le{dG2F{nT!M zquP|;6d2zU#rC&j2Y!d1!Cdy;2oO{~1u3)Yq^!?Zw!|}oWq+?K@%z$*PlI!jvVUL% zJ;UF*0Cc?lEF?|r??Kp=Dt(~@h-LpUij3zN8Iutib+6&A=V|G@%+$QFB~#95?)VW6 zegTrF8rB4fW&b#m{u4@{UX`98frg(7?4JQ=Q=~-MKgZOWwts;a8T&=FL{piw`9RiM zh7sT;QbrHpo?jB*vP`Q?KrHbhqF;fi_6&5thM0~>ev~3gyZ?rx$!`G?)8_9OGE=1A zMgSu^3^Ko`jemfR``5KYPq9y6MJ}`Km#Z!DM>gj?%(s7%X0-pzM&MwEKl?9|7yK1? zT6UO3Aj14NQlY8rSMaWFTexjgSYkpbNdGR9$p4RVE%_%c`IoT-m|q3`B9i|bzV94MrmJA^tNlys7);?C(5=@TjD zNaak5rB4>=Q;hVfYBETtQRs9Lx{rCm>I{4oI>QK+yUuB8XC{nlbyl6Rv3Kn$dX44G zs@k<5#i?xC*&n&La{$Vs%>PtNacuzgkTaXbl$EV;cvQzU*{*XSLZ-bxvE<+!1Z~d# zmUA#-Ez^k(QG2P<&LLWAM}n24^%JyOXamwN2ko?eeIARp%C02CDG7!iVK|ixr-5Og{xxAiN|Ib5$+9BB zvQk)9k);Jwzn;9#CBE=h*935L^!VI3LPgJD+x z%F#k4KT=>V)xg%DU^_$DSOYn%fhP5zUd)wtMd&c@S`JH}I8LSban1%y+S$lBJ;%Jv zF-|ecHgKciHZ{iT0AqEKe2i6uV@TaY(B0fSBFZgiGhRo5xCMcjcJd66gOzhGe-|ic zD}U!PzM!E%4N|}t2PJB@MaJM&kypbIJ*D5vl~GbAoi~y&>^$*8iR5J=Up-u|4CQww z{7^}dj|%yAlJ5Zd)c%z+tS7pY0-D;Iak1OCL0pT z;=C)_Ja48LG|yEWN{~MwAxj8Co4p0lI1f2*jZ&+O^R_racdmw5sTJc|I!Y^@w}Xde zhw~1T7CBOW%va7ed*Ha%a46?pZ19u8dtIb2?OdnoKR;Z6p7zLG#nU&$=&+&}?G zLBNfsbaq&PG*m{;d+70-;PKA>zAeb7yuxr9i$s?5-h{hRlVCFZKU7K(<-8wvY3BoU z{s#@w&2)YnogcA7>xUxPmh)j~ojE8=eBod)T-uf^RI^y)r&|c(R)z`O-aukGA2CgH z8=D5n*H{`1fgcr!AB&QxPRZ}Njuz+O4r>x*_|EM>Q%#qhPv9x5F19O5l4$CesswFx z=YI#zQU$=teix`G#tqW9t60hHjN0MTY=;Yk<};va1C3e4m*~5jA`awh2tnBbM}H1v zjqP-gA#*+-!@QSr0rLyvP~TS*>fBE{)F{paCc~^>400YM?L%;WOWb;v^Khc^zX(hj z=MmHRj|#%a*!W+H8y~X2OeHL^oyVo!B~Va=z?vuGK=>+v{+B>_l33tR=WDT*UpH2M zwhHYQ6f%+xUfzl+?x}%h@gv_dJRo% zcZ%F`w+J(ZI}PAFd-j zW)oG|Bf^6N##b>rR&gNtMa4l4Dh@U(Ao~y!!Rv=|K*LJ?01B6=AGwEt$~_#OY-Rd` zEyYsBa*t5bYuzL1s&>v&<`q186kuiCIrJ!ZSkSp$lvwUOGgh()T0V*;ZZUH{q$7CU z1tuEZE+ENJy>h#OS1yHeVT{&gU17P4#Cnz$u+BY(v`C4ILVIkL_BcFmAHod2b_+KA zHgA!x<{nS3`3w~NxhF)r)9#6Q+>Bk?9Fkt;NjG&Q{f-&Sia(aa|KM9`4evPnYS4$PMV(Sq#E)r9t^}DDNmI-YWML z;z5F<+#Z0=%A75brPg3Hokof|%3Xo?4MVlNGWHtiSZTPdG&=f|38|Z?E?ia@S$7Rl z_o=9%*An$apiVGB8p;aR?-_R;)h|)*dZ-^Ky>t7amg${~ib7Hc_YLHjuiOoL;5gH8 zDEBN)jSyf`Qgkbq z`z2=O9-f8#&2hYJLHejN`(WykoUxkcS2IReY7R7rd#=eC-K_vOeW+G4*XOrx0mzU% zDtDWNcX993!=z@jj>PUd&$tU4DSK1HEfh1JyA`r^MHC9r(qfhV!ie6zh+)G;z%eu!PcD|$xP*c( zg`oESzOYi2aG8@K`YXQ9jo+{U{zso?nF77mmw*Y^= zfWLv@Z;UAc{@n)rd-%ISxi`h&-#Zr1`(p4YG@|bGesZBZePAr{2W#ME<0GEZ-4F4_ zL(1irhkFa`nAGp$7)_WfR-5702%y6mRkl4`ZhN@g_Tc!>eGjSZ>-k{K$E9&^2dXSa zX^#4z0J5fhd2MMl%8T4j;$^0STZud6-a#050>;GtRij)8t)lo;0>xd@e?CnVpD`%z zCJHWO*RcV_XQ8sTVB~&|3hse|rijpTKMx7f&~UHd{Q@cO!*XHz6y0yR_g7y(0Ig~F zK_QY2jDzAw+8=6ylAvQ@Ama=db%5uZLQ6hEX3o}&wTaJ0sKUeQDDk5Z`#sU{rr z=_yta3NHx5j|u-Llt^QL$_pC%Gdcqc!|u=d{ulB47vuLY@dD-%)i0^-SJ2k%Yp-Xe zv%+$JEgG@T=>A5W{@VzUixio2P1^mv;QRxnAgo^IuZE~U#v}2c_+*}P|IFV7c=MM? zf^z>Fll)EazaoPEPBM59=`YeekpB~pGw#253lF}^-yY@uo4La zP2NFNb+A!&NNh-g35pJdAx+FjhvE3c=;5Q3cQ~|Hi!1L4qz>MZ6f@gG^m;gGBx_dQ zoG4SCl;Z}jpT|)U?l46;vo{x1*sfLHJPO6!8lh*h>n#BK&i@6WNFGbc;Lo98;OxI(kJGCDRODl$lN0O!_l3Y)cT+bxA9+TXx$0XO& z#xO~8Iq#1V1l-GERC;K*q&$<>dQ57^R#ToNx2UE(Np4x{cua3Q!CONncElO3w<>BE zuNQO^!(6gF6vEXtgT2?&-ZijyM!%aY=Lg1MwLFvla{BYu!pt`Bbeg%&n7N+q$6S7V ze&Fq|+Iog*$~VN#!o+t{zL>AnY%x*B)R#4|cNS?el6q&8dA{;C?vdvl!vn4yiBD1< z7S}n(G*koLfN_C0Xz0Qi(Ga9h866qK@v1SHHpg6BVoZ_(1Jk*C;o54rfT}=kh}LZ& zAFpL(H6CHjR%ZI^ji6;F_pjfQ$L>^h9nkX5OLVD{j0j~miCKX6M%g4>+iqZl)a^i! z-9dTE+d(wwSUZ8HwR)&bLWJjrqywFA5bp*}X4CNCE_r=H)g(VAj~Z_Ynfua2h!w7sr4yP0@i8<>4d{qCY)#C|@e$ z=tE_7;^bf>IGzwvnf%Z22AjQ61g$`1o&#=C_mZ#9nk z2vHsYlzS8bO}7DVx>DMuypN9Ku#Xu`o@CPA?NDNQ$f22Mc3{_TU<;1Z;yAk*Gd@Y! zcK~(=mTamoE$>c)=u*@-pcR!w*od)j#V!^2K z;5Z(72y~{^l=pBvh<#CPX~v0swwdxC0p}ERSBo?0%8ynBc#jFpFF{+4lgEYjz{#^i zv1;Xg1$W*P@W{-5tfFC4eM?wwSR?Yjnh2ODp)Bov&A9pNku2{Uk*N}e%KN5CqP=ek zvTsKVO5S&Hm+`*KSbNGyoTIXBIXSz`C1;*0^S&p^A_-&73-6_(yPJ!ZV$QRWimarJ$iwJVS7@Lap{UXG`}KavAeA6MYVPmj&PCO2nn$3O&jo;beb$=qf?n@aItr+@~ zq1B&)zT4V6VuV@#R5Xh$3;5I6llQH2ExRV4V7)@(SKReEDnm3j%ak!k#v$AGBQq@LnqCJlW+(_4vtvbM=;7no!8$0}#rzX#$6|6AJ5HhD1sza_k9Ce4iEVOK`-A6=u;X&_Ym}{3DBnz^oq#&ayZEHS5{%K z0_;}5mrh@Bvhr8sBHh)sMEP99xBNA<2haOR(1o$lUu&-X(|Lhoxc)k!TyH4*#Sdo~ zBT%eB$_Df9%;*W1Mak+Gu)fx-GF%~<;D`Y%MZ;HF2EB49&P63 z5}?__i)EaXEK>-uvUFMWn&tC=eOg6P8ny9^uhrGh`q1{g67a2`7a&ZhVG;A@B+ zKC0_YRO^^V!)l!&9is#+ZFxhAr3BzC15T}9Rse(j(jOJg+l}TOa<`M3&BD1qUc8>) z*z~*E^m5Y2#4GCypY;U>Cl6=Gkz80l%Zg}lx&+?N_?OaSCu6X?Ow_&+w`>Yl5EufL ze>pGU*(;(Kk<*la<+zT0GacI-)5!Wc>QDbI#xfk}!QIM=TsV(RyG~5I9+0i2Fzp6j9E^(_agkoiNAKpPZl|W?5 zM~MB1BVw4hjSKUmgt^?n{8$Y0;|8WA|NbWk^OJjlc}FA6I|=hssnC1ey;~A9kX97M_d~xQz;><4)<$ZfW$?pW}g5v?A zd@zBMiM{_YP#vBUuzgUI)2;!sJf0Ur-As8Ox#R6P>i5GKm@nv3gIoZaqD_X77)_gd#6 z=PBnV?+I^#+w30hE%VlRBi=>MtIqSzPn=u5&$+!$x4X%?*uBMTcklG3c?Wn`dpCMF zyUV;g7PAbguGL$}1e%WW`87gY?V;tf z!0>-y`TP_i+kx$c>Hw_L{_`@K{D{Hu0)t^im{=;a{2v=$erS-zB5K`hu>TYd+T{NX z2Br&PMfpERv$f&#KRNRpmL%`^1%>{~`;|_e`v9)<(=c z-NRP;2WaJVkN+B!Spx-{rzfzPumOX)vc{-1_dzn;_*B}$Wg1H`aDYzJNgI^TKteh{ zc(jPfLbYyUGxXuOcp((Ey1AxSqa4Usx|M44gR+6Ex%Yv#Q@Y&@m%0P88O)k#f0b^c zp_BfrCsF@dyw*(pp;fNA^?`K;Jr$gZw$szdjK;;Eo=*CGfN~N(rp+f8t@OSI>T@cs zQ3n9(OcKum@f0DhJ20YI7f9HHe1CD@0VJPI=O;H1PTOJW10z~}5L*rlILY^5M+uP0 zY9909hJnU8pG@n(aFM6M@m&nthv$5NL}|>_h!E@(D9x0=g_l^bs0h`OF%?ev>~Y;J zrRRuob16yo6Esf$aI-u*KO~a48A5&Xrx)<9i%v@dUt7vsnx9I?URWq{k0$XV5O>ra z;McE9P@*V+dyggMaiHw1KfkY8AjCpX5K?Z4=*1wNf{%6z`LJ9YWGsDBf_#aPFD3cO zAfG<&;eEXA&f$TJckrMl1?NPH%Ur;I)KuFp!4pAGd*dLzmC zRdsW`NvLzi7JfyY#aH*{1*{kVOI8n(B?QaF`eO=~9x|Mp$%zvL_3t47CxLi&GaBjg zV*k0YJ36+Yx8gDz9dBT?>jD*RqatjRhns6B7vPm%oU zK=Z4E_QYPTrMcaK_|V+$$l`cR;w6M_PYUB!M|D?M@1(q4l(#0#RX2?F`9|JuBQNn1 z@-9fqV^N|n!j^qzjmCbxW<3(kmiiJzYFb~aIvc8#Xx>5A!GipdkxTUOM<={Qp{d6bibW4-$5rN zjs1qz*djd4QaCFEU;*3am7k@Y&lsp~P8=I763UJcS4;D?O95ddnP=iOkG=}OM` z9HsP4GSH%z@_bKS_jw;lG3n^|bdNTtdo)k?)RA(xBATD{&GegWN$U?$Gxxt`K$hC% z6^Ofq*!k_i^x8z7925BU08QZ616iDO9*+vveH7MZ^~dV0<0eImz8w&n2cqL(N`C@( zO=bKKF9XN{K8c(5=qBKfjM8`TbtyboUf;=^a3|7*veKWzO)LI42W{@};>$9=xWG9y zjlGIY6Lx?dIi{e^W`({x_9iPAbR@~mGz%7S`aR&{VRrp_z7BVeh-dDN9sLEqj(m3? zope8)#4Myw;3u8*fN|1;#!2H*skDAbLV%w**FpeW6PY$POC%L&9-&^u!lR_CHrQi? z#Rg+F6Tw1f&|fC9#~HPW^JJF(iUIV5iQ2?V;P|TGcoIdK{#r~3SyJchR{9&U+r9|| z^@rXxzf+bl#O8ynZRzh2&wQo7JC^tCqn;T>K;; zyFbH@|5ruzbEX<8%y|~(So(+1AYUoz=jt5yJk^^ajnb?nYOQK&2(kA?Dt!q`XCSf4jkgh` ze;HZpGgbT*#HaPIA)Y~C3JEQBM0~bH|1MhH%IM#NxJmzkE%~zX*y_6VV=dbf7*gv# z4A9(+kUn541^w5!&G}(K-Dtv31Ej_O9=Et0ib9KHC!(HIss%}mwVaRwUj1(|=RZXF znn8F?9l}5kOLeJ0C7UfsQ7z(K1r}`#(vT2jjD!d4C1mL=NWgYNtqp=^Jgw_lK}+P+ zfF(nzNsSYY#@p&OPBI!N*J+%>0WX+}chvzen1;J}zze41 zrf$FsxOor{c)`BBF#}#O12>5QFPO=fX21((@uoW91^eL^(GuVz0j^M30lyQ72fSdm zY3xA04#0pH@Z*4Zzzg_g02?@9!B8Dp==nqO1}Pga4~rT<9UM-t@QZ+GUdx(TY2uPg zaAci3j$&#Q%%Rk|DqwwpiXXCA9wb97km}%6>cQIuv8FC+GW7sv(0WY^>omzn0>L6` zn5Tl*@s~+xzz+rLG)akoNaJ5{T&(GMYC0jZDL9cM4vK4&_El$e2<0XT7lDJtkX!v< zN;qo-C&AXHU5Mu;y70mK6V0eV8nME@S8_3{Es)T%=ph7Vd$v-WYzk>3)hk$ks zPE5*QHAcQ{EpYWRSY0pr^%T9>h+Y$m?xX0nPMPD0n zdXuo)N(}gHHYkvYW79TX>{daMTc>j~nE`w~BWoW44@d<(AeF(oP-q1_6h&Ai!oo3K zJ_VFApk#sy#0aknMxnRnH&MGiR?9j8%U1!9L^T@+3Iz{D5g7jh9*Sy?KcxwF8y*%2 z?dECKASo1R&_$$@gn$w*j$`E#Ht3}W`DH|oZ^RpxR`7q5$pIc|V%84a<_hqiC}Hr& zfBzx)E+;;;Z}b=N|4{0TzADwx|7u_bR~jvErWV!;^3kbz4M$ytE}af|S_-3M@K*f7 zy8%y1$-Lyh;J>W*(X(`yo*fJXBYKfOPA}FcYgY&QRJ}^~>ofH^I@H^AS?|(U>5KGB c`UU+CeVu+>KdtZAxB9R6uj(dD!zoMsKi5dg=l}o! literal 6926 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 F{{yTc03ZMW diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/ExpressionStandaloneSetupGenerated.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/ExpressionStandaloneSetupGenerated.java index 7492f2be62..9e8f6eb3a6 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/ExpressionStandaloneSetupGenerated.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/ExpressionStandaloneSetupGenerated.java @@ -7,16 +7,16 @@ import com.google.inject.Injector; import org.eclipse.emf.ecore.resource.Resource; import org.eclipse.xtext.ISetup; -import org.eclipse.xtext.common.TerminalsStandaloneSetup; import org.eclipse.xtext.resource.IResourceFactory; import org.eclipse.xtext.resource.IResourceServiceProvider; +import org.eclipse.xtext.xbase.XbaseStandaloneSetup; @SuppressWarnings("all") public class ExpressionStandaloneSetupGenerated implements ISetup { @Override public Injector createInjectorAndDoEMFRegistration() { - TerminalsStandaloneSetup.doSetup(); + XbaseStandaloneSetup.doSetup(); Injector injector = createInjector(); register(injector); diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.g b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.g index d43b101b82..9f6c64d56c 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.g +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.g @@ -1879,7 +1879,7 @@ ruleIntegerLiteral returns [EObject current=null] $current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.INT"); + "org.eclipse.xtext.xbase.Xbase.INT"); } ) ) @@ -1980,7 +1980,7 @@ ruleStringLiteral returns [EObject current=null] $current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.STRING"); + "org.eclipse.xtext.xbase.Xtype.STRING"); } ) ) @@ -2773,13 +2773,6299 @@ ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToke } ; +// Entry rule entryRuleXExpression +entryRuleXExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionRule()); } + iv_ruleXExpression=ruleXExpression + { $current=$iv_ruleXExpression.current; } + EOF; + +// Rule XExpression +ruleXExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + { + newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + this_XAssignment_0=ruleXAssignment + { + $current = $this_XAssignment_0.current; + afterParserOrEnumRuleCall(); + } +; + +// Entry rule entryRuleXAssignment +entryRuleXAssignment returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAssignmentRule()); } + iv_ruleXAssignment=ruleXAssignment + { $current=$iv_ruleXAssignment.current; } + EOF; + +// Rule XAssignment +ruleXAssignment returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAssignmentRule()); + } + } + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + ruleFeatureCallID + { + afterParserOrEnumRuleCall(); + } + ) + ) + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + ruleOpSingleAssign + { + afterParserOrEnumRuleCall(); + } + ( + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + lv_value_3_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + $current, + "value", + lv_value_3_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + this_XOrExpression_4=ruleXOrExpression + { + $current = $this_XOrExpression_4.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpMultiAssign + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAssignmentRule()); + } + } + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + ruleOpMultiAssign + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + lv_rightOperand_7_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_7_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) + ) +; + +// Entry rule entryRuleOpSingleAssign +entryRuleOpSingleAssign returns [String current=null]: + { newCompositeNode(grammarAccess.getOpSingleAssignRule()); } + iv_ruleOpSingleAssign=ruleOpSingleAssign + { $current=$iv_ruleOpSingleAssign.current.getText(); } + EOF; + +// Rule OpSingleAssign +ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } +; + +// Entry rule entryRuleOpMultiAssign +entryRuleOpMultiAssign returns [String current=null]: + { newCompositeNode(grammarAccess.getOpMultiAssignRule()); } + iv_ruleOpMultiAssign=ruleOpMultiAssign + { $current=$iv_ruleOpMultiAssign.current.getText(); } + EOF; + +// Rule OpMultiAssign +ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='+=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + | + kw='-=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + | + kw='*=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + | + kw='/=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + | + kw='%=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + ) + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + )? + kw='>=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + ) + ) +; + +// Entry rule entryRuleXOrExpression +entryRuleXOrExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXOrExpressionRule()); } + iv_ruleXOrExpression=ruleXOrExpression + { $current=$iv_ruleXOrExpression.current; } + EOF; + +// Rule XOrExpression +ruleXOrExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + this_XAndExpression_0=ruleXAndExpression + { + $current = $this_XAndExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpOr + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXOrExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpOr + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXAndExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXOrExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAndExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpOr +entryRuleOpOr returns [String current=null]: + { newCompositeNode(grammarAccess.getOpOrRule()); } + iv_ruleOpOr=ruleOpOr + { $current=$iv_ruleOpOr.current.getText(); } + EOF; + +// Rule OpOr +ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='||' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + } +; + +// Entry rule entryRuleXAndExpression +entryRuleXAndExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAndExpressionRule()); } + iv_ruleXAndExpression=ruleXAndExpression + { $current=$iv_ruleXAndExpression.current; } + EOF; + +// Rule XAndExpression +ruleXAndExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + this_XEqualityExpression_0=ruleXEqualityExpression + { + $current = $this_XEqualityExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpAnd + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAndExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpAnd + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXEqualityExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAndExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XEqualityExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpAnd +entryRuleOpAnd returns [String current=null]: + { newCompositeNode(grammarAccess.getOpAndRule()); } + iv_ruleOpAnd=ruleOpAnd + { $current=$iv_ruleOpAnd.current.getText(); } + EOF; + +// Rule OpAnd +ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='&&' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } +; + +// Entry rule entryRuleXEqualityExpression +entryRuleXEqualityExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXEqualityExpressionRule()); } + iv_ruleXEqualityExpression=ruleXEqualityExpression + { $current=$iv_ruleXEqualityExpression.current; } + EOF; + +// Rule XEqualityExpression +ruleXEqualityExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + this_XRelationalExpression_0=ruleXRelationalExpression + { + $current = $this_XRelationalExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpEquality + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXEqualityExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpEquality + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXRelationalExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XRelationalExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpEquality +entryRuleOpEquality returns [String current=null]: + { newCompositeNode(grammarAccess.getOpEqualityRule()); } + iv_ruleOpEquality=ruleOpEquality + { $current=$iv_ruleOpEquality.current.getText(); } + EOF; + +// Rule OpEquality +ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='==' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + | + kw='!=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + | + kw='===' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + | + kw='!==' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXRelationalExpression +entryRuleXRelationalExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXRelationalExpressionRule()); } + iv_ruleXRelationalExpression=ruleXRelationalExpression + { $current=$iv_ruleXRelationalExpression.current; } + EOF; + +// Rule XRelationalExpression +ruleXRelationalExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression + { + $current = $this_XOtherOperatorExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + ( + (( + ( + ) + 'instanceof' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), + $current); + } + ) + otherlv_2='instanceof' + { + newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + (( + ( + ) + ( + ( + ruleOpCompare + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXRelationalExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + ruleOpCompare + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + lv_rightOperand_6_0=ruleXOtherOperatorExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_6_0, + "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + )* + ) +; + +// Entry rule entryRuleOpCompare +entryRuleOpCompare returns [String current=null]: + { newCompositeNode(grammarAccess.getOpCompareRule()); } + iv_ruleOpCompare=ruleOpCompare + { $current=$iv_ruleOpCompare.current.getText(); } + EOF; + +// Rule OpCompare +ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='>=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + ) + | + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + | + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXOtherOperatorExpression +entryRuleXOtherOperatorExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); } + iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression + { $current=$iv_ruleXOtherOperatorExpression.current; } + EOF; + +// Rule XOtherOperatorExpression +ruleXOtherOperatorExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + this_XAdditiveExpression_0=ruleXAdditiveExpression + { + $current = $this_XAdditiveExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpOther + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpOther + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXAdditiveExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpOther +entryRuleOpOther returns [String current=null]: + { newCompositeNode(grammarAccess.getOpOtherRule()); } + iv_ruleOpOther=ruleOpOther + { $current=$iv_ruleOpOther.current.getText(); } + EOF; + +// Rule OpOther +ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='->' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + | + kw='..<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + kw='..' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + ) + | + kw='..' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + | + kw='=>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + ( + ( + (( + '>' + '>' + ) + )=> + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + ) + ) + | + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + ) + ) + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + ( + ( + (( + '<' + '<' + ) + )=> + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + ) + ) + | + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + | + kw='=>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + ) + ) + | + kw='<>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + | + kw='?:' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + ) +; + +// Entry rule entryRuleXAdditiveExpression +entryRuleXAdditiveExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); } + iv_ruleXAdditiveExpression=ruleXAdditiveExpression + { $current=$iv_ruleXAdditiveExpression.current; } + EOF; + +// Rule XAdditiveExpression +ruleXAdditiveExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression + { + $current = $this_XMultiplicativeExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpAdd + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAdditiveExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpAdd + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXMultiplicativeExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpAdd +entryRuleOpAdd returns [String current=null]: + { newCompositeNode(grammarAccess.getOpAddRule()); } + iv_ruleOpAdd=ruleOpAdd + { $current=$iv_ruleOpAdd.current.getText(); } + EOF; + +// Rule OpAdd +ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='+' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + | + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + ) +; + +// Entry rule entryRuleXMultiplicativeExpression +entryRuleXMultiplicativeExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); } + iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression + { $current=$iv_ruleXMultiplicativeExpression.current; } + EOF; + +// Rule XMultiplicativeExpression +ruleXMultiplicativeExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + this_XUnaryOperation_0=ruleXUnaryOperation + { + $current = $this_XUnaryOperation_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpMulti + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpMulti + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXUnaryOperation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpMulti +entryRuleOpMulti returns [String current=null]: + { newCompositeNode(grammarAccess.getOpMultiRule()); } + iv_ruleOpMulti=ruleOpMulti + { $current=$iv_ruleOpMulti.current.getText(); } + EOF; + +// Rule OpMulti +ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + | + kw='**' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + | + kw='/' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + | + kw='%' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXUnaryOperation +entryRuleXUnaryOperation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXUnaryOperationRule()); } + iv_ruleXUnaryOperation=ruleXUnaryOperation + { $current=$iv_ruleXUnaryOperation.current; } + EOF; + +// Rule XUnaryOperation +ruleXUnaryOperation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXUnaryOperationRule()); + } + } + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + ruleOpUnary + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + lv_operand_2_0=ruleXUnaryOperation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXUnaryOperationRule()); + } + set( + $current, + "operand", + lv_operand_2_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + this_XCastedExpression_3=ruleXCastedExpression + { + $current = $this_XCastedExpression_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleOpUnary +entryRuleOpUnary returns [String current=null]: + { newCompositeNode(grammarAccess.getOpUnaryRule()); } + iv_ruleOpUnary=ruleOpUnary + { $current=$iv_ruleOpUnary.current.getText(); } + EOF; + +// Rule OpUnary +ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='!' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + | + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + | + kw='+' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + ) +; + +// Entry rule entryRuleXCastedExpression +entryRuleXCastedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCastedExpressionRule()); } + iv_ruleXCastedExpression=ruleXCastedExpression + { $current=$iv_ruleXCastedExpression.current; } + EOF; + +// Rule XCastedExpression +ruleXCastedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + this_XPostfixOperation_0=ruleXPostfixOperation + { + $current = $this_XPostfixOperation_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + 'as' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(), + $current); + } + ) + otherlv_2='as' + { + newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCastedExpressionRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleXPostfixOperation +entryRuleXPostfixOperation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXPostfixOperationRule()); } + iv_ruleXPostfixOperation=ruleXPostfixOperation + { $current=$iv_ruleXPostfixOperation.current; } + EOF; + +// Rule XPostfixOperation +ruleXPostfixOperation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + this_XMemberFeatureCall_0=ruleXMemberFeatureCall + { + $current = $this_XMemberFeatureCall_0.current; + afterParserOrEnumRuleCall(); + } + ( + (( + ( + ) + ( + ( + ruleOpPostfix + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXPostfixOperationRule()); + } + } + { + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + ruleOpPostfix + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + )? + ) +; + +// Entry rule entryRuleOpPostfix +entryRuleOpPostfix returns [String current=null]: + { newCompositeNode(grammarAccess.getOpPostfixRule()); } + iv_ruleOpPostfix=ruleOpPostfix + { $current=$iv_ruleOpPostfix.current.getText(); } + EOF; + +// Rule OpPostfix +ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='++' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + | + kw='--' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + ) +; + +// Entry rule entryRuleXMemberFeatureCall +entryRuleXMemberFeatureCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); } + iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall + { $current=$iv_ruleXMemberFeatureCall.current; } + EOF; + +// Rule XMemberFeatureCall +ruleXMemberFeatureCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + this_XPrimaryExpression_0=ruleXPrimaryExpression + { + $current = $this_XPrimaryExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + ( + (( + ( + ) + ( + '.' + | + ( + ( + '::' + ) + ) + ) + ( + ( + ruleFeatureCallID + ) + ) + ruleOpSingleAssign + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(), + $current); + } + ) + ( + otherlv_2='.' + { + newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + | + ( + ( + lv_explicitStatic_3_0='::' + { + newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitStatic", lv_explicitStatic_3_0 != null, "::"); + } + ) + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + ruleFeatureCallID + { + afterParserOrEnumRuleCall(); + } + ) + ) + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + ruleOpSingleAssign + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + lv_value_6_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + set( + $current, + "value", + lv_value_6_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + (( + ( + ) + ( + '.' + | + ( + ( + '?.' + ) + ) + | + ( + ( + '::' + ) + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), + $current); + } + ) + ( + otherlv_8='.' + { + newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + | + ( + ( + lv_nullSafe_9_0='?.' + { + newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "nullSafe", lv_nullSafe_9_0 != null, "?."); + } + ) + ) + | + ( + ( + lv_explicitStatic_10_0='::' + { + newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitStatic", lv_explicitStatic_10_0 != null, "::"); + } + ) + ) + ) + ) + ) + ( + otherlv_11='<' + { + newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + lv_typeArguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_13=',' + { + newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + lv_typeArguments_14_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_14_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15='>' + { + newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + ruleIdOrSuper + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitOperationCall_17_0='(' + { + newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitOperationCall", lv_explicitOperationCall_17_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + lv_memberCallArguments_18_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_18_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + lv_memberCallArguments_19_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_19_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_20=',' + { + newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + lv_memberCallArguments_21_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_21_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_22=')' + { + newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + lv_memberCallArguments_23_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_23_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) + )* + ) +; + +// Entry rule entryRuleXPrimaryExpression +entryRuleXPrimaryExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); } + iv_ruleXPrimaryExpression=ruleXPrimaryExpression + { $current=$iv_ruleXPrimaryExpression.current; } + EOF; + +// Rule XPrimaryExpression +ruleXPrimaryExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } + this_XConstructorCall_0=ruleXConstructorCall + { + $current = $this_XConstructorCall_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + this_XBlockExpression_1=ruleXBlockExpression + { + $current = $this_XBlockExpression_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + this_XSwitchExpression_2=ruleXSwitchExpression + { + $current = $this_XSwitchExpression_2.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + 'synchronized' + '(' + ) + )=> + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + this_XSynchronizedExpression_3=ruleXSynchronizedExpression + { + $current = $this_XSynchronizedExpression_3.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } + this_XFeatureCall_4=ruleXFeatureCall + { + $current = $this_XFeatureCall_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } + this_XLiteral_5=ruleXLiteral + { + $current = $this_XLiteral_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } + this_XIfExpression_6=ruleXIfExpression + { + $current = $this_XIfExpression_6.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + 'for' + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + this_XForLoopExpression_7=ruleXForLoopExpression + { + $current = $this_XForLoopExpression_7.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression + { + $current = $this_XBasicForLoopExpression_8.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } + this_XWhileExpression_9=ruleXWhileExpression + { + $current = $this_XWhileExpression_9.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } + this_XDoWhileExpression_10=ruleXDoWhileExpression + { + $current = $this_XDoWhileExpression_10.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } + this_XThrowExpression_11=ruleXThrowExpression + { + $current = $this_XThrowExpression_11.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + this_XReturnExpression_12=ruleXReturnExpression + { + $current = $this_XReturnExpression_12.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression + { + $current = $this_XTryCatchFinallyExpression_13.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + this_XParenthesizedExpression_14=ruleXParenthesizedExpression + { + $current = $this_XParenthesizedExpression_14.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXLiteral +entryRuleXLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXLiteralRule()); } + iv_ruleXLiteral=ruleXLiteral + { $current=$iv_ruleXLiteral.current; } + EOF; + +// Rule XLiteral +ruleXLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } + this_XCollectionLiteral_0=ruleXCollectionLiteral + { + $current = $this_XCollectionLiteral_0.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + '[' + ) + )=> + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } + this_XClosure_1=ruleXClosure + { + $current = $this_XClosure_1.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + this_XBooleanLiteral_2=ruleXBooleanLiteral + { + $current = $this_XBooleanLiteral_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + this_XNumberLiteral_3=ruleXNumberLiteral + { + $current = $this_XNumberLiteral_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + this_XNullLiteral_4=ruleXNullLiteral + { + $current = $this_XNullLiteral_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + this_XStringLiteral_5=ruleXStringLiteral + { + $current = $this_XStringLiteral_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + this_XTypeLiteral_6=ruleXTypeLiteral + { + $current = $this_XTypeLiteral_6.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXCollectionLiteral +entryRuleXCollectionLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCollectionLiteralRule()); } + iv_ruleXCollectionLiteral=ruleXCollectionLiteral + { $current=$iv_ruleXCollectionLiteral.current; } + EOF; + +// Rule XCollectionLiteral +ruleXCollectionLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + this_XSetLiteral_0=ruleXSetLiteral + { + $current = $this_XSetLiteral_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + this_XListLiteral_1=ruleXListLiteral + { + $current = $this_XListLiteral_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXSetLiteral +entryRuleXSetLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSetLiteralRule()); } + iv_ruleXSetLiteral=ruleXSetLiteral + { $current=$iv_ruleXSetLiteral.current; } + EOF; + +// Rule XSetLiteral +ruleXSetLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(), + $current); + } + ) + otherlv_1='#' + { + newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + otherlv_2='{' + { + newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + lv_elements_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + $current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + lv_elements_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + $current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6='}' + { + newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleXListLiteral +entryRuleXListLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXListLiteralRule()); } + iv_ruleXListLiteral=ruleXListLiteral + { $current=$iv_ruleXListLiteral.current; } + EOF; + +// Rule XListLiteral +ruleXListLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(), + $current); + } + ) + otherlv_1='#' + { + newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + otherlv_2='[' + { + newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + lv_elements_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + $current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + lv_elements_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + $current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=']' + { + newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleXClosure +entryRuleXClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXClosureRule()); } + iv_ruleXClosure=ruleXClosure + { $current=$iv_ruleXClosure.current; } + EOF; + +// Rule XClosure +ruleXClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + '[' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(), + $current); + } + ) + otherlv_1='[' + { + newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + ) + ) + ( + (( + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + lv_declaredFormalParameters_2_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_2_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + lv_declaredFormalParameters_4_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_4_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + lv_explicitSyntax_5_0='|' + { + newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXClosureRule()); + } + setWithLastConsumed($current, "explicitSyntax", lv_explicitSyntax_5_0 != null, "|"); + } + ) + ) + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + lv_expression_6_0=ruleXExpressionInClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + set( + $current, + "expression", + lv_expression_6_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_7=']' + { + newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + ) +; + +// Entry rule entryRuleXExpressionInClosure +entryRuleXExpressionInClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionInClosureRule()); } + iv_ruleXExpressionInClosure=ruleXExpressionInClosure + { $current=$iv_ruleXExpressionInClosure.current; } + EOF; + +// Rule XExpressionInClosure +ruleXExpressionInClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(), + $current); + } + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + lv_expressions_1_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule()); + } + add( + $current, + "expressions", + lv_expressions_1_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=';' + { + newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + )? + )* + ) +; + +// Entry rule entryRuleXShortClosure +entryRuleXShortClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXShortClosureRule()); } + iv_ruleXShortClosure=ruleXShortClosure + { $current=$iv_ruleXShortClosure.current; } + EOF; + +// Rule XShortClosure +ruleXShortClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(), + $current); + } + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + lv_declaredFormalParameters_1_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_1_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + lv_declaredFormalParameters_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + lv_explicitSyntax_4_0='|' + { + newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXShortClosureRule()); + } + setWithLastConsumed($current, "explicitSyntax", lv_explicitSyntax_4_0 != null, "|"); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + lv_expression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + set( + $current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXParenthesizedExpression +entryRuleXParenthesizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); } + iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression + { $current=$iv_ruleXParenthesizedExpression.current; } + EOF; + +// Rule XParenthesizedExpression +ruleXParenthesizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + { + newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + this_XExpression_1=ruleXExpression + { + $current = $this_XExpression_1.current; + afterParserOrEnumRuleCall(); + } + otherlv_2=')' + { + newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + ) +; + +// Entry rule entryRuleXIfExpression +entryRuleXIfExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXIfExpressionRule()); } + iv_ruleXIfExpression=ruleXIfExpression + { $current=$iv_ruleXIfExpression.current; } + EOF; + +// Rule XIfExpression +ruleXIfExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(), + $current); + } + ) + otherlv_1='if' + { + newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + lv_if_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "if", + lv_if_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + lv_then_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('else')=> + otherlv_6='else' + { + newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + lv_else_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "else", + lv_else_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleXSwitchExpression +entryRuleXSwitchExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSwitchExpressionRule()); } + iv_ruleXSwitchExpression=ruleXSwitchExpression + { $current=$iv_ruleXSwitchExpression.current; } + EOF; + +// Rule XSwitchExpression +ruleXSwitchExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(), + $current); + } + ) + otherlv_1='switch' + { + newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + ( + ( + ( + (( + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + lv_declaredParam_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + lv_switch_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "switch", + lv_switch_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + ) + | + ( + ( + (( + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + lv_declaredParam_7_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_7_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_8=':' + { + newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + lv_switch_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "switch", + lv_switch_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + otherlv_10='{' + { + newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + lv_cases_11_0=ruleXCasePart + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + add( + $current, + "cases", + lv_cases_11_0, + "org.eclipse.xtext.xbase.Xbase.XCasePart"); + afterParserOrEnumRuleCall(); + } + ) + )* + ( + otherlv_12='default' + { + newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + otherlv_13=':' + { + newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + lv_default_14_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "default", + lv_default_14_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + otherlv_15='}' + { + newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + ) +; + +// Entry rule entryRuleXCasePart +entryRuleXCasePart returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCasePartRule()); } + iv_ruleXCasePart=ruleXCasePart + { $current=$iv_ruleXCasePart.current; } + EOF; + +// Rule XCasePart +ruleXCasePart returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXCasePartAccess().getXCasePartAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeGuard_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "typeGuard", + lv_typeGuard_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + otherlv_2='case' + { + newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + lv_case_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "case", + lv_case_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + ( + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + lv_then_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + lv_fallThrough_6_0=',' + { + newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXCasePartRule()); + } + setWithLastConsumed($current, "fallThrough", lv_fallThrough_6_0 != null, ","); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleXForLoopExpression +entryRuleXForLoopExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXForLoopExpressionRule()); } + iv_ruleXForLoopExpression=ruleXForLoopExpression + { $current=$iv_ruleXForLoopExpression.current; } + EOF; + +// Rule XForLoopExpression +ruleXForLoopExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + 'for' + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(), + $current); + } + ) + otherlv_1='for' + { + newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + lv_declaredParam_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + lv_forExpression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "forExpression", + lv_forExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + lv_eachExpression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "eachExpression", + lv_eachExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXBasicForLoopExpression +entryRuleXBasicForLoopExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); } + iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression + { $current=$iv_ruleXBasicForLoopExpression.current; } + EOF; + +// Rule XBasicForLoopExpression +ruleXBasicForLoopExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(), + $current); + } + ) + otherlv_1='for' + { + newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "initExpressions", + lv_initExpressions_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "initExpressions", + lv_initExpressions_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=';' + { + newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + lv_expression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + $current, + "expression", + lv_expression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + )? + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + lv_updateExpressions_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "updateExpressions", + lv_updateExpressions_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_10=',' + { + newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + lv_updateExpressions_11_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "updateExpressions", + lv_updateExpressions_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_12=')' + { + newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + lv_eachExpression_13_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + $current, + "eachExpression", + lv_eachExpression_13_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXWhileExpression +entryRuleXWhileExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXWhileExpressionRule()); } + iv_ruleXWhileExpression=ruleXWhileExpression + { $current=$iv_ruleXWhileExpression.current; } + EOF; + +// Rule XWhileExpression +ruleXWhileExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(), + $current); + } + ) + otherlv_1='while' + { + newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + lv_predicate_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + $current, + "predicate", + lv_predicate_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + lv_body_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + $current, + "body", + lv_body_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXDoWhileExpression +entryRuleXDoWhileExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); } + iv_ruleXDoWhileExpression=ruleXDoWhileExpression + { $current=$iv_ruleXDoWhileExpression.current; } + EOF; + +// Rule XDoWhileExpression +ruleXDoWhileExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(), + $current); + } + ) + otherlv_1='do' + { + newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + lv_body_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + $current, + "body", + lv_body_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3='while' + { + newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + otherlv_4='(' + { + newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + lv_predicate_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + $current, + "predicate", + lv_predicate_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + ) +; + +// Entry rule entryRuleXBlockExpression +entryRuleXBlockExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBlockExpressionRule()); } + iv_ruleXBlockExpression=ruleXBlockExpression + { $current=$iv_ruleXBlockExpression.current; } + EOF; + +// Rule XBlockExpression +ruleXBlockExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(), + $current); + } + ) + otherlv_1='{' + { + newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + lv_expressions_2_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBlockExpressionRule()); + } + add( + $current, + "expressions", + lv_expressions_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=';' + { + newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + )? + )* + otherlv_4='}' + { + newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + ) +; + +// Entry rule entryRuleXExpressionOrVarDeclaration +entryRuleXExpressionOrVarDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); } + iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration + { $current=$iv_ruleXExpressionOrVarDeclaration.current; } + EOF; + +// Rule XExpressionOrVarDeclaration +ruleXExpressionOrVarDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } + this_XVariableDeclaration_0=ruleXVariableDeclaration + { + $current = $this_XVariableDeclaration_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } + this_XExpression_1=ruleXExpression + { + $current = $this_XExpression_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXVariableDeclaration +entryRuleXVariableDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXVariableDeclarationRule()); } + iv_ruleXVariableDeclaration=ruleXVariableDeclaration + { $current=$iv_ruleXVariableDeclaration.current; } + EOF; + +// Rule XVariableDeclaration +ruleXVariableDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(), + $current); + } + ) + ( + ( + ( + lv_writeable_1_0='var' + { + newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXVariableDeclarationRule()); + } + setWithLastConsumed($current, "writeable", lv_writeable_1_0 != null, "var"); + } + ) + ) + | + otherlv_2='val' + { + newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + ) + ( + ( + (( + ( + ( + ruleJvmTypeReference + ) + ) + ( + ( + ruleValidID + ) + ) + ) + )=> + ( + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + lv_name_4_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "name", + lv_name_4_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + lv_name_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "name", + lv_name_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_6='=' + { + newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + lv_right_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "right", + lv_right_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleJvmFormalParameter +entryRuleJvmFormalParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmFormalParameterRule()); } + iv_ruleJvmFormalParameter=ruleJvmFormalParameter + { $current=$iv_ruleJvmFormalParameter.current; } + EOF; + +// Rule JvmFormalParameter +ruleJvmFormalParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + lv_parameterType_0_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + $current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + lv_name_1_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleFullJvmFormalParameter +entryRuleFullJvmFormalParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); } + iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter + { $current=$iv_ruleFullJvmFormalParameter.current; } + EOF; + +// Rule FullJvmFormalParameter +ruleFullJvmFormalParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + lv_parameterType_0_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + $current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + lv_name_1_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXFeatureCall +entryRuleXFeatureCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFeatureCallRule()); } + iv_ruleXFeatureCall=ruleXFeatureCall + { $current=$iv_ruleXFeatureCall.current; } + EOF; + +// Rule XFeatureCall +ruleXFeatureCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(), + $current); + } + ) + ( + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_typeArguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_typeArguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + ruleIdOrSuper + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitOperationCall_7_0='(' + { + newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + setWithLastConsumed($current, "explicitOperationCall", lv_explicitOperationCall_7_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + lv_featureCallArguments_8_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_8_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + lv_featureCallArguments_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_10=',' + { + newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + lv_featureCallArguments_11_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_12=')' + { + newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + lv_featureCallArguments_13_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_13_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleFeatureCallID +entryRuleFeatureCallID returns [String current=null]: + { newCompositeNode(grammarAccess.getFeatureCallIDRule()); } + iv_ruleFeatureCallID=ruleFeatureCallID + { $current=$iv_ruleFeatureCallID.current.getText(); } + EOF; + +// Rule FeatureCallID +ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + | + kw='extends' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + | + kw='static' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + | + kw='import' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + | + kw='extension' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + ) +; + +// Entry rule entryRuleIdOrSuper +entryRuleIdOrSuper returns [String current=null]: + { newCompositeNode(grammarAccess.getIdOrSuperRule()); } + iv_ruleIdOrSuper=ruleIdOrSuper + { $current=$iv_ruleIdOrSuper.current.getText(); } + EOF; + +// Rule IdOrSuper +ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + this_FeatureCallID_0=ruleFeatureCallID + { + $current.merge(this_FeatureCallID_0); + } + { + afterParserOrEnumRuleCall(); + } + | + kw='super' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + ) +; + +// Entry rule entryRuleXConstructorCall +entryRuleXConstructorCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXConstructorCallRule()); } + iv_ruleXConstructorCall=ruleXConstructorCall + { $current=$iv_ruleXConstructorCall.current; } + EOF; + +// Rule XConstructorCall +ruleXConstructorCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(), + $current); + } + ) + otherlv_1='new' + { + newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_3='<' + { + newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + lv_typeArguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_5=',' + { + newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + lv_typeArguments_6_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_7='>' + { + newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + )? + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitConstructorCall_8_0='(' + { + newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + setWithLastConsumed($current, "explicitConstructorCall", lv_explicitConstructorCall_8_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + lv_arguments_9_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + lv_arguments_10_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + lv_arguments_12_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_13=')' + { + newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + lv_arguments_14_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_14_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleXBooleanLiteral +entryRuleXBooleanLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBooleanLiteralRule()); } + iv_ruleXBooleanLiteral=ruleXBooleanLiteral + { $current=$iv_ruleXBooleanLiteral.current; } + EOF; + +// Rule XBooleanLiteral +ruleXBooleanLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(), + $current); + } + ) + ( + otherlv_1='false' + { + newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + | + ( + ( + lv_isTrue_2_0='true' + { + newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXBooleanLiteralRule()); + } + setWithLastConsumed($current, "isTrue", lv_isTrue_2_0 != null, "true"); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleXNullLiteral +entryRuleXNullLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXNullLiteralRule()); } + iv_ruleXNullLiteral=ruleXNullLiteral + { $current=$iv_ruleXNullLiteral.current; } + EOF; + +// Rule XNullLiteral +ruleXNullLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(), + $current); + } + ) + otherlv_1='null' + { + newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + ) +; + +// Entry rule entryRuleXNumberLiteral +entryRuleXNumberLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXNumberLiteralRule()); } + iv_ruleXNumberLiteral=ruleXNumberLiteral + { $current=$iv_ruleXNumberLiteral.current; } + EOF; + +// Rule XNumberLiteral +ruleXNumberLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + lv_value_1_0=ruleNumber + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXNumberLiteralRule()); + } + set( + $current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xbase.Number"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXStringLiteral +entryRuleXStringLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXStringLiteralRule()); } + iv_ruleXStringLiteral=ruleXStringLiteral + { $current=$iv_ruleXStringLiteral.current; } + EOF; + +// Rule XStringLiteral +ruleXStringLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(), + $current); + } + ) + ( + ( + lv_value_1_0=RULE_STRING + { + newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXStringLiteralRule()); + } + setWithLastConsumed( + $current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + } + ) + ) + ) +; + +// Entry rule entryRuleXTypeLiteral +entryRuleXTypeLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXTypeLiteralRule()); } + iv_ruleXTypeLiteral=ruleXTypeLiteral + { $current=$iv_ruleXTypeLiteral.current; } + EOF; + +// Rule XTypeLiteral +ruleXTypeLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(), + $current); + } + ) + otherlv_1='typeof' + { + newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXTypeLiteralRule()); + } + } + { + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + lv_arrayDimensions_4_0=ruleArrayBrackets + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTypeLiteralRule()); + } + add( + $current, + "arrayDimensions", + lv_arrayDimensions_4_0, + "org.eclipse.xtext.xbase.Xtype.ArrayBrackets"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_5=')' + { + newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + ) +; + +// Entry rule entryRuleXThrowExpression +entryRuleXThrowExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXThrowExpressionRule()); } + iv_ruleXThrowExpression=ruleXThrowExpression + { $current=$iv_ruleXThrowExpression.current; } + EOF; + +// Rule XThrowExpression +ruleXThrowExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(), + $current); + } + ) + otherlv_1='throw' + { + newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXThrowExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXReturnExpression +entryRuleXReturnExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXReturnExpressionRule()); } + iv_ruleXReturnExpression=ruleXReturnExpression + { $current=$iv_ruleXReturnExpression.current; } + EOF; + +// Rule XReturnExpression +ruleXReturnExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(), + $current); + } + ) + otherlv_1='return' + { + newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + ( + ('extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING)=> + ( + { + newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXReturnExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleXTryCatchFinallyExpression +entryRuleXTryCatchFinallyExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); } + iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression + { $current=$iv_ruleXTryCatchFinallyExpression.current; } + EOF; + +// Rule XTryCatchFinallyExpression +ruleXTryCatchFinallyExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(), + $current); + } + ) + otherlv_1='try' + { + newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + ('catch')=> + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + lv_catchClauses_3_0=ruleXCatchClause + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + add( + $current, + "catchClauses", + lv_catchClauses_3_0, + "org.eclipse.xtext.xbase.Xbase.XCatchClause"); + afterParserOrEnumRuleCall(); + } + ) + )+ + ( + ( + ('finally')=> + otherlv_4='finally' + { + newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + lv_finallyExpression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "finallyExpression", + lv_finallyExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) + | + ( + otherlv_6='finally' + { + newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + lv_finallyExpression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "finallyExpression", + lv_finallyExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ) +; + +// Entry rule entryRuleXSynchronizedExpression +entryRuleXSynchronizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); } + iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression + { $current=$iv_ruleXSynchronizedExpression.current; } + EOF; + +// Rule XSynchronizedExpression +ruleXSynchronizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + 'synchronized' + '(' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(), + $current); + } + ) + otherlv_1='synchronized' + { + newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + lv_param_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + $current, + "param", + lv_param_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + lv_expression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + $current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXCatchClause +entryRuleXCatchClause returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCatchClauseRule()); } + iv_ruleXCatchClause=ruleXCatchClause + { $current=$iv_ruleXCatchClause.current; } + EOF; + +// Rule XCatchClause +ruleXCatchClause returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ('catch')=> + otherlv_0='catch' + { + newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + ) + otherlv_1='(' + { + newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + lv_declaredParam_2_0=ruleFullJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_2_0, + "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3=')' + { + newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + lv_expression_4_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + $current, + "expression", + lv_expression_4_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameRule()); } + iv_ruleQualifiedName=ruleQualifiedName + { $current=$iv_ruleQualifiedName.current.getText(); } + EOF; + +// Rule QualifiedName +ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + ( + ( + ('.')=> + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + ) + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + this_ValidID_2=ruleValidID + { + $current.merge(this_ValidID_2); + } + { + afterParserOrEnumRuleCall(); + } + )* + ) +; + +// Entry rule entryRuleNumber +entryRuleNumber returns [String current=null]@init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +}: + { newCompositeNode(grammarAccess.getNumberRule()); } + iv_ruleNumber=ruleNumber + { $current=$iv_ruleNumber.current.getText(); } + EOF; +finally { + myHiddenTokenState.restore(); +} + +// Rule Number +ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +} +@after { + leaveRule(); +}: + ( + this_HEX_0=RULE_HEX + { + $current.merge(this_HEX_0); + } + { + newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + | + ( + ( + this_INT_1=RULE_INT + { + $current.merge(this_INT_1); + } + { + newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + | + this_DECIMAL_2=RULE_DECIMAL + { + $current.merge(this_DECIMAL_2); + } + { + newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + ) + ( + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + ( + this_INT_4=RULE_INT + { + $current.merge(this_INT_4); + } + { + newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + | + this_DECIMAL_5=RULE_DECIMAL + { + $current.merge(this_DECIMAL_5); + } + { + newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + ) + )? + ) + ) +; +finally { + myHiddenTokenState.restore(); +} + +// Entry rule entryRuleJvmTypeReference +entryRuleJvmTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); } + iv_ruleJvmTypeReference=ruleJvmTypeReference + { $current=$iv_ruleJvmTypeReference.current; } + EOF; + +// Rule JvmTypeReference +ruleJvmTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference + { + $current = $this_JvmParameterizedTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + ( + (( + ( + ) + ruleArrayBrackets + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + $current); + } + ) + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + ruleArrayBrackets + { + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + this_XFunctionTypeRef_3=ruleXFunctionTypeRef + { + $current = $this_XFunctionTypeRef_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets returns [String current=null]: + { newCompositeNode(grammarAccess.getArrayBracketsRule()); } + iv_ruleArrayBrackets=ruleArrayBrackets + { $current=$iv_ruleArrayBrackets.current.getText(); } + EOF; + +// Rule ArrayBrackets +ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='[' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + kw=']' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + ) +; + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); } + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef + { $current=$iv_ruleXFunctionTypeRef.current; } + EOF; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + lv_paramTypes_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + lv_paramTypes_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + )? + otherlv_5='=>' + { + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + lv_returnType_6_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + $current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference + { $current=$iv_ruleJvmParameterizedTypeReference.current; } + EOF; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_arguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_arguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + ( + ( + (( + ( + ) + '.' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + $current); + } + ) + otherlv_7='.' + { + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + ruleValidID + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_9='<' + { + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + lv_arguments_10_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + lv_arguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_13='>' + { + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + )? + )* + )? + ) +; + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); } + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference + { $current=$iv_ruleJvmArgumentTypeReference.current; } + EOF; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + this_JvmTypeReference_0=ruleJvmTypeReference + { + $current = $this_JvmTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference + { + $current = $this_JvmWildcardTypeReference_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); } + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference + { $current=$iv_ruleJvmWildcardTypeReference.current; } + EOF; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + $current); + } + ) + otherlv_1='?' + { + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + lv_constraints_2_0=ruleJvmUpperBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + lv_constraints_3_0=ruleJvmUpperBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + lv_constraints_4_0=ruleJvmLowerBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + lv_constraints_5_0=ruleJvmLowerBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + )? + ) +; + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundRule()); } + iv_ruleJvmUpperBound=ruleJvmUpperBound + { $current=$iv_ruleJvmUpperBound.current; } + EOF; + +// Rule JvmUpperBound +ruleJvmUpperBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='extends' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); } + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded + { $current=$iv_ruleJvmUpperBoundAnded.current; } + EOF; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundRule()); } + iv_ruleJvmLowerBound=ruleJvmLowerBound + { $current=$iv_ruleJvmLowerBound.current; } + EOF; + +// Rule JvmLowerBound +ruleJvmLowerBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='super' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); } + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded + { $current=$iv_ruleJvmLowerBoundAnded.current; } + EOF; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); } + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard + { $current=$iv_ruleQualifiedNameWithWildcard.current.getText(); } + EOF; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + this_QualifiedName_0=ruleQualifiedName + { + $current.merge(this_QualifiedName_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + ) +; + +// Entry rule entryRuleValidID +entryRuleValidID returns [String current=null]: + { newCompositeNode(grammarAccess.getValidIDRule()); } + iv_ruleValidID=ruleValidID + { $current=$iv_ruleValidID.current.getText(); } + EOF; + +// Rule ValidID +ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_ID_0=RULE_ID + { + $current.merge(this_ID_0); + } + { + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + } +; + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXImportDeclarationRule()); } + iv_ruleXImportDeclaration=ruleXImportDeclaration + { $current=$iv_ruleXImportDeclaration.current; } + EOF; + +// Rule XImportDeclaration +ruleXImportDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='import' + { + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + ( + ( + ( + ( + lv_static_1_0='static' + { + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "static", lv_static_1_0 != null, "static"); + } + ) + ) + ( + ( + lv_extension_2_0='extension' + { + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "extension", lv_extension_2_0 != null, "extension"); + } + ) + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + ruleQualifiedNameInStaticImport + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + lv_wildcard_4_0='*' + { + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "wildcard", lv_wildcard_4_0 != null, "*"); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + lv_memberName_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + )? + ) +; + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); } + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport + { $current=$iv_ruleQualifiedNameInStaticImport.current.getText(); } + EOF; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + )+ +; + RULE_REAL : ('0'..'9')* '.' ('0'..'9')*; -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; +RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?; + +RULE_INT : '0'..'9' ('0'..'9'|'_')*; + +RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?; -RULE_INT : ('0'..'9')+; +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.tokens b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.tokens index e3352517ec..f9a08bae50 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.tokens +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpression.tokens @@ -1,65 +1,109 @@ -'!'=40 -'!='=31 -'&&'=28 -'('=15 -')'=16 -'*'=38 -'+'=36 -','=42 -'-'=37 -'->'=17 -'.'=41 -'/'=39 -':'=14 -'::'=63 -'<'=35 -'<='=33 -'='=13 -'=='=30 -'>'=34 -'>='=32 -'?'=18 -'Collection'=58 -'GLOBALVAR'=56 -'List'=59 -'Set'=60 -'['=61 -']'=62 -'case'=26 -'collect'=44 -'default'=24 -'else'=21 -'exists'=48 -'false'=54 -'forAll'=51 -'if'=19 -'implies'=29 -'let'=12 -'new'=57 -'notExists'=49 -'null'=55 -'reject'=47 -'select'=45 -'selectFirst'=46 -'sortBy'=50 -'switch'=22 -'then'=20 -'true'=53 -'typeSelect'=43 -'{'=23 -'|'=52 -'||'=27 -'}'=25 -RULE_ANY_OTHER=11 +'!'=42 +'!='=33 +'!=='=72 +'#'=85 +'%'=80 +'%='=70 +'&&'=30 +'&'=104 +'('=17 +')'=18 +'*'=40 +'**'=79 +'*='=68 +'+'=38 +'++'=82 +'+='=66 +','=44 +'-'=39 +'--'=83 +'-='=67 +'->'=19 +'.'=43 +'..'=75 +'..<'=74 +'/'=41 +'/='=69 +':'=16 +'::'=65 +';'=86 +'<'=37 +'<='=35 +'<>'=77 +'='=15 +'=='=32 +'==='=71 +'=>'=76 +'>'=36 +'>='=34 +'?'=20 +'?.'=84 +'?:'=78 +'Collection'=60 +'GLOBALVAR'=58 +'List'=61 +'Set'=62 +'['=63 +']'=64 +'as'=81 +'case'=28 +'catch'=103 +'collect'=46 +'default'=26 +'do'=89 +'else'=23 +'exists'=50 +'extends'=92 +'extension'=95 +'false'=56 +'finally'=101 +'for'=87 +'forAll'=53 +'if'=21 +'implies'=31 +'import'=94 +'instanceof'=73 +'let'=14 +'new'=59 +'notExists'=51 +'null'=57 +'reject'=49 +'return'=99 +'select'=47 +'selectFirst'=48 +'sortBy'=52 +'static'=93 +'super'=96 +'switch'=24 +'synchronized'=102 +'then'=22 +'throw'=98 +'true'=55 +'try'=100 +'typeSelect'=45 +'typeof'=97 +'val'=91 +'var'=90 +'while'=88 +'{'=25 +'|'=54 +'||'=29 +'}'=27 +RULE_ANY_OTHER=13 +RULE_DECIMAL=9 +RULE_HEX=8 RULE_ID=7 RULE_INT=4 -RULE_ML_COMMENT=8 +RULE_ML_COMMENT=10 RULE_REAL=5 -RULE_SL_COMMENT=9 +RULE_SL_COMMENT=11 RULE_STRING=6 -RULE_WS=10 -T__12=12 -T__13=13 +RULE_WS=12 +T__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 T__14=14 T__15=15 T__16=16 @@ -110,3 +154,39 @@ T__60=60 T__61=61 T__62=62 T__63=63 +T__64=64 +T__65=65 +T__66=66 +T__67=67 +T__68=68 +T__69=69 +T__70=70 +T__71=71 +T__72=72 +T__73=73 +T__74=74 +T__75=75 +T__76=76 +T__77=77 +T__78=78 +T__79=79 +T__80=80 +T__81=81 +T__82=82 +T__83=83 +T__84=84 +T__85=85 +T__86=86 +T__87=87 +T__88=88 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionLexer.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionLexer.java index ffd6f27896..bef42e86e8 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionLexer.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionLexer.java @@ -12,19 +12,12 @@ @SuppressWarnings("all") public class InternalExpressionLexer extends Lexer { + public static final int RULE_HEX=8; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -34,22 +27,16 @@ public class InternalExpressionLexer extends Lexer { public static final int T__61=61; public static final int RULE_ID=7; public static final int RULE_REAL=5; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; public static final int RULE_INT=4; - public static final int T__29=29; - public static final int T__22=22; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; - public static final int T__24=24; - public static final int T__25=25; + public static final int T__66=66; + public static final int RULE_ML_COMMENT=10; + public static final int T__67=67; + public static final int T__68=68; + public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; - public static final int T__21=21; - public static final int RULE_STRING=6; - public static final int RULE_SL_COMMENT=9; + public static final int T__64=64; + public static final int T__65=65; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; @@ -57,12 +44,9 @@ public class InternalExpressionLexer extends Lexer { public static final int T__34=34; public static final int T__35=35; public static final int T__36=36; - public static final int EOF=-1; public static final int T__30=30; public static final int T__31=31; public static final int T__32=32; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -73,6 +57,63 @@ public class InternalExpressionLexer extends Lexer { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=6; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__75=75; + public static final int T__76=76; + public static final int T__80=80; + public static final int T__81=81; + public static final int T__82=82; + public static final int T__83=83; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__89=89; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__87=87; // delegates // delegators @@ -87,10 +128,10 @@ public InternalExpressionLexer(CharStream input, RecognizerSharedState state) { } public String getGrammarFileName() { return "InternalExpression.g"; } - // $ANTLR start "T__12" - public final void mT__12() throws RecognitionException { + // $ANTLR start "T__14" + public final void mT__14() throws RecognitionException { try { - int _type = T__12; + int _type = T__14; int _channel = DEFAULT_TOKEN_CHANNEL; // InternalExpression.g:11:7: ( 'let' ) // InternalExpression.g:11:9: 'let' @@ -98,46 +139,6 @@ public final void mT__12() throws RecognitionException { match("let"); - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__12" - - // $ANTLR start "T__13" - public final void mT__13() throws RecognitionException { - try { - int _type = T__13; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:12:7: ( '=' ) - // InternalExpression.g:12:9: '=' - { - match('='); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__13" - - // $ANTLR start "T__14" - public final void mT__14() throws RecognitionException { - try { - int _type = T__14; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:13:7: ( ':' ) - // InternalExpression.g:13:9: ':' - { - match(':'); - } state.type = _type; @@ -153,10 +154,10 @@ public final void mT__15() throws RecognitionException { try { int _type = T__15; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:14:7: ( '(' ) - // InternalExpression.g:14:9: '(' + // InternalExpression.g:12:7: ( '=' ) + // InternalExpression.g:12:9: '=' { - match('('); + match('='); } @@ -173,10 +174,10 @@ public final void mT__16() throws RecognitionException { try { int _type = T__16; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:15:7: ( ')' ) - // InternalExpression.g:15:9: ')' + // InternalExpression.g:13:7: ( ':' ) + // InternalExpression.g:13:9: ':' { - match(')'); + match(':'); } @@ -193,11 +194,10 @@ public final void mT__17() throws RecognitionException { try { int _type = T__17; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:16:7: ( '->' ) - // InternalExpression.g:16:9: '->' + // InternalExpression.g:14:7: ( '(' ) + // InternalExpression.g:14:9: '(' { - match("->"); - + match('('); } @@ -214,10 +214,10 @@ public final void mT__18() throws RecognitionException { try { int _type = T__18; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:17:7: ( '?' ) - // InternalExpression.g:17:9: '?' + // InternalExpression.g:15:7: ( ')' ) + // InternalExpression.g:15:9: ')' { - match('?'); + match(')'); } @@ -234,10 +234,10 @@ public final void mT__19() throws RecognitionException { try { int _type = T__19; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:18:7: ( 'if' ) - // InternalExpression.g:18:9: 'if' + // InternalExpression.g:16:7: ( '->' ) + // InternalExpression.g:16:9: '->' { - match("if"); + match("->"); } @@ -255,11 +255,10 @@ public final void mT__20() throws RecognitionException { try { int _type = T__20; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:19:7: ( 'then' ) - // InternalExpression.g:19:9: 'then' + // InternalExpression.g:17:7: ( '?' ) + // InternalExpression.g:17:9: '?' { - match("then"); - + match('?'); } @@ -276,10 +275,10 @@ public final void mT__21() throws RecognitionException { try { int _type = T__21; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:20:7: ( 'else' ) - // InternalExpression.g:20:9: 'else' + // InternalExpression.g:18:7: ( 'if' ) + // InternalExpression.g:18:9: 'if' { - match("else"); + match("if"); } @@ -297,10 +296,10 @@ public final void mT__22() throws RecognitionException { try { int _type = T__22; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:21:7: ( 'switch' ) - // InternalExpression.g:21:9: 'switch' + // InternalExpression.g:19:7: ( 'then' ) + // InternalExpression.g:19:9: 'then' { - match("switch"); + match("then"); } @@ -318,10 +317,11 @@ public final void mT__23() throws RecognitionException { try { int _type = T__23; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:22:7: ( '{' ) - // InternalExpression.g:22:9: '{' + // InternalExpression.g:20:7: ( 'else' ) + // InternalExpression.g:20:9: 'else' { - match('{'); + match("else"); + } @@ -338,10 +338,10 @@ public final void mT__24() throws RecognitionException { try { int _type = T__24; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:23:7: ( 'default' ) - // InternalExpression.g:23:9: 'default' + // InternalExpression.g:21:7: ( 'switch' ) + // InternalExpression.g:21:9: 'switch' { - match("default"); + match("switch"); } @@ -359,10 +359,10 @@ public final void mT__25() throws RecognitionException { try { int _type = T__25; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:24:7: ( '}' ) - // InternalExpression.g:24:9: '}' + // InternalExpression.g:22:7: ( '{' ) + // InternalExpression.g:22:9: '{' { - match('}'); + match('{'); } @@ -379,10 +379,10 @@ public final void mT__26() throws RecognitionException { try { int _type = T__26; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:25:7: ( 'case' ) - // InternalExpression.g:25:9: 'case' + // InternalExpression.g:23:7: ( 'default' ) + // InternalExpression.g:23:9: 'default' { - match("case"); + match("default"); } @@ -400,11 +400,10 @@ public final void mT__27() throws RecognitionException { try { int _type = T__27; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:26:7: ( '||' ) - // InternalExpression.g:26:9: '||' + // InternalExpression.g:24:7: ( '}' ) + // InternalExpression.g:24:9: '}' { - match("||"); - + match('}'); } @@ -421,10 +420,10 @@ public final void mT__28() throws RecognitionException { try { int _type = T__28; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:27:7: ( '&&' ) - // InternalExpression.g:27:9: '&&' + // InternalExpression.g:25:7: ( 'case' ) + // InternalExpression.g:25:9: 'case' { - match("&&"); + match("case"); } @@ -442,10 +441,10 @@ public final void mT__29() throws RecognitionException { try { int _type = T__29; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:28:7: ( 'implies' ) - // InternalExpression.g:28:9: 'implies' + // InternalExpression.g:26:7: ( '||' ) + // InternalExpression.g:26:9: '||' { - match("implies"); + match("||"); } @@ -463,10 +462,10 @@ public final void mT__30() throws RecognitionException { try { int _type = T__30; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:29:7: ( '==' ) - // InternalExpression.g:29:9: '==' + // InternalExpression.g:27:7: ( '&&' ) + // InternalExpression.g:27:9: '&&' { - match("=="); + match("&&"); } @@ -484,10 +483,10 @@ public final void mT__31() throws RecognitionException { try { int _type = T__31; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:30:7: ( '!=' ) - // InternalExpression.g:30:9: '!=' + // InternalExpression.g:28:7: ( 'implies' ) + // InternalExpression.g:28:9: 'implies' { - match("!="); + match("implies"); } @@ -505,10 +504,10 @@ public final void mT__32() throws RecognitionException { try { int _type = T__32; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:31:7: ( '>=' ) - // InternalExpression.g:31:9: '>=' + // InternalExpression.g:29:7: ( '==' ) + // InternalExpression.g:29:9: '==' { - match(">="); + match("=="); } @@ -526,10 +525,10 @@ public final void mT__33() throws RecognitionException { try { int _type = T__33; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:32:7: ( '<=' ) - // InternalExpression.g:32:9: '<=' + // InternalExpression.g:30:7: ( '!=' ) + // InternalExpression.g:30:9: '!=' { - match("<="); + match("!="); } @@ -547,10 +546,11 @@ public final void mT__34() throws RecognitionException { try { int _type = T__34; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:33:7: ( '>' ) - // InternalExpression.g:33:9: '>' + // InternalExpression.g:31:7: ( '>=' ) + // InternalExpression.g:31:9: '>=' { - match('>'); + match(">="); + } @@ -567,10 +567,11 @@ public final void mT__35() throws RecognitionException { try { int _type = T__35; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:34:7: ( '<' ) - // InternalExpression.g:34:9: '<' + // InternalExpression.g:32:7: ( '<=' ) + // InternalExpression.g:32:9: '<=' { - match('<'); + match("<="); + } @@ -587,10 +588,10 @@ public final void mT__36() throws RecognitionException { try { int _type = T__36; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:35:7: ( '+' ) - // InternalExpression.g:35:9: '+' + // InternalExpression.g:33:7: ( '>' ) + // InternalExpression.g:33:9: '>' { - match('+'); + match('>'); } @@ -607,10 +608,10 @@ public final void mT__37() throws RecognitionException { try { int _type = T__37; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:36:7: ( '-' ) - // InternalExpression.g:36:9: '-' + // InternalExpression.g:34:7: ( '<' ) + // InternalExpression.g:34:9: '<' { - match('-'); + match('<'); } @@ -627,10 +628,10 @@ public final void mT__38() throws RecognitionException { try { int _type = T__38; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:37:7: ( '*' ) - // InternalExpression.g:37:9: '*' + // InternalExpression.g:35:7: ( '+' ) + // InternalExpression.g:35:9: '+' { - match('*'); + match('+'); } @@ -647,10 +648,10 @@ public final void mT__39() throws RecognitionException { try { int _type = T__39; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:38:7: ( '/' ) - // InternalExpression.g:38:9: '/' + // InternalExpression.g:36:7: ( '-' ) + // InternalExpression.g:36:9: '-' { - match('/'); + match('-'); } @@ -667,10 +668,10 @@ public final void mT__40() throws RecognitionException { try { int _type = T__40; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:39:7: ( '!' ) - // InternalExpression.g:39:9: '!' + // InternalExpression.g:37:7: ( '*' ) + // InternalExpression.g:37:9: '*' { - match('!'); + match('*'); } @@ -687,10 +688,10 @@ public final void mT__41() throws RecognitionException { try { int _type = T__41; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:40:7: ( '.' ) - // InternalExpression.g:40:9: '.' + // InternalExpression.g:38:7: ( '/' ) + // InternalExpression.g:38:9: '/' { - match('.'); + match('/'); } @@ -707,10 +708,10 @@ public final void mT__42() throws RecognitionException { try { int _type = T__42; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:41:7: ( ',' ) - // InternalExpression.g:41:9: ',' + // InternalExpression.g:39:7: ( '!' ) + // InternalExpression.g:39:9: '!' { - match(','); + match('!'); } @@ -727,11 +728,10 @@ public final void mT__43() throws RecognitionException { try { int _type = T__43; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:42:7: ( 'typeSelect' ) - // InternalExpression.g:42:9: 'typeSelect' + // InternalExpression.g:40:7: ( '.' ) + // InternalExpression.g:40:9: '.' { - match("typeSelect"); - + match('.'); } @@ -748,11 +748,10 @@ public final void mT__44() throws RecognitionException { try { int _type = T__44; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:43:7: ( 'collect' ) - // InternalExpression.g:43:9: 'collect' + // InternalExpression.g:41:7: ( ',' ) + // InternalExpression.g:41:9: ',' { - match("collect"); - + match(','); } @@ -769,10 +768,10 @@ public final void mT__45() throws RecognitionException { try { int _type = T__45; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:44:7: ( 'select' ) - // InternalExpression.g:44:9: 'select' + // InternalExpression.g:42:7: ( 'typeSelect' ) + // InternalExpression.g:42:9: 'typeSelect' { - match("select"); + match("typeSelect"); } @@ -790,10 +789,10 @@ public final void mT__46() throws RecognitionException { try { int _type = T__46; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:45:7: ( 'selectFirst' ) - // InternalExpression.g:45:9: 'selectFirst' + // InternalExpression.g:43:7: ( 'collect' ) + // InternalExpression.g:43:9: 'collect' { - match("selectFirst"); + match("collect"); } @@ -811,10 +810,10 @@ public final void mT__47() throws RecognitionException { try { int _type = T__47; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:46:7: ( 'reject' ) - // InternalExpression.g:46:9: 'reject' + // InternalExpression.g:44:7: ( 'select' ) + // InternalExpression.g:44:9: 'select' { - match("reject"); + match("select"); } @@ -832,10 +831,10 @@ public final void mT__48() throws RecognitionException { try { int _type = T__48; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:47:7: ( 'exists' ) - // InternalExpression.g:47:9: 'exists' + // InternalExpression.g:45:7: ( 'selectFirst' ) + // InternalExpression.g:45:9: 'selectFirst' { - match("exists"); + match("selectFirst"); } @@ -853,10 +852,10 @@ public final void mT__49() throws RecognitionException { try { int _type = T__49; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:48:7: ( 'notExists' ) - // InternalExpression.g:48:9: 'notExists' + // InternalExpression.g:46:7: ( 'reject' ) + // InternalExpression.g:46:9: 'reject' { - match("notExists"); + match("reject"); } @@ -874,10 +873,10 @@ public final void mT__50() throws RecognitionException { try { int _type = T__50; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:49:7: ( 'sortBy' ) - // InternalExpression.g:49:9: 'sortBy' + // InternalExpression.g:47:7: ( 'exists' ) + // InternalExpression.g:47:9: 'exists' { - match("sortBy"); + match("exists"); } @@ -895,10 +894,10 @@ public final void mT__51() throws RecognitionException { try { int _type = T__51; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:50:7: ( 'forAll' ) - // InternalExpression.g:50:9: 'forAll' + // InternalExpression.g:48:7: ( 'notExists' ) + // InternalExpression.g:48:9: 'notExists' { - match("forAll"); + match("notExists"); } @@ -916,10 +915,11 @@ public final void mT__52() throws RecognitionException { try { int _type = T__52; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:51:7: ( '|' ) - // InternalExpression.g:51:9: '|' + // InternalExpression.g:49:7: ( 'sortBy' ) + // InternalExpression.g:49:9: 'sortBy' { - match('|'); + match("sortBy"); + } @@ -936,10 +936,10 @@ public final void mT__53() throws RecognitionException { try { int _type = T__53; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:52:7: ( 'true' ) - // InternalExpression.g:52:9: 'true' + // InternalExpression.g:50:7: ( 'forAll' ) + // InternalExpression.g:50:9: 'forAll' { - match("true"); + match("forAll"); } @@ -957,11 +957,10 @@ public final void mT__54() throws RecognitionException { try { int _type = T__54; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:53:7: ( 'false' ) - // InternalExpression.g:53:9: 'false' + // InternalExpression.g:51:7: ( '|' ) + // InternalExpression.g:51:9: '|' { - match("false"); - + match('|'); } @@ -978,10 +977,10 @@ public final void mT__55() throws RecognitionException { try { int _type = T__55; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:54:7: ( 'null' ) - // InternalExpression.g:54:9: 'null' + // InternalExpression.g:52:7: ( 'true' ) + // InternalExpression.g:52:9: 'true' { - match("null"); + match("true"); } @@ -999,10 +998,10 @@ public final void mT__56() throws RecognitionException { try { int _type = T__56; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:55:7: ( 'GLOBALVAR' ) - // InternalExpression.g:55:9: 'GLOBALVAR' + // InternalExpression.g:53:7: ( 'false' ) + // InternalExpression.g:53:9: 'false' { - match("GLOBALVAR"); + match("false"); } @@ -1020,10 +1019,10 @@ public final void mT__57() throws RecognitionException { try { int _type = T__57; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:56:7: ( 'new' ) - // InternalExpression.g:56:9: 'new' + // InternalExpression.g:54:7: ( 'null' ) + // InternalExpression.g:54:9: 'null' { - match("new"); + match("null"); } @@ -1041,10 +1040,10 @@ public final void mT__58() throws RecognitionException { try { int _type = T__58; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:57:7: ( 'Collection' ) - // InternalExpression.g:57:9: 'Collection' + // InternalExpression.g:55:7: ( 'GLOBALVAR' ) + // InternalExpression.g:55:9: 'GLOBALVAR' { - match("Collection"); + match("GLOBALVAR"); } @@ -1062,10 +1061,10 @@ public final void mT__59() throws RecognitionException { try { int _type = T__59; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:58:7: ( 'List' ) - // InternalExpression.g:58:9: 'List' + // InternalExpression.g:56:7: ( 'new' ) + // InternalExpression.g:56:9: 'new' { - match("List"); + match("new"); } @@ -1083,10 +1082,10 @@ public final void mT__60() throws RecognitionException { try { int _type = T__60; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:59:7: ( 'Set' ) - // InternalExpression.g:59:9: 'Set' + // InternalExpression.g:57:7: ( 'Collection' ) + // InternalExpression.g:57:9: 'Collection' { - match("Set"); + match("Collection"); } @@ -1104,10 +1103,11 @@ public final void mT__61() throws RecognitionException { try { int _type = T__61; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:60:7: ( '[' ) - // InternalExpression.g:60:9: '[' + // InternalExpression.g:58:7: ( 'List' ) + // InternalExpression.g:58:9: 'List' { - match('['); + match("List"); + } @@ -1124,10 +1124,11 @@ public final void mT__62() throws RecognitionException { try { int _type = T__62; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:61:7: ( ']' ) - // InternalExpression.g:61:9: ']' + // InternalExpression.g:59:7: ( 'Set' ) + // InternalExpression.g:59:9: 'Set' { - match(']'); + match("Set"); + } @@ -1144,11 +1145,10 @@ public final void mT__63() throws RecognitionException { try { int _type = T__63; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:62:7: ( '::' ) - // InternalExpression.g:62:9: '::' + // InternalExpression.g:60:7: ( '[' ) + // InternalExpression.g:60:9: '[' { - match("::"); - + match('['); } @@ -1160,65 +1160,15 @@ public final void mT__63() throws RecognitionException { } // $ANTLR end "T__63" - // $ANTLR start "RULE_REAL" - public final void mRULE_REAL() throws RecognitionException { + // $ANTLR start "T__64" + public final void mT__64() throws RecognitionException { try { - int _type = RULE_REAL; + int _type = T__64; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2776:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) - // InternalExpression.g:2776:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + // InternalExpression.g:61:7: ( ']' ) + // InternalExpression.g:61:9: ']' { - // InternalExpression.g:2776:13: ( '0' .. '9' )* - loop1: - do { - int alt1=2; - int LA1_0 = input.LA(1); - - if ( ((LA1_0>='0' && LA1_0<='9')) ) { - alt1=1; - } - - - switch (alt1) { - case 1 : - // InternalExpression.g:2776:14: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - break loop1; - } - } while (true); - - match('.'); - // InternalExpression.g:2776:29: ( '0' .. '9' )* - loop2: - do { - int alt2=2; - int LA2_0 = input.LA(1); - - if ( ((LA2_0>='0' && LA2_0<='9')) ) { - alt2=1; - } - - - switch (alt2) { - case 1 : - // InternalExpression.g:2776:30: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - break loop2; - } - } while (true); - + match(']'); } @@ -1228,75 +1178,80 @@ public final void mRULE_REAL() throws RecognitionException { finally { } } - // $ANTLR end "RULE_REAL" + // $ANTLR end "T__64" - // $ANTLR start "RULE_ID" - public final void mRULE_ID() throws RecognitionException { + // $ANTLR start "T__65" + public final void mT__65() throws RecognitionException { try { - int _type = RULE_ID; + int _type = T__65; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2778:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalExpression.g:2778:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalExpression.g:62:7: ( '::' ) + // InternalExpression.g:62:9: '::' { - // InternalExpression.g:2778:11: ( '^' )? - int alt3=2; - int LA3_0 = input.LA(1); - - if ( (LA3_0=='^') ) { - alt3=1; - } - switch (alt3) { - case 1 : - // InternalExpression.g:2778:11: '^' - { - match('^'); + match("::"); - } - break; } - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { - input.consume(); + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__65" - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + // $ANTLR start "T__66" + public final void mT__66() throws RecognitionException { + try { + int _type = T__66; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:63:7: ( '+=' ) + // InternalExpression.g:63:9: '+=' + { + match("+="); - // InternalExpression.g:2778:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop4: - do { - int alt4=2; - int LA4_0 = input.LA(1); - if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { - alt4=1; - } + } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__66" - switch (alt4) { - case 1 : - // InternalExpression.g: - { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { - input.consume(); + // $ANTLR start "T__67" + public final void mT__67() throws RecognitionException { + try { + int _type = T__67; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:64:7: ( '-=' ) + // InternalExpression.g:64:9: '-=' + { + match("-="); - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + } - } - break; + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__67" - default : - break loop4; - } - } while (true); + // $ANTLR start "T__68" + public final void mT__68() throws RecognitionException { + try { + int _type = T__68; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:65:7: ( '*=' ) + // InternalExpression.g:65:9: '*=' + { + match("*="); } @@ -1307,44 +1262,1050 @@ public final void mRULE_ID() throws RecognitionException { finally { } } - // $ANTLR end "RULE_ID" + // $ANTLR end "T__68" - // $ANTLR start "RULE_INT" - public final void mRULE_INT() throws RecognitionException { + // $ANTLR start "T__69" + public final void mT__69() throws RecognitionException { try { - int _type = RULE_INT; + int _type = T__69; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2780:10: ( ( '0' .. '9' )+ ) - // InternalExpression.g:2780:12: ( '0' .. '9' )+ + // InternalExpression.g:66:7: ( '/=' ) + // InternalExpression.g:66:9: '/=' { - // InternalExpression.g:2780:12: ( '0' .. '9' )+ - int cnt5=0; - loop5: - do { - int alt5=2; - int LA5_0 = input.LA(1); + match("/="); - if ( ((LA5_0>='0' && LA5_0<='9')) ) { - alt5=1; + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__69" + + // $ANTLR start "T__70" + public final void mT__70() throws RecognitionException { + try { + int _type = T__70; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:67:7: ( '%=' ) + // InternalExpression.g:67:9: '%=' + { + match("%="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__70" + + // $ANTLR start "T__71" + public final void mT__71() throws RecognitionException { + try { + int _type = T__71; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:68:7: ( '===' ) + // InternalExpression.g:68:9: '===' + { + match("==="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__71" + + // $ANTLR start "T__72" + public final void mT__72() throws RecognitionException { + try { + int _type = T__72; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:69:7: ( '!==' ) + // InternalExpression.g:69:9: '!==' + { + match("!=="); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__72" + + // $ANTLR start "T__73" + public final void mT__73() throws RecognitionException { + try { + int _type = T__73; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:70:7: ( 'instanceof' ) + // InternalExpression.g:70:9: 'instanceof' + { + match("instanceof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__73" + + // $ANTLR start "T__74" + public final void mT__74() throws RecognitionException { + try { + int _type = T__74; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:71:7: ( '..<' ) + // InternalExpression.g:71:9: '..<' + { + match("..<"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__74" + + // $ANTLR start "T__75" + public final void mT__75() throws RecognitionException { + try { + int _type = T__75; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:72:7: ( '..' ) + // InternalExpression.g:72:9: '..' + { + match(".."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__75" + + // $ANTLR start "T__76" + public final void mT__76() throws RecognitionException { + try { + int _type = T__76; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:73:7: ( '=>' ) + // InternalExpression.g:73:9: '=>' + { + match("=>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__76" + + // $ANTLR start "T__77" + public final void mT__77() throws RecognitionException { + try { + int _type = T__77; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:74:7: ( '<>' ) + // InternalExpression.g:74:9: '<>' + { + match("<>"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__77" + + // $ANTLR start "T__78" + public final void mT__78() throws RecognitionException { + try { + int _type = T__78; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:75:7: ( '?:' ) + // InternalExpression.g:75:9: '?:' + { + match("?:"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__78" + + // $ANTLR start "T__79" + public final void mT__79() throws RecognitionException { + try { + int _type = T__79; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:76:7: ( '**' ) + // InternalExpression.g:76:9: '**' + { + match("**"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__79" + + // $ANTLR start "T__80" + public final void mT__80() throws RecognitionException { + try { + int _type = T__80; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:77:7: ( '%' ) + // InternalExpression.g:77:9: '%' + { + match('%'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__80" + + // $ANTLR start "T__81" + public final void mT__81() throws RecognitionException { + try { + int _type = T__81; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:78:7: ( 'as' ) + // InternalExpression.g:78:9: 'as' + { + match("as"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__81" + + // $ANTLR start "T__82" + public final void mT__82() throws RecognitionException { + try { + int _type = T__82; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:79:7: ( '++' ) + // InternalExpression.g:79:9: '++' + { + match("++"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__82" + + // $ANTLR start "T__83" + public final void mT__83() throws RecognitionException { + try { + int _type = T__83; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:80:7: ( '--' ) + // InternalExpression.g:80:9: '--' + { + match("--"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__83" + + // $ANTLR start "T__84" + public final void mT__84() throws RecognitionException { + try { + int _type = T__84; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:81:7: ( '?.' ) + // InternalExpression.g:81:9: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__84" + + // $ANTLR start "T__85" + public final void mT__85() throws RecognitionException { + try { + int _type = T__85; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:82:7: ( '#' ) + // InternalExpression.g:82:9: '#' + { + match('#'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__85" + + // $ANTLR start "T__86" + public final void mT__86() throws RecognitionException { + try { + int _type = T__86; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:83:7: ( ';' ) + // InternalExpression.g:83:9: ';' + { + match(';'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__86" + + // $ANTLR start "T__87" + public final void mT__87() throws RecognitionException { + try { + int _type = T__87; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:84:7: ( 'for' ) + // InternalExpression.g:84:9: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__87" + + // $ANTLR start "T__88" + public final void mT__88() throws RecognitionException { + try { + int _type = T__88; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:85:7: ( 'while' ) + // InternalExpression.g:85:9: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:86:7: ( 'do' ) + // InternalExpression.g:86:9: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" + + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:87:7: ( 'var' ) + // InternalExpression.g:87:9: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__90" + + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { + try { + int _type = T__91; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:88:7: ( 'val' ) + // InternalExpression.g:88:9: 'val' + { + match("val"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" + + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:89:7: ( 'extends' ) + // InternalExpression.g:89:9: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" + + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:90:7: ( 'static' ) + // InternalExpression.g:90:9: 'static' + { + match("static"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:91:7: ( 'import' ) + // InternalExpression.g:91:9: 'import' + { + match("import"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:92:7: ( 'extension' ) + // InternalExpression.g:92:9: 'extension' + { + match("extension"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__95" + + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { + try { + int _type = T__96; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:93:7: ( 'super' ) + // InternalExpression.g:93:9: 'super' + { + match("super"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" + + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:94:7: ( 'typeof' ) + // InternalExpression.g:94:9: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__97" + + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { + try { + int _type = T__98; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:95:7: ( 'throw' ) + // InternalExpression.g:95:9: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:96:7: ( 'return' ) + // InternalExpression.g:96:9: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:97:8: ( 'try' ) + // InternalExpression.g:97:10: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:98:8: ( 'finally' ) + // InternalExpression.g:98:10: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:99:8: ( 'synchronized' ) + // InternalExpression.g:99:10: 'synchronized' + { + match("synchronized"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:100:8: ( 'catch' ) + // InternalExpression.g:100:10: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:101:8: ( '&' ) + // InternalExpression.g:101:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "RULE_REAL" + public final void mRULE_REAL() throws RecognitionException { + try { + int _type = RULE_REAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:9058:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) + // InternalExpression.g:9058:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + { + // InternalExpression.g:9058:13: ( '0' .. '9' )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( ((LA1_0>='0' && LA1_0<='9')) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalExpression.g:9058:14: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop1; + } + } while (true); + + match('.'); + // InternalExpression.g:9058:29: ( '0' .. '9' )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( ((LA2_0>='0' && LA2_0<='9')) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalExpression.g:9058:30: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_REAL" + + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:9060:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // InternalExpression.g:9060:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // InternalExpression.g:9060:12: ( '0x' | '0X' ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='0') ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1=='x') ) { + alt3=1; + } + else if ( (LA3_1=='X') ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalExpression.g:9060:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // InternalExpression.g:9060:18: '0X' + { + match("0X"); + + + } + break; + + } + + // InternalExpression.g:9060:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ + int cnt4=0; + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='f')) ) { + alt4=1; } - switch (alt5) { + switch (alt4) { case 1 : - // InternalExpression.g:2780:13: '0' .. '9' + // InternalExpression.g: { - matchRange('0','9'); + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + } break; default : - if ( cnt5 >= 1 ) break loop5; + if ( cnt4 >= 1 ) break loop4; EarlyExitException eee = - new EarlyExitException(5, input); + new EarlyExitException(4, input); throw eee; } - cnt5++; + cnt4++; + } while (true); + + // InternalExpression.g:9060:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='#') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalExpression.g:9060:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // InternalExpression.g:9060:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='B'||LA5_0=='b') ) { + alt5=1; + } + else if ( (LA5_0=='L'||LA5_0=='l') ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalExpression.g:9060:64: ( 'b' | 'B' ) ( 'i' | 'I' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='I'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExpression.g:9060:84: ( 'l' | 'L' ) + { + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_HEX" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:9062:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // InternalExpression.g:9062:12: '0' .. '9' ( '0' .. '9' | '_' )* + { + matchRange('0','9'); + // InternalExpression.g:9062:21: ( '0' .. '9' | '_' )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||LA7_0=='_') ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalExpression.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } } while (true); @@ -1358,52 +2319,257 @@ public final void mRULE_INT() throws RecognitionException { } // $ANTLR end "RULE_INT" + // $ANTLR start "RULE_DECIMAL" + public final void mRULE_DECIMAL() throws RecognitionException { + try { + int _type = RULE_DECIMAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:9064:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // InternalExpression.g:9064:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // InternalExpression.g:9064:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='E'||LA9_0=='e') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalExpression.g:9064:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalExpression.g:9064:36: ( '+' | '-' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='+'||LA8_0=='-') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalExpression.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_INT(); + + } + break; + + } + + // InternalExpression.g:9064:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='B'||LA10_0=='b') ) { + alt10=1; + } + else if ( (LA10_0=='D'||LA10_0=='F'||LA10_0=='L'||LA10_0=='d'||LA10_0=='f'||LA10_0=='l') ) { + alt10=2; + } + switch (alt10) { + case 1 : + // InternalExpression.g:9064:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalExpression.g:9064:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) + { + if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECIMAL" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalExpression.g:9066:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalExpression.g:9066:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + { + // InternalExpression.g:9066:11: ( '^' )? + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0=='^') ) { + alt11=1; + } + switch (alt11) { + case 1 : + // InternalExpression.g:9066:11: '^' + { + match('^'); + + } + break; + + } + + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalExpression.g:9066:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0=='$'||(LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalExpression.g: + { + if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop12; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + // $ANTLR start "RULE_STRING" public final void mRULE_STRING() throws RecognitionException { try { int _type = RULE_STRING; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2782:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalExpression.g:2782:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalExpression.g:9068:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalExpression.g:9068:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) { - // InternalExpression.g:2782:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt8=2; - int LA8_0 = input.LA(1); + // InternalExpression.g:9068:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA8_0=='\"') ) { - alt8=1; + if ( (LA17_0=='\"') ) { + alt17=1; } - else if ( (LA8_0=='\'') ) { - alt8=2; + else if ( (LA17_0=='\'') ) { + alt17=2; } else { NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + new NoViableAltException("", 17, 0, input); throw nvae; } - switch (alt8) { + switch (alt17) { case 1 : - // InternalExpression.g:2782:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + // InternalExpression.g:9068:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? { match('\"'); - // InternalExpression.g:2782:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop6: + // InternalExpression.g:9068:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop13: do { - int alt6=3; - int LA6_0 = input.LA(1); + int alt13=3; + int LA13_0 = input.LA(1); - if ( (LA6_0=='\\') ) { - alt6=1; + if ( (LA13_0=='\\') ) { + alt13=1; } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; + else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) { + alt13=2; } - switch (alt6) { + switch (alt13) { case 1 : - // InternalExpression.g:2782:21: '\\\\' . + // InternalExpression.g:9068:21: '\\\\' . { match('\\'); matchAny(); @@ -1411,7 +2577,7 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= } break; case 2 : - // InternalExpression.g:2782:28: ~ ( ( '\\\\' | '\"' ) ) + // InternalExpression.g:9068:28: ~ ( ( '\\\\' | '\"' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1427,35 +2593,52 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= break; default : - break loop6; + break loop13; } } while (true); - match('\"'); + // InternalExpression.g:9068:44: ( '\"' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\"') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalExpression.g:9068:44: '\"' + { + match('\"'); + + } + break; + + } + } break; case 2 : - // InternalExpression.g:2782:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + // InternalExpression.g:9068:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? { match('\''); - // InternalExpression.g:2782:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop7: + // InternalExpression.g:9068:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop15: do { - int alt7=3; - int LA7_0 = input.LA(1); + int alt15=3; + int LA15_0 = input.LA(1); - if ( (LA7_0=='\\') ) { - alt7=1; + if ( (LA15_0=='\\') ) { + alt15=1; } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; + else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) { + alt15=2; } - switch (alt7) { + switch (alt15) { case 1 : - // InternalExpression.g:2782:54: '\\\\' . + // InternalExpression.g:9068:55: '\\\\' . { match('\\'); matchAny(); @@ -1463,7 +2646,7 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= } break; case 2 : - // InternalExpression.g:2782:61: ~ ( ( '\\\\' | '\\'' ) ) + // InternalExpression.g:9068:62: ~ ( ( '\\\\' | '\\'' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1475,15 +2658,32 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= throw mse;} - } - break; + } + break; + + default : + break loop15; + } + } while (true); + + // InternalExpression.g:9068:79: ( '\\'' )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalExpression.g:9068:79: '\\'' + { + match('\''); + + } + break; - default : - break loop7; - } - } while (true); + } - match('\''); } break; @@ -1506,37 +2706,37 @@ public final void mRULE_ML_COMMENT() throws RecognitionException { try { int _type = RULE_ML_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2784:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalExpression.g:2784:19: '/*' ( options {greedy=false; } : . )* '*/' + // InternalExpression.g:9070:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalExpression.g:9070:19: '/*' ( options {greedy=false; } : . )* '*/' { match("/*"); - // InternalExpression.g:2784:24: ( options {greedy=false; } : . )* - loop9: + // InternalExpression.g:9070:24: ( options {greedy=false; } : . )* + loop18: do { - int alt9=2; - int LA9_0 = input.LA(1); + int alt18=2; + int LA18_0 = input.LA(1); - if ( (LA9_0=='*') ) { - int LA9_1 = input.LA(2); + if ( (LA18_0=='*') ) { + int LA18_1 = input.LA(2); - if ( (LA9_1=='/') ) { - alt9=2; + if ( (LA18_1=='/') ) { + alt18=2; } - else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) { + alt18=1; } } - else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) { + alt18=1; } - switch (alt9) { + switch (alt18) { case 1 : - // InternalExpression.g:2784:52: . + // InternalExpression.g:9070:52: . { matchAny(); @@ -1544,7 +2744,7 @@ else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { break; default : - break loop9; + break loop18; } } while (true); @@ -1566,25 +2766,25 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { try { int _type = RULE_SL_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2786:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalExpression.g:2786:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + // InternalExpression.g:9072:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalExpression.g:9072:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? { match("//"); - // InternalExpression.g:2786:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop10: + // InternalExpression.g:9072:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop19: do { - int alt10=2; - int LA10_0 = input.LA(1); + int alt19=2; + int LA19_0 = input.LA(1); - if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\uFFFF')) ) { - alt10=1; + if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { + alt19=1; } - switch (alt10) { + switch (alt19) { case 1 : - // InternalExpression.g:2786:24: ~ ( ( '\\n' | '\\r' ) ) + // InternalExpression.g:9072:24: ~ ( ( '\\n' | '\\r' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1600,31 +2800,31 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { break; default : - break loop10; + break loop19; } } while (true); - // InternalExpression.g:2786:40: ( ( '\\r' )? '\\n' )? - int alt12=2; - int LA12_0 = input.LA(1); + // InternalExpression.g:9072:40: ( ( '\\r' )? '\\n' )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA12_0=='\n'||LA12_0=='\r') ) { - alt12=1; + if ( (LA21_0=='\n'||LA21_0=='\r') ) { + alt21=1; } - switch (alt12) { + switch (alt21) { case 1 : - // InternalExpression.g:2786:41: ( '\\r' )? '\\n' + // InternalExpression.g:9072:41: ( '\\r' )? '\\n' { - // InternalExpression.g:2786:41: ( '\\r' )? - int alt11=2; - int LA11_0 = input.LA(1); + // InternalExpression.g:9072:41: ( '\\r' )? + int alt20=2; + int LA20_0 = input.LA(1); - if ( (LA11_0=='\r') ) { - alt11=1; + if ( (LA20_0=='\r') ) { + alt20=1; } - switch (alt11) { + switch (alt20) { case 1 : - // InternalExpression.g:2786:41: '\\r' + // InternalExpression.g:9072:41: '\\r' { match('\r'); @@ -1656,22 +2856,22 @@ public final void mRULE_WS() throws RecognitionException { try { int _type = RULE_WS; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2788:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalExpression.g:2788:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + // InternalExpression.g:9074:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalExpression.g:9074:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ { - // InternalExpression.g:2788:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt13=0; - loop13: + // InternalExpression.g:9074:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt22=0; + loop22: do { - int alt13=2; - int LA13_0 = input.LA(1); + int alt22=2; + int LA22_0 = input.LA(1); - if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) { - alt13=1; + if ( ((LA22_0>='\t' && LA22_0<='\n')||LA22_0=='\r'||LA22_0==' ') ) { + alt22=1; } - switch (alt13) { + switch (alt22) { case 1 : // InternalExpression.g: { @@ -1689,12 +2889,12 @@ public final void mRULE_WS() throws RecognitionException { break; default : - if ( cnt13 >= 1 ) break loop13; + if ( cnt22 >= 1 ) break loop22; EarlyExitException eee = - new EarlyExitException(13, input); + new EarlyExitException(22, input); throw eee; } - cnt13++; + cnt22++; } while (true); @@ -1713,8 +2913,8 @@ public final void mRULE_ANY_OTHER() throws RecognitionException { try { int _type = RULE_ANY_OTHER; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalExpression.g:2790:16: ( . ) - // InternalExpression.g:2790:18: . + // InternalExpression.g:9076:16: ( . ) + // InternalExpression.g:9076:18: . { matchAny(); @@ -1729,425 +2929,712 @@ public final void mRULE_ANY_OTHER() throws RecognitionException { // $ANTLR end "RULE_ANY_OTHER" public void mTokens() throws RecognitionException { - // InternalExpression.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | RULE_REAL | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt14=60; - alt14 = dfa14.predict(input); - switch (alt14) { + // InternalExpression.g:1:8: ( T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | RULE_REAL | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt23=101; + alt23 = dfa23.predict(input); + switch (alt23) { case 1 : - // InternalExpression.g:1:10: T__12 + // InternalExpression.g:1:10: T__14 { - mT__12(); + mT__14(); } break; case 2 : - // InternalExpression.g:1:16: T__13 + // InternalExpression.g:1:16: T__15 + { + mT__15(); + + } + break; + case 3 : + // InternalExpression.g:1:22: T__16 + { + mT__16(); + + } + break; + case 4 : + // InternalExpression.g:1:28: T__17 + { + mT__17(); + + } + break; + case 5 : + // InternalExpression.g:1:34: T__18 + { + mT__18(); + + } + break; + case 6 : + // InternalExpression.g:1:40: T__19 + { + mT__19(); + + } + break; + case 7 : + // InternalExpression.g:1:46: T__20 + { + mT__20(); + + } + break; + case 8 : + // InternalExpression.g:1:52: T__21 + { + mT__21(); + + } + break; + case 9 : + // InternalExpression.g:1:58: T__22 + { + mT__22(); + + } + break; + case 10 : + // InternalExpression.g:1:64: T__23 + { + mT__23(); + + } + break; + case 11 : + // InternalExpression.g:1:70: T__24 + { + mT__24(); + + } + break; + case 12 : + // InternalExpression.g:1:76: T__25 + { + mT__25(); + + } + break; + case 13 : + // InternalExpression.g:1:82: T__26 + { + mT__26(); + + } + break; + case 14 : + // InternalExpression.g:1:88: T__27 + { + mT__27(); + + } + break; + case 15 : + // InternalExpression.g:1:94: T__28 + { + mT__28(); + + } + break; + case 16 : + // InternalExpression.g:1:100: T__29 + { + mT__29(); + + } + break; + case 17 : + // InternalExpression.g:1:106: T__30 + { + mT__30(); + + } + break; + case 18 : + // InternalExpression.g:1:112: T__31 + { + mT__31(); + + } + break; + case 19 : + // InternalExpression.g:1:118: T__32 + { + mT__32(); + + } + break; + case 20 : + // InternalExpression.g:1:124: T__33 + { + mT__33(); + + } + break; + case 21 : + // InternalExpression.g:1:130: T__34 + { + mT__34(); + + } + break; + case 22 : + // InternalExpression.g:1:136: T__35 + { + mT__35(); + + } + break; + case 23 : + // InternalExpression.g:1:142: T__36 + { + mT__36(); + + } + break; + case 24 : + // InternalExpression.g:1:148: T__37 + { + mT__37(); + + } + break; + case 25 : + // InternalExpression.g:1:154: T__38 + { + mT__38(); + + } + break; + case 26 : + // InternalExpression.g:1:160: T__39 + { + mT__39(); + + } + break; + case 27 : + // InternalExpression.g:1:166: T__40 + { + mT__40(); + + } + break; + case 28 : + // InternalExpression.g:1:172: T__41 + { + mT__41(); + + } + break; + case 29 : + // InternalExpression.g:1:178: T__42 + { + mT__42(); + + } + break; + case 30 : + // InternalExpression.g:1:184: T__43 + { + mT__43(); + + } + break; + case 31 : + // InternalExpression.g:1:190: T__44 + { + mT__44(); + + } + break; + case 32 : + // InternalExpression.g:1:196: T__45 + { + mT__45(); + + } + break; + case 33 : + // InternalExpression.g:1:202: T__46 + { + mT__46(); + + } + break; + case 34 : + // InternalExpression.g:1:208: T__47 + { + mT__47(); + + } + break; + case 35 : + // InternalExpression.g:1:214: T__48 + { + mT__48(); + + } + break; + case 36 : + // InternalExpression.g:1:220: T__49 + { + mT__49(); + + } + break; + case 37 : + // InternalExpression.g:1:226: T__50 + { + mT__50(); + + } + break; + case 38 : + // InternalExpression.g:1:232: T__51 + { + mT__51(); + + } + break; + case 39 : + // InternalExpression.g:1:238: T__52 + { + mT__52(); + + } + break; + case 40 : + // InternalExpression.g:1:244: T__53 + { + mT__53(); + + } + break; + case 41 : + // InternalExpression.g:1:250: T__54 + { + mT__54(); + + } + break; + case 42 : + // InternalExpression.g:1:256: T__55 + { + mT__55(); + + } + break; + case 43 : + // InternalExpression.g:1:262: T__56 { - mT__13(); + mT__56(); } break; - case 3 : - // InternalExpression.g:1:22: T__14 + case 44 : + // InternalExpression.g:1:268: T__57 { - mT__14(); + mT__57(); } break; - case 4 : - // InternalExpression.g:1:28: T__15 + case 45 : + // InternalExpression.g:1:274: T__58 { - mT__15(); + mT__58(); } break; - case 5 : - // InternalExpression.g:1:34: T__16 + case 46 : + // InternalExpression.g:1:280: T__59 { - mT__16(); + mT__59(); } break; - case 6 : - // InternalExpression.g:1:40: T__17 + case 47 : + // InternalExpression.g:1:286: T__60 { - mT__17(); + mT__60(); } break; - case 7 : - // InternalExpression.g:1:46: T__18 + case 48 : + // InternalExpression.g:1:292: T__61 { - mT__18(); + mT__61(); } break; - case 8 : - // InternalExpression.g:1:52: T__19 + case 49 : + // InternalExpression.g:1:298: T__62 { - mT__19(); + mT__62(); } break; - case 9 : - // InternalExpression.g:1:58: T__20 + case 50 : + // InternalExpression.g:1:304: T__63 { - mT__20(); + mT__63(); } break; - case 10 : - // InternalExpression.g:1:64: T__21 + case 51 : + // InternalExpression.g:1:310: T__64 { - mT__21(); + mT__64(); } break; - case 11 : - // InternalExpression.g:1:70: T__22 + case 52 : + // InternalExpression.g:1:316: T__65 { - mT__22(); + mT__65(); } break; - case 12 : - // InternalExpression.g:1:76: T__23 + case 53 : + // InternalExpression.g:1:322: T__66 { - mT__23(); + mT__66(); } break; - case 13 : - // InternalExpression.g:1:82: T__24 + case 54 : + // InternalExpression.g:1:328: T__67 { - mT__24(); + mT__67(); } break; - case 14 : - // InternalExpression.g:1:88: T__25 + case 55 : + // InternalExpression.g:1:334: T__68 { - mT__25(); + mT__68(); } break; - case 15 : - // InternalExpression.g:1:94: T__26 + case 56 : + // InternalExpression.g:1:340: T__69 { - mT__26(); + mT__69(); } break; - case 16 : - // InternalExpression.g:1:100: T__27 + case 57 : + // InternalExpression.g:1:346: T__70 { - mT__27(); + mT__70(); } break; - case 17 : - // InternalExpression.g:1:106: T__28 + case 58 : + // InternalExpression.g:1:352: T__71 { - mT__28(); + mT__71(); } break; - case 18 : - // InternalExpression.g:1:112: T__29 + case 59 : + // InternalExpression.g:1:358: T__72 { - mT__29(); + mT__72(); } break; - case 19 : - // InternalExpression.g:1:118: T__30 + case 60 : + // InternalExpression.g:1:364: T__73 { - mT__30(); + mT__73(); } break; - case 20 : - // InternalExpression.g:1:124: T__31 + case 61 : + // InternalExpression.g:1:370: T__74 { - mT__31(); + mT__74(); } break; - case 21 : - // InternalExpression.g:1:130: T__32 + case 62 : + // InternalExpression.g:1:376: T__75 { - mT__32(); + mT__75(); } break; - case 22 : - // InternalExpression.g:1:136: T__33 + case 63 : + // InternalExpression.g:1:382: T__76 { - mT__33(); + mT__76(); } break; - case 23 : - // InternalExpression.g:1:142: T__34 + case 64 : + // InternalExpression.g:1:388: T__77 { - mT__34(); + mT__77(); } break; - case 24 : - // InternalExpression.g:1:148: T__35 + case 65 : + // InternalExpression.g:1:394: T__78 { - mT__35(); + mT__78(); } break; - case 25 : - // InternalExpression.g:1:154: T__36 + case 66 : + // InternalExpression.g:1:400: T__79 { - mT__36(); + mT__79(); } break; - case 26 : - // InternalExpression.g:1:160: T__37 + case 67 : + // InternalExpression.g:1:406: T__80 { - mT__37(); + mT__80(); } break; - case 27 : - // InternalExpression.g:1:166: T__38 + case 68 : + // InternalExpression.g:1:412: T__81 { - mT__38(); + mT__81(); } break; - case 28 : - // InternalExpression.g:1:172: T__39 + case 69 : + // InternalExpression.g:1:418: T__82 { - mT__39(); + mT__82(); } break; - case 29 : - // InternalExpression.g:1:178: T__40 + case 70 : + // InternalExpression.g:1:424: T__83 { - mT__40(); + mT__83(); } break; - case 30 : - // InternalExpression.g:1:184: T__41 + case 71 : + // InternalExpression.g:1:430: T__84 { - mT__41(); + mT__84(); } break; - case 31 : - // InternalExpression.g:1:190: T__42 + case 72 : + // InternalExpression.g:1:436: T__85 { - mT__42(); + mT__85(); } break; - case 32 : - // InternalExpression.g:1:196: T__43 + case 73 : + // InternalExpression.g:1:442: T__86 { - mT__43(); + mT__86(); } break; - case 33 : - // InternalExpression.g:1:202: T__44 + case 74 : + // InternalExpression.g:1:448: T__87 { - mT__44(); + mT__87(); } break; - case 34 : - // InternalExpression.g:1:208: T__45 + case 75 : + // InternalExpression.g:1:454: T__88 { - mT__45(); + mT__88(); } break; - case 35 : - // InternalExpression.g:1:214: T__46 + case 76 : + // InternalExpression.g:1:460: T__89 { - mT__46(); + mT__89(); } break; - case 36 : - // InternalExpression.g:1:220: T__47 + case 77 : + // InternalExpression.g:1:466: T__90 { - mT__47(); + mT__90(); } break; - case 37 : - // InternalExpression.g:1:226: T__48 + case 78 : + // InternalExpression.g:1:472: T__91 { - mT__48(); + mT__91(); } break; - case 38 : - // InternalExpression.g:1:232: T__49 + case 79 : + // InternalExpression.g:1:478: T__92 { - mT__49(); + mT__92(); } break; - case 39 : - // InternalExpression.g:1:238: T__50 + case 80 : + // InternalExpression.g:1:484: T__93 { - mT__50(); + mT__93(); } break; - case 40 : - // InternalExpression.g:1:244: T__51 + case 81 : + // InternalExpression.g:1:490: T__94 { - mT__51(); + mT__94(); } break; - case 41 : - // InternalExpression.g:1:250: T__52 + case 82 : + // InternalExpression.g:1:496: T__95 { - mT__52(); + mT__95(); } break; - case 42 : - // InternalExpression.g:1:256: T__53 + case 83 : + // InternalExpression.g:1:502: T__96 { - mT__53(); + mT__96(); } break; - case 43 : - // InternalExpression.g:1:262: T__54 + case 84 : + // InternalExpression.g:1:508: T__97 { - mT__54(); + mT__97(); } break; - case 44 : - // InternalExpression.g:1:268: T__55 + case 85 : + // InternalExpression.g:1:514: T__98 { - mT__55(); + mT__98(); } break; - case 45 : - // InternalExpression.g:1:274: T__56 + case 86 : + // InternalExpression.g:1:520: T__99 { - mT__56(); + mT__99(); } break; - case 46 : - // InternalExpression.g:1:280: T__57 + case 87 : + // InternalExpression.g:1:526: T__100 { - mT__57(); + mT__100(); } break; - case 47 : - // InternalExpression.g:1:286: T__58 + case 88 : + // InternalExpression.g:1:533: T__101 { - mT__58(); + mT__101(); } break; - case 48 : - // InternalExpression.g:1:292: T__59 + case 89 : + // InternalExpression.g:1:540: T__102 { - mT__59(); + mT__102(); } break; - case 49 : - // InternalExpression.g:1:298: T__60 + case 90 : + // InternalExpression.g:1:547: T__103 { - mT__60(); + mT__103(); } break; - case 50 : - // InternalExpression.g:1:304: T__61 + case 91 : + // InternalExpression.g:1:554: T__104 { - mT__61(); + mT__104(); } break; - case 51 : - // InternalExpression.g:1:310: T__62 + case 92 : + // InternalExpression.g:1:561: RULE_REAL { - mT__62(); + mRULE_REAL(); } break; - case 52 : - // InternalExpression.g:1:316: T__63 + case 93 : + // InternalExpression.g:1:571: RULE_HEX { - mT__63(); + mRULE_HEX(); } break; - case 53 : - // InternalExpression.g:1:322: RULE_REAL + case 94 : + // InternalExpression.g:1:580: RULE_INT { - mRULE_REAL(); + mRULE_INT(); } break; - case 54 : - // InternalExpression.g:1:332: RULE_ID + case 95 : + // InternalExpression.g:1:589: RULE_DECIMAL { - mRULE_ID(); + mRULE_DECIMAL(); } break; - case 55 : - // InternalExpression.g:1:340: RULE_INT + case 96 : + // InternalExpression.g:1:602: RULE_ID { - mRULE_INT(); + mRULE_ID(); } break; - case 56 : - // InternalExpression.g:1:349: RULE_STRING + case 97 : + // InternalExpression.g:1:610: RULE_STRING { mRULE_STRING(); } break; - case 57 : - // InternalExpression.g:1:361: RULE_ML_COMMENT + case 98 : + // InternalExpression.g:1:622: RULE_ML_COMMENT { mRULE_ML_COMMENT(); } break; - case 58 : - // InternalExpression.g:1:377: RULE_SL_COMMENT + case 99 : + // InternalExpression.g:1:638: RULE_SL_COMMENT { mRULE_SL_COMMENT(); } break; - case 59 : - // InternalExpression.g:1:393: RULE_WS + case 100 : + // InternalExpression.g:1:654: RULE_WS { mRULE_WS(); } break; - case 60 : - // InternalExpression.g:1:401: RULE_ANY_OTHER + case 101 : + // InternalExpression.g:1:662: RULE_ANY_OTHER { mRULE_ANY_OTHER(); @@ -2159,65 +3646,72 @@ public void mTokens() throws RecognitionException { } - protected DFA14 dfa14 = new DFA14(this); - static final String DFA14_eotS = - "\1\uffff\1\53\1\55\1\57\2\uffff\1\63\1\uffff\4\53\1\uffff\1\53\1\uffff\1\53\1\105\1\51\1\110\1\112\1\114\2\uffff\1\121\1\122\1\uffff\7\53\2\uffff\1\141\1\51\1\uffff\2\51\2\uffff\1\53\12\uffff\1\146\11\53\1\uffff\1\53\1\uffff\2\53\21\uffff\12\53\3\uffff\1\141\2\uffff\1\175\1\uffff\17\53\1\u008d\5\53\1\u0093\1\uffff\1\53\1\u0095\1\53\1\u0097\1\u0098\5\53\1\u009e\3\53\1\u00a2\1\uffff\4\53\1\u00a7\1\uffff\1\53\1\uffff\1\53\2\uffff\5\53\1\uffff\3\53\1\uffff\1\53\1\u00b3\2\53\1\uffff\2\53\1\u00b8\1\u00b9\1\u00bb\1\u00bc\2\53\1\u00bf\1\53\1\u00c1\1\uffff\2\53\1\u00c4\1\53\2\uffff\1\53\2\uffff\1\u00c7\1\u00c8\1\uffff\1\53\1\uffff\2\53\1\uffff\2\53\2\uffff\5\53\1\u00d3\1\u00d4\1\53\1\u00d6\1\53\2\uffff\1\u00d8\1\uffff\1\u00d9\2\uffff"; - static final String DFA14_eofS = - "\u00da\uffff"; - static final String DFA14_minS = - "\1\0\1\145\1\75\1\72\2\uffff\1\76\1\uffff\1\146\1\150\1\154\1\145\1\uffff\1\145\1\uffff\1\141\1\174\1\46\3\75\2\uffff\1\52\1\60\1\uffff\2\145\1\141\1\114\1\157\1\151\1\145\2\uffff\1\56\1\101\1\uffff\2\0\2\uffff\1\164\12\uffff\1\60\1\160\1\145\1\160\1\165\1\163\2\151\1\154\1\162\1\uffff\1\146\1\uffff\1\163\1\154\21\uffff\1\152\1\164\1\154\1\167\1\162\1\154\1\117\1\154\1\163\1\164\3\uffff\1\56\2\uffff\1\60\1\uffff\1\154\1\156\3\145\1\163\1\164\1\145\1\164\1\141\1\145\1\154\1\145\1\105\1\154\1\60\1\101\1\163\1\102\1\154\1\164\1\60\1\uffff\1\151\1\60\1\123\2\60\1\164\2\143\1\102\1\165\1\60\1\145\1\143\1\170\1\60\1\uffff\1\154\1\145\1\101\1\145\1\60\1\uffff\1\145\1\uffff\1\145\2\uffff\1\163\1\150\1\164\1\171\1\154\1\uffff\1\143\1\164\1\151\1\uffff\1\154\1\60\1\114\1\143\1\uffff\1\163\1\154\4\60\2\164\1\60\1\163\1\60\1\uffff\1\126\1\164\1\60\1\145\2\uffff\1\151\2\uffff\2\60\1\uffff\1\164\1\uffff\1\101\1\151\1\uffff\1\143\1\162\2\uffff\1\163\1\122\1\157\1\164\1\163\2\60\1\156\1\60\1\164\2\uffff\1\60\1\uffff\1\60\2\uffff"; - static final String DFA14_maxS = - "\1\uffff\1\145\1\75\1\72\2\uffff\1\76\1\uffff\1\155\1\171\1\170\1\167\1\uffff\1\145\1\uffff\1\157\1\174\1\46\3\75\2\uffff\1\57\1\71\1\uffff\1\145\1\165\1\157\1\114\1\157\1\151\1\145\2\uffff\1\71\1\172\1\uffff\2\uffff\2\uffff\1\164\12\uffff\1\172\1\160\1\145\1\160\1\165\1\163\2\151\1\154\1\162\1\uffff\1\146\1\uffff\1\163\1\154\21\uffff\1\152\1\164\1\154\1\167\1\162\1\154\1\117\1\154\1\163\1\164\3\uffff\1\71\2\uffff\1\172\1\uffff\1\154\1\156\3\145\1\163\1\164\1\145\1\164\1\141\1\145\1\154\1\145\1\105\1\154\1\172\1\101\1\163\1\102\1\154\1\164\1\172\1\uffff\1\151\1\172\1\123\2\172\1\164\2\143\1\102\1\165\1\172\1\145\1\143\1\170\1\172\1\uffff\1\154\1\145\1\101\1\145\1\172\1\uffff\1\145\1\uffff\1\145\2\uffff\1\163\1\150\1\164\1\171\1\154\1\uffff\1\143\1\164\1\151\1\uffff\1\154\1\172\1\114\1\143\1\uffff\1\163\1\154\4\172\2\164\1\172\1\163\1\172\1\uffff\1\126\1\164\1\172\1\145\2\uffff\1\151\2\uffff\2\172\1\uffff\1\164\1\uffff\1\101\1\151\1\uffff\1\143\1\162\2\uffff\1\163\1\122\1\157\1\164\1\163\2\172\1\156\1\172\1\164\2\uffff\1\172\1\uffff\1\172\2\uffff"; - static final String DFA14_acceptS = - "\4\uffff\1\4\1\5\1\uffff\1\7\4\uffff\1\14\1\uffff\1\16\6\uffff\1\31\1\33\2\uffff\1\37\7\uffff\1\62\1\63\2\uffff\1\66\2\uffff\1\73\1\74\1\uffff\1\66\1\23\1\2\1\64\1\3\1\4\1\5\1\6\1\32\1\7\12\uffff\1\14\1\uffff\1\16\2\uffff\1\20\1\51\1\21\1\24\1\35\1\25\1\27\1\26\1\30\1\31\1\33\1\71\1\72\1\34\1\36\1\65\1\37\12\uffff\1\62\1\63\1\67\1\uffff\1\70\1\73\1\uffff\1\10\26\uffff\1\1\17\uffff\1\56\5\uffff\1\61\1\uffff\1\11\1\uffff\1\52\1\12\5\uffff\1\17\3\uffff\1\54\4\uffff\1\60\13\uffff\1\53\4\uffff\1\45\1\13\1\uffff\1\42\1\47\2\uffff\1\44\1\uffff\1\50\2\uffff\1\22\2\uffff\1\15\1\41\12\uffff\1\46\1\55\1\uffff\1\40\1\uffff\1\57\1\43"; - static final String DFA14_specialS = - "\1\1\45\uffff\1\0\1\2\u00b2\uffff}>"; - static final String[] DFA14_transitionS = { - "\11\51\2\50\2\51\1\50\22\51\1\50\1\22\1\46\3\51\1\21\1\47\1\4\1\5\1\26\1\25\1\31\1\6\1\30\1\27\12\43\1\3\1\51\1\24\1\2\1\23\1\7\1\51\2\45\1\36\3\45\1\35\4\45\1\37\6\45\1\40\7\45\1\41\1\51\1\42\1\44\1\45\1\51\2\45\1\17\1\15\1\12\1\34\2\45\1\10\2\45\1\1\1\45\1\33\3\45\1\32\1\13\1\11\6\45\1\14\1\20\1\16\uff82\51", - "\1\52", - "\1\54", - "\1\56", + protected DFA23 dfa23 = new DFA23(this); + static final String DFA23_eotS = + "\1\uffff\1\62\1\65\1\67\2\uffff\1\75\1\100\4\62\1\uffff\1\62\1\uffff\1\62\1\126\1\130\1\132\1\134\1\137\1\142\1\145\1\151\1\153\1\uffff\7\62\2\uffff\1\174\1\62\2\uffff\2\62\2\u0083\1\60\5\uffff\1\62\1\uffff\1\u008b\15\uffff\1\u008c\15\62\1\uffff\1\62\1\u009e\1\uffff\2\62\4\uffff\1\u00a3\20\uffff\1\u00a5\3\uffff\13\62\4\uffff\1\u00b2\2\uffff\2\62\2\uffff\2\u0083\3\uffff\1\u00b6\3\uffff\6\62\1\u00be\12\62\1\uffff\3\62\4\uffff\4\62\1\u00d0\1\u00d2\5\62\1\u00d8\1\uffff\1\62\1\u00da\1\u00db\1\uffff\3\62\1\u00df\2\62\1\u00e3\1\uffff\1\u00e4\11\62\1\u00ee\5\62\1\u00f4\1\uffff\1\62\1\uffff\4\62\1\u00fa\1\uffff\1\62\2\uffff\3\62\1\uffff\1\u00ff\2\62\2\uffff\6\62\1\u0109\2\62\1\uffff\1\u010c\4\62\1\uffff\1\62\1\u0112\3\62\1\uffff\1\u0116\1\62\1\u0118\1\62\1\uffff\1\62\1\u011b\1\u011c\2\62\1\u011f\1\u0121\1\u0122\1\u0123\1\uffff\2\62\1\uffff\1\62\1\u0127\1\u0128\1\62\1\u012a\1\uffff\3\62\1\uffff\1\u012e\1\uffff\2\62\2\uffff\1\u0131\1\62\1\uffff\1\62\3\uffff\1\62\1\u0135\1\u0136\2\uffff\1\62\1\uffff\1\u0138\2\62\1\uffff\2\62\1\uffff\3\62\2\uffff\1\62\1\uffff\4\62\1\u0145\2\62\1\u0148\1\u0149\1\62\1\u014b\1\u014c\1\uffff\2\62\2\uffff\1\u014f\2\uffff\1\u0150\1\62\2\uffff\1\u0152\1\uffff"; + static final String DFA23_eofS = + "\u0153\uffff"; + static final String DFA23_minS = + "\1\0\1\145\1\75\1\72\2\uffff\1\55\1\56\1\146\1\150\1\154\1\145\1\uffff\1\145\1\uffff\1\141\1\174\1\46\3\75\1\53\2\52\1\56\1\uffff\2\145\1\141\1\114\1\157\1\151\1\145\2\uffff\1\75\1\163\2\uffff\1\150\1\141\2\56\1\44\5\uffff\1\164\1\uffff\1\75\15\uffff\1\44\1\160\1\163\1\145\1\160\1\165\1\163\2\151\1\154\1\162\1\141\1\160\1\156\1\uffff\1\146\1\44\1\uffff\1\163\1\154\4\uffff\1\75\20\uffff\1\74\3\uffff\1\152\1\164\1\154\1\167\1\162\1\154\1\156\1\117\1\154\1\163\1\164\4\uffff\1\44\2\uffff\1\151\1\154\2\uffff\1\56\1\60\3\uffff\1\44\3\uffff\1\154\1\164\1\156\1\157\2\145\1\44\1\145\1\163\1\145\1\164\1\145\2\164\1\145\1\143\1\141\1\uffff\1\145\1\143\1\154\4\uffff\1\145\1\165\1\105\1\154\2\44\1\163\1\141\1\102\1\154\1\164\1\44\1\uffff\1\154\2\44\1\uffff\1\151\1\162\1\141\1\44\1\167\1\123\1\44\1\uffff\1\44\1\164\1\156\2\143\1\102\1\151\1\162\1\150\1\165\1\44\1\150\1\145\1\143\1\162\1\170\1\44\1\uffff\1\154\1\uffff\1\145\1\154\1\101\1\145\1\44\1\uffff\1\145\2\uffff\1\145\1\164\1\156\1\uffff\1\44\1\145\1\146\2\uffff\1\163\1\144\1\150\1\164\1\171\1\143\1\44\1\162\1\154\1\uffff\1\44\1\143\1\164\1\156\1\151\1\uffff\1\154\1\44\1\154\1\114\1\143\1\uffff\1\44\1\163\1\44\1\143\1\uffff\1\154\2\44\1\163\1\151\4\44\1\uffff\1\157\1\164\1\uffff\1\164\2\44\1\163\1\44\1\uffff\1\171\1\126\1\164\1\uffff\1\44\1\uffff\2\145\2\uffff\1\44\1\157\1\uffff\1\151\3\uffff\1\156\2\44\2\uffff\1\164\1\uffff\1\44\1\101\1\151\1\uffff\1\157\1\143\1\uffff\1\156\1\162\1\151\2\uffff\1\163\1\uffff\1\122\1\157\1\146\1\164\1\44\1\163\1\172\2\44\1\156\2\44\1\uffff\1\164\1\145\2\uffff\1\44\2\uffff\1\44\1\144\2\uffff\1\44\1\uffff"; + static final String DFA23_maxS = + "\1\uffff\1\145\1\76\1\72\2\uffff\1\76\1\72\1\156\1\171\1\170\1\171\1\uffff\1\157\1\uffff\1\157\1\174\1\46\2\75\1\76\3\75\1\71\1\uffff\1\145\1\165\1\157\1\114\1\157\1\151\1\145\2\uffff\1\75\1\163\2\uffff\1\150\1\141\1\170\1\154\1\172\5\uffff\1\164\1\uffff\1\75\15\uffff\1\172\1\160\1\163\1\162\1\160\1\171\1\163\1\164\1\151\1\154\1\162\1\141\1\160\1\156\1\uffff\1\146\1\172\1\uffff\1\164\1\154\4\uffff\1\75\20\uffff\1\74\3\uffff\2\164\1\154\1\167\1\162\1\154\1\156\1\117\1\154\1\163\1\164\4\uffff\1\172\2\uffff\1\151\1\162\2\uffff\2\154\3\uffff\1\172\3\uffff\1\157\1\164\1\156\1\157\2\145\1\172\1\145\1\163\1\145\1\164\1\145\2\164\1\145\1\143\1\141\1\uffff\1\145\1\143\1\154\4\uffff\1\145\1\165\1\105\1\154\2\172\1\163\1\141\1\102\1\154\1\164\1\172\1\uffff\1\154\2\172\1\uffff\1\151\1\162\1\141\1\172\1\167\1\157\1\172\1\uffff\1\172\1\164\1\156\2\143\1\102\1\151\1\162\1\150\1\165\1\172\1\150\1\145\1\143\1\162\1\170\1\172\1\uffff\1\154\1\uffff\1\145\1\154\1\101\1\145\1\172\1\uffff\1\145\2\uffff\1\145\1\164\1\156\1\uffff\1\172\1\145\1\146\2\uffff\2\163\1\150\1\164\1\171\1\143\1\172\1\162\1\154\1\uffff\1\172\1\143\1\164\1\156\1\151\1\uffff\1\154\1\172\1\154\1\114\1\143\1\uffff\1\172\1\163\1\172\1\143\1\uffff\1\154\2\172\1\163\1\151\4\172\1\uffff\1\157\1\164\1\uffff\1\164\2\172\1\163\1\172\1\uffff\1\171\1\126\1\164\1\uffff\1\172\1\uffff\2\145\2\uffff\1\172\1\157\1\uffff\1\151\3\uffff\1\156\2\172\2\uffff\1\164\1\uffff\1\172\1\101\1\151\1\uffff\1\157\1\143\1\uffff\1\156\1\162\1\151\2\uffff\1\163\1\uffff\1\122\1\157\1\146\1\164\1\172\1\163\3\172\1\156\2\172\1\uffff\1\164\1\145\2\uffff\1\172\2\uffff\1\172\1\144\2\uffff\1\172\1\uffff"; + static final String DFA23_acceptS = + "\4\uffff\1\4\1\5\6\uffff\1\14\1\uffff\1\16\12\uffff\1\37\7\uffff\1\62\1\63\2\uffff\1\110\1\111\5\uffff\1\140\2\141\1\144\1\145\1\uffff\1\140\1\uffff\1\77\1\2\1\64\1\3\1\4\1\5\1\6\1\66\1\106\1\32\1\101\1\107\1\7\16\uffff\1\14\2\uffff\1\16\2\uffff\1\20\1\51\1\21\1\133\1\uffff\1\35\1\25\1\27\1\26\1\100\1\30\1\65\1\105\1\31\1\67\1\102\1\33\1\70\1\142\1\143\1\34\1\uffff\1\36\1\134\1\37\13\uffff\1\62\1\63\1\71\1\103\1\uffff\1\110\1\111\2\uffff\1\135\1\136\2\uffff\1\137\1\141\1\144\1\uffff\1\72\1\23\1\10\21\uffff\1\114\3\uffff\1\73\1\24\1\75\1\76\14\uffff\1\104\3\uffff\1\1\7\uffff\1\127\21\uffff\1\56\1\uffff\1\112\5\uffff\1\61\1\uffff\1\115\1\116\3\uffff\1\11\3\uffff\1\52\1\12\11\uffff\1\17\5\uffff\1\54\5\uffff\1\60\4\uffff\1\125\11\uffff\1\123\2\uffff\1\132\5\uffff\1\53\3\uffff\1\113\1\uffff\1\121\2\uffff\1\124\1\45\2\uffff\1\13\1\uffff\1\42\1\47\1\120\3\uffff\1\44\1\126\1\uffff\1\50\3\uffff\1\22\2\uffff\1\117\3\uffff\1\15\1\41\1\uffff\1\130\14\uffff\1\122\2\uffff\1\46\1\55\1\uffff\1\74\1\40\2\uffff\1\57\1\43\1\uffff\1\131"; + static final String DFA23_specialS = + "\1\0\u0152\uffff}>"; + static final String[] DFA23_transitionS = { + "\11\60\2\57\2\60\1\57\22\60\1\57\1\22\1\55\1\45\1\54\1\43\1\21\1\56\1\4\1\5\1\26\1\25\1\31\1\6\1\30\1\27\1\51\11\52\1\3\1\46\1\24\1\2\1\23\1\7\1\60\2\54\1\36\3\54\1\35\4\54\1\37\6\54\1\40\7\54\1\41\1\60\1\42\1\53\1\54\1\60\1\44\1\54\1\17\1\15\1\12\1\34\2\54\1\10\2\54\1\1\1\54\1\33\3\54\1\32\1\13\1\11\1\54\1\50\1\47\3\54\1\14\1\20\1\16\uff82\60", + "\1\61", + "\1\63\1\64", + "\1\66", "", "", - "\1\62", + "\1\74\17\uffff\1\73\1\72", + "\1\77\13\uffff\1\76", + "\1\101\6\uffff\1\102\1\103", + "\1\104\11\uffff\1\106\6\uffff\1\105", + "\1\107\13\uffff\1\110", + "\1\112\11\uffff\1\113\4\uffff\1\114\1\115\1\uffff\1\111\1\uffff\1\116", "", - "\1\65\6\uffff\1\66", - "\1\67\11\uffff\1\71\6\uffff\1\70", - "\1\72\13\uffff\1\73", - "\1\75\11\uffff\1\76\7\uffff\1\74", + "\1\120\11\uffff\1\121", "", - "\1\100", + "\1\123\15\uffff\1\124", + "\1\125", + "\1\127", + "\1\131", + "\1\133", + "\1\135\1\136", + "\1\141\21\uffff\1\140", + "\1\144\22\uffff\1\143", + "\1\147\4\uffff\1\150\15\uffff\1\146", + "\1\152\1\uffff\12\154", "", - "\1\102\15\uffff\1\103", - "\1\104", - "\1\106", - "\1\107", - "\1\111", - "\1\113", + "\1\156", + "\1\161\11\uffff\1\157\5\uffff\1\160", + "\1\163\7\uffff\1\164\5\uffff\1\162", + "\1\165", + "\1\166", + "\1\167", + "\1\170", "", "", - "\1\117\4\uffff\1\120", - "\12\123", + "\1\173", + "\1\175", "", - "\1\125", - "\1\130\11\uffff\1\126\5\uffff\1\127", - "\1\132\15\uffff\1\131", - "\1\133", - "\1\134", - "\1\135", - "\1\136", "", + "\1\u0080", + "\1\u0081", + "\1\154\1\uffff\12\u0084\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\13\uffff\1\u0082\6\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\13\uffff\1\u0082", + "\1\154\1\uffff\12\u0084\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\22\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086", + "\1\62\34\uffff\32\62\4\uffff\1\62\1\uffff\32\62", "", - "\1\123\1\uffff\12\142", - "\32\53\4\uffff\1\53\1\uffff\32\53", "", - "\0\143", - "\0\143", "", "", - "\1\145", "", + "\1\u0089", "", + "\1\u008a", "", "", "", @@ -2226,30 +3720,36 @@ public void mTokens() throws RecognitionException { "", "", "", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\1\147", - "\1\150", - "\1\151", - "\1\152", - "\1\153", - "\1\154", - "\1\155", - "\1\156", - "\1\157", "", - "\1\160", "", - "\1\161", - "\1\162", "", "", "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u008d", + "\1\u008e", + "\1\u008f\14\uffff\1\u0090", + "\1\u0091", + "\1\u0092\3\uffff\1\u0093", + "\1\u0094", + "\1\u0095\12\uffff\1\u0096", + "\1\u0097", + "\1\u0098", + "\1\u0099", + "\1\u009a", + "\1\u009b", + "\1\u009c", "", + "\1\u009d", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", "", + "\1\u009f\1\u00a0", + "\1\u00a1", "", "", "", "", + "\1\u00a2", "", "", "", @@ -2258,288 +3758,390 @@ public void mTokens() throws RecognitionException { "", "", "", - "\1\163", - "\1\164", - "\1\165", - "\1\166", - "\1\167", - "\1\170", - "\1\171", - "\1\172", - "\1\173", - "\1\174", "", "", "", - "\1\123\1\uffff\12\142", "", "", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", "", - "\1\176", - "\1\177", - "\1\u0080", - "\1\u0081", - "\1\u0082", - "\1\u0083", - "\1\u0084", - "\1\u0085", - "\1\u0086", - "\1\u0087", - "\1\u0088", - "\1\u0089", - "\1\u008a", - "\1\u008b", - "\1\u008c", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\1\u008e", - "\1\u008f", - "\1\u0090", - "\1\u0091", - "\1\u0092", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", "", - "\1\u0094", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\1\u0096", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\1\u0099", - "\1\u009a", - "\1\u009b", - "\1\u009c", - "\1\u009d", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\1\u009f", - "\1\u00a0", - "\1\u00a1", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", "", - "\1\u00a3", "\1\u00a4", - "\1\u00a5", - "\1\u00a6", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "", - "\1\u00a8", "", - "\1\u00a9", "", "", + "\1\u00a6\11\uffff\1\u00a7", + "\1\u00a8", + "\1\u00a9", "\1\u00aa", "\1\u00ab", "\1\u00ac", "\1\u00ad", "\1\u00ae", - "", "\1\u00af", "\1\u00b0", "\1\u00b1", "", - "\1\u00b2", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\1\u00b4", - "\1\u00b5", - "", - "\1\u00b6", - "\1\u00b7", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\12\53\7\uffff\5\53\1\u00ba\24\53\4\uffff\1\53\1\uffff\32\53", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "", + "", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\u00b3", + "\1\u00b5\5\uffff\1\u00b4", + "", + "", + "\1\154\1\uffff\12\u0084\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\22\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086", + "\12\u0085\10\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086\22\uffff\1\u0085\2\uffff\1\u0086\1\uffff\3\u0086\5\uffff\1\u0086", + "", + "", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "", + "\1\u00b7\2\uffff\1\u00b8", + "\1\u00b9", + "\1\u00ba", + "\1\u00bb", + "\1\u00bc", "\1\u00bd", - "\1\u00be", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u00bf", "\1\u00c0", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "", + "\1\u00c1", "\1\u00c2", "\1\u00c3", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\u00c4", "\1\u00c5", - "", - "", "\1\u00c6", - "", - "", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\u00c7", + "\1\u00c8", "", "\1\u00c9", - "", "\1\u00ca", "\1\u00cb", "", - "\1\u00cc", - "\1\u00cd", "", "", + "", + "\1\u00cc", + "\1\u00cd", "\1\u00ce", "\1\u00cf", - "\1\u00d0", - "\1\u00d1", - "\1\u00d2", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\1\u00d1\31\62\4\uffff\1\62\1\uffff\32\62", + "\1\u00d3", + "\1\u00d4", "\1\u00d5", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\u00d6", "\1\u00d7", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u00d9", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u00dc", + "\1\u00dd", + "\1\u00de", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u00e0", + "\1\u00e1\33\uffff\1\u00e2", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u00e5", + "\1\u00e6", + "\1\u00e7", + "\1\u00e8", + "\1\u00e9", + "\1\u00ea", + "\1\u00eb", + "\1\u00ec", + "\1\u00ed", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u00ef", + "\1\u00f0", + "\1\u00f1", + "\1\u00f2", + "\1\u00f3", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u00f5", + "", + "\1\u00f6", + "\1\u00f7", + "\1\u00f8", + "\1\u00f9", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u00fb", + "", + "", + "\1\u00fc", + "\1\u00fd", + "\1\u00fe", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0100", + "\1\u0101", + "", + "", + "\1\u0102", + "\1\u0103\16\uffff\1\u0104", + "\1\u0105", + "\1\u0106", + "\1\u0107", + "\1\u0108", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u010a", + "\1\u010b", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u010d", + "\1\u010e", + "\1\u010f", + "\1\u0110", "", + "\1\u0111", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0113", + "\1\u0114", + "\1\u0115", "", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0117", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0119", "", - "\12\53\7\uffff\32\53\4\uffff\1\53\1\uffff\32\53", + "\1\u011a", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u011d", + "\1\u011e", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\5\62\1\u0120\24\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", "", + "\1\u0124", + "\1\u0125", + "", + "\1\u0126", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0129", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u012b", + "\1\u012c", + "\1\u012d", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u012f", + "\1\u0130", + "", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0132", + "", + "\1\u0133", + "", + "", + "", + "\1\u0134", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\u0137", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0139", + "\1\u013a", + "", + "\1\u013b", + "\1\u013c", + "", + "\1\u013d", + "\1\u013e", + "\1\u013f", + "", + "", + "\1\u0140", + "", + "\1\u0141", + "\1\u0142", + "\1\u0143", + "\1\u0144", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0146", + "\1\u0147", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u014a", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "\1\u014d", + "\1\u014e", + "", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", + "\1\u0151", + "", + "", + "\1\62\13\uffff\12\62\7\uffff\32\62\4\uffff\1\62\1\uffff\32\62", "" }; - static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); - static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); - static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); - static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); - static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); - static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); - static final short[][] DFA14_transition; + static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); + static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); + static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); + static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); + static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); + static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); + static final short[][] DFA23_transition; static { - int numStates = DFA14_transitionS.length; - DFA14_transition = new short[numStates][]; + int numStates = DFA23_transitionS.length; + DFA23_transition = new short[numStates][]; for (int i=0; i='\u0000' && LA14_38<='\uFFFF')) ) {s = 99;} + if ( (LA23_0=='l') ) {s = 1;} - else s = 41; + else if ( (LA23_0=='=') ) {s = 2;} - if ( s>=0 ) return s; - break; - case 1 : - int LA14_0 = input.LA(1); + else if ( (LA23_0==':') ) {s = 3;} - s = -1; - if ( (LA14_0=='l') ) {s = 1;} + else if ( (LA23_0=='(') ) {s = 4;} - else if ( (LA14_0=='=') ) {s = 2;} + else if ( (LA23_0==')') ) {s = 5;} - else if ( (LA14_0==':') ) {s = 3;} + else if ( (LA23_0=='-') ) {s = 6;} - else if ( (LA14_0=='(') ) {s = 4;} + else if ( (LA23_0=='?') ) {s = 7;} - else if ( (LA14_0==')') ) {s = 5;} + else if ( (LA23_0=='i') ) {s = 8;} - else if ( (LA14_0=='-') ) {s = 6;} + else if ( (LA23_0=='t') ) {s = 9;} - else if ( (LA14_0=='?') ) {s = 7;} + else if ( (LA23_0=='e') ) {s = 10;} - else if ( (LA14_0=='i') ) {s = 8;} + else if ( (LA23_0=='s') ) {s = 11;} - else if ( (LA14_0=='t') ) {s = 9;} + else if ( (LA23_0=='{') ) {s = 12;} - else if ( (LA14_0=='e') ) {s = 10;} + else if ( (LA23_0=='d') ) {s = 13;} - else if ( (LA14_0=='s') ) {s = 11;} + else if ( (LA23_0=='}') ) {s = 14;} - else if ( (LA14_0=='{') ) {s = 12;} + else if ( (LA23_0=='c') ) {s = 15;} - else if ( (LA14_0=='d') ) {s = 13;} + else if ( (LA23_0=='|') ) {s = 16;} - else if ( (LA14_0=='}') ) {s = 14;} + else if ( (LA23_0=='&') ) {s = 17;} - else if ( (LA14_0=='c') ) {s = 15;} + else if ( (LA23_0=='!') ) {s = 18;} - else if ( (LA14_0=='|') ) {s = 16;} + else if ( (LA23_0=='>') ) {s = 19;} - else if ( (LA14_0=='&') ) {s = 17;} + else if ( (LA23_0=='<') ) {s = 20;} - else if ( (LA14_0=='!') ) {s = 18;} + else if ( (LA23_0=='+') ) {s = 21;} - else if ( (LA14_0=='>') ) {s = 19;} + else if ( (LA23_0=='*') ) {s = 22;} - else if ( (LA14_0=='<') ) {s = 20;} + else if ( (LA23_0=='/') ) {s = 23;} - else if ( (LA14_0=='+') ) {s = 21;} + else if ( (LA23_0=='.') ) {s = 24;} - else if ( (LA14_0=='*') ) {s = 22;} + else if ( (LA23_0==',') ) {s = 25;} - else if ( (LA14_0=='/') ) {s = 23;} + else if ( (LA23_0=='r') ) {s = 26;} - else if ( (LA14_0=='.') ) {s = 24;} + else if ( (LA23_0=='n') ) {s = 27;} - else if ( (LA14_0==',') ) {s = 25;} + else if ( (LA23_0=='f') ) {s = 28;} - else if ( (LA14_0=='r') ) {s = 26;} + else if ( (LA23_0=='G') ) {s = 29;} - else if ( (LA14_0=='n') ) {s = 27;} + else if ( (LA23_0=='C') ) {s = 30;} - else if ( (LA14_0=='f') ) {s = 28;} + else if ( (LA23_0=='L') ) {s = 31;} - else if ( (LA14_0=='G') ) {s = 29;} + else if ( (LA23_0=='S') ) {s = 32;} - else if ( (LA14_0=='C') ) {s = 30;} + else if ( (LA23_0=='[') ) {s = 33;} - else if ( (LA14_0=='L') ) {s = 31;} + else if ( (LA23_0==']') ) {s = 34;} - else if ( (LA14_0=='S') ) {s = 32;} + else if ( (LA23_0=='%') ) {s = 35;} - else if ( (LA14_0=='[') ) {s = 33;} + else if ( (LA23_0=='a') ) {s = 36;} - else if ( (LA14_0==']') ) {s = 34;} + else if ( (LA23_0=='#') ) {s = 37;} - else if ( ((LA14_0>='0' && LA14_0<='9')) ) {s = 35;} + else if ( (LA23_0==';') ) {s = 38;} - else if ( (LA14_0=='^') ) {s = 36;} + else if ( (LA23_0=='w') ) {s = 39;} - else if ( ((LA14_0>='A' && LA14_0<='B')||(LA14_0>='D' && LA14_0<='F')||(LA14_0>='H' && LA14_0<='K')||(LA14_0>='M' && LA14_0<='R')||(LA14_0>='T' && LA14_0<='Z')||LA14_0=='_'||(LA14_0>='a' && LA14_0<='b')||(LA14_0>='g' && LA14_0<='h')||(LA14_0>='j' && LA14_0<='k')||LA14_0=='m'||(LA14_0>='o' && LA14_0<='q')||(LA14_0>='u' && LA14_0<='z')) ) {s = 37;} + else if ( (LA23_0=='v') ) {s = 40;} - else if ( (LA14_0=='\"') ) {s = 38;} + else if ( (LA23_0=='0') ) {s = 41;} - else if ( (LA14_0=='\'') ) {s = 39;} + else if ( ((LA23_0>='1' && LA23_0<='9')) ) {s = 42;} - else if ( ((LA14_0>='\t' && LA14_0<='\n')||LA14_0=='\r'||LA14_0==' ') ) {s = 40;} + else if ( (LA23_0=='^') ) {s = 43;} - else if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||(LA14_0>='#' && LA14_0<='%')||LA14_0==';'||LA14_0=='@'||LA14_0=='\\'||LA14_0=='`'||(LA14_0>='~' && LA14_0<='\uFFFF')) ) {s = 41;} + else if ( (LA23_0=='$'||(LA23_0>='A' && LA23_0<='B')||(LA23_0>='D' && LA23_0<='F')||(LA23_0>='H' && LA23_0<='K')||(LA23_0>='M' && LA23_0<='R')||(LA23_0>='T' && LA23_0<='Z')||LA23_0=='_'||LA23_0=='b'||(LA23_0>='g' && LA23_0<='h')||(LA23_0>='j' && LA23_0<='k')||LA23_0=='m'||(LA23_0>='o' && LA23_0<='q')||LA23_0=='u'||(LA23_0>='x' && LA23_0<='z')) ) {s = 44;} - if ( s>=0 ) return s; - break; - case 2 : - int LA14_39 = input.LA(1); + else if ( (LA23_0=='\"') ) {s = 45;} - s = -1; - if ( ((LA14_39>='\u0000' && LA14_39<='\uFFFF')) ) {s = 99;} + else if ( (LA23_0=='\'') ) {s = 46;} + + else if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {s = 47;} - else s = 41; + else if ( ((LA23_0>='\u0000' && LA23_0<='\b')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\u001F')||LA23_0=='@'||LA23_0=='\\'||LA23_0=='`'||(LA23_0>='~' && LA23_0<='\uFFFF')) ) {s = 48;} if ( s>=0 ) return s; break; } NoViableAltException nvae = - new NoViableAltException(getDescription(), 14, _s, input); + new NoViableAltException(getDescription(), 23, _s, input); error(nvae); throw nvae; } diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionParser.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionParser.java index e505339071..9644f9dc1b 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionParser.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/parser/antlr/internal/InternalExpressionParser.java @@ -22,21 +22,14 @@ @SuppressWarnings("all") public class InternalExpressionParser extends AbstractInternalAntlrParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_INT", "RULE_REAL", "RULE_STRING", "RULE_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'let'", "'='", "':'", "'('", "')'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'{'", "'default'", "'}'", "'case'", "'||'", "'&&'", "'implies'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'.'", "','", "'typeSelect'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'|'", "'true'", "'false'", "'null'", "'GLOBALVAR'", "'new'", "'Collection'", "'List'", "'Set'", "'['", "']'", "'::'" + "", "", "", "", "RULE_INT", "RULE_REAL", "RULE_STRING", "RULE_ID", "RULE_HEX", "RULE_DECIMAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'let'", "'='", "':'", "'('", "')'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'{'", "'default'", "'}'", "'case'", "'||'", "'&&'", "'implies'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'.'", "','", "'typeSelect'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'|'", "'true'", "'false'", "'null'", "'GLOBALVAR'", "'new'", "'Collection'", "'List'", "'Set'", "'['", "']'", "'::'", "'+='", "'-='", "'*='", "'/='", "'%='", "'==='", "'!=='", "'instanceof'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'**'", "'%'", "'as'", "'++'", "'--'", "'?.'", "'#'", "';'", "'for'", "'while'", "'do'", "'var'", "'val'", "'extends'", "'static'", "'import'", "'extension'", "'super'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'&'" }; + public static final int RULE_HEX=8; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -46,22 +39,16 @@ public class InternalExpressionParser extends AbstractInternalAntlrParser { public static final int T__61=61; public static final int RULE_ID=7; public static final int RULE_REAL=5; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; public static final int RULE_INT=4; - public static final int T__29=29; - public static final int T__22=22; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; - public static final int T__24=24; - public static final int T__25=25; + public static final int T__66=66; + public static final int RULE_ML_COMMENT=10; + public static final int T__67=67; + public static final int T__68=68; + public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; - public static final int T__21=21; - public static final int RULE_STRING=6; - public static final int RULE_SL_COMMENT=9; + public static final int T__64=64; + public static final int T__65=65; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; @@ -69,12 +56,9 @@ public class InternalExpressionParser extends AbstractInternalAntlrParser { public static final int T__34=34; public static final int T__35=35; public static final int T__36=36; - public static final int EOF=-1; public static final int T__30=30; public static final int T__31=31; public static final int T__32=32; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -85,6 +69,63 @@ public class InternalExpressionParser extends AbstractInternalAntlrParser { public static final int T__41=41; public static final int T__42=42; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__70=70; + public static final int T__71=71; + public static final int T__72=72; + public static final int RULE_STRING=6; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__78=78; + public static final int T__79=79; + public static final int T__73=73; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__75=75; + public static final int T__76=76; + public static final int T__80=80; + public static final int T__81=81; + public static final int T__82=82; + public static final int T__83=83; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__89=89; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__87=87; // delegates // delegators @@ -349,7 +390,7 @@ public final EObject ruleLetExpression() throws RecognitionException { // InternalExpression.g:126:2: (otherlv_0= 'let' ( (lv_identifier_1_0= ruleIdentifier ) ) otherlv_2= '=' ( (lv_varExpr_3_0= ruleExpression ) ) otherlv_4= ':' ( (lv_target_5_0= ruleExpression ) ) ) // InternalExpression.g:127:3: otherlv_0= 'let' ( (lv_identifier_1_0= ruleIdentifier ) ) otherlv_2= '=' ( (lv_varExpr_3_0= ruleExpression ) ) otherlv_4= ':' ( (lv_target_5_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,12,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,14,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getLetExpressionAccess().getLetKeyword_0()); @@ -390,7 +431,7 @@ public final EObject ruleLetExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,13,FOLLOW_5); if (state.failed) return current; + otherlv_2=(Token)match(input,15,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); @@ -431,7 +472,7 @@ public final EObject ruleLetExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,14,FOLLOW_5); if (state.failed) return current; + otherlv_4=(Token)match(input,16,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getLetExpressionAccess().getColonKeyword_4()); @@ -558,7 +599,7 @@ public final EObject ruleCastedExpression() throws RecognitionException { // InternalExpression.g:214:2: (otherlv_0= '(' ( (lv_type_1_0= ruleType ) ) otherlv_2= ')' ( (lv_target_3_0= ruleExpression ) ) ) // InternalExpression.g:215:3: otherlv_0= '(' ( (lv_type_1_0= ruleType ) ) otherlv_2= ')' ( (lv_target_3_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,15,FOLLOW_7); if (state.failed) return current; + otherlv_0=(Token)match(input,17,FOLLOW_7); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -599,7 +640,7 @@ public final EObject ruleCastedExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,16,FOLLOW_5); if (state.failed) return current; + otherlv_2=(Token)match(input,18,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); @@ -747,7 +788,7 @@ public final EObject ruleChainExpression() throws RecognitionException { int alt2=2; int LA2_0 = input.LA(1); - if ( (LA2_0==17) ) { + if ( (LA2_0==19) ) { alt2=1; } @@ -769,7 +810,7 @@ public final EObject ruleChainExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,17,FOLLOW_5); if (state.failed) return current; + otherlv_2=(Token)match(input,19,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); @@ -905,7 +946,7 @@ public final EObject ruleChainedExpression() throws RecognitionException { // InternalExpression.g:338:2: (this_IfExpressionKw_0= ruleIfExpressionKw | this_IfExpressionTri_1= ruleIfExpressionTri | this_SwitchExpression_2= ruleSwitchExpression ) int alt3=3; switch ( input.LA(1) ) { - case 19: + case 21: { alt3=1; } @@ -914,12 +955,10 @@ public final EObject ruleChainedExpression() throws RecognitionException { case RULE_REAL: case RULE_STRING: case RULE_ID: - case 15: - case 23: - case 37: - case 40: - case 43: - case 44: + case 17: + case 25: + case 39: + case 42: case 45: case 46: case 47: @@ -927,19 +966,21 @@ public final EObject ruleChainedExpression() throws RecognitionException { case 49: case 50: case 51: + case 52: case 53: - case 54: case 55: case 56: case 57: case 58: case 59: case 60: + case 61: + case 62: { alt3=2; } break; - case 22: + case 24: { alt3=3; } @@ -1127,7 +1168,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { int alt4=2; int LA4_0 = input.LA(1); - if ( (LA4_0==18) ) { + if ( (LA4_0==20) ) { alt4=1; } switch (alt4) { @@ -1147,7 +1188,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { } - otherlv_2=(Token)match(input,18,FOLLOW_5); if (state.failed) return current; + otherlv_2=(Token)match(input,20,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); @@ -1188,7 +1229,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { } - otherlv_4=(Token)match(input,14,FOLLOW_5); if (state.failed) return current; + otherlv_4=(Token)match(input,16,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); @@ -1324,7 +1365,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { // InternalExpression.g:465:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleChainedExpression ) ) otherlv_2= 'then' ( (lv_thenPart_3_0= ruleChainedExpression ) ) ( ( 'else' )=> (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) )? ) // InternalExpression.g:466:3: otherlv_0= 'if' ( (lv_condition_1_0= ruleChainedExpression ) ) otherlv_2= 'then' ( (lv_thenPart_3_0= ruleChainedExpression ) ) ( ( 'else' )=> (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) )? { - otherlv_0=(Token)match(input,19,FOLLOW_5); if (state.failed) return current; + otherlv_0=(Token)match(input,21,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); @@ -1365,7 +1406,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { } - otherlv_2=(Token)match(input,20,FOLLOW_5); if (state.failed) return current; + otherlv_2=(Token)match(input,22,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); @@ -1410,7 +1451,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { int alt5=2; int LA5_0 = input.LA(1); - if ( (LA5_0==21) ) { + if ( (LA5_0==23) ) { int LA5_1 = input.LA(2); if ( (synpred2_InternalExpression()) ) { @@ -1424,7 +1465,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { // InternalExpression.g:514:4: (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) // InternalExpression.g:515:5: otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) { - otherlv_4=(Token)match(input,21,FOLLOW_5); if (state.failed) return current; + otherlv_4=(Token)match(input,23,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); @@ -1567,7 +1608,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { // InternalExpression.g:558:2: (otherlv_0= 'switch' (otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' )? otherlv_4= '{' ( (lv_case_5_0= ruleCase ) )* otherlv_6= 'default' otherlv_7= ':' ( (lv_defaultExpr_8_0= ruleOrExpression ) ) otherlv_9= '}' ) // InternalExpression.g:559:3: otherlv_0= 'switch' (otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' )? otherlv_4= '{' ( (lv_case_5_0= ruleCase ) )* otherlv_6= 'default' otherlv_7= ':' ( (lv_defaultExpr_8_0= ruleOrExpression ) ) otherlv_9= '}' { - otherlv_0=(Token)match(input,22,FOLLOW_13); if (state.failed) return current; + otherlv_0=(Token)match(input,24,FOLLOW_13); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); @@ -1577,14 +1618,14 @@ public final EObject ruleSwitchExpression() throws RecognitionException { int alt6=2; int LA6_0 = input.LA(1); - if ( (LA6_0==15) ) { + if ( (LA6_0==17) ) { alt6=1; } switch (alt6) { case 1 : // InternalExpression.g:564:4: otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' { - otherlv_1=(Token)match(input,15,FOLLOW_14); if (state.failed) return current; + otherlv_1=(Token)match(input,17,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); @@ -1625,7 +1666,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,16,FOLLOW_15); if (state.failed) return current; + otherlv_3=(Token)match(input,18,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); @@ -1637,7 +1678,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,23,FOLLOW_16); if (state.failed) return current; + otherlv_4=(Token)match(input,25,FOLLOW_16); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); @@ -1649,7 +1690,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { int alt7=2; int LA7_0 = input.LA(1); - if ( (LA7_0==26) ) { + if ( (LA7_0==28) ) { alt7=1; } @@ -1696,13 +1737,13 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } } while (true); - otherlv_6=(Token)match(input,24,FOLLOW_6); if (state.failed) return current; + otherlv_6=(Token)match(input,26,FOLLOW_6); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - otherlv_7=(Token)match(input,14,FOLLOW_14); if (state.failed) return current; + otherlv_7=(Token)match(input,16,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); @@ -1743,7 +1784,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_9=(Token)match(input,25,FOLLOW_2); if (state.failed) return current; + otherlv_9=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_9, grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); @@ -1835,7 +1876,7 @@ public final EObject ruleCase() throws RecognitionException { // InternalExpression.g:664:2: (otherlv_0= 'case' ( (lv_condition_1_0= ruleOrExpression ) ) otherlv_2= ':' ( (lv_thenPar_3_0= ruleOrExpression ) ) ) // InternalExpression.g:665:3: otherlv_0= 'case' ( (lv_condition_1_0= ruleOrExpression ) ) otherlv_2= ':' ( (lv_thenPar_3_0= ruleOrExpression ) ) { - otherlv_0=(Token)match(input,26,FOLLOW_14); if (state.failed) return current; + otherlv_0=(Token)match(input,28,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getCaseAccess().getCaseKeyword_0()); @@ -1876,7 +1917,7 @@ public final EObject ruleCase() throws RecognitionException { } - otherlv_2=(Token)match(input,14,FOLLOW_14); if (state.failed) return current; + otherlv_2=(Token)match(input,16,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getCaseAccess().getColonKeyword_2()); @@ -2024,7 +2065,7 @@ public final EObject ruleOrExpression() throws RecognitionException { int alt8=2; int LA8_0 = input.LA(1); - if ( (LA8_0==27) ) { + if ( (LA8_0==29) ) { alt8=1; } @@ -2052,7 +2093,7 @@ public final EObject ruleOrExpression() throws RecognitionException { // InternalExpression.g:747:5: (lv_operator_2_0= '||' ) // InternalExpression.g:748:6: lv_operator_2_0= '||' { - lv_operator_2_0=(Token)match(input,27,FOLLOW_14); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,29,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); @@ -2223,7 +2264,7 @@ public final EObject ruleAndExpression() throws RecognitionException { int alt9=2; int LA9_0 = input.LA(1); - if ( (LA9_0==28) ) { + if ( (LA9_0==30) ) { alt9=1; } @@ -2251,7 +2292,7 @@ public final EObject ruleAndExpression() throws RecognitionException { // InternalExpression.g:816:5: (lv_operator_2_0= '&&' ) // InternalExpression.g:817:6: lv_operator_2_0= '&&' { - lv_operator_2_0=(Token)match(input,28,FOLLOW_14); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,30,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); @@ -2422,7 +2463,7 @@ public final EObject ruleImpliesExpression() throws RecognitionException { int alt10=2; int LA10_0 = input.LA(1); - if ( (LA10_0==29) ) { + if ( (LA10_0==31) ) { alt10=1; } @@ -2450,7 +2491,7 @@ public final EObject ruleImpliesExpression() throws RecognitionException { // InternalExpression.g:885:5: (lv_operator_2_0= 'implies' ) // InternalExpression.g:886:6: lv_operator_2_0= 'implies' { - lv_operator_2_0=(Token)match(input,29,FOLLOW_14); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,31,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); @@ -2626,7 +2667,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { int alt12=2; int LA12_0 = input.LA(1); - if ( ((LA12_0>=30 && LA12_0<=35)) ) { + if ( ((LA12_0>=32 && LA12_0<=37)) ) { alt12=1; } @@ -2657,32 +2698,32 @@ public final EObject ruleRelationalExpression() throws RecognitionException { // InternalExpression.g:955:6: (lv_operator_2_1= '==' | lv_operator_2_2= '!=' | lv_operator_2_3= '>=' | lv_operator_2_4= '<=' | lv_operator_2_5= '>' | lv_operator_2_6= '<' ) int alt11=6; switch ( input.LA(1) ) { - case 30: + case 32: { alt11=1; } break; - case 31: + case 33: { alt11=2; } break; - case 32: + case 34: { alt11=3; } break; - case 33: + case 35: { alt11=4; } break; - case 34: + case 36: { alt11=5; } break; - case 35: + case 37: { alt11=6; } @@ -2699,7 +2740,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 1 : // InternalExpression.g:956:7: lv_operator_2_1= '==' { - lv_operator_2_1=(Token)match(input,30,FOLLOW_14); if (state.failed) return current; + lv_operator_2_1=(Token)match(input,32,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_1, grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); @@ -2719,7 +2760,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 2 : // InternalExpression.g:967:7: lv_operator_2_2= '!=' { - lv_operator_2_2=(Token)match(input,31,FOLLOW_14); if (state.failed) return current; + lv_operator_2_2=(Token)match(input,33,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_2, grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); @@ -2739,7 +2780,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 3 : // InternalExpression.g:978:7: lv_operator_2_3= '>=' { - lv_operator_2_3=(Token)match(input,32,FOLLOW_14); if (state.failed) return current; + lv_operator_2_3=(Token)match(input,34,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_3, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); @@ -2759,7 +2800,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 4 : // InternalExpression.g:989:7: lv_operator_2_4= '<=' { - lv_operator_2_4=(Token)match(input,33,FOLLOW_14); if (state.failed) return current; + lv_operator_2_4=(Token)match(input,35,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_4, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); @@ -2779,7 +2820,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 5 : // InternalExpression.g:1000:7: lv_operator_2_5= '>' { - lv_operator_2_5=(Token)match(input,34,FOLLOW_14); if (state.failed) return current; + lv_operator_2_5=(Token)match(input,36,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_5, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); @@ -2799,7 +2840,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 6 : // InternalExpression.g:1011:7: lv_operator_2_6= '<' { - lv_operator_2_6=(Token)match(input,35,FOLLOW_14); if (state.failed) return current; + lv_operator_2_6=(Token)match(input,37,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_6, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); @@ -2977,7 +3018,7 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { int alt14=2; int LA14_0 = input.LA(1); - if ( ((LA14_0>=36 && LA14_0<=37)) ) { + if ( ((LA14_0>=38 && LA14_0<=39)) ) { alt14=1; } @@ -3009,10 +3050,10 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { int alt13=2; int LA13_0 = input.LA(1); - if ( (LA13_0==36) ) { + if ( (LA13_0==38) ) { alt13=1; } - else if ( (LA13_0==37) ) { + else if ( (LA13_0==39) ) { alt13=2; } else { @@ -3026,7 +3067,7 @@ else if ( (LA13_0==37) ) { case 1 : // InternalExpression.g:1082:7: lv_name_2_1= '+' { - lv_name_2_1=(Token)match(input,36,FOLLOW_14); if (state.failed) return current; + lv_name_2_1=(Token)match(input,38,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_1, grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); @@ -3046,7 +3087,7 @@ else if ( (LA13_0==37) ) { case 2 : // InternalExpression.g:1093:7: lv_name_2_2= '-' { - lv_name_2_2=(Token)match(input,37,FOLLOW_14); if (state.failed) return current; + lv_name_2_2=(Token)match(input,39,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_2, grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); @@ -3224,7 +3265,7 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException int alt16=2; int LA16_0 = input.LA(1); - if ( ((LA16_0>=38 && LA16_0<=39)) ) { + if ( ((LA16_0>=40 && LA16_0<=41)) ) { alt16=1; } @@ -3256,10 +3297,10 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException int alt15=2; int LA15_0 = input.LA(1); - if ( (LA15_0==38) ) { + if ( (LA15_0==40) ) { alt15=1; } - else if ( (LA15_0==39) ) { + else if ( (LA15_0==41) ) { alt15=2; } else { @@ -3273,7 +3314,7 @@ else if ( (LA15_0==39) ) { case 1 : // InternalExpression.g:1164:7: lv_name_2_1= '*' { - lv_name_2_1=(Token)match(input,38,FOLLOW_14); if (state.failed) return current; + lv_name_2_1=(Token)match(input,40,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_1, grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); @@ -3293,7 +3334,7 @@ else if ( (LA15_0==39) ) { case 2 : // InternalExpression.g:1175:7: lv_name_2_2= '/' { - lv_name_2_2=(Token)match(input,39,FOLLOW_14); if (state.failed) return current; + lv_name_2_2=(Token)match(input,41,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_2, grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); @@ -3448,10 +3489,10 @@ public final EObject ruleUnaryOrInfixExpression() throws RecognitionException { int alt17=2; int LA17_0 = input.LA(1); - if ( (LA17_0==37||LA17_0==40) ) { + if ( (LA17_0==39||LA17_0==42) ) { alt17=1; } - else if ( ((LA17_0>=RULE_INT && LA17_0<=RULE_ID)||LA17_0==15||LA17_0==23||(LA17_0>=43 && LA17_0<=51)||(LA17_0>=53 && LA17_0<=60)) ) { + else if ( ((LA17_0>=RULE_INT && LA17_0<=RULE_ID)||LA17_0==17||LA17_0==25||(LA17_0>=45 && LA17_0<=53)||(LA17_0>=55 && LA17_0<=62)) ) { alt17=2; } else { @@ -3600,10 +3641,10 @@ public final EObject ruleUnaryExpression() throws RecognitionException { int alt18=2; int LA18_0 = input.LA(1); - if ( (LA18_0==40) ) { + if ( (LA18_0==42) ) { alt18=1; } - else if ( (LA18_0==37) ) { + else if ( (LA18_0==39) ) { alt18=2; } else { @@ -3617,7 +3658,7 @@ else if ( (LA18_0==37) ) { case 1 : // InternalExpression.g:1266:6: lv_name_0_1= '!' { - lv_name_0_1=(Token)match(input,40,FOLLOW_14); if (state.failed) return current; + lv_name_0_1=(Token)match(input,42,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_1, grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); @@ -3637,7 +3678,7 @@ else if ( (LA18_0==37) ) { case 2 : // InternalExpression.g:1277:6: lv_name_0_2= '-' { - lv_name_0_2=(Token)match(input,37,FOLLOW_14); if (state.failed) return current; + lv_name_0_2=(Token)match(input,39,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_2, grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); @@ -3837,42 +3878,42 @@ public final EObject ruleInfixExpression() throws RecognitionException { int alt23=5; int LA23_0 = input.LA(1); - if ( (LA23_0==41) ) { + if ( (LA23_0==43) ) { switch ( input.LA(2) ) { - case 58: - case 59: - case 60: - { - alt23=2; - } - break; case RULE_ID: { - int LA23_4 = input.LA(3); + int LA23_3 = input.LA(3); - if ( (LA23_4==EOF||LA23_4==14||(LA23_4>=16 && LA23_4<=18)||(LA23_4>=20 && LA23_4<=21)||(LA23_4>=24 && LA23_4<=39)||(LA23_4>=41 && LA23_4<=42)||LA23_4==63) ) { + if ( (LA23_3==EOF||LA23_3==16||(LA23_3>=18 && LA23_3<=20)||(LA23_3>=22 && LA23_3<=23)||(LA23_3>=26 && LA23_3<=41)||(LA23_3>=43 && LA23_3<=44)||LA23_3==65) ) { alt23=2; } - else if ( (LA23_4==15) ) { + else if ( (LA23_3==17) ) { alt23=1; } } break; - case 43: + case 60: + case 61: + case 62: { - alt23=3; + alt23=2; } break; - case 44: case 45: + { + alt23=3; + } + break; case 46: case 47: case 48: case 49: case 50: case 51: + case 52: + case 53: { alt23=4; } @@ -3903,7 +3944,7 @@ else if ( (LA23_4==15) ) { } - otherlv_2=(Token)match(input,41,FOLLOW_3); if (state.failed) return current; + otherlv_2=(Token)match(input,43,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); @@ -3944,7 +3985,7 @@ else if ( (LA23_4==15) ) { } - otherlv_4=(Token)match(input,15,FOLLOW_26); if (state.failed) return current; + otherlv_4=(Token)match(input,17,FOLLOW_26); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); @@ -3954,7 +3995,7 @@ else if ( (LA23_4==15) ) { int alt20=2; int LA20_0 = input.LA(1); - if ( ((LA20_0>=RULE_INT && LA20_0<=RULE_ID)||LA20_0==12||LA20_0==15||LA20_0==19||(LA20_0>=22 && LA20_0<=23)||LA20_0==37||LA20_0==40||(LA20_0>=43 && LA20_0<=51)||(LA20_0>=53 && LA20_0<=60)) ) { + if ( ((LA20_0>=RULE_INT && LA20_0<=RULE_ID)||LA20_0==14||LA20_0==17||LA20_0==21||(LA20_0>=24 && LA20_0<=25)||LA20_0==39||LA20_0==42||(LA20_0>=45 && LA20_0<=53)||(LA20_0>=55 && LA20_0<=62)) ) { alt20=1; } switch (alt20) { @@ -4002,7 +4043,7 @@ else if ( (LA23_4==15) ) { int alt19=2; int LA19_0 = input.LA(1); - if ( (LA19_0==42) ) { + if ( (LA19_0==44) ) { alt19=1; } @@ -4011,7 +4052,7 @@ else if ( (LA23_4==15) ) { case 1 : // InternalExpression.g:1393:7: otherlv_6= ',' ( (lv_params_7_0= ruleExpression ) ) { - otherlv_6=(Token)match(input,42,FOLLOW_5); if (state.failed) return current; + otherlv_6=(Token)match(input,44,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); @@ -4067,7 +4108,7 @@ else if ( (LA23_4==15) ) { } - otherlv_8=(Token)match(input,16,FOLLOW_24); if (state.failed) return current; + otherlv_8=(Token)match(input,18,FOLLOW_24); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_8, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); @@ -4098,7 +4139,7 @@ else if ( (LA23_4==15) ) { } - otherlv_10=(Token)match(input,41,FOLLOW_7); if (state.failed) return current; + otherlv_10=(Token)match(input,43,FOLLOW_7); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_10, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); @@ -4164,7 +4205,7 @@ else if ( (LA23_4==15) ) { } - otherlv_13=(Token)match(input,41,FOLLOW_28); if (state.failed) return current; + otherlv_13=(Token)match(input,43,FOLLOW_28); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_13, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); @@ -4176,7 +4217,7 @@ else if ( (LA23_4==15) ) { // InternalExpression.g:1470:6: (lv_name_14_0= 'typeSelect' ) // InternalExpression.g:1471:7: lv_name_14_0= 'typeSelect' { - lv_name_14_0=(Token)match(input,43,FOLLOW_25); if (state.failed) return current; + lv_name_14_0=(Token)match(input,45,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_14_0, grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); @@ -4196,7 +4237,7 @@ else if ( (LA23_4==15) ) { } - otherlv_15=(Token)match(input,15,FOLLOW_7); if (state.failed) return current; + otherlv_15=(Token)match(input,17,FOLLOW_7); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_15, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); @@ -4237,7 +4278,7 @@ else if ( (LA23_4==15) ) { } - otherlv_17=(Token)match(input,16,FOLLOW_24); if (state.failed) return current; + otherlv_17=(Token)match(input,18,FOLLOW_24); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_17, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); @@ -4268,7 +4309,7 @@ else if ( (LA23_4==15) ) { } - otherlv_19=(Token)match(input,41,FOLLOW_29); if (state.failed) return current; + otherlv_19=(Token)match(input,43,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_19, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); @@ -4283,42 +4324,42 @@ else if ( (LA23_4==15) ) { // InternalExpression.g:1526:7: (lv_name_20_1= 'collect' | lv_name_20_2= 'select' | lv_name_20_3= 'selectFirst' | lv_name_20_4= 'reject' | lv_name_20_5= 'exists' | lv_name_20_6= 'notExists' | lv_name_20_7= 'sortBy' | lv_name_20_8= 'forAll' ) int alt21=8; switch ( input.LA(1) ) { - case 44: + case 46: { alt21=1; } break; - case 45: + case 47: { alt21=2; } break; - case 46: + case 48: { alt21=3; } break; - case 47: + case 49: { alt21=4; } break; - case 48: + case 50: { alt21=5; } break; - case 49: + case 51: { alt21=6; } break; - case 50: + case 52: { alt21=7; } break; - case 51: + case 53: { alt21=8; } @@ -4335,7 +4376,7 @@ else if ( (LA23_4==15) ) { case 1 : // InternalExpression.g:1527:8: lv_name_20_1= 'collect' { - lv_name_20_1=(Token)match(input,44,FOLLOW_25); if (state.failed) return current; + lv_name_20_1=(Token)match(input,46,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_1, grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); @@ -4355,7 +4396,7 @@ else if ( (LA23_4==15) ) { case 2 : // InternalExpression.g:1538:8: lv_name_20_2= 'select' { - lv_name_20_2=(Token)match(input,45,FOLLOW_25); if (state.failed) return current; + lv_name_20_2=(Token)match(input,47,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_2, grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); @@ -4375,7 +4416,7 @@ else if ( (LA23_4==15) ) { case 3 : // InternalExpression.g:1549:8: lv_name_20_3= 'selectFirst' { - lv_name_20_3=(Token)match(input,46,FOLLOW_25); if (state.failed) return current; + lv_name_20_3=(Token)match(input,48,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_3, grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); @@ -4395,7 +4436,7 @@ else if ( (LA23_4==15) ) { case 4 : // InternalExpression.g:1560:8: lv_name_20_4= 'reject' { - lv_name_20_4=(Token)match(input,47,FOLLOW_25); if (state.failed) return current; + lv_name_20_4=(Token)match(input,49,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_4, grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); @@ -4415,7 +4456,7 @@ else if ( (LA23_4==15) ) { case 5 : // InternalExpression.g:1571:8: lv_name_20_5= 'exists' { - lv_name_20_5=(Token)match(input,48,FOLLOW_25); if (state.failed) return current; + lv_name_20_5=(Token)match(input,50,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_5, grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); @@ -4435,7 +4476,7 @@ else if ( (LA23_4==15) ) { case 6 : // InternalExpression.g:1582:8: lv_name_20_6= 'notExists' { - lv_name_20_6=(Token)match(input,49,FOLLOW_25); if (state.failed) return current; + lv_name_20_6=(Token)match(input,51,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_6, grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); @@ -4455,7 +4496,7 @@ else if ( (LA23_4==15) ) { case 7 : // InternalExpression.g:1593:8: lv_name_20_7= 'sortBy' { - lv_name_20_7=(Token)match(input,50,FOLLOW_25); if (state.failed) return current; + lv_name_20_7=(Token)match(input,52,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_7, grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); @@ -4475,7 +4516,7 @@ else if ( (LA23_4==15) ) { case 8 : // InternalExpression.g:1604:8: lv_name_20_8= 'forAll' { - lv_name_20_8=(Token)match(input,51,FOLLOW_25); if (state.failed) return current; + lv_name_20_8=(Token)match(input,53,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_8, grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); @@ -4501,7 +4542,7 @@ else if ( (LA23_4==15) ) { } - otherlv_21=(Token)match(input,15,FOLLOW_5); if (state.failed) return current; + otherlv_21=(Token)match(input,17,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_21, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); @@ -4514,7 +4555,7 @@ else if ( (LA23_4==15) ) { if ( (LA22_0==RULE_ID) ) { int LA22_1 = input.LA(2); - if ( (LA22_1==52) ) { + if ( (LA22_1==54) ) { alt22=1; } } @@ -4557,7 +4598,7 @@ else if ( (LA23_4==15) ) { } - otherlv_23=(Token)match(input,52,FOLLOW_5); if (state.failed) return current; + otherlv_23=(Token)match(input,54,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_23, grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); @@ -4604,7 +4645,7 @@ else if ( (LA23_4==15) ) { } - otherlv_25=(Token)match(input,16,FOLLOW_24); if (state.failed) return current; + otherlv_25=(Token)match(input,18,FOLLOW_24); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_25, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); @@ -4717,16 +4758,14 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case RULE_INT: case RULE_REAL: case RULE_STRING: - case 53: - case 54: case 55: + case 56: + case 57: { alt24=1; } break; case RULE_ID: - case 43: - case 44: case 45: case 46: case 47: @@ -4734,29 +4773,31 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case 49: case 50: case 51: - case 58: - case 59: + case 52: + case 53: case 60: + case 61: + case 62: { alt24=2; } break; - case 23: + case 25: { alt24=3; } break; - case 57: + case 59: { alt24=4; } break; - case 56: + case 58: { alt24=5; } break; - case 15: + case 17: { alt24=6; } @@ -4992,8 +5033,8 @@ public final EObject ruleLiteral() throws RecognitionException { // InternalExpression.g:1761:2: (this_BooleanLiteral_0= ruleBooleanLiteral | this_IntegerLiteral_1= ruleIntegerLiteral | this_NullLiteral_2= ruleNullLiteral | this_RealLiteral_3= ruleRealLiteral | this_StringLiteral_4= ruleStringLiteral ) int alt25=5; switch ( input.LA(1) ) { - case 53: - case 54: + case 55: + case 56: { alt25=1; } @@ -5003,7 +5044,7 @@ public final EObject ruleLiteral() throws RecognitionException { alt25=2; } break; - case 55: + case 57: { alt25=3; } @@ -5226,10 +5267,10 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { int alt26=2; int LA26_0 = input.LA(1); - if ( (LA26_0==53) ) { + if ( (LA26_0==55) ) { alt26=1; } - else if ( (LA26_0==54) ) { + else if ( (LA26_0==56) ) { alt26=2; } else { @@ -5243,7 +5284,7 @@ else if ( (LA26_0==54) ) { case 1 : // InternalExpression.g:1827:5: lv_val_0_1= 'true' { - lv_val_0_1=(Token)match(input,53,FOLLOW_2); if (state.failed) return current; + lv_val_0_1=(Token)match(input,55,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_1, grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); @@ -5263,7 +5304,7 @@ else if ( (LA26_0==54) ) { case 2 : // InternalExpression.g:1838:5: lv_val_0_2= 'false' { - lv_val_0_2=(Token)match(input,54,FOLLOW_2); if (state.failed) return current; + lv_val_0_2=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_2, grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); @@ -5385,7 +5426,7 @@ public final EObject ruleIntegerLiteral() throws RecognitionException { current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.INT"); + "org.eclipse.xtext.xbase.Xbase.INT"); } @@ -5475,7 +5516,7 @@ public final EObject ruleNullLiteral() throws RecognitionException { // InternalExpression.g:1904:3: (lv_val_0_0= 'null' ) // InternalExpression.g:1905:4: lv_val_0_0= 'null' { - lv_val_0_0=(Token)match(input,55,FOLLOW_2); if (state.failed) return current; + lv_val_0_0=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_0, grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); @@ -5696,7 +5737,7 @@ public final EObject ruleStringLiteral() throws RecognitionException { current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.STRING"); + "org.eclipse.xtext.xbase.Xtype.STRING"); } @@ -5786,7 +5827,7 @@ public final EObject ruleParanthesizedExpression() throws RecognitionException { // InternalExpression.g:2004:2: (otherlv_0= '(' this_Expression_1= ruleExpression otherlv_2= ')' ) // InternalExpression.g:2005:3: otherlv_0= '(' this_Expression_1= ruleExpression otherlv_2= ')' { - otherlv_0=(Token)match(input,15,FOLLOW_5); if (state.failed) return current; + otherlv_0=(Token)match(input,17,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -5808,7 +5849,7 @@ public final EObject ruleParanthesizedExpression() throws RecognitionException { afterParserOrEnumRuleCall(); } - otherlv_2=(Token)match(input,16,FOLLOW_2); if (state.failed) return current; + otherlv_2=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); @@ -5897,7 +5938,7 @@ public final EObject ruleGlobalVarExpression() throws RecognitionException { // InternalExpression.g:2039:2: (otherlv_0= 'GLOBALVAR' ( (lv_name_1_0= ruleIdentifier ) ) ) // InternalExpression.g:2040:3: otherlv_0= 'GLOBALVAR' ( (lv_name_1_0= ruleIdentifier ) ) { - otherlv_0=(Token)match(input,56,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,58,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); @@ -6030,12 +6071,12 @@ public final EObject ruleFeatureCall() throws RecognitionException { { int LA27_1 = input.LA(2); - if ( (LA27_1==15) ) { - alt27=1; - } - else if ( (LA27_1==EOF||LA27_1==14||(LA27_1>=16 && LA27_1<=18)||(LA27_1>=20 && LA27_1<=21)||(LA27_1>=24 && LA27_1<=39)||(LA27_1>=41 && LA27_1<=42)||LA27_1==63) ) { + if ( (LA27_1==EOF||LA27_1==16||(LA27_1>=18 && LA27_1<=20)||(LA27_1>=22 && LA27_1<=23)||(LA27_1>=26 && LA27_1<=41)||(LA27_1>=43 && LA27_1<=44)||LA27_1==65) ) { alt27=2; } + else if ( (LA27_1==17) ) { + alt27=1; + } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = @@ -6045,26 +6086,26 @@ else if ( (LA27_1==EOF||LA27_1==14||(LA27_1>=16 && LA27_1<=18)||(LA27_1>=20 && L } } break; - case 58: - case 59: case 60: + case 61: + case 62: { alt27=2; } break; - case 44: - case 45: case 46: case 47: case 48: case 49: case 50: case 51: + case 52: + case 53: { alt27=3; } break; - case 43: + case 45: { alt27=4; } @@ -6309,7 +6350,7 @@ public final EObject ruleOperationCall() throws RecognitionException { } - otherlv_1=(Token)match(input,15,FOLLOW_26); if (state.failed) return current; + otherlv_1=(Token)match(input,17,FOLLOW_26); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); @@ -6319,7 +6360,7 @@ public final EObject ruleOperationCall() throws RecognitionException { int alt29=2; int LA29_0 = input.LA(1); - if ( ((LA29_0>=RULE_INT && LA29_0<=RULE_ID)||LA29_0==12||LA29_0==15||LA29_0==19||(LA29_0>=22 && LA29_0<=23)||LA29_0==37||LA29_0==40||(LA29_0>=43 && LA29_0<=51)||(LA29_0>=53 && LA29_0<=60)) ) { + if ( ((LA29_0>=RULE_INT && LA29_0<=RULE_ID)||LA29_0==14||LA29_0==17||LA29_0==21||(LA29_0>=24 && LA29_0<=25)||LA29_0==39||LA29_0==42||(LA29_0>=45 && LA29_0<=53)||(LA29_0>=55 && LA29_0<=62)) ) { alt29=1; } switch (alt29) { @@ -6367,7 +6408,7 @@ public final EObject ruleOperationCall() throws RecognitionException { int alt28=2; int LA28_0 = input.LA(1); - if ( (LA28_0==42) ) { + if ( (LA28_0==44) ) { alt28=1; } @@ -6376,7 +6417,7 @@ public final EObject ruleOperationCall() throws RecognitionException { case 1 : // InternalExpression.g:2191:5: otherlv_3= ',' ( (lv_params_4_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,42,FOLLOW_5); if (state.failed) return current; + otherlv_3=(Token)match(input,44,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); @@ -6432,7 +6473,7 @@ public final EObject ruleOperationCall() throws RecognitionException { } - otherlv_5=(Token)match(input,16,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); @@ -6538,7 +6579,7 @@ public final EObject ruleListLiteral() throws RecognitionException { } - otherlv_1=(Token)match(input,23,FOLLOW_31); if (state.failed) return current; + otherlv_1=(Token)match(input,25,FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); @@ -6548,7 +6589,7 @@ public final EObject ruleListLiteral() throws RecognitionException { int alt31=2; int LA31_0 = input.LA(1); - if ( ((LA31_0>=RULE_INT && LA31_0<=RULE_ID)||LA31_0==12||LA31_0==15||LA31_0==19||(LA31_0>=22 && LA31_0<=23)||LA31_0==37||LA31_0==40||(LA31_0>=43 && LA31_0<=51)||(LA31_0>=53 && LA31_0<=60)) ) { + if ( ((LA31_0>=RULE_INT && LA31_0<=RULE_ID)||LA31_0==14||LA31_0==17||LA31_0==21||(LA31_0>=24 && LA31_0<=25)||LA31_0==39||LA31_0==42||(LA31_0>=45 && LA31_0<=53)||(LA31_0>=55 && LA31_0<=62)) ) { alt31=1; } switch (alt31) { @@ -6596,7 +6637,7 @@ public final EObject ruleListLiteral() throws RecognitionException { int alt30=2; int LA30_0 = input.LA(1); - if ( (LA30_0==42) ) { + if ( (LA30_0==44) ) { alt30=1; } @@ -6605,7 +6646,7 @@ public final EObject ruleListLiteral() throws RecognitionException { case 1 : // InternalExpression.g:2271:5: otherlv_3= ',' ( (lv_elements_4_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,42,FOLLOW_5); if (state.failed) return current; + otherlv_3=(Token)match(input,44,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); @@ -6661,7 +6702,7 @@ public final EObject ruleListLiteral() throws RecognitionException { } - otherlv_5=(Token)match(input,25,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); @@ -6750,7 +6791,7 @@ public final EObject ruleConstructorCallExpression() throws RecognitionException // InternalExpression.g:2318:2: (otherlv_0= 'new' ( (lv_type_1_0= ruleSimpleType ) ) ) // InternalExpression.g:2319:3: otherlv_0= 'new' ( (lv_type_1_0= ruleSimpleType ) ) { - otherlv_0=(Token)match(input,57,FOLLOW_7); if (state.failed) return current; + otherlv_0=(Token)match(input,59,FOLLOW_7); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); @@ -6882,7 +6923,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { // InternalExpression.g:2362:4: (lv_name_0_0= 'typeSelect' ) // InternalExpression.g:2363:5: lv_name_0_0= 'typeSelect' { - lv_name_0_0=(Token)match(input,43,FOLLOW_25); if (state.failed) return current; + lv_name_0_0=(Token)match(input,45,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_0, grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); @@ -6902,7 +6943,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,15,FOLLOW_7); if (state.failed) return current; + otherlv_1=(Token)match(input,17,FOLLOW_7); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); @@ -6943,7 +6984,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,16,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); @@ -7053,42 +7094,42 @@ public final EObject ruleCollectionExpression() throws RecognitionException { // InternalExpression.g:2423:5: (lv_name_0_1= 'collect' | lv_name_0_2= 'select' | lv_name_0_3= 'selectFirst' | lv_name_0_4= 'reject' | lv_name_0_5= 'exists' | lv_name_0_6= 'notExists' | lv_name_0_7= 'sortBy' | lv_name_0_8= 'forAll' ) int alt32=8; switch ( input.LA(1) ) { - case 44: + case 46: { alt32=1; } break; - case 45: + case 47: { alt32=2; } break; - case 46: + case 48: { alt32=3; } break; - case 47: + case 49: { alt32=4; } break; - case 48: + case 50: { alt32=5; } break; - case 49: + case 51: { alt32=6; } break; - case 50: + case 52: { alt32=7; } break; - case 51: + case 53: { alt32=8; } @@ -7105,7 +7146,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 1 : // InternalExpression.g:2424:6: lv_name_0_1= 'collect' { - lv_name_0_1=(Token)match(input,44,FOLLOW_25); if (state.failed) return current; + lv_name_0_1=(Token)match(input,46,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_1, grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); @@ -7125,7 +7166,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 2 : // InternalExpression.g:2435:6: lv_name_0_2= 'select' { - lv_name_0_2=(Token)match(input,45,FOLLOW_25); if (state.failed) return current; + lv_name_0_2=(Token)match(input,47,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_2, grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); @@ -7145,7 +7186,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 3 : // InternalExpression.g:2446:6: lv_name_0_3= 'selectFirst' { - lv_name_0_3=(Token)match(input,46,FOLLOW_25); if (state.failed) return current; + lv_name_0_3=(Token)match(input,48,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_3, grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); @@ -7165,7 +7206,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 4 : // InternalExpression.g:2457:6: lv_name_0_4= 'reject' { - lv_name_0_4=(Token)match(input,47,FOLLOW_25); if (state.failed) return current; + lv_name_0_4=(Token)match(input,49,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_4, grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); @@ -7185,7 +7226,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 5 : // InternalExpression.g:2468:6: lv_name_0_5= 'exists' { - lv_name_0_5=(Token)match(input,48,FOLLOW_25); if (state.failed) return current; + lv_name_0_5=(Token)match(input,50,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_5, grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); @@ -7205,7 +7246,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 6 : // InternalExpression.g:2479:6: lv_name_0_6= 'notExists' { - lv_name_0_6=(Token)match(input,49,FOLLOW_25); if (state.failed) return current; + lv_name_0_6=(Token)match(input,51,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_6, grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); @@ -7225,7 +7266,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 7 : // InternalExpression.g:2490:6: lv_name_0_7= 'sortBy' { - lv_name_0_7=(Token)match(input,50,FOLLOW_25); if (state.failed) return current; + lv_name_0_7=(Token)match(input,52,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_7, grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); @@ -7245,7 +7286,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 8 : // InternalExpression.g:2501:6: lv_name_0_8= 'forAll' { - lv_name_0_8=(Token)match(input,51,FOLLOW_25); if (state.failed) return current; + lv_name_0_8=(Token)match(input,53,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_8, grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); @@ -7271,7 +7312,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,15,FOLLOW_5); if (state.failed) return current; + otherlv_1=(Token)match(input,17,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); @@ -7284,7 +7325,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { if ( (LA33_0==RULE_ID) ) { int LA33_1 = input.LA(2); - if ( (LA33_1==52) ) { + if ( (LA33_1==54) ) { alt33=1; } } @@ -7327,7 +7368,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,52,FOLLOW_5); if (state.failed) return current; + otherlv_3=(Token)match(input,54,FOLLOW_5); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); @@ -7374,7 +7415,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_5=(Token)match(input,16,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); @@ -7465,7 +7506,7 @@ public final EObject ruleType() throws RecognitionException { int alt34=2; int LA34_0 = input.LA(1); - if ( ((LA34_0>=58 && LA34_0<=60)) ) { + if ( ((LA34_0>=60 && LA34_0<=62)) ) { alt34=1; } else if ( (LA34_0==RULE_ID) ) { @@ -7619,17 +7660,17 @@ public final EObject ruleCollectionType() throws RecognitionException { // InternalExpression.g:2623:5: (lv_cl_0_1= 'Collection' | lv_cl_0_2= 'List' | lv_cl_0_3= 'Set' ) int alt35=3; switch ( input.LA(1) ) { - case 58: + case 60: { alt35=1; } break; - case 59: + case 61: { alt35=2; } break; - case 60: + case 62: { alt35=3; } @@ -7646,7 +7687,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 1 : // InternalExpression.g:2624:6: lv_cl_0_1= 'Collection' { - lv_cl_0_1=(Token)match(input,58,FOLLOW_33); if (state.failed) return current; + lv_cl_0_1=(Token)match(input,60,FOLLOW_33); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_1, grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); @@ -7666,7 +7707,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 2 : // InternalExpression.g:2635:6: lv_cl_0_2= 'List' { - lv_cl_0_2=(Token)match(input,59,FOLLOW_33); if (state.failed) return current; + lv_cl_0_2=(Token)match(input,61,FOLLOW_33); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_2, grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); @@ -7686,7 +7727,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 3 : // InternalExpression.g:2646:6: lv_cl_0_3= 'Set' { - lv_cl_0_3=(Token)match(input,60,FOLLOW_33); if (state.failed) return current; + lv_cl_0_3=(Token)match(input,62,FOLLOW_33); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_3, grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); @@ -7712,7 +7753,7 @@ public final EObject ruleCollectionType() throws RecognitionException { } - otherlv_1=(Token)match(input,61,FOLLOW_7); if (state.failed) return current; + otherlv_1=(Token)match(input,63,FOLLOW_7); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); @@ -7753,7 +7794,7 @@ public final EObject ruleCollectionType() throws RecognitionException { } - otherlv_3=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); @@ -7885,7 +7926,7 @@ public final EObject ruleSimpleType() throws RecognitionException { int alt36=2; int LA36_0 = input.LA(1); - if ( (LA36_0==63) ) { + if ( (LA36_0==65) ) { alt36=1; } @@ -7894,7 +7935,7 @@ public final EObject ruleSimpleType() throws RecognitionException { case 1 : // InternalExpression.g:2725:4: otherlv_1= '::' ( (lv_id_2_0= ruleIdentifier ) ) { - otherlv_1=(Token)match(input,63,FOLLOW_3); if (state.failed) return current; + otherlv_1=(Token)match(input,65,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); @@ -8053,189 +8094,22357 @@ public final AntlrDatatypeRuleToken ruleIdentifier() throws RecognitionException } // $ANTLR end "ruleIdentifier" - // $ANTLR start synpred1_InternalExpression - public final void synpred1_InternalExpression_fragment() throws RecognitionException { - // InternalExpression.g:89:4: ( ruleCastedExpression ) - // InternalExpression.g:89:5: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); - state._fsp--; - if (state.failed) return ; + // $ANTLR start "entryRuleXExpression" + // InternalExpression.g:2777:1: entryRuleXExpression returns [EObject current=null] : iv_ruleXExpression= ruleXExpression EOF ; + public final EObject entryRuleXExpression() throws RecognitionException { + EObject current = null; - } - } - // $ANTLR end synpred1_InternalExpression + EObject iv_ruleXExpression = null; - // $ANTLR start synpred2_InternalExpression - public final void synpred2_InternalExpression_fragment() throws RecognitionException { - // InternalExpression.g:513:4: ( 'else' ) - // InternalExpression.g:513:5: 'else' - { - match(input,21,FOLLOW_2); if (state.failed) return ; - } - } - // $ANTLR end synpred2_InternalExpression + try { + // InternalExpression.g:2777:52: (iv_ruleXExpression= ruleXExpression EOF ) + // InternalExpression.g:2778:2: iv_ruleXExpression= ruleXExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpression=ruleXExpression(); - // Delegated rules + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } - public final boolean synpred2_InternalExpression() { - state.backtracking++; - int start = input.mark(); - try { - synpred2_InternalExpression_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred1_InternalExpression() { - state.backtracking++; - int start = input.mark(); - try { - synpred1_InternalExpression_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; + return current; } + // $ANTLR end "entryRuleXExpression" - protected DFA1 dfa1 = new DFA1(this); - static final String dfa_1s = "\36\uffff"; - static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; - static final String dfa_3s = "\1\74\1\uffff\1\0\33\uffff"; - static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; - static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; - static final String[] dfa_6s = { - "\4\3\4\uffff\1\1\2\uffff\1\2\3\uffff\1\3\2\uffff\2\3\15\uffff\1\3\2\uffff\1\3\2\uffff\11\3\1\uffff\10\3", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - }; - - static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); - static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); - static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); - static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); - static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); - static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + // $ANTLR start "ruleXExpression" + // InternalExpression.g:2784:1: ruleXExpression returns [EObject current=null] : this_XAssignment_0= ruleXAssignment ; + public final EObject ruleXExpression() throws RecognitionException { + EObject current = null; - class DFA1 extends DFA { + EObject this_XAssignment_0 = null; - public DFA1(BaseRecognizer recognizer) { - this.recognizer = recognizer; - this.decisionNumber = 1; - this.eot = dfa_1; - this.eof = dfa_1; - this.min = dfa_2; - this.max = dfa_3; - this.accept = dfa_4; - this.special = dfa_5; - this.transition = dfa_6; - } - public String getDescription() { - return "78:2: (this_LetExpression_0= ruleLetExpression | ( ( ruleCastedExpression )=>this_CastedExpression_1= ruleCastedExpression ) | this_ChainExpression_2= ruleChainExpression )"; - } - public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { - TokenStream input = (TokenStream)_input; - int _s = s; - switch ( s ) { - case 0 : - int LA1_2 = input.LA(1); - - int index1_2 = input.index(); - input.rewind(); - s = -1; - if ( (synpred1_InternalExpression()) ) {s = 29;} - else if ( (true) ) {s = 3;} + enterRule(); + + try { + // InternalExpression.g:2790:2: (this_XAssignment_0= ruleXAssignment ) + // InternalExpression.g:2791:2: this_XAssignment_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + + } + pushFollow(FOLLOW_2); + this_XAssignment_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAssignment_0; + afterParserOrEnumRuleCall(); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpression" + + + // $ANTLR start "entryRuleXAssignment" + // InternalExpression.g:2802:1: entryRuleXAssignment returns [EObject current=null] : iv_ruleXAssignment= ruleXAssignment EOF ; + public final EObject entryRuleXAssignment() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAssignment = null; + + + try { + // InternalExpression.g:2802:52: (iv_ruleXAssignment= ruleXAssignment EOF ) + // InternalExpression.g:2803:2: iv_ruleXAssignment= ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAssignment=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAssignment; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAssignment" + + + // $ANTLR start "ruleXAssignment" + // InternalExpression.g:2809:1: ruleXAssignment returns [EObject current=null] : ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ; + public final EObject ruleXAssignment() throws RecognitionException { + EObject current = null; + + EObject lv_value_3_0 = null; + + EObject this_XOrExpression_4 = null; + + EObject lv_rightOperand_7_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:2815:2: ( ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ) + // InternalExpression.g:2816:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) + { + // InternalExpression.g:2816:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) + int alt38=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA38_1 = input.LA(2); + + if ( (LA38_1==EOF||LA38_1==RULE_INT||(LA38_1>=RULE_STRING && LA38_1<=RULE_DECIMAL)||(LA38_1>=16 && LA38_1<=19)||LA38_1==21||(LA38_1>=23 && LA38_1<=30)||(LA38_1>=32 && LA38_1<=34)||(LA38_1>=36 && LA38_1<=44)||(LA38_1>=55 && LA38_1<=57)||LA38_1==59||(LA38_1>=63 && LA38_1<=103)) ) { + alt38=2; + } + else if ( (LA38_1==15) ) { + alt38=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 38, 1, input); + + throw nvae; + } + } + break; + case 92: + { + int LA38_2 = input.LA(2); + + if ( (LA38_2==EOF||LA38_2==RULE_INT||(LA38_2>=RULE_STRING && LA38_2<=RULE_DECIMAL)||(LA38_2>=16 && LA38_2<=19)||LA38_2==21||(LA38_2>=23 && LA38_2<=30)||(LA38_2>=32 && LA38_2<=34)||(LA38_2>=36 && LA38_2<=44)||(LA38_2>=55 && LA38_2<=57)||LA38_2==59||(LA38_2>=63 && LA38_2<=103)) ) { + alt38=2; + } + else if ( (LA38_2==15) ) { + alt38=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 38, 2, input); + + throw nvae; + } + } + break; + case 93: + { + int LA38_3 = input.LA(2); + + if ( (LA38_3==EOF||LA38_3==RULE_INT||(LA38_3>=RULE_STRING && LA38_3<=RULE_DECIMAL)||(LA38_3>=16 && LA38_3<=19)||LA38_3==21||(LA38_3>=23 && LA38_3<=30)||(LA38_3>=32 && LA38_3<=34)||(LA38_3>=36 && LA38_3<=44)||(LA38_3>=55 && LA38_3<=57)||LA38_3==59||(LA38_3>=63 && LA38_3<=103)) ) { + alt38=2; + } + else if ( (LA38_3==15) ) { + alt38=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 38, 3, input); + + throw nvae; + } + } + break; + case 94: + { + int LA38_4 = input.LA(2); + + if ( (LA38_4==EOF||LA38_4==RULE_INT||(LA38_4>=RULE_STRING && LA38_4<=RULE_DECIMAL)||(LA38_4>=16 && LA38_4<=19)||LA38_4==21||(LA38_4>=23 && LA38_4<=30)||(LA38_4>=32 && LA38_4<=34)||(LA38_4>=36 && LA38_4<=44)||(LA38_4>=55 && LA38_4<=57)||LA38_4==59||(LA38_4>=63 && LA38_4<=103)) ) { + alt38=2; + } + else if ( (LA38_4==15) ) { + alt38=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 38, 4, input); + + throw nvae; + } + } + break; + case 95: + { + int LA38_5 = input.LA(2); + + if ( (LA38_5==15) ) { + alt38=1; + } + else if ( (LA38_5==EOF||LA38_5==RULE_INT||(LA38_5>=RULE_STRING && LA38_5<=RULE_DECIMAL)||(LA38_5>=16 && LA38_5<=19)||LA38_5==21||(LA38_5>=23 && LA38_5<=30)||(LA38_5>=32 && LA38_5<=34)||(LA38_5>=36 && LA38_5<=44)||(LA38_5>=55 && LA38_5<=57)||LA38_5==59||(LA38_5>=63 && LA38_5<=103)) ) { + alt38=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 38, 5, input); + + throw nvae; + } + } + break; + case RULE_INT: + case RULE_STRING: + case RULE_HEX: + case RULE_DECIMAL: + case 17: + case 21: + case 24: + case 25: + case 37: + case 38: + case 39: + case 42: + case 55: + case 56: + case 57: + case 59: + case 63: + case 85: + case 87: + case 88: + case 89: + case 96: + case 97: + case 98: + case 99: + case 100: + case 102: + { + alt38=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 38, 0, input); + + throw nvae; + } + + switch (alt38) { + case 1 : + // InternalExpression.g:2817:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) + { + // InternalExpression.g:2817:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) + // InternalExpression.g:2818:4: () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) + { + // InternalExpression.g:2818:4: () + // InternalExpression.g:2819:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(), + current); + + } + + } + + // InternalExpression.g:2825:4: ( ( ruleFeatureCallID ) ) + // InternalExpression.g:2826:5: ( ruleFeatureCallID ) + { + // InternalExpression.g:2826:5: ( ruleFeatureCallID ) + // InternalExpression.g:2827:6: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAssignmentRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + + } + pushFollow(FOLLOW_4); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + + } + pushFollow(FOLLOW_36); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:2848:4: ( (lv_value_3_0= ruleXAssignment ) ) + // InternalExpression.g:2849:5: (lv_value_3_0= ruleXAssignment ) + { + // InternalExpression.g:2849:5: (lv_value_3_0= ruleXAssignment ) + // InternalExpression.g:2850:6: lv_value_3_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + + } + pushFollow(FOLLOW_2); + lv_value_3_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + current, + "value", + lv_value_3_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:2869:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) + { + // InternalExpression.g:2869:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) + // InternalExpression.g:2870:4: this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_37); + this_XOrExpression_4=ruleXOrExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XOrExpression_4; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:2878:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? + int alt37=2; + alt37 = dfa37.predict(input); + switch (alt37) { + case 1 : + // InternalExpression.g:2879:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) + { + // InternalExpression.g:2879:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) + // InternalExpression.g:2880:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) + { + // InternalExpression.g:2890:6: ( () ( ( ruleOpMultiAssign ) ) ) + // InternalExpression.g:2891:7: () ( ( ruleOpMultiAssign ) ) + { + // InternalExpression.g:2891:7: () + // InternalExpression.g:2892:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:2898:7: ( ( ruleOpMultiAssign ) ) + // InternalExpression.g:2899:8: ( ruleOpMultiAssign ) + { + // InternalExpression.g:2899:8: ( ruleOpMultiAssign ) + // InternalExpression.g:2900:9: ruleOpMultiAssign + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAssignmentRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:2916:5: ( (lv_rightOperand_7_0= ruleXAssignment ) ) + // InternalExpression.g:2917:6: (lv_rightOperand_7_0= ruleXAssignment ) + { + // InternalExpression.g:2917:6: (lv_rightOperand_7_0= ruleXAssignment ) + // InternalExpression.g:2918:7: lv_rightOperand_7_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_rightOperand_7_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_7_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAssignment" + + + // $ANTLR start "entryRuleOpSingleAssign" + // InternalExpression.g:2941:1: entryRuleOpSingleAssign returns [String current=null] : iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ; + public final String entryRuleOpSingleAssign() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpSingleAssign = null; + + + try { + // InternalExpression.g:2941:54: (iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ) + // InternalExpression.g:2942:2: iv_ruleOpSingleAssign= ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpSingleAssignRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpSingleAssign=ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpSingleAssign.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpSingleAssign" + + + // $ANTLR start "ruleOpSingleAssign" + // InternalExpression.g:2948:1: ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '=' ; + public final AntlrDatatypeRuleToken ruleOpSingleAssign() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:2954:2: (kw= '=' ) + // InternalExpression.g:2955:2: kw= '=' + { + kw=(Token)match(input,15,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpSingleAssign" + + + // $ANTLR start "entryRuleOpMultiAssign" + // InternalExpression.g:2963:1: entryRuleOpMultiAssign returns [String current=null] : iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ; + public final String entryRuleOpMultiAssign() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpMultiAssign = null; + + + try { + // InternalExpression.g:2963:53: (iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ) + // InternalExpression.g:2964:2: iv_ruleOpMultiAssign= ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpMultiAssign=ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpMultiAssign.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpMultiAssign" + + + // $ANTLR start "ruleOpMultiAssign" + // InternalExpression.g:2970:1: ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ; + public final AntlrDatatypeRuleToken ruleOpMultiAssign() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:2976:2: ( (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ) + // InternalExpression.g:2977:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) + { + // InternalExpression.g:2977:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) + int alt40=7; + switch ( input.LA(1) ) { + case 66: + { + alt40=1; + } + break; + case 67: + { + alt40=2; + } + break; + case 68: + { + alt40=3; + } + break; + case 69: + { + alt40=4; + } + break; + case 70: + { + alt40=5; + } + break; + case 37: + { + alt40=6; + } + break; + case 36: + { + alt40=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); + + throw nvae; + } + + switch (alt40) { + case 1 : + // InternalExpression.g:2978:3: kw= '+=' + { + kw=(Token)match(input,66,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:2984:3: kw= '-=' + { + kw=(Token)match(input,67,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:2990:3: kw= '*=' + { + kw=(Token)match(input,68,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalExpression.g:2996:3: kw= '/=' + { + kw=(Token)match(input,69,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + + } + + } + break; + case 5 : + // InternalExpression.g:3002:3: kw= '%=' + { + kw=(Token)match(input,70,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + + } + + } + break; + case 6 : + // InternalExpression.g:3008:3: (kw= '<' kw= '<' kw= '=' ) + { + // InternalExpression.g:3008:3: (kw= '<' kw= '<' kw= '=' ) + // InternalExpression.g:3009:4: kw= '<' kw= '<' kw= '=' + { + kw=(Token)match(input,37,FOLLOW_38); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + + } + kw=(Token)match(input,37,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + + } + kw=(Token)match(input,15,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + + } + + } + + + } + break; + case 7 : + // InternalExpression.g:3026:3: (kw= '>' (kw= '>' )? kw= '>=' ) + { + // InternalExpression.g:3026:3: (kw= '>' (kw= '>' )? kw= '>=' ) + // InternalExpression.g:3027:4: kw= '>' (kw= '>' )? kw= '>=' + { + kw=(Token)match(input,36,FOLLOW_39); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + + } + // InternalExpression.g:3032:4: (kw= '>' )? + int alt39=2; + int LA39_0 = input.LA(1); + + if ( (LA39_0==36) ) { + alt39=1; + } + switch (alt39) { + case 1 : + // InternalExpression.g:3033:5: kw= '>' + { + kw=(Token)match(input,36,FOLLOW_40); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + + } + + } + break; + + } + + kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + + } + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpMultiAssign" + + + // $ANTLR start "entryRuleXOrExpression" + // InternalExpression.g:3049:1: entryRuleXOrExpression returns [EObject current=null] : iv_ruleXOrExpression= ruleXOrExpression EOF ; + public final EObject entryRuleXOrExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXOrExpression = null; + + + try { + // InternalExpression.g:3049:54: (iv_ruleXOrExpression= ruleXOrExpression EOF ) + // InternalExpression.g:3050:2: iv_ruleXOrExpression= ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXOrExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXOrExpression=ruleXOrExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXOrExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXOrExpression" + + + // $ANTLR start "ruleXOrExpression" + // InternalExpression.g:3056:1: ruleXOrExpression returns [EObject current=null] : (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ; + public final EObject ruleXOrExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAndExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3062:2: ( (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ) + // InternalExpression.g:3063:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) + { + // InternalExpression.g:3063:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) + // InternalExpression.g:3064:3: this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_18); + this_XAndExpression_0=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAndExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3072:3: ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* + loop41: + do { + int alt41=2; + int LA41_0 = input.LA(1); + + if ( (LA41_0==29) ) { + int LA41_2 = input.LA(2); + + if ( (synpred4_InternalExpression()) ) { + alt41=1; + } + + + } + + + switch (alt41) { + case 1 : + // InternalExpression.g:3073:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) + { + // InternalExpression.g:3073:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) + // InternalExpression.g:3074:5: ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) + { + // InternalExpression.g:3084:5: ( () ( ( ruleOpOr ) ) ) + // InternalExpression.g:3085:6: () ( ( ruleOpOr ) ) + { + // InternalExpression.g:3085:6: () + // InternalExpression.g:3086:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3092:6: ( ( ruleOpOr ) ) + // InternalExpression.g:3093:7: ( ruleOpOr ) + { + // InternalExpression.g:3093:7: ( ruleOpOr ) + // InternalExpression.g:3094:8: ruleOpOr + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXOrExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpOr(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3110:4: ( (lv_rightOperand_3_0= ruleXAndExpression ) ) + // InternalExpression.g:3111:5: (lv_rightOperand_3_0= ruleXAndExpression ) + { + // InternalExpression.g:3111:5: (lv_rightOperand_3_0= ruleXAndExpression ) + // InternalExpression.g:3112:6: lv_rightOperand_3_0= ruleXAndExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_18); + lv_rightOperand_3_0=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXOrExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAndExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop41; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXOrExpression" + + + // $ANTLR start "entryRuleOpOr" + // InternalExpression.g:3134:1: entryRuleOpOr returns [String current=null] : iv_ruleOpOr= ruleOpOr EOF ; + public final String entryRuleOpOr() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpOr = null; + + + try { + // InternalExpression.g:3134:44: (iv_ruleOpOr= ruleOpOr EOF ) + // InternalExpression.g:3135:2: iv_ruleOpOr= ruleOpOr EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpOr=ruleOpOr(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpOr.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpOr" + + + // $ANTLR start "ruleOpOr" + // InternalExpression.g:3141:1: ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '||' ; + public final AntlrDatatypeRuleToken ruleOpOr() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:3147:2: (kw= '||' ) + // InternalExpression.g:3148:2: kw= '||' + { + kw=(Token)match(input,29,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpOr" + + + // $ANTLR start "entryRuleXAndExpression" + // InternalExpression.g:3156:1: entryRuleXAndExpression returns [EObject current=null] : iv_ruleXAndExpression= ruleXAndExpression EOF ; + public final EObject entryRuleXAndExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAndExpression = null; + + + try { + // InternalExpression.g:3156:55: (iv_ruleXAndExpression= ruleXAndExpression EOF ) + // InternalExpression.g:3157:2: iv_ruleXAndExpression= ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAndExpression=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAndExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAndExpression" + + + // $ANTLR start "ruleXAndExpression" + // InternalExpression.g:3163:1: ruleXAndExpression returns [EObject current=null] : (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ; + public final EObject ruleXAndExpression() throws RecognitionException { + EObject current = null; + + EObject this_XEqualityExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3169:2: ( (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ) + // InternalExpression.g:3170:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) + { + // InternalExpression.g:3170:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) + // InternalExpression.g:3171:3: this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_19); + this_XEqualityExpression_0=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XEqualityExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3179:3: ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* + loop42: + do { + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==30) ) { + int LA42_2 = input.LA(2); + + if ( (synpred5_InternalExpression()) ) { + alt42=1; + } + + + } + + + switch (alt42) { + case 1 : + // InternalExpression.g:3180:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) + { + // InternalExpression.g:3180:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) + // InternalExpression.g:3181:5: ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) + { + // InternalExpression.g:3191:5: ( () ( ( ruleOpAnd ) ) ) + // InternalExpression.g:3192:6: () ( ( ruleOpAnd ) ) + { + // InternalExpression.g:3192:6: () + // InternalExpression.g:3193:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3199:6: ( ( ruleOpAnd ) ) + // InternalExpression.g:3200:7: ( ruleOpAnd ) + { + // InternalExpression.g:3200:7: ( ruleOpAnd ) + // InternalExpression.g:3201:8: ruleOpAnd + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAndExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3217:4: ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) + // InternalExpression.g:3218:5: (lv_rightOperand_3_0= ruleXEqualityExpression ) + { + // InternalExpression.g:3218:5: (lv_rightOperand_3_0= ruleXEqualityExpression ) + // InternalExpression.g:3219:6: lv_rightOperand_3_0= ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_19); + lv_rightOperand_3_0=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAndExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XEqualityExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop42; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAndExpression" + + + // $ANTLR start "entryRuleOpAnd" + // InternalExpression.g:3241:1: entryRuleOpAnd returns [String current=null] : iv_ruleOpAnd= ruleOpAnd EOF ; + public final String entryRuleOpAnd() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpAnd = null; + + + try { + // InternalExpression.g:3241:45: (iv_ruleOpAnd= ruleOpAnd EOF ) + // InternalExpression.g:3242:2: iv_ruleOpAnd= ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpAnd=ruleOpAnd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpAnd.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpAnd" + + + // $ANTLR start "ruleOpAnd" + // InternalExpression.g:3248:1: ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '&&' ; + public final AntlrDatatypeRuleToken ruleOpAnd() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:3254:2: (kw= '&&' ) + // InternalExpression.g:3255:2: kw= '&&' + { + kw=(Token)match(input,30,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpAnd" + + + // $ANTLR start "entryRuleXEqualityExpression" + // InternalExpression.g:3263:1: entryRuleXEqualityExpression returns [EObject current=null] : iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ; + public final EObject entryRuleXEqualityExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXEqualityExpression = null; + + + try { + // InternalExpression.g:3263:60: (iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ) + // InternalExpression.g:3264:2: iv_ruleXEqualityExpression= ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXEqualityExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXEqualityExpression=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXEqualityExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXEqualityExpression" + + + // $ANTLR start "ruleXEqualityExpression" + // InternalExpression.g:3270:1: ruleXEqualityExpression returns [EObject current=null] : (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ; + public final EObject ruleXEqualityExpression() throws RecognitionException { + EObject current = null; + + EObject this_XRelationalExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3276:2: ( (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ) + // InternalExpression.g:3277:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) + { + // InternalExpression.g:3277:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) + // InternalExpression.g:3278:3: this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_41); + this_XRelationalExpression_0=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XRelationalExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3286:3: ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* + loop43: + do { + int alt43=2; + switch ( input.LA(1) ) { + case 32: + { + int LA43_2 = input.LA(2); + + if ( (synpred6_InternalExpression()) ) { + alt43=1; + } + + + } + break; + case 33: + { + int LA43_3 = input.LA(2); + + if ( (synpred6_InternalExpression()) ) { + alt43=1; + } + + + } + break; + case 71: + { + int LA43_4 = input.LA(2); + + if ( (synpred6_InternalExpression()) ) { + alt43=1; + } + + + } + break; + case 72: + { + int LA43_5 = input.LA(2); + + if ( (synpred6_InternalExpression()) ) { + alt43=1; + } + + + } + break; + + } + + switch (alt43) { + case 1 : + // InternalExpression.g:3287:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) + { + // InternalExpression.g:3287:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) + // InternalExpression.g:3288:5: ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) + { + // InternalExpression.g:3298:5: ( () ( ( ruleOpEquality ) ) ) + // InternalExpression.g:3299:6: () ( ( ruleOpEquality ) ) + { + // InternalExpression.g:3299:6: () + // InternalExpression.g:3300:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3306:6: ( ( ruleOpEquality ) ) + // InternalExpression.g:3307:7: ( ruleOpEquality ) + { + // InternalExpression.g:3307:7: ( ruleOpEquality ) + // InternalExpression.g:3308:8: ruleOpEquality + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXEqualityExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3324:4: ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) + // InternalExpression.g:3325:5: (lv_rightOperand_3_0= ruleXRelationalExpression ) + { + // InternalExpression.g:3325:5: (lv_rightOperand_3_0= ruleXRelationalExpression ) + // InternalExpression.g:3326:6: lv_rightOperand_3_0= ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_41); + lv_rightOperand_3_0=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XRelationalExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop43; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXEqualityExpression" + + + // $ANTLR start "entryRuleOpEquality" + // InternalExpression.g:3348:1: entryRuleOpEquality returns [String current=null] : iv_ruleOpEquality= ruleOpEquality EOF ; + public final String entryRuleOpEquality() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpEquality = null; + + + try { + // InternalExpression.g:3348:50: (iv_ruleOpEquality= ruleOpEquality EOF ) + // InternalExpression.g:3349:2: iv_ruleOpEquality= ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpEquality=ruleOpEquality(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpEquality.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpEquality" + + + // $ANTLR start "ruleOpEquality" + // InternalExpression.g:3355:1: ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ; + public final AntlrDatatypeRuleToken ruleOpEquality() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:3361:2: ( (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ) + // InternalExpression.g:3362:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) + { + // InternalExpression.g:3362:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) + int alt44=4; + switch ( input.LA(1) ) { + case 32: + { + alt44=1; + } + break; + case 33: + { + alt44=2; + } + break; + case 71: + { + alt44=3; + } + break; + case 72: + { + alt44=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 44, 0, input); + + throw nvae; + } + + switch (alt44) { + case 1 : + // InternalExpression.g:3363:3: kw= '==' + { + kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:3369:3: kw= '!=' + { + kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:3375:3: kw= '===' + { + kw=(Token)match(input,71,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalExpression.g:3381:3: kw= '!==' + { + kw=(Token)match(input,72,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpEquality" + + + // $ANTLR start "entryRuleXRelationalExpression" + // InternalExpression.g:3390:1: entryRuleXRelationalExpression returns [EObject current=null] : iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ; + public final EObject entryRuleXRelationalExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXRelationalExpression = null; + + + try { + // InternalExpression.g:3390:62: (iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ) + // InternalExpression.g:3391:2: iv_ruleXRelationalExpression= ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXRelationalExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXRelationalExpression=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXRelationalExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXRelationalExpression" + + + // $ANTLR start "ruleXRelationalExpression" + // InternalExpression.g:3397:1: ruleXRelationalExpression returns [EObject current=null] : (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ; + public final EObject ruleXRelationalExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject this_XOtherOperatorExpression_0 = null; + + EObject lv_type_3_0 = null; + + EObject lv_rightOperand_6_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3403:2: ( (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ) + // InternalExpression.g:3404:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) + { + // InternalExpression.g:3404:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) + // InternalExpression.g:3405:3: this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_42); + this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XOtherOperatorExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3413:3: ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* + loop45: + do { + int alt45=3; + switch ( input.LA(1) ) { + case 37: + { + int LA45_2 = input.LA(2); + + if ( (synpred8_InternalExpression()) ) { + alt45=2; + } + + + } + break; + case 36: + { + int LA45_3 = input.LA(2); + + if ( (synpred8_InternalExpression()) ) { + alt45=2; + } + + + } + break; + case 73: + { + int LA45_4 = input.LA(2); + + if ( (synpred7_InternalExpression()) ) { + alt45=1; + } + + + } + break; + case 34: + { + int LA45_5 = input.LA(2); + + if ( (synpred8_InternalExpression()) ) { + alt45=2; + } + + + } + break; + + } + + switch (alt45) { + case 1 : + // InternalExpression.g:3414:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) + { + // InternalExpression.g:3414:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) + // InternalExpression.g:3415:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) + { + // InternalExpression.g:3415:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) + // InternalExpression.g:3416:6: ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) + { + // InternalExpression.g:3422:6: ( () otherlv_2= 'instanceof' ) + // InternalExpression.g:3423:7: () otherlv_2= 'instanceof' + { + // InternalExpression.g:3423:7: () + // InternalExpression.g:3424:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), + current); + + } + + } + + otherlv_2=(Token)match(input,73,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + + } + + } + + + } + + // InternalExpression.g:3436:5: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalExpression.g:3437:6: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalExpression.g:3437:6: (lv_type_3_0= ruleJvmTypeReference ) + // InternalExpression.g:3438:7: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + + } + pushFollow(FOLLOW_42); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:3457:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) + { + // InternalExpression.g:3457:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) + // InternalExpression.g:3458:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) + { + // InternalExpression.g:3458:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) + // InternalExpression.g:3459:6: ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) + { + // InternalExpression.g:3469:6: ( () ( ( ruleOpCompare ) ) ) + // InternalExpression.g:3470:7: () ( ( ruleOpCompare ) ) + { + // InternalExpression.g:3470:7: () + // InternalExpression.g:3471:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3477:7: ( ( ruleOpCompare ) ) + // InternalExpression.g:3478:8: ( ruleOpCompare ) + { + // InternalExpression.g:3478:8: ( ruleOpCompare ) + // InternalExpression.g:3479:9: ruleOpCompare + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXRelationalExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3495:5: ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) + // InternalExpression.g:3496:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) + { + // InternalExpression.g:3496:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) + // InternalExpression.g:3497:7: lv_rightOperand_6_0= ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + + } + pushFollow(FOLLOW_42); + lv_rightOperand_6_0=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_6_0, + "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + default : + break loop45; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXRelationalExpression" + + + // $ANTLR start "entryRuleOpCompare" + // InternalExpression.g:3520:1: entryRuleOpCompare returns [String current=null] : iv_ruleOpCompare= ruleOpCompare EOF ; + public final String entryRuleOpCompare() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpCompare = null; + + + try { + // InternalExpression.g:3520:49: (iv_ruleOpCompare= ruleOpCompare EOF ) + // InternalExpression.g:3521:2: iv_ruleOpCompare= ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpCompare=ruleOpCompare(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpCompare.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpCompare" + + + // $ANTLR start "ruleOpCompare" + // InternalExpression.g:3527:1: ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ; + public final AntlrDatatypeRuleToken ruleOpCompare() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:3533:2: ( (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ) + // InternalExpression.g:3534:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) + { + // InternalExpression.g:3534:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) + int alt46=4; + switch ( input.LA(1) ) { + case 34: + { + alt46=1; + } + break; + case 37: + { + int LA46_2 = input.LA(2); + + if ( (LA46_2==EOF||LA46_2==RULE_INT||(LA46_2>=RULE_STRING && LA46_2<=RULE_DECIMAL)||LA46_2==17||LA46_2==21||(LA46_2>=24 && LA46_2<=25)||(LA46_2>=37 && LA46_2<=39)||LA46_2==42||(LA46_2>=55 && LA46_2<=57)||LA46_2==59||LA46_2==63||LA46_2==85||(LA46_2>=87 && LA46_2<=89)||(LA46_2>=92 && LA46_2<=100)||LA46_2==102) ) { + alt46=4; + } + else if ( (LA46_2==15) ) { + alt46=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 46, 2, input); + + throw nvae; + } + } + break; + case 36: + { + alt46=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 46, 0, input); + + throw nvae; + } + + switch (alt46) { + case 1 : + // InternalExpression.g:3535:3: kw= '>=' + { + kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:3541:3: (kw= '<' kw= '=' ) + { + // InternalExpression.g:3541:3: (kw= '<' kw= '=' ) + // InternalExpression.g:3542:4: kw= '<' kw= '=' + { + kw=(Token)match(input,37,FOLLOW_4); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + + } + kw=(Token)match(input,15,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + + } + + } + + + } + break; + case 3 : + // InternalExpression.g:3554:3: kw= '>' + { + kw=(Token)match(input,36,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalExpression.g:3560:3: kw= '<' + { + kw=(Token)match(input,37,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpCompare" + + + // $ANTLR start "entryRuleXOtherOperatorExpression" + // InternalExpression.g:3569:1: entryRuleXOtherOperatorExpression returns [EObject current=null] : iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ; + public final EObject entryRuleXOtherOperatorExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXOtherOperatorExpression = null; + + + try { + // InternalExpression.g:3569:65: (iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ) + // InternalExpression.g:3570:2: iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXOtherOperatorExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" + + + // $ANTLR start "ruleXOtherOperatorExpression" + // InternalExpression.g:3576:1: ruleXOtherOperatorExpression returns [EObject current=null] : (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ; + public final EObject ruleXOtherOperatorExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAdditiveExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3582:2: ( (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ) + // InternalExpression.g:3583:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) + { + // InternalExpression.g:3583:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) + // InternalExpression.g:3584:3: this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_44); + this_XAdditiveExpression_0=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAdditiveExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3592:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* + loop47: + do { + int alt47=2; + alt47 = dfa47.predict(input); + switch (alt47) { + case 1 : + // InternalExpression.g:3593:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) + { + // InternalExpression.g:3593:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) + // InternalExpression.g:3594:5: ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) + { + // InternalExpression.g:3604:5: ( () ( ( ruleOpOther ) ) ) + // InternalExpression.g:3605:6: () ( ( ruleOpOther ) ) + { + // InternalExpression.g:3605:6: () + // InternalExpression.g:3606:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3612:6: ( ( ruleOpOther ) ) + // InternalExpression.g:3613:7: ( ruleOpOther ) + { + // InternalExpression.g:3613:7: ( ruleOpOther ) + // InternalExpression.g:3614:8: ruleOpOther + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpOther(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3630:4: ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) + // InternalExpression.g:3631:5: (lv_rightOperand_3_0= ruleXAdditiveExpression ) + { + // InternalExpression.g:3631:5: (lv_rightOperand_3_0= ruleXAdditiveExpression ) + // InternalExpression.g:3632:6: lv_rightOperand_3_0= ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_44); + lv_rightOperand_3_0=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop47; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXOtherOperatorExpression" + + + // $ANTLR start "entryRuleOpOther" + // InternalExpression.g:3654:1: entryRuleOpOther returns [String current=null] : iv_ruleOpOther= ruleOpOther EOF ; + public final String entryRuleOpOther() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpOther = null; + + + try { + // InternalExpression.g:3654:47: (iv_ruleOpOther= ruleOpOther EOF ) + // InternalExpression.g:3655:2: iv_ruleOpOther= ruleOpOther EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpOtherRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpOther=ruleOpOther(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpOther.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpOther" + + + // $ANTLR start "ruleOpOther" + // InternalExpression.g:3661:1: ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ; + public final AntlrDatatypeRuleToken ruleOpOther() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:3667:2: ( (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ) + // InternalExpression.g:3668:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) + { + // InternalExpression.g:3668:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) + int alt50=9; + alt50 = dfa50.predict(input); + switch (alt50) { + case 1 : + // InternalExpression.g:3669:3: kw= '->' + { + kw=(Token)match(input,19,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:3675:3: kw= '..<' + { + kw=(Token)match(input,74,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:3681:3: (kw= '>' kw= '..' ) + { + // InternalExpression.g:3681:3: (kw= '>' kw= '..' ) + // InternalExpression.g:3682:4: kw= '>' kw= '..' + { + kw=(Token)match(input,36,FOLLOW_45); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + + } + kw=(Token)match(input,75,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + + } + + } + + + } + break; + case 4 : + // InternalExpression.g:3694:3: kw= '..' + { + kw=(Token)match(input,75,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + + } + + } + break; + case 5 : + // InternalExpression.g:3700:3: kw= '=>' + { + kw=(Token)match(input,76,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + + } + + } + break; + case 6 : + // InternalExpression.g:3706:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) + { + // InternalExpression.g:3706:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) + // InternalExpression.g:3707:4: kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) + { + kw=(Token)match(input,36,FOLLOW_46); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + + } + // InternalExpression.g:3712:4: ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) + int alt48=2; + int LA48_0 = input.LA(1); + + if ( (LA48_0==36) ) { + int LA48_1 = input.LA(2); + + if ( (LA48_1==36) && (synpred10_InternalExpression())) { + alt48=1; + } + else if ( (LA48_1==EOF||LA48_1==RULE_INT||(LA48_1>=RULE_STRING && LA48_1<=RULE_DECIMAL)||LA48_1==17||LA48_1==21||(LA48_1>=24 && LA48_1<=25)||(LA48_1>=37 && LA48_1<=39)||LA48_1==42||(LA48_1>=55 && LA48_1<=57)||LA48_1==59||LA48_1==63||LA48_1==85||(LA48_1>=87 && LA48_1<=89)||(LA48_1>=92 && LA48_1<=100)||LA48_1==102) ) { + alt48=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 48, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 48, 0, input); + + throw nvae; + } + switch (alt48) { + case 1 : + // InternalExpression.g:3713:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) + { + // InternalExpression.g:3713:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) + // InternalExpression.g:3714:6: ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) + { + // InternalExpression.g:3719:6: (kw= '>' kw= '>' ) + // InternalExpression.g:3720:7: kw= '>' kw= '>' + { + kw=(Token)match(input,36,FOLLOW_46); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + + } + kw=(Token)match(input,36,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:3733:5: kw= '>' + { + kw=(Token)match(input,36,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + + } + + } + break; + + } + + + } + + + } + break; + case 7 : + // InternalExpression.g:3741:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) + { + // InternalExpression.g:3741:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) + // InternalExpression.g:3742:4: kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) + { + kw=(Token)match(input,37,FOLLOW_47); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + + } + // InternalExpression.g:3747:4: ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) + int alt49=3; + int LA49_0 = input.LA(1); + + if ( (LA49_0==37) ) { + int LA49_1 = input.LA(2); + + if ( (synpred11_InternalExpression()) ) { + alt49=1; + } + else if ( (true) ) { + alt49=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 49, 1, input); + + throw nvae; + } + } + else if ( (LA49_0==76) ) { + alt49=3; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 49, 0, input); + + throw nvae; + } + switch (alt49) { + case 1 : + // InternalExpression.g:3748:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) + { + // InternalExpression.g:3748:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) + // InternalExpression.g:3749:6: ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) + { + // InternalExpression.g:3754:6: (kw= '<' kw= '<' ) + // InternalExpression.g:3755:7: kw= '<' kw= '<' + { + kw=(Token)match(input,37,FOLLOW_38); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + + } + kw=(Token)match(input,37,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:3768:5: kw= '<' + { + kw=(Token)match(input,37,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:3774:5: kw= '=>' + { + kw=(Token)match(input,76,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + + } + + } + break; + + } + + + } + + + } + break; + case 8 : + // InternalExpression.g:3782:3: kw= '<>' + { + kw=(Token)match(input,77,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + + } + + } + break; + case 9 : + // InternalExpression.g:3788:3: kw= '?:' + { + kw=(Token)match(input,78,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpOther" + + + // $ANTLR start "entryRuleXAdditiveExpression" + // InternalExpression.g:3797:1: entryRuleXAdditiveExpression returns [EObject current=null] : iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ; + public final EObject entryRuleXAdditiveExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAdditiveExpression = null; + + + try { + // InternalExpression.g:3797:60: (iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ) + // InternalExpression.g:3798:2: iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAdditiveExpression=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAdditiveExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAdditiveExpression" + + + // $ANTLR start "ruleXAdditiveExpression" + // InternalExpression.g:3804:1: ruleXAdditiveExpression returns [EObject current=null] : (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ; + public final EObject ruleXAdditiveExpression() throws RecognitionException { + EObject current = null; + + EObject this_XMultiplicativeExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3810:2: ( (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ) + // InternalExpression.g:3811:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) + { + // InternalExpression.g:3811:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) + // InternalExpression.g:3812:3: this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_22); + this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XMultiplicativeExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3820:3: ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* + loop51: + do { + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==38) ) { + int LA51_2 = input.LA(2); + + if ( (synpred12_InternalExpression()) ) { + alt51=1; + } + + + } + else if ( (LA51_0==39) ) { + int LA51_3 = input.LA(2); + + if ( (synpred12_InternalExpression()) ) { + alt51=1; + } + + + } + + + switch (alt51) { + case 1 : + // InternalExpression.g:3821:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) + { + // InternalExpression.g:3821:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) + // InternalExpression.g:3822:5: ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) + { + // InternalExpression.g:3832:5: ( () ( ( ruleOpAdd ) ) ) + // InternalExpression.g:3833:6: () ( ( ruleOpAdd ) ) + { + // InternalExpression.g:3833:6: () + // InternalExpression.g:3834:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3840:6: ( ( ruleOpAdd ) ) + // InternalExpression.g:3841:7: ( ruleOpAdd ) + { + // InternalExpression.g:3841:7: ( ruleOpAdd ) + // InternalExpression.g:3842:8: ruleOpAdd + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAdditiveExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3858:4: ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) + // InternalExpression.g:3859:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) + { + // InternalExpression.g:3859:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) + // InternalExpression.g:3860:6: lv_rightOperand_3_0= ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_22); + lv_rightOperand_3_0=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop51; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAdditiveExpression" + + + // $ANTLR start "entryRuleOpAdd" + // InternalExpression.g:3882:1: entryRuleOpAdd returns [String current=null] : iv_ruleOpAdd= ruleOpAdd EOF ; + public final String entryRuleOpAdd() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpAdd = null; + + + try { + // InternalExpression.g:3882:45: (iv_ruleOpAdd= ruleOpAdd EOF ) + // InternalExpression.g:3883:2: iv_ruleOpAdd= ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpAdd=ruleOpAdd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpAdd.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpAdd" + + + // $ANTLR start "ruleOpAdd" + // InternalExpression.g:3889:1: ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+' | kw= '-' ) ; + public final AntlrDatatypeRuleToken ruleOpAdd() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:3895:2: ( (kw= '+' | kw= '-' ) ) + // InternalExpression.g:3896:2: (kw= '+' | kw= '-' ) + { + // InternalExpression.g:3896:2: (kw= '+' | kw= '-' ) + int alt52=2; + int LA52_0 = input.LA(1); + + if ( (LA52_0==38) ) { + alt52=1; + } + else if ( (LA52_0==39) ) { + alt52=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 52, 0, input); + + throw nvae; + } + switch (alt52) { + case 1 : + // InternalExpression.g:3897:3: kw= '+' + { + kw=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:3903:3: kw= '-' + { + kw=(Token)match(input,39,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpAdd" + + + // $ANTLR start "entryRuleXMultiplicativeExpression" + // InternalExpression.g:3912:1: entryRuleXMultiplicativeExpression returns [EObject current=null] : iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ; + public final EObject entryRuleXMultiplicativeExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXMultiplicativeExpression = null; + + + try { + // InternalExpression.g:3912:66: (iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ) + // InternalExpression.g:3913:2: iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXMultiplicativeExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // InternalExpression.g:3919:1: ruleXMultiplicativeExpression returns [EObject current=null] : (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ; + public final EObject ruleXMultiplicativeExpression() throws RecognitionException { + EObject current = null; + + EObject this_XUnaryOperation_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:3925:2: ( (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ) + // InternalExpression.g:3926:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) + { + // InternalExpression.g:3926:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) + // InternalExpression.g:3927:3: this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + + } + pushFollow(FOLLOW_48); + this_XUnaryOperation_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XUnaryOperation_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:3935:3: ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* + loop53: + do { + int alt53=2; + switch ( input.LA(1) ) { + case 40: + { + int LA53_2 = input.LA(2); + + if ( (synpred13_InternalExpression()) ) { + alt53=1; + } + + + } + break; + case 79: + { + int LA53_3 = input.LA(2); + + if ( (synpred13_InternalExpression()) ) { + alt53=1; + } + + + } + break; + case 41: + { + int LA53_4 = input.LA(2); + + if ( (synpred13_InternalExpression()) ) { + alt53=1; + } + + + } + break; + case 80: + { + int LA53_5 = input.LA(2); + + if ( (synpred13_InternalExpression()) ) { + alt53=1; + } + + + } + break; + + } + + switch (alt53) { + case 1 : + // InternalExpression.g:3936:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) + { + // InternalExpression.g:3936:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) + // InternalExpression.g:3937:5: ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) + { + // InternalExpression.g:3947:5: ( () ( ( ruleOpMulti ) ) ) + // InternalExpression.g:3948:6: () ( ( ruleOpMulti ) ) + { + // InternalExpression.g:3948:6: () + // InternalExpression.g:3949:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:3955:6: ( ( ruleOpMulti ) ) + // InternalExpression.g:3956:7: ( ruleOpMulti ) + { + // InternalExpression.g:3956:7: ( ruleOpMulti ) + // InternalExpression.g:3957:8: ruleOpMulti + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:3973:4: ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) + // InternalExpression.g:3974:5: (lv_rightOperand_3_0= ruleXUnaryOperation ) + { + // InternalExpression.g:3974:5: (lv_rightOperand_3_0= ruleXUnaryOperation ) + // InternalExpression.g:3975:6: lv_rightOperand_3_0= ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_48); + lv_rightOperand_3_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop53; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXMultiplicativeExpression" + + + // $ANTLR start "entryRuleOpMulti" + // InternalExpression.g:3997:1: entryRuleOpMulti returns [String current=null] : iv_ruleOpMulti= ruleOpMulti EOF ; + public final String entryRuleOpMulti() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpMulti = null; + + + try { + // InternalExpression.g:3997:47: (iv_ruleOpMulti= ruleOpMulti EOF ) + // InternalExpression.g:3998:2: iv_ruleOpMulti= ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpMulti=ruleOpMulti(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpMulti.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpMulti" + + + // $ANTLR start "ruleOpMulti" + // InternalExpression.g:4004:1: ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ; + public final AntlrDatatypeRuleToken ruleOpMulti() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:4010:2: ( (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ) + // InternalExpression.g:4011:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) + { + // InternalExpression.g:4011:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) + int alt54=4; + switch ( input.LA(1) ) { + case 40: + { + alt54=1; + } + break; + case 79: + { + alt54=2; + } + break; + case 41: + { + alt54=3; + } + break; + case 80: + { + alt54=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 54, 0, input); + + throw nvae; + } + + switch (alt54) { + case 1 : + // InternalExpression.g:4012:3: kw= '*' + { + kw=(Token)match(input,40,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:4018:3: kw= '**' + { + kw=(Token)match(input,79,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:4024:3: kw= '/' + { + kw=(Token)match(input,41,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + + } + + } + break; + case 4 : + // InternalExpression.g:4030:3: kw= '%' + { + kw=(Token)match(input,80,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpMulti" + + + // $ANTLR start "entryRuleXUnaryOperation" + // InternalExpression.g:4039:1: entryRuleXUnaryOperation returns [EObject current=null] : iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ; + public final EObject entryRuleXUnaryOperation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXUnaryOperation = null; + + + try { + // InternalExpression.g:4039:56: (iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ) + // InternalExpression.g:4040:2: iv_ruleXUnaryOperation= ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXUnaryOperation=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXUnaryOperation; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXUnaryOperation" + + + // $ANTLR start "ruleXUnaryOperation" + // InternalExpression.g:4046:1: ruleXUnaryOperation returns [EObject current=null] : ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ; + public final EObject ruleXUnaryOperation() throws RecognitionException { + EObject current = null; + + EObject lv_operand_2_0 = null; + + EObject this_XCastedExpression_3 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4052:2: ( ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ) + // InternalExpression.g:4053:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) + { + // InternalExpression.g:4053:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) + int alt55=2; + int LA55_0 = input.LA(1); + + if ( ((LA55_0>=38 && LA55_0<=39)||LA55_0==42) ) { + alt55=1; + } + else if ( (LA55_0==RULE_INT||(LA55_0>=RULE_STRING && LA55_0<=RULE_DECIMAL)||LA55_0==17||LA55_0==21||(LA55_0>=24 && LA55_0<=25)||LA55_0==37||(LA55_0>=55 && LA55_0<=57)||LA55_0==59||LA55_0==63||LA55_0==85||(LA55_0>=87 && LA55_0<=89)||(LA55_0>=92 && LA55_0<=100)||LA55_0==102) ) { + alt55=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 55, 0, input); + + throw nvae; + } + switch (alt55) { + case 1 : + // InternalExpression.g:4054:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) + { + // InternalExpression.g:4054:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) + // InternalExpression.g:4055:4: () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) + { + // InternalExpression.g:4055:4: () + // InternalExpression.g:4056:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(), + current); + + } + + } + + // InternalExpression.g:4062:4: ( ( ruleOpUnary ) ) + // InternalExpression.g:4063:5: ( ruleOpUnary ) + { + // InternalExpression.g:4063:5: ( ruleOpUnary ) + // InternalExpression.g:4064:6: ruleOpUnary + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXUnaryOperationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + + } + pushFollow(FOLLOW_36); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:4078:4: ( (lv_operand_2_0= ruleXUnaryOperation ) ) + // InternalExpression.g:4079:5: (lv_operand_2_0= ruleXUnaryOperation ) + { + // InternalExpression.g:4079:5: (lv_operand_2_0= ruleXUnaryOperation ) + // InternalExpression.g:4080:6: lv_operand_2_0= ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + + } + pushFollow(FOLLOW_2); + lv_operand_2_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXUnaryOperationRule()); + } + set( + current, + "operand", + lv_operand_2_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:4099:3: this_XCastedExpression_3= ruleXCastedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XCastedExpression_3=ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XCastedExpression_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXUnaryOperation" + + + // $ANTLR start "entryRuleOpUnary" + // InternalExpression.g:4111:1: entryRuleOpUnary returns [String current=null] : iv_ruleOpUnary= ruleOpUnary EOF ; + public final String entryRuleOpUnary() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpUnary = null; + + + try { + // InternalExpression.g:4111:47: (iv_ruleOpUnary= ruleOpUnary EOF ) + // InternalExpression.g:4112:2: iv_ruleOpUnary= ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpUnary=ruleOpUnary(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpUnary.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpUnary" + + + // $ANTLR start "ruleOpUnary" + // InternalExpression.g:4118:1: ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '!' | kw= '-' | kw= '+' ) ; + public final AntlrDatatypeRuleToken ruleOpUnary() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:4124:2: ( (kw= '!' | kw= '-' | kw= '+' ) ) + // InternalExpression.g:4125:2: (kw= '!' | kw= '-' | kw= '+' ) + { + // InternalExpression.g:4125:2: (kw= '!' | kw= '-' | kw= '+' ) + int alt56=3; + switch ( input.LA(1) ) { + case 42: + { + alt56=1; + } + break; + case 39: + { + alt56=2; + } + break; + case 38: + { + alt56=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 56, 0, input); + + throw nvae; + } + + switch (alt56) { + case 1 : + // InternalExpression.g:4126:3: kw= '!' + { + kw=(Token)match(input,42,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:4132:3: kw= '-' + { + kw=(Token)match(input,39,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:4138:3: kw= '+' + { + kw=(Token)match(input,38,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpUnary" + + + // $ANTLR start "entryRuleXCastedExpression" + // InternalExpression.g:4147:1: entryRuleXCastedExpression returns [EObject current=null] : iv_ruleXCastedExpression= ruleXCastedExpression EOF ; + public final EObject entryRuleXCastedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCastedExpression = null; + + + try { + // InternalExpression.g:4147:58: (iv_ruleXCastedExpression= ruleXCastedExpression EOF ) + // InternalExpression.g:4148:2: iv_ruleXCastedExpression= ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCastedExpression=ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCastedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCastedExpression" + + + // $ANTLR start "ruleXCastedExpression" + // InternalExpression.g:4154:1: ruleXCastedExpression returns [EObject current=null] : (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ; + public final EObject ruleXCastedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject this_XPostfixOperation_0 = null; + + EObject lv_type_3_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4160:2: ( (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ) + // InternalExpression.g:4161:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) + { + // InternalExpression.g:4161:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) + // InternalExpression.g:4162:3: this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + + } + pushFollow(FOLLOW_49); + this_XPostfixOperation_0=ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XPostfixOperation_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:4170:3: ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* + loop57: + do { + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==81) ) { + int LA57_2 = input.LA(2); + + if ( (synpred14_InternalExpression()) ) { + alt57=1; + } + + + } + + + switch (alt57) { + case 1 : + // InternalExpression.g:4171:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) + { + // InternalExpression.g:4171:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) + // InternalExpression.g:4172:5: ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) + { + // InternalExpression.g:4178:5: ( () otherlv_2= 'as' ) + // InternalExpression.g:4179:6: () otherlv_2= 'as' + { + // InternalExpression.g:4179:6: () + // InternalExpression.g:4180:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(), + current); + + } + + } + + otherlv_2=(Token)match(input,81,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + + } + + } + + + } + + // InternalExpression.g:4192:4: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalExpression.g:4193:5: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalExpression.g:4193:5: (lv_type_3_0= ruleJvmTypeReference ) + // InternalExpression.g:4194:6: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_49); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCastedExpressionRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop57; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCastedExpression" + + + // $ANTLR start "entryRuleXPostfixOperation" + // InternalExpression.g:4216:1: entryRuleXPostfixOperation returns [EObject current=null] : iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ; + public final EObject entryRuleXPostfixOperation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXPostfixOperation = null; + + + try { + // InternalExpression.g:4216:58: (iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ) + // InternalExpression.g:4217:2: iv_ruleXPostfixOperation= ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXPostfixOperationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXPostfixOperation=ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXPostfixOperation; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXPostfixOperation" + + + // $ANTLR start "ruleXPostfixOperation" + // InternalExpression.g:4223:1: ruleXPostfixOperation returns [EObject current=null] : (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ; + public final EObject ruleXPostfixOperation() throws RecognitionException { + EObject current = null; + + EObject this_XMemberFeatureCall_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4229:2: ( (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ) + // InternalExpression.g:4230:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) + { + // InternalExpression.g:4230:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) + // InternalExpression.g:4231:3: this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + + } + pushFollow(FOLLOW_50); + this_XMemberFeatureCall_0=ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XMemberFeatureCall_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:4239:3: ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==82) ) { + int LA58_1 = input.LA(2); + + if ( (synpred15_InternalExpression()) ) { + alt58=1; + } + } + else if ( (LA58_0==83) ) { + int LA58_2 = input.LA(2); + + if ( (synpred15_InternalExpression()) ) { + alt58=1; + } + } + switch (alt58) { + case 1 : + // InternalExpression.g:4240:4: ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) + { + // InternalExpression.g:4250:4: ( () ( ( ruleOpPostfix ) ) ) + // InternalExpression.g:4251:5: () ( ( ruleOpPostfix ) ) + { + // InternalExpression.g:4251:5: () + // InternalExpression.g:4252:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(), + current); + + } + + } + + // InternalExpression.g:4258:5: ( ( ruleOpPostfix ) ) + // InternalExpression.g:4259:6: ( ruleOpPostfix ) + { + // InternalExpression.g:4259:6: ( ruleOpPostfix ) + // InternalExpression.g:4260:7: ruleOpPostfix + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXPostfixOperationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + + } + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXPostfixOperation" + + + // $ANTLR start "entryRuleOpPostfix" + // InternalExpression.g:4280:1: entryRuleOpPostfix returns [String current=null] : iv_ruleOpPostfix= ruleOpPostfix EOF ; + public final String entryRuleOpPostfix() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpPostfix = null; + + + try { + // InternalExpression.g:4280:49: (iv_ruleOpPostfix= ruleOpPostfix EOF ) + // InternalExpression.g:4281:2: iv_ruleOpPostfix= ruleOpPostfix EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpPostfix=ruleOpPostfix(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpPostfix.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpPostfix" + + + // $ANTLR start "ruleOpPostfix" + // InternalExpression.g:4287:1: ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '++' | kw= '--' ) ; + public final AntlrDatatypeRuleToken ruleOpPostfix() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:4293:2: ( (kw= '++' | kw= '--' ) ) + // InternalExpression.g:4294:2: (kw= '++' | kw= '--' ) + { + // InternalExpression.g:4294:2: (kw= '++' | kw= '--' ) + int alt59=2; + int LA59_0 = input.LA(1); + + if ( (LA59_0==82) ) { + alt59=1; + } + else if ( (LA59_0==83) ) { + alt59=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 59, 0, input); + + throw nvae; + } + switch (alt59) { + case 1 : + // InternalExpression.g:4295:3: kw= '++' + { + kw=(Token)match(input,82,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:4301:3: kw= '--' + { + kw=(Token)match(input,83,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpPostfix" + + + // $ANTLR start "entryRuleXMemberFeatureCall" + // InternalExpression.g:4310:1: entryRuleXMemberFeatureCall returns [EObject current=null] : iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ; + public final EObject entryRuleXMemberFeatureCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXMemberFeatureCall = null; + + + try { + // InternalExpression.g:4310:59: (iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ) + // InternalExpression.g:4311:2: iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXMemberFeatureCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXMemberFeatureCall" + + + // $ANTLR start "ruleXMemberFeatureCall" + // InternalExpression.g:4317:1: ruleXMemberFeatureCall returns [EObject current=null] : (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ; + public final EObject ruleXMemberFeatureCall() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_explicitStatic_3_0=null; + Token otherlv_8=null; + Token lv_nullSafe_9_0=null; + Token lv_explicitStatic_10_0=null; + Token otherlv_11=null; + Token otherlv_13=null; + Token otherlv_15=null; + Token lv_explicitOperationCall_17_0=null; + Token otherlv_20=null; + Token otherlv_22=null; + EObject this_XPrimaryExpression_0 = null; + + EObject lv_value_6_0 = null; + + EObject lv_typeArguments_12_0 = null; + + EObject lv_typeArguments_14_0 = null; + + EObject lv_memberCallArguments_18_0 = null; + + EObject lv_memberCallArguments_19_0 = null; + + EObject lv_memberCallArguments_21_0 = null; + + EObject lv_memberCallArguments_23_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4323:2: ( (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ) + // InternalExpression.g:4324:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) + { + // InternalExpression.g:4324:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) + // InternalExpression.g:4325:3: this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_51); + this_XPrimaryExpression_0=ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XPrimaryExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:4333:3: ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* + loop68: + do { + int alt68=3; + switch ( input.LA(1) ) { + case 43: + { + int LA68_2 = input.LA(2); + + if ( (synpred16_InternalExpression()) ) { + alt68=1; + } + else if ( (synpred17_InternalExpression()) ) { + alt68=2; + } + + + } + break; + case 65: + { + int LA68_3 = input.LA(2); + + if ( (synpred16_InternalExpression()) ) { + alt68=1; + } + else if ( (synpred17_InternalExpression()) ) { + alt68=2; + } + + + } + break; + case 84: + { + int LA68_4 = input.LA(2); + + if ( (synpred17_InternalExpression()) ) { + alt68=2; + } + + + } + break; + + } + + switch (alt68) { + case 1 : + // InternalExpression.g:4334:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) + { + // InternalExpression.g:4334:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) + // InternalExpression.g:4335:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) + { + // InternalExpression.g:4335:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) + // InternalExpression.g:4336:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + { + // InternalExpression.g:4356:6: ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + // InternalExpression.g:4357:7: () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign + { + // InternalExpression.g:4357:7: () + // InternalExpression.g:4358:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(), + current); + + } + + } + + // InternalExpression.g:4364:7: (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) + int alt60=2; + int LA60_0 = input.LA(1); + + if ( (LA60_0==43) ) { + alt60=1; + } + else if ( (LA60_0==65) ) { + alt60=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 60, 0, input); + + throw nvae; + } + switch (alt60) { + case 1 : + // InternalExpression.g:4365:8: otherlv_2= '.' + { + otherlv_2=(Token)match(input,43,FOLLOW_52); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:4370:8: ( (lv_explicitStatic_3_0= '::' ) ) + { + // InternalExpression.g:4370:8: ( (lv_explicitStatic_3_0= '::' ) ) + // InternalExpression.g:4371:9: (lv_explicitStatic_3_0= '::' ) + { + // InternalExpression.g:4371:9: (lv_explicitStatic_3_0= '::' ) + // InternalExpression.g:4372:10: lv_explicitStatic_3_0= '::' + { + lv_explicitStatic_3_0=(Token)match(input,65,FOLLOW_52); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitStatic", lv_explicitStatic_3_0 != null, "::"); + + } + + } + + + } + + + } + break; + + } + + // InternalExpression.g:4385:7: ( ( ruleFeatureCallID ) ) + // InternalExpression.g:4386:8: ( ruleFeatureCallID ) + { + // InternalExpression.g:4386:8: ( ruleFeatureCallID ) + // InternalExpression.g:4387:9: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + + } + pushFollow(FOLLOW_4); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + + } + pushFollow(FOLLOW_36); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:4410:5: ( (lv_value_6_0= ruleXAssignment ) ) + // InternalExpression.g:4411:6: (lv_value_6_0= ruleXAssignment ) + { + // InternalExpression.g:4411:6: (lv_value_6_0= ruleXAssignment ) + // InternalExpression.g:4412:7: lv_value_6_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + + } + pushFollow(FOLLOW_51); + lv_value_6_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + set( + current, + "value", + lv_value_6_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:4431:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) + { + // InternalExpression.g:4431:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) + // InternalExpression.g:4432:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? + { + // InternalExpression.g:4432:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) + // InternalExpression.g:4433:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) + { + // InternalExpression.g:4453:6: ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) + // InternalExpression.g:4454:7: () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) + { + // InternalExpression.g:4454:7: () + // InternalExpression.g:4455:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), + current); + + } + + } + + // InternalExpression.g:4461:7: (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) + int alt61=3; + switch ( input.LA(1) ) { + case 43: + { + alt61=1; + } + break; + case 84: + { + alt61=2; + } + break; + case 65: + { + alt61=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 61, 0, input); + + throw nvae; + } + + switch (alt61) { + case 1 : + // InternalExpression.g:4462:8: otherlv_8= '.' + { + otherlv_8=(Token)match(input,43,FOLLOW_53); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:4467:8: ( (lv_nullSafe_9_0= '?.' ) ) + { + // InternalExpression.g:4467:8: ( (lv_nullSafe_9_0= '?.' ) ) + // InternalExpression.g:4468:9: (lv_nullSafe_9_0= '?.' ) + { + // InternalExpression.g:4468:9: (lv_nullSafe_9_0= '?.' ) + // InternalExpression.g:4469:10: lv_nullSafe_9_0= '?.' + { + lv_nullSafe_9_0=(Token)match(input,84,FOLLOW_53); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "nullSafe", lv_nullSafe_9_0 != null, "?."); + + } + + } + + + } + + + } + break; + case 3 : + // InternalExpression.g:4482:8: ( (lv_explicitStatic_10_0= '::' ) ) + { + // InternalExpression.g:4482:8: ( (lv_explicitStatic_10_0= '::' ) ) + // InternalExpression.g:4483:9: (lv_explicitStatic_10_0= '::' ) + { + // InternalExpression.g:4483:9: (lv_explicitStatic_10_0= '::' ) + // InternalExpression.g:4484:10: lv_explicitStatic_10_0= '::' + { + lv_explicitStatic_10_0=(Token)match(input,65,FOLLOW_53); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitStatic", lv_explicitStatic_10_0 != null, "::"); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + // InternalExpression.g:4499:5: (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? + int alt63=2; + int LA63_0 = input.LA(1); + + if ( (LA63_0==37) ) { + alt63=1; + } + switch (alt63) { + case 1 : + // InternalExpression.g:4500:6: otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' + { + otherlv_11=(Token)match(input,37,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + + } + // InternalExpression.g:4504:6: ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:4505:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:4505:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:4506:8: lv_typeArguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + + } + pushFollow(FOLLOW_55); + lv_typeArguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:4523:6: (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* + loop62: + do { + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==44) ) { + alt62=1; + } + + + switch (alt62) { + case 1 : + // InternalExpression.g:4524:7: otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_13=(Token)match(input,44,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + + } + // InternalExpression.g:4528:7: ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:4529:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:4529:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:4530:9: lv_typeArguments_14_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + + } + pushFollow(FOLLOW_55); + lv_typeArguments_14_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_14_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop62; + } + } while (true); + + otherlv_15=(Token)match(input,36,FOLLOW_53); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + + } + + } + break; + + } + + // InternalExpression.g:4553:5: ( ( ruleIdOrSuper ) ) + // InternalExpression.g:4554:6: ( ruleIdOrSuper ) + { + // InternalExpression.g:4554:6: ( ruleIdOrSuper ) + // InternalExpression.g:4555:7: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + + } + pushFollow(FOLLOW_56); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:4569:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? + int alt66=2; + alt66 = dfa66.predict(input); + switch (alt66) { + case 1 : + // InternalExpression.g:4570:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' + { + // InternalExpression.g:4570:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) + // InternalExpression.g:4571:7: ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) + { + // InternalExpression.g:4575:7: (lv_explicitOperationCall_17_0= '(' ) + // InternalExpression.g:4576:8: lv_explicitOperationCall_17_0= '(' + { + lv_explicitOperationCall_17_0=(Token)match(input,17,FOLLOW_57); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitOperationCall", lv_explicitOperationCall_17_0 != null, "("); + + } + + } + + + } + + // InternalExpression.g:4588:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? + int alt65=3; + alt65 = dfa65.predict(input); + switch (alt65) { + case 1 : + // InternalExpression.g:4589:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) + { + // InternalExpression.g:4589:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) + // InternalExpression.g:4590:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) + { + // InternalExpression.g:4615:8: (lv_memberCallArguments_18_0= ruleXShortClosure ) + // InternalExpression.g:4616:9: lv_memberCallArguments_18_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + + } + pushFollow(FOLLOW_8); + lv_memberCallArguments_18_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_18_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:4634:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) + { + // InternalExpression.g:4634:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) + // InternalExpression.g:4635:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* + { + // InternalExpression.g:4635:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) + // InternalExpression.g:4636:9: (lv_memberCallArguments_19_0= ruleXExpression ) + { + // InternalExpression.g:4636:9: (lv_memberCallArguments_19_0= ruleXExpression ) + // InternalExpression.g:4637:10: lv_memberCallArguments_19_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + + } + pushFollow(FOLLOW_27); + lv_memberCallArguments_19_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_19_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:4654:8: (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* + loop64: + do { + int alt64=2; + int LA64_0 = input.LA(1); + + if ( (LA64_0==44) ) { + alt64=1; + } + + + switch (alt64) { + case 1 : + // InternalExpression.g:4655:9: otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) + { + otherlv_20=(Token)match(input,44,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + + } + // InternalExpression.g:4659:9: ( (lv_memberCallArguments_21_0= ruleXExpression ) ) + // InternalExpression.g:4660:10: (lv_memberCallArguments_21_0= ruleXExpression ) + { + // InternalExpression.g:4660:10: (lv_memberCallArguments_21_0= ruleXExpression ) + // InternalExpression.g:4661:11: lv_memberCallArguments_21_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + + } + pushFollow(FOLLOW_27); + lv_memberCallArguments_21_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_21_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop64; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_22=(Token)match(input,18,FOLLOW_58); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + + } + + } + break; + + } + + // InternalExpression.g:4686:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? + int alt67=2; + alt67 = dfa67.predict(input); + switch (alt67) { + case 1 : + // InternalExpression.g:4687:6: ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) + { + // InternalExpression.g:4693:6: (lv_memberCallArguments_23_0= ruleXClosure ) + // InternalExpression.g:4694:7: lv_memberCallArguments_23_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + + } + pushFollow(FOLLOW_51); + lv_memberCallArguments_23_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_23_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + break; + + default : + break loop68; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXMemberFeatureCall" + + + // $ANTLR start "entryRuleXPrimaryExpression" + // InternalExpression.g:4717:1: entryRuleXPrimaryExpression returns [EObject current=null] : iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ; + public final EObject entryRuleXPrimaryExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXPrimaryExpression = null; + + + try { + // InternalExpression.g:4717:59: (iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ) + // InternalExpression.g:4718:2: iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXPrimaryExpression=ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXPrimaryExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXPrimaryExpression" + + + // $ANTLR start "ruleXPrimaryExpression" + // InternalExpression.g:4724:1: ruleXPrimaryExpression returns [EObject current=null] : (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ; + public final EObject ruleXPrimaryExpression() throws RecognitionException { + EObject current = null; + + EObject this_XConstructorCall_0 = null; + + EObject this_XBlockExpression_1 = null; + + EObject this_XSwitchExpression_2 = null; + + EObject this_XSynchronizedExpression_3 = null; + + EObject this_XFeatureCall_4 = null; + + EObject this_XLiteral_5 = null; + + EObject this_XIfExpression_6 = null; + + EObject this_XForLoopExpression_7 = null; + + EObject this_XBasicForLoopExpression_8 = null; + + EObject this_XWhileExpression_9 = null; + + EObject this_XDoWhileExpression_10 = null; + + EObject this_XThrowExpression_11 = null; + + EObject this_XReturnExpression_12 = null; + + EObject this_XTryCatchFinallyExpression_13 = null; + + EObject this_XParenthesizedExpression_14 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4730:2: ( (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ) + // InternalExpression.g:4731:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) + { + // InternalExpression.g:4731:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) + int alt69=15; + alt69 = dfa69.predict(input); + switch (alt69) { + case 1 : + // InternalExpression.g:4732:3: this_XConstructorCall_0= ruleXConstructorCall + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XConstructorCall_0=ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XConstructorCall_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:4741:3: this_XBlockExpression_1= ruleXBlockExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XBlockExpression_1=ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBlockExpression_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 3 : + // InternalExpression.g:4750:3: this_XSwitchExpression_2= ruleXSwitchExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + + } + pushFollow(FOLLOW_2); + this_XSwitchExpression_2=ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSwitchExpression_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 4 : + // InternalExpression.g:4759:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) + { + // InternalExpression.g:4759:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) + // InternalExpression.g:4760:4: ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + + } + pushFollow(FOLLOW_2); + this_XSynchronizedExpression_3=ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSynchronizedExpression_3; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 5 : + // InternalExpression.g:4777:3: this_XFeatureCall_4= ruleXFeatureCall + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + + } + pushFollow(FOLLOW_2); + this_XFeatureCall_4=ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFeatureCall_4; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 6 : + // InternalExpression.g:4786:3: this_XLiteral_5= ruleXLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + + } + pushFollow(FOLLOW_2); + this_XLiteral_5=ruleXLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XLiteral_5; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 7 : + // InternalExpression.g:4795:3: this_XIfExpression_6= ruleXIfExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + + } + pushFollow(FOLLOW_2); + this_XIfExpression_6=ruleXIfExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XIfExpression_6; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 8 : + // InternalExpression.g:4804:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) + { + // InternalExpression.g:4804:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) + // InternalExpression.g:4805:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + + } + pushFollow(FOLLOW_2); + this_XForLoopExpression_7=ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XForLoopExpression_7; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 9 : + // InternalExpression.g:4828:3: this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + + } + pushFollow(FOLLOW_2); + this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBasicForLoopExpression_8; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 10 : + // InternalExpression.g:4837:3: this_XWhileExpression_9= ruleXWhileExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + + } + pushFollow(FOLLOW_2); + this_XWhileExpression_9=ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XWhileExpression_9; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 11 : + // InternalExpression.g:4846:3: this_XDoWhileExpression_10= ruleXDoWhileExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + + } + pushFollow(FOLLOW_2); + this_XDoWhileExpression_10=ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XDoWhileExpression_10; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 12 : + // InternalExpression.g:4855:3: this_XThrowExpression_11= ruleXThrowExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + + } + pushFollow(FOLLOW_2); + this_XThrowExpression_11=ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XThrowExpression_11; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 13 : + // InternalExpression.g:4864:3: this_XReturnExpression_12= ruleXReturnExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + + } + pushFollow(FOLLOW_2); + this_XReturnExpression_12=ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XReturnExpression_12; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 14 : + // InternalExpression.g:4873:3: this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + + } + pushFollow(FOLLOW_2); + this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XTryCatchFinallyExpression_13; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 15 : + // InternalExpression.g:4882:3: this_XParenthesizedExpression_14= ruleXParenthesizedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + + } + pushFollow(FOLLOW_2); + this_XParenthesizedExpression_14=ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XParenthesizedExpression_14; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXPrimaryExpression" + + + // $ANTLR start "entryRuleXLiteral" + // InternalExpression.g:4894:1: entryRuleXLiteral returns [EObject current=null] : iv_ruleXLiteral= ruleXLiteral EOF ; + public final EObject entryRuleXLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXLiteral = null; + + + try { + // InternalExpression.g:4894:49: (iv_ruleXLiteral= ruleXLiteral EOF ) + // InternalExpression.g:4895:2: iv_ruleXLiteral= ruleXLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXLiteral=ruleXLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXLiteral" + + + // $ANTLR start "ruleXLiteral" + // InternalExpression.g:4901:1: ruleXLiteral returns [EObject current=null] : (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ; + public final EObject ruleXLiteral() throws RecognitionException { + EObject current = null; + + EObject this_XCollectionLiteral_0 = null; + + EObject this_XClosure_1 = null; + + EObject this_XBooleanLiteral_2 = null; + + EObject this_XNumberLiteral_3 = null; + + EObject this_XNullLiteral_4 = null; + + EObject this_XStringLiteral_5 = null; + + EObject this_XTypeLiteral_6 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4907:2: ( (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ) + // InternalExpression.g:4908:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) + { + // InternalExpression.g:4908:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) + int alt70=7; + int LA70_0 = input.LA(1); + + if ( (LA70_0==85) ) { + alt70=1; + } + else if ( (LA70_0==63) && (synpred23_InternalExpression())) { + alt70=2; + } + else if ( ((LA70_0>=55 && LA70_0<=56)) ) { + alt70=3; + } + else if ( (LA70_0==RULE_INT||(LA70_0>=RULE_HEX && LA70_0<=RULE_DECIMAL)) ) { + alt70=4; + } + else if ( (LA70_0==57) ) { + alt70=5; + } + else if ( (LA70_0==RULE_STRING) ) { + alt70=6; + } + else if ( (LA70_0==97) ) { + alt70=7; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 70, 0, input); + + throw nvae; + } + switch (alt70) { + case 1 : + // InternalExpression.g:4909:3: this_XCollectionLiteral_0= ruleXCollectionLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XCollectionLiteral_0=ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XCollectionLiteral_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:4918:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) + { + // InternalExpression.g:4918:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) + // InternalExpression.g:4919:4: ( ( () '[' ) )=>this_XClosure_1= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XClosure_1=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XClosure_1; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 3 : + // InternalExpression.g:4935:3: this_XBooleanLiteral_2= ruleXBooleanLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + + } + pushFollow(FOLLOW_2); + this_XBooleanLiteral_2=ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBooleanLiteral_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 4 : + // InternalExpression.g:4944:3: this_XNumberLiteral_3= ruleXNumberLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + + } + pushFollow(FOLLOW_2); + this_XNumberLiteral_3=ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XNumberLiteral_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 5 : + // InternalExpression.g:4953:3: this_XNullLiteral_4= ruleXNullLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + + } + pushFollow(FOLLOW_2); + this_XNullLiteral_4=ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XNullLiteral_4; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 6 : + // InternalExpression.g:4962:3: this_XStringLiteral_5= ruleXStringLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + + } + pushFollow(FOLLOW_2); + this_XStringLiteral_5=ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XStringLiteral_5; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 7 : + // InternalExpression.g:4971:3: this_XTypeLiteral_6= ruleXTypeLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + + } + pushFollow(FOLLOW_2); + this_XTypeLiteral_6=ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XTypeLiteral_6; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXLiteral" + + + // $ANTLR start "entryRuleXCollectionLiteral" + // InternalExpression.g:4983:1: entryRuleXCollectionLiteral returns [EObject current=null] : iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ; + public final EObject entryRuleXCollectionLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCollectionLiteral = null; + + + try { + // InternalExpression.g:4983:59: (iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ) + // InternalExpression.g:4984:2: iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCollectionLiteral=ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCollectionLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCollectionLiteral" + + + // $ANTLR start "ruleXCollectionLiteral" + // InternalExpression.g:4990:1: ruleXCollectionLiteral returns [EObject current=null] : (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ; + public final EObject ruleXCollectionLiteral() throws RecognitionException { + EObject current = null; + + EObject this_XSetLiteral_0 = null; + + EObject this_XListLiteral_1 = null; + + + + enterRule(); + + try { + // InternalExpression.g:4996:2: ( (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ) + // InternalExpression.g:4997:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) + { + // InternalExpression.g:4997:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==85) ) { + int LA71_1 = input.LA(2); + + if ( (LA71_1==63) ) { + alt71=2; + } + else if ( (LA71_1==25) ) { + alt71=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 71, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 71, 0, input); + + throw nvae; + } + switch (alt71) { + case 1 : + // InternalExpression.g:4998:3: this_XSetLiteral_0= ruleXSetLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XSetLiteral_0=ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSetLiteral_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:5007:3: this_XListLiteral_1= ruleXListLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XListLiteral_1=ruleXListLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XListLiteral_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCollectionLiteral" + + + // $ANTLR start "entryRuleXSetLiteral" + // InternalExpression.g:5019:1: entryRuleXSetLiteral returns [EObject current=null] : iv_ruleXSetLiteral= ruleXSetLiteral EOF ; + public final EObject entryRuleXSetLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSetLiteral = null; + + + try { + // InternalExpression.g:5019:52: (iv_ruleXSetLiteral= ruleXSetLiteral EOF ) + // InternalExpression.g:5020:2: iv_ruleXSetLiteral= ruleXSetLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSetLiteral=ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSetLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSetLiteral" + + + // $ANTLR start "ruleXSetLiteral" + // InternalExpression.g:5026:1: ruleXSetLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ; + public final EObject ruleXSetLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_elements_3_0 = null; + + EObject lv_elements_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5032:2: ( ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ) + // InternalExpression.g:5033:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) + { + // InternalExpression.g:5033:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) + // InternalExpression.g:5034:3: () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' + { + // InternalExpression.g:5034:3: () + // InternalExpression.g:5035:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,85,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + + } + otherlv_2=(Token)match(input,25,FOLLOW_59); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + + } + // InternalExpression.g:5049:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? + int alt73=2; + int LA73_0 = input.LA(1); + + if ( (LA73_0==RULE_INT||(LA73_0>=RULE_STRING && LA73_0<=RULE_DECIMAL)||LA73_0==17||LA73_0==21||(LA73_0>=24 && LA73_0<=25)||(LA73_0>=37 && LA73_0<=39)||LA73_0==42||(LA73_0>=55 && LA73_0<=57)||LA73_0==59||LA73_0==63||LA73_0==85||(LA73_0>=87 && LA73_0<=89)||(LA73_0>=92 && LA73_0<=100)||LA73_0==102) ) { + alt73=1; + } + switch (alt73) { + case 1 : + // InternalExpression.g:5050:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + { + // InternalExpression.g:5050:4: ( (lv_elements_3_0= ruleXExpression ) ) + // InternalExpression.g:5051:5: (lv_elements_3_0= ruleXExpression ) + { + // InternalExpression.g:5051:5: (lv_elements_3_0= ruleXExpression ) + // InternalExpression.g:5052:6: lv_elements_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_32); + lv_elements_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:5069:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + loop72: + do { + int alt72=2; + int LA72_0 = input.LA(1); + + if ( (LA72_0==44) ) { + alt72=1; + } + + + switch (alt72) { + case 1 : + // InternalExpression.g:5070:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,44,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + + } + // InternalExpression.g:5074:5: ( (lv_elements_5_0= ruleXExpression ) ) + // InternalExpression.g:5075:6: (lv_elements_5_0= ruleXExpression ) + { + // InternalExpression.g:5075:6: (lv_elements_5_0= ruleXExpression ) + // InternalExpression.g:5076:7: lv_elements_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_32); + lv_elements_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop72; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSetLiteral" + + + // $ANTLR start "entryRuleXListLiteral" + // InternalExpression.g:5103:1: entryRuleXListLiteral returns [EObject current=null] : iv_ruleXListLiteral= ruleXListLiteral EOF ; + public final EObject entryRuleXListLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXListLiteral = null; + + + try { + // InternalExpression.g:5103:53: (iv_ruleXListLiteral= ruleXListLiteral EOF ) + // InternalExpression.g:5104:2: iv_ruleXListLiteral= ruleXListLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXListLiteral=ruleXListLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXListLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXListLiteral" + + + // $ANTLR start "ruleXListLiteral" + // InternalExpression.g:5110:1: ruleXListLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ; + public final EObject ruleXListLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_elements_3_0 = null; + + EObject lv_elements_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5116:2: ( ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ) + // InternalExpression.g:5117:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) + { + // InternalExpression.g:5117:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) + // InternalExpression.g:5118:3: () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' + { + // InternalExpression.g:5118:3: () + // InternalExpression.g:5119:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,85,FOLLOW_33); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + + } + otherlv_2=(Token)match(input,63,FOLLOW_60); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + + } + // InternalExpression.g:5133:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? + int alt75=2; + int LA75_0 = input.LA(1); + + if ( (LA75_0==RULE_INT||(LA75_0>=RULE_STRING && LA75_0<=RULE_DECIMAL)||LA75_0==17||LA75_0==21||(LA75_0>=24 && LA75_0<=25)||(LA75_0>=37 && LA75_0<=39)||LA75_0==42||(LA75_0>=55 && LA75_0<=57)||LA75_0==59||LA75_0==63||LA75_0==85||(LA75_0>=87 && LA75_0<=89)||(LA75_0>=92 && LA75_0<=100)||LA75_0==102) ) { + alt75=1; + } + switch (alt75) { + case 1 : + // InternalExpression.g:5134:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + { + // InternalExpression.g:5134:4: ( (lv_elements_3_0= ruleXExpression ) ) + // InternalExpression.g:5135:5: (lv_elements_3_0= ruleXExpression ) + { + // InternalExpression.g:5135:5: (lv_elements_3_0= ruleXExpression ) + // InternalExpression.g:5136:6: lv_elements_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_61); + lv_elements_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:5153:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + loop74: + do { + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==44) ) { + alt74=1; + } + + + switch (alt74) { + case 1 : + // InternalExpression.g:5154:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,44,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + + } + // InternalExpression.g:5158:5: ( (lv_elements_5_0= ruleXExpression ) ) + // InternalExpression.g:5159:6: (lv_elements_5_0= ruleXExpression ) + { + // InternalExpression.g:5159:6: (lv_elements_5_0= ruleXExpression ) + // InternalExpression.g:5160:7: lv_elements_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_61); + lv_elements_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop74; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXListLiteral" + + + // $ANTLR start "entryRuleXClosure" + // InternalExpression.g:5187:1: entryRuleXClosure returns [EObject current=null] : iv_ruleXClosure= ruleXClosure EOF ; + public final EObject entryRuleXClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXClosure = null; + + + try { + // InternalExpression.g:5187:49: (iv_ruleXClosure= ruleXClosure EOF ) + // InternalExpression.g:5188:2: iv_ruleXClosure= ruleXClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXClosure=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXClosure" + + + // $ANTLR start "ruleXClosure" + // InternalExpression.g:5194:1: ruleXClosure returns [EObject current=null] : ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ; + public final EObject ruleXClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token lv_explicitSyntax_5_0=null; + Token otherlv_7=null; + EObject lv_declaredFormalParameters_2_0 = null; + + EObject lv_declaredFormalParameters_4_0 = null; + + EObject lv_expression_6_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5200:2: ( ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ) + // InternalExpression.g:5201:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) + { + // InternalExpression.g:5201:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) + // InternalExpression.g:5202:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' + { + // InternalExpression.g:5202:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) + // InternalExpression.g:5203:4: ( ( () '[' ) )=> ( () otherlv_1= '[' ) + { + // InternalExpression.g:5209:4: ( () otherlv_1= '[' ) + // InternalExpression.g:5210:5: () otherlv_1= '[' + { + // InternalExpression.g:5210:5: () + // InternalExpression.g:5211:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,63,FOLLOW_62); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + + } + + } + + + } + + // InternalExpression.g:5223:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? + int alt78=2; + alt78 = dfa78.predict(input); + switch (alt78) { + case 1 : + // InternalExpression.g:5224:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) + { + // InternalExpression.g:5247:4: ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) + // InternalExpression.g:5248:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) + { + // InternalExpression.g:5248:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==RULE_ID||LA77_0==17||LA77_0==76) ) { + alt77=1; + } + switch (alt77) { + case 1 : + // InternalExpression.g:5249:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* + { + // InternalExpression.g:5249:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:5250:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:5250:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) + // InternalExpression.g:5251:8: lv_declaredFormalParameters_2_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + + } + pushFollow(FOLLOW_63); + lv_declaredFormalParameters_2_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_2_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:5268:6: (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* + loop76: + do { + int alt76=2; + int LA76_0 = input.LA(1); + + if ( (LA76_0==44) ) { + alt76=1; + } + + + switch (alt76) { + case 1 : + // InternalExpression.g:5269:7: otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) + { + otherlv_3=(Token)match(input,44,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + + } + // InternalExpression.g:5273:7: ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:5274:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:5274:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) + // InternalExpression.g:5275:9: lv_declaredFormalParameters_4_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + + } + pushFollow(FOLLOW_63); + lv_declaredFormalParameters_4_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_4_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop76; + } + } while (true); + + + } + break; + + } + + // InternalExpression.g:5294:5: ( (lv_explicitSyntax_5_0= '|' ) ) + // InternalExpression.g:5295:6: (lv_explicitSyntax_5_0= '|' ) + { + // InternalExpression.g:5295:6: (lv_explicitSyntax_5_0= '|' ) + // InternalExpression.g:5296:7: lv_explicitSyntax_5_0= '|' + { + lv_explicitSyntax_5_0=(Token)match(input,54,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXClosureRule()); + } + setWithLastConsumed(current, "explicitSyntax", lv_explicitSyntax_5_0 != null, "|"); + + } + + } + + + } + + + } + + + } + break; + + } + + // InternalExpression.g:5310:3: ( (lv_expression_6_0= ruleXExpressionInClosure ) ) + // InternalExpression.g:5311:4: (lv_expression_6_0= ruleXExpressionInClosure ) + { + // InternalExpression.g:5311:4: (lv_expression_6_0= ruleXExpressionInClosure ) + // InternalExpression.g:5312:5: lv_expression_6_0= ruleXExpressionInClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_34); + lv_expression_6_0=ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + set( + current, + "expression", + lv_expression_6_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_7=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXClosure" + + + // $ANTLR start "entryRuleXExpressionInClosure" + // InternalExpression.g:5337:1: entryRuleXExpressionInClosure returns [EObject current=null] : iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ; + public final EObject entryRuleXExpressionInClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXExpressionInClosure = null; + + + try { + // InternalExpression.g:5337:61: (iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ) + // InternalExpression.g:5338:2: iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionInClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpressionInClosure=ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpressionInClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpressionInClosure" + + + // $ANTLR start "ruleXExpressionInClosure" + // InternalExpression.g:5344:1: ruleXExpressionInClosure returns [EObject current=null] : ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ; + public final EObject ruleXExpressionInClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject lv_expressions_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5350:2: ( ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ) + // InternalExpression.g:5351:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) + { + // InternalExpression.g:5351:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) + // InternalExpression.g:5352:3: () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* + { + // InternalExpression.g:5352:3: () + // InternalExpression.g:5353:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(), + current); + + } + + } + + // InternalExpression.g:5359:3: ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* + loop80: + do { + int alt80=2; + int LA80_0 = input.LA(1); + + if ( (LA80_0==RULE_INT||(LA80_0>=RULE_STRING && LA80_0<=RULE_DECIMAL)||LA80_0==17||LA80_0==21||(LA80_0>=24 && LA80_0<=25)||(LA80_0>=37 && LA80_0<=39)||LA80_0==42||(LA80_0>=55 && LA80_0<=57)||LA80_0==59||LA80_0==63||LA80_0==85||(LA80_0>=87 && LA80_0<=100)||LA80_0==102) ) { + alt80=1; + } + + + switch (alt80) { + case 1 : + // InternalExpression.g:5360:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? + { + // InternalExpression.g:5360:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:5361:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:5361:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:5362:6: lv_expressions_1_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + + } + pushFollow(FOLLOW_65); + lv_expressions_1_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule()); + } + add( + current, + "expressions", + lv_expressions_1_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:5379:4: (otherlv_2= ';' )? + int alt79=2; + int LA79_0 = input.LA(1); + + if ( (LA79_0==86) ) { + alt79=1; + } + switch (alt79) { + case 1 : + // InternalExpression.g:5380:5: otherlv_2= ';' + { + otherlv_2=(Token)match(input,86,FOLLOW_66); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + + } + + } + break; + + } + + + } + break; + + default : + break loop80; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpressionInClosure" + + + // $ANTLR start "entryRuleXShortClosure" + // InternalExpression.g:5390:1: entryRuleXShortClosure returns [EObject current=null] : iv_ruleXShortClosure= ruleXShortClosure EOF ; + public final EObject entryRuleXShortClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXShortClosure = null; + + + try { + // InternalExpression.g:5390:54: (iv_ruleXShortClosure= ruleXShortClosure EOF ) + // InternalExpression.g:5391:2: iv_ruleXShortClosure= ruleXShortClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXShortClosure=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXShortClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXShortClosure" + + + // $ANTLR start "ruleXShortClosure" + // InternalExpression.g:5397:1: ruleXShortClosure returns [EObject current=null] : ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXShortClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_explicitSyntax_4_0=null; + EObject lv_declaredFormalParameters_1_0 = null; + + EObject lv_declaredFormalParameters_3_0 = null; + + EObject lv_expression_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5403:2: ( ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ) + // InternalExpression.g:5404:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) + { + // InternalExpression.g:5404:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) + // InternalExpression.g:5405:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) + { + // InternalExpression.g:5405:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) + // InternalExpression.g:5406:4: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) + { + // InternalExpression.g:5431:4: ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) + // InternalExpression.g:5432:5: () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) + { + // InternalExpression.g:5432:5: () + // InternalExpression.g:5433:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(), + current); + + } + + } + + // InternalExpression.g:5439:5: ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? + int alt82=2; + int LA82_0 = input.LA(1); + + if ( (LA82_0==RULE_ID||LA82_0==17||LA82_0==76) ) { + alt82=1; + } + switch (alt82) { + case 1 : + // InternalExpression.g:5440:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* + { + // InternalExpression.g:5440:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:5441:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:5441:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) + // InternalExpression.g:5442:8: lv_declaredFormalParameters_1_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + + } + pushFollow(FOLLOW_63); + lv_declaredFormalParameters_1_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_1_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:5459:6: (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* + loop81: + do { + int alt81=2; + int LA81_0 = input.LA(1); + + if ( (LA81_0==44) ) { + alt81=1; + } + + + switch (alt81) { + case 1 : + // InternalExpression.g:5460:7: otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) + { + otherlv_2=(Token)match(input,44,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + + } + // InternalExpression.g:5464:7: ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:5465:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:5465:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) + // InternalExpression.g:5466:9: lv_declaredFormalParameters_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + + } + pushFollow(FOLLOW_63); + lv_declaredFormalParameters_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop81; + } + } while (true); + + + } + break; + + } + + // InternalExpression.g:5485:5: ( (lv_explicitSyntax_4_0= '|' ) ) + // InternalExpression.g:5486:6: (lv_explicitSyntax_4_0= '|' ) + { + // InternalExpression.g:5486:6: (lv_explicitSyntax_4_0= '|' ) + // InternalExpression.g:5487:7: lv_explicitSyntax_4_0= '|' + { + lv_explicitSyntax_4_0=(Token)match(input,54,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXShortClosureRule()); + } + setWithLastConsumed(current, "explicitSyntax", lv_explicitSyntax_4_0 != null, "|"); + + } + + } + + + } + + + } + + + } + + // InternalExpression.g:5501:3: ( (lv_expression_5_0= ruleXExpression ) ) + // InternalExpression.g:5502:4: (lv_expression_5_0= ruleXExpression ) + { + // InternalExpression.g:5502:4: (lv_expression_5_0= ruleXExpression ) + // InternalExpression.g:5503:5: lv_expression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + set( + current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXShortClosure" + + + // $ANTLR start "entryRuleXParenthesizedExpression" + // InternalExpression.g:5524:1: entryRuleXParenthesizedExpression returns [EObject current=null] : iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ; + public final EObject entryRuleXParenthesizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXParenthesizedExpression = null; + + + try { + // InternalExpression.g:5524:65: (iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ) + // InternalExpression.g:5525:2: iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXParenthesizedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXParenthesizedExpression" + + + // $ANTLR start "ruleXParenthesizedExpression" + // InternalExpression.g:5531:1: ruleXParenthesizedExpression returns [EObject current=null] : (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ; + public final EObject ruleXParenthesizedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + EObject this_XExpression_1 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5537:2: ( (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ) + // InternalExpression.g:5538:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) + { + // InternalExpression.g:5538:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) + // InternalExpression.g:5539:3: otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' + { + otherlv_0=(Token)match(input,17,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_8); + this_XExpression_1=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XExpression_1; + afterParserOrEnumRuleCall(); + + } + otherlv_2=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXParenthesizedExpression" + + + // $ANTLR start "entryRuleXIfExpression" + // InternalExpression.g:5559:1: entryRuleXIfExpression returns [EObject current=null] : iv_ruleXIfExpression= ruleXIfExpression EOF ; + public final EObject entryRuleXIfExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXIfExpression = null; + + + try { + // InternalExpression.g:5559:54: (iv_ruleXIfExpression= ruleXIfExpression EOF ) + // InternalExpression.g:5560:2: iv_ruleXIfExpression= ruleXIfExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXIfExpression=ruleXIfExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXIfExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXIfExpression" + + + // $ANTLR start "ruleXIfExpression" + // InternalExpression.g:5566:1: ruleXIfExpression returns [EObject current=null] : ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ; + public final EObject ruleXIfExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_if_3_0 = null; + + EObject lv_then_5_0 = null; + + EObject lv_else_7_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5572:2: ( ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ) + // InternalExpression.g:5573:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) + { + // InternalExpression.g:5573:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) + // InternalExpression.g:5574:3: () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? + { + // InternalExpression.g:5574:3: () + // InternalExpression.g:5575:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,21,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + + } + otherlv_2=(Token)match(input,17,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExpression.g:5589:3: ( (lv_if_3_0= ruleXExpression ) ) + // InternalExpression.g:5590:4: (lv_if_3_0= ruleXExpression ) + { + // InternalExpression.g:5590:4: (lv_if_3_0= ruleXExpression ) + // InternalExpression.g:5591:5: lv_if_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_8); + lv_if_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "if", + lv_if_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,18,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + + } + // InternalExpression.g:5612:3: ( (lv_then_5_0= ruleXExpression ) ) + // InternalExpression.g:5613:4: (lv_then_5_0= ruleXExpression ) + { + // InternalExpression.g:5613:4: (lv_then_5_0= ruleXExpression ) + // InternalExpression.g:5614:5: lv_then_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_12); + lv_then_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:5631:3: ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? + int alt83=2; + int LA83_0 = input.LA(1); + + if ( (LA83_0==23) ) { + int LA83_1 = input.LA(2); + + if ( (synpred27_InternalExpression()) ) { + alt83=1; + } + } + switch (alt83) { + case 1 : + // InternalExpression.g:5632:4: ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) + { + // InternalExpression.g:5632:4: ( ( 'else' )=>otherlv_6= 'else' ) + // InternalExpression.g:5633:5: ( 'else' )=>otherlv_6= 'else' + { + otherlv_6=(Token)match(input,23,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + + } + + } + + // InternalExpression.g:5639:4: ( (lv_else_7_0= ruleXExpression ) ) + // InternalExpression.g:5640:5: (lv_else_7_0= ruleXExpression ) + { + // InternalExpression.g:5640:5: (lv_else_7_0= ruleXExpression ) + // InternalExpression.g:5641:6: lv_else_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + + } + pushFollow(FOLLOW_2); + lv_else_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "else", + lv_else_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXIfExpression" + + + // $ANTLR start "entryRuleXSwitchExpression" + // InternalExpression.g:5663:1: entryRuleXSwitchExpression returns [EObject current=null] : iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ; + public final EObject entryRuleXSwitchExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSwitchExpression = null; + + + try { + // InternalExpression.g:5663:58: (iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ) + // InternalExpression.g:5664:2: iv_ruleXSwitchExpression= ruleXSwitchExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSwitchExpression=ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSwitchExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSwitchExpression" + + + // $ANTLR start "ruleXSwitchExpression" + // InternalExpression.g:5670:1: ruleXSwitchExpression returns [EObject current=null] : ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ; + public final EObject ruleXSwitchExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + Token otherlv_12=null; + Token otherlv_13=null; + Token otherlv_15=null; + EObject lv_declaredParam_3_0 = null; + + EObject lv_switch_5_0 = null; + + EObject lv_declaredParam_7_0 = null; + + EObject lv_switch_9_0 = null; + + EObject lv_cases_11_0 = null; + + EObject lv_default_14_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5676:2: ( ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ) + // InternalExpression.g:5677:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) + { + // InternalExpression.g:5677:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) + // InternalExpression.g:5678:3: () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' + { + // InternalExpression.g:5678:3: () + // InternalExpression.g:5679:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,24,FOLLOW_67); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + + } + // InternalExpression.g:5689:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) + int alt85=2; + alt85 = dfa85.predict(input); + switch (alt85) { + case 1 : + // InternalExpression.g:5690:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) + { + // InternalExpression.g:5690:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) + // InternalExpression.g:5691:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' + { + // InternalExpression.g:5691:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) + // InternalExpression.g:5692:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + { + // InternalExpression.g:5702:6: (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + // InternalExpression.g:5703:7: otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' + { + otherlv_2=(Token)match(input,17,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + + } + // InternalExpression.g:5707:7: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:5708:8: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:5708:8: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + // InternalExpression.g:5709:9: lv_declaredParam_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + + } + pushFollow(FOLLOW_6); + lv_declaredParam_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,16,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + + } + + } + + + } + + // InternalExpression.g:5732:5: ( (lv_switch_5_0= ruleXExpression ) ) + // InternalExpression.g:5733:6: (lv_switch_5_0= ruleXExpression ) + { + // InternalExpression.g:5733:6: (lv_switch_5_0= ruleXExpression ) + // InternalExpression.g:5734:7: lv_switch_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_8); + lv_switch_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "switch", + lv_switch_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,18,FOLLOW_15); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + + } + + } + + + } + break; + case 2 : + // InternalExpression.g:5757:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) + { + // InternalExpression.g:5757:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) + // InternalExpression.g:5758:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) + { + // InternalExpression.g:5758:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? + int alt84=2; + alt84 = dfa84.predict(input); + switch (alt84) { + case 1 : + // InternalExpression.g:5759:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) + { + // InternalExpression.g:5768:6: ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) + // InternalExpression.g:5769:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' + { + // InternalExpression.g:5769:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:5770:8: (lv_declaredParam_7_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:5770:8: (lv_declaredParam_7_0= ruleJvmFormalParameter ) + // InternalExpression.g:5771:9: lv_declaredParam_7_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + + } + pushFollow(FOLLOW_6); + lv_declaredParam_7_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_7_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_8=(Token)match(input,16,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + + } + + } + + + } + break; + + } + + // InternalExpression.g:5794:5: ( (lv_switch_9_0= ruleXExpression ) ) + // InternalExpression.g:5795:6: (lv_switch_9_0= ruleXExpression ) + { + // InternalExpression.g:5795:6: (lv_switch_9_0= ruleXExpression ) + // InternalExpression.g:5796:7: lv_switch_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_15); + lv_switch_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "switch", + lv_switch_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + otherlv_10=(Token)match(input,25,FOLLOW_68); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + + } + // InternalExpression.g:5819:3: ( (lv_cases_11_0= ruleXCasePart ) )* + loop86: + do { + int alt86=2; + int LA86_0 = input.LA(1); + + if ( (LA86_0==RULE_ID||(LA86_0>=16 && LA86_0<=17)||LA86_0==28||LA86_0==44||LA86_0==76) ) { + alt86=1; + } + + + switch (alt86) { + case 1 : + // InternalExpression.g:5820:4: (lv_cases_11_0= ruleXCasePart ) + { + // InternalExpression.g:5820:4: (lv_cases_11_0= ruleXCasePart ) + // InternalExpression.g:5821:5: lv_cases_11_0= ruleXCasePart + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_68); + lv_cases_11_0=ruleXCasePart(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + add( + current, + "cases", + lv_cases_11_0, + "org.eclipse.xtext.xbase.Xbase.XCasePart"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop86; + } + } while (true); + + // InternalExpression.g:5838:3: (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==26) ) { + alt87=1; + } + switch (alt87) { + case 1 : + // InternalExpression.g:5839:4: otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) + { + otherlv_12=(Token)match(input,26,FOLLOW_6); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + + } + otherlv_13=(Token)match(input,16,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + + } + // InternalExpression.g:5847:4: ( (lv_default_14_0= ruleXExpression ) ) + // InternalExpression.g:5848:5: (lv_default_14_0= ruleXExpression ) + { + // InternalExpression.g:5848:5: (lv_default_14_0= ruleXExpression ) + // InternalExpression.g:5849:6: lv_default_14_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + + } + pushFollow(FOLLOW_17); + lv_default_14_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "default", + lv_default_14_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + otherlv_15=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSwitchExpression" + + + // $ANTLR start "entryRuleXCasePart" + // InternalExpression.g:5875:1: entryRuleXCasePart returns [EObject current=null] : iv_ruleXCasePart= ruleXCasePart EOF ; + public final EObject entryRuleXCasePart() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCasePart = null; + + + try { + // InternalExpression.g:5875:50: (iv_ruleXCasePart= ruleXCasePart EOF ) + // InternalExpression.g:5876:2: iv_ruleXCasePart= ruleXCasePart EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCasePart=ruleXCasePart(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCasePart; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCasePart" + + + // $ANTLR start "ruleXCasePart" + // InternalExpression.g:5882:1: ruleXCasePart returns [EObject current=null] : ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ; + public final EObject ruleXCasePart() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token otherlv_4=null; + Token lv_fallThrough_6_0=null; + EObject lv_typeGuard_1_0 = null; + + EObject lv_case_3_0 = null; + + EObject lv_then_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:5888:2: ( ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ) + // InternalExpression.g:5889:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) + { + // InternalExpression.g:5889:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) + // InternalExpression.g:5890:3: () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) + { + // InternalExpression.g:5890:3: () + // InternalExpression.g:5891:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXCasePartAccess().getXCasePartAction_0(), + current); + + } + + } + + // InternalExpression.g:5897:3: ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? + int alt88=2; + int LA88_0 = input.LA(1); + + if ( (LA88_0==RULE_ID||LA88_0==17||LA88_0==76) ) { + alt88=1; + } + switch (alt88) { + case 1 : + // InternalExpression.g:5898:4: (lv_typeGuard_1_0= ruleJvmTypeReference ) + { + // InternalExpression.g:5898:4: (lv_typeGuard_1_0= ruleJvmTypeReference ) + // InternalExpression.g:5899:5: lv_typeGuard_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_69); + lv_typeGuard_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "typeGuard", + lv_typeGuard_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + // InternalExpression.g:5916:3: (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? + int alt89=2; + int LA89_0 = input.LA(1); + + if ( (LA89_0==28) ) { + alt89=1; + } + switch (alt89) { + case 1 : + // InternalExpression.g:5917:4: otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) + { + otherlv_2=(Token)match(input,28,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + + } + // InternalExpression.g:5921:4: ( (lv_case_3_0= ruleXExpression ) ) + // InternalExpression.g:5922:5: (lv_case_3_0= ruleXExpression ) + { + // InternalExpression.g:5922:5: (lv_case_3_0= ruleXExpression ) + // InternalExpression.g:5923:6: lv_case_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_70); + lv_case_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "case", + lv_case_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalExpression.g:5941:3: ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) + int alt90=2; + int LA90_0 = input.LA(1); + + if ( (LA90_0==16) ) { + alt90=1; + } + else if ( (LA90_0==44) ) { + alt90=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 90, 0, input); + + throw nvae; + } + switch (alt90) { + case 1 : + // InternalExpression.g:5942:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) + { + // InternalExpression.g:5942:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) + // InternalExpression.g:5943:5: otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,16,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + + } + // InternalExpression.g:5947:5: ( (lv_then_5_0= ruleXExpression ) ) + // InternalExpression.g:5948:6: (lv_then_5_0= ruleXExpression ) + { + // InternalExpression.g:5948:6: (lv_then_5_0= ruleXExpression ) + // InternalExpression.g:5949:7: lv_then_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + + } + pushFollow(FOLLOW_2); + lv_then_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:5968:4: ( (lv_fallThrough_6_0= ',' ) ) + { + // InternalExpression.g:5968:4: ( (lv_fallThrough_6_0= ',' ) ) + // InternalExpression.g:5969:5: (lv_fallThrough_6_0= ',' ) + { + // InternalExpression.g:5969:5: (lv_fallThrough_6_0= ',' ) + // InternalExpression.g:5970:6: lv_fallThrough_6_0= ',' + { + lv_fallThrough_6_0=(Token)match(input,44,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXCasePartRule()); + } + setWithLastConsumed(current, "fallThrough", lv_fallThrough_6_0 != null, ","); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCasePart" + + + // $ANTLR start "entryRuleXForLoopExpression" + // InternalExpression.g:5987:1: entryRuleXForLoopExpression returns [EObject current=null] : iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ; + public final EObject entryRuleXForLoopExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXForLoopExpression = null; + + + try { + // InternalExpression.g:5987:59: (iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ) + // InternalExpression.g:5988:2: iv_ruleXForLoopExpression= ruleXForLoopExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXForLoopExpression=ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXForLoopExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXForLoopExpression" + + + // $ANTLR start "ruleXForLoopExpression" + // InternalExpression.g:5994:1: ruleXForLoopExpression returns [EObject current=null] : ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ; + public final EObject ruleXForLoopExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_declaredParam_3_0 = null; + + EObject lv_forExpression_5_0 = null; + + EObject lv_eachExpression_7_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6000:2: ( ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ) + // InternalExpression.g:6001:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) + { + // InternalExpression.g:6001:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) + // InternalExpression.g:6002:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) + { + // InternalExpression.g:6002:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) + // InternalExpression.g:6003:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + { + // InternalExpression.g:6016:4: ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + // InternalExpression.g:6017:5: () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' + { + // InternalExpression.g:6017:5: () + // InternalExpression.g:6018:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,87,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + + } + otherlv_2=(Token)match(input,17,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + + } + // InternalExpression.g:6032:5: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) + // InternalExpression.g:6033:6: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + { + // InternalExpression.g:6033:6: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + // InternalExpression.g:6034:7: lv_declaredParam_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + + } + pushFollow(FOLLOW_6); + lv_declaredParam_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,16,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + + } + + } + + + } + + // InternalExpression.g:6057:3: ( (lv_forExpression_5_0= ruleXExpression ) ) + // InternalExpression.g:6058:4: (lv_forExpression_5_0= ruleXExpression ) + { + // InternalExpression.g:6058:4: (lv_forExpression_5_0= ruleXExpression ) + // InternalExpression.g:6059:5: lv_forExpression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_8); + lv_forExpression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "forExpression", + lv_forExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,18,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + + } + // InternalExpression.g:6080:3: ( (lv_eachExpression_7_0= ruleXExpression ) ) + // InternalExpression.g:6081:4: (lv_eachExpression_7_0= ruleXExpression ) + { + // InternalExpression.g:6081:4: (lv_eachExpression_7_0= ruleXExpression ) + // InternalExpression.g:6082:5: lv_eachExpression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_eachExpression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "eachExpression", + lv_eachExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXForLoopExpression" + + + // $ANTLR start "entryRuleXBasicForLoopExpression" + // InternalExpression.g:6103:1: entryRuleXBasicForLoopExpression returns [EObject current=null] : iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ; + public final EObject entryRuleXBasicForLoopExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBasicForLoopExpression = null; + + + try { + // InternalExpression.g:6103:64: (iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ) + // InternalExpression.g:6104:2: iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBasicForLoopExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBasicForLoopExpression" + + + // $ANTLR start "ruleXBasicForLoopExpression" + // InternalExpression.g:6110:1: ruleXBasicForLoopExpression returns [EObject current=null] : ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ; + public final EObject ruleXBasicForLoopExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + Token otherlv_12=null; + EObject lv_initExpressions_3_0 = null; + + EObject lv_initExpressions_5_0 = null; + + EObject lv_expression_7_0 = null; + + EObject lv_updateExpressions_9_0 = null; + + EObject lv_updateExpressions_11_0 = null; + + EObject lv_eachExpression_13_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6116:2: ( ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ) + // InternalExpression.g:6117:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) + { + // InternalExpression.g:6117:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) + // InternalExpression.g:6118:3: () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) + { + // InternalExpression.g:6118:3: () + // InternalExpression.g:6119:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,87,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + + } + otherlv_2=(Token)match(input,17,FOLLOW_71); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExpression.g:6133:3: ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? + int alt92=2; + int LA92_0 = input.LA(1); + + if ( (LA92_0==RULE_INT||(LA92_0>=RULE_STRING && LA92_0<=RULE_DECIMAL)||LA92_0==17||LA92_0==21||(LA92_0>=24 && LA92_0<=25)||(LA92_0>=37 && LA92_0<=39)||LA92_0==42||(LA92_0>=55 && LA92_0<=57)||LA92_0==59||LA92_0==63||LA92_0==85||(LA92_0>=87 && LA92_0<=100)||LA92_0==102) ) { + alt92=1; + } + switch (alt92) { + case 1 : + // InternalExpression.g:6134:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* + { + // InternalExpression.g:6134:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:6135:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:6135:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:6136:6: lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_72); + lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "initExpressions", + lv_initExpressions_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6153:4: (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* + loop91: + do { + int alt91=2; + int LA91_0 = input.LA(1); + + if ( (LA91_0==44) ) { + alt91=1; + } + + + switch (alt91) { + case 1 : + // InternalExpression.g:6154:5: otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) + { + otherlv_4=(Token)match(input,44,FOLLOW_73); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + + } + // InternalExpression.g:6158:5: ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:6159:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:6159:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:6160:7: lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_72); + lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "initExpressions", + lv_initExpressions_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop91; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,86,FOLLOW_74); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + + } + // InternalExpression.g:6183:3: ( (lv_expression_7_0= ruleXExpression ) )? + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==RULE_INT||(LA93_0>=RULE_STRING && LA93_0<=RULE_DECIMAL)||LA93_0==17||LA93_0==21||(LA93_0>=24 && LA93_0<=25)||(LA93_0>=37 && LA93_0<=39)||LA93_0==42||(LA93_0>=55 && LA93_0<=57)||LA93_0==59||LA93_0==63||LA93_0==85||(LA93_0>=87 && LA93_0<=89)||(LA93_0>=92 && LA93_0<=100)||LA93_0==102) ) { + alt93=1; + } + switch (alt93) { + case 1 : + // InternalExpression.g:6184:4: (lv_expression_7_0= ruleXExpression ) + { + // InternalExpression.g:6184:4: (lv_expression_7_0= ruleXExpression ) + // InternalExpression.g:6185:5: lv_expression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_75); + lv_expression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + current, + "expression", + lv_expression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + otherlv_8=(Token)match(input,86,FOLLOW_76); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + + } + // InternalExpression.g:6206:3: ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? + int alt95=2; + int LA95_0 = input.LA(1); + + if ( (LA95_0==RULE_INT||(LA95_0>=RULE_STRING && LA95_0<=RULE_DECIMAL)||LA95_0==17||LA95_0==21||(LA95_0>=24 && LA95_0<=25)||(LA95_0>=37 && LA95_0<=39)||LA95_0==42||(LA95_0>=55 && LA95_0<=57)||LA95_0==59||LA95_0==63||LA95_0==85||(LA95_0>=87 && LA95_0<=89)||(LA95_0>=92 && LA95_0<=100)||LA95_0==102) ) { + alt95=1; + } + switch (alt95) { + case 1 : + // InternalExpression.g:6207:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* + { + // InternalExpression.g:6207:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) + // InternalExpression.g:6208:5: (lv_updateExpressions_9_0= ruleXExpression ) + { + // InternalExpression.g:6208:5: (lv_updateExpressions_9_0= ruleXExpression ) + // InternalExpression.g:6209:6: lv_updateExpressions_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + + } + pushFollow(FOLLOW_27); + lv_updateExpressions_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "updateExpressions", + lv_updateExpressions_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6226:4: (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* + loop94: + do { + int alt94=2; + int LA94_0 = input.LA(1); + + if ( (LA94_0==44) ) { + alt94=1; + } + + + switch (alt94) { + case 1 : + // InternalExpression.g:6227:5: otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) + { + otherlv_10=(Token)match(input,44,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + + } + // InternalExpression.g:6231:5: ( (lv_updateExpressions_11_0= ruleXExpression ) ) + // InternalExpression.g:6232:6: (lv_updateExpressions_11_0= ruleXExpression ) + { + // InternalExpression.g:6232:6: (lv_updateExpressions_11_0= ruleXExpression ) + // InternalExpression.g:6233:7: lv_updateExpressions_11_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + + } + pushFollow(FOLLOW_27); + lv_updateExpressions_11_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "updateExpressions", + lv_updateExpressions_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop94; + } + } while (true); + + + } + break; + + } + + otherlv_12=(Token)match(input,18,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + + } + // InternalExpression.g:6256:3: ( (lv_eachExpression_13_0= ruleXExpression ) ) + // InternalExpression.g:6257:4: (lv_eachExpression_13_0= ruleXExpression ) + { + // InternalExpression.g:6257:4: (lv_eachExpression_13_0= ruleXExpression ) + // InternalExpression.g:6258:5: lv_eachExpression_13_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + + } + pushFollow(FOLLOW_2); + lv_eachExpression_13_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + current, + "eachExpression", + lv_eachExpression_13_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBasicForLoopExpression" + + + // $ANTLR start "entryRuleXWhileExpression" + // InternalExpression.g:6279:1: entryRuleXWhileExpression returns [EObject current=null] : iv_ruleXWhileExpression= ruleXWhileExpression EOF ; + public final EObject entryRuleXWhileExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXWhileExpression = null; + + + try { + // InternalExpression.g:6279:57: (iv_ruleXWhileExpression= ruleXWhileExpression EOF ) + // InternalExpression.g:6280:2: iv_ruleXWhileExpression= ruleXWhileExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXWhileExpression=ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXWhileExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXWhileExpression" + + + // $ANTLR start "ruleXWhileExpression" + // InternalExpression.g:6286:1: ruleXWhileExpression returns [EObject current=null] : ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXWhileExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_predicate_3_0 = null; + + EObject lv_body_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6292:2: ( ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ) + // InternalExpression.g:6293:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) + { + // InternalExpression.g:6293:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) + // InternalExpression.g:6294:3: () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) + { + // InternalExpression.g:6294:3: () + // InternalExpression.g:6295:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,88,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + + } + otherlv_2=(Token)match(input,17,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExpression.g:6309:3: ( (lv_predicate_3_0= ruleXExpression ) ) + // InternalExpression.g:6310:4: (lv_predicate_3_0= ruleXExpression ) + { + // InternalExpression.g:6310:4: (lv_predicate_3_0= ruleXExpression ) + // InternalExpression.g:6311:5: lv_predicate_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_8); + lv_predicate_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + current, + "predicate", + lv_predicate_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,18,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + + } + // InternalExpression.g:6332:3: ( (lv_body_5_0= ruleXExpression ) ) + // InternalExpression.g:6333:4: (lv_body_5_0= ruleXExpression ) + { + // InternalExpression.g:6333:4: (lv_body_5_0= ruleXExpression ) + // InternalExpression.g:6334:5: lv_body_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_2); + lv_body_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + current, + "body", + lv_body_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXWhileExpression" + + + // $ANTLR start "entryRuleXDoWhileExpression" + // InternalExpression.g:6355:1: entryRuleXDoWhileExpression returns [EObject current=null] : iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ; + public final EObject entryRuleXDoWhileExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXDoWhileExpression = null; + + + try { + // InternalExpression.g:6355:59: (iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ) + // InternalExpression.g:6356:2: iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXDoWhileExpression=ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXDoWhileExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXDoWhileExpression" + + + // $ANTLR start "ruleXDoWhileExpression" + // InternalExpression.g:6362:1: ruleXDoWhileExpression returns [EObject current=null] : ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ; + public final EObject ruleXDoWhileExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_body_2_0 = null; + + EObject lv_predicate_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6368:2: ( ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ) + // InternalExpression.g:6369:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) + { + // InternalExpression.g:6369:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) + // InternalExpression.g:6370:3: () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' + { + // InternalExpression.g:6370:3: () + // InternalExpression.g:6371:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,89,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + + } + // InternalExpression.g:6381:3: ( (lv_body_2_0= ruleXExpression ) ) + // InternalExpression.g:6382:4: (lv_body_2_0= ruleXExpression ) + { + // InternalExpression.g:6382:4: (lv_body_2_0= ruleXExpression ) + // InternalExpression.g:6383:5: lv_body_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_77); + lv_body_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + current, + "body", + lv_body_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_3=(Token)match(input,88,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + + } + otherlv_4=(Token)match(input,17,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + + } + // InternalExpression.g:6408:3: ( (lv_predicate_5_0= ruleXExpression ) ) + // InternalExpression.g:6409:4: (lv_predicate_5_0= ruleXExpression ) + { + // InternalExpression.g:6409:4: (lv_predicate_5_0= ruleXExpression ) + // InternalExpression.g:6410:5: lv_predicate_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_8); + lv_predicate_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + current, + "predicate", + lv_predicate_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXDoWhileExpression" + + + // $ANTLR start "entryRuleXBlockExpression" + // InternalExpression.g:6435:1: entryRuleXBlockExpression returns [EObject current=null] : iv_ruleXBlockExpression= ruleXBlockExpression EOF ; + public final EObject entryRuleXBlockExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBlockExpression = null; + + + try { + // InternalExpression.g:6435:57: (iv_ruleXBlockExpression= ruleXBlockExpression EOF ) + // InternalExpression.g:6436:2: iv_ruleXBlockExpression= ruleXBlockExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBlockExpression=ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBlockExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBlockExpression" + + + // $ANTLR start "ruleXBlockExpression" + // InternalExpression.g:6442:1: ruleXBlockExpression returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ; + public final EObject ruleXBlockExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + EObject lv_expressions_2_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6448:2: ( ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ) + // InternalExpression.g:6449:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) + { + // InternalExpression.g:6449:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) + // InternalExpression.g:6450:3: () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' + { + // InternalExpression.g:6450:3: () + // InternalExpression.g:6451:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,25,FOLLOW_78); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + + } + // InternalExpression.g:6461:3: ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* + loop97: + do { + int alt97=2; + int LA97_0 = input.LA(1); + + if ( (LA97_0==RULE_INT||(LA97_0>=RULE_STRING && LA97_0<=RULE_DECIMAL)||LA97_0==17||LA97_0==21||(LA97_0>=24 && LA97_0<=25)||(LA97_0>=37 && LA97_0<=39)||LA97_0==42||(LA97_0>=55 && LA97_0<=57)||LA97_0==59||LA97_0==63||LA97_0==85||(LA97_0>=87 && LA97_0<=100)||LA97_0==102) ) { + alt97=1; + } + + + switch (alt97) { + case 1 : + // InternalExpression.g:6462:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? + { + // InternalExpression.g:6462:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) + // InternalExpression.g:6463:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) + { + // InternalExpression.g:6463:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) + // InternalExpression.g:6464:6: lv_expressions_2_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + + } + pushFollow(FOLLOW_79); + lv_expressions_2_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBlockExpressionRule()); + } + add( + current, + "expressions", + lv_expressions_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6481:4: (otherlv_3= ';' )? + int alt96=2; + int LA96_0 = input.LA(1); + + if ( (LA96_0==86) ) { + alt96=1; + } + switch (alt96) { + case 1 : + // InternalExpression.g:6482:5: otherlv_3= ';' + { + otherlv_3=(Token)match(input,86,FOLLOW_78); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + + } + + } + break; + + } + + + } + break; + + default : + break loop97; + } + } while (true); + + otherlv_4=(Token)match(input,27,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBlockExpression" + + + // $ANTLR start "entryRuleXExpressionOrVarDeclaration" + // InternalExpression.g:6496:1: entryRuleXExpressionOrVarDeclaration returns [EObject current=null] : iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ; + public final EObject entryRuleXExpressionOrVarDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXExpressionOrVarDeclaration = null; + + + try { + // InternalExpression.g:6496:68: (iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ) + // InternalExpression.g:6497:2: iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpressionOrVarDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" + + + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // InternalExpression.g:6503:1: ruleXExpressionOrVarDeclaration returns [EObject current=null] : (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ; + public final EObject ruleXExpressionOrVarDeclaration() throws RecognitionException { + EObject current = null; + + EObject this_XVariableDeclaration_0 = null; + + EObject this_XExpression_1 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6509:2: ( (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ) + // InternalExpression.g:6510:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) + { + // InternalExpression.g:6510:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) + int alt98=2; + int LA98_0 = input.LA(1); + + if ( ((LA98_0>=90 && LA98_0<=91)) ) { + alt98=1; + } + else if ( (LA98_0==RULE_INT||(LA98_0>=RULE_STRING && LA98_0<=RULE_DECIMAL)||LA98_0==17||LA98_0==21||(LA98_0>=24 && LA98_0<=25)||(LA98_0>=37 && LA98_0<=39)||LA98_0==42||(LA98_0>=55 && LA98_0<=57)||LA98_0==59||LA98_0==63||LA98_0==85||(LA98_0>=87 && LA98_0<=89)||(LA98_0>=92 && LA98_0<=100)||LA98_0==102) ) { + alt98=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 98, 0, input); + + throw nvae; + } + switch (alt98) { + case 1 : + // InternalExpression.g:6511:3: this_XVariableDeclaration_0= ruleXVariableDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XVariableDeclaration_0=ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XVariableDeclaration_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:6520:3: this_XExpression_1= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XExpression_1=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XExpression_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpressionOrVarDeclaration" + + + // $ANTLR start "entryRuleXVariableDeclaration" + // InternalExpression.g:6532:1: entryRuleXVariableDeclaration returns [EObject current=null] : iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ; + public final EObject entryRuleXVariableDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXVariableDeclaration = null; + + + try { + // InternalExpression.g:6532:61: (iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ) + // InternalExpression.g:6533:2: iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXVariableDeclaration=ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXVariableDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXVariableDeclaration" + + + // $ANTLR start "ruleXVariableDeclaration" + // InternalExpression.g:6539:1: ruleXVariableDeclaration returns [EObject current=null] : ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ; + public final EObject ruleXVariableDeclaration() throws RecognitionException { + EObject current = null; + + Token lv_writeable_1_0=null; + Token otherlv_2=null; + Token otherlv_6=null; + EObject lv_type_3_0 = null; + + AntlrDatatypeRuleToken lv_name_4_0 = null; + + AntlrDatatypeRuleToken lv_name_5_0 = null; + + EObject lv_right_7_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6545:2: ( ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ) + // InternalExpression.g:6546:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) + { + // InternalExpression.g:6546:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) + // InternalExpression.g:6547:3: () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? + { + // InternalExpression.g:6547:3: () + // InternalExpression.g:6548:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(), + current); + + } + + } + + // InternalExpression.g:6554:3: ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) + int alt99=2; + int LA99_0 = input.LA(1); + + if ( (LA99_0==90) ) { + alt99=1; + } + else if ( (LA99_0==91) ) { + alt99=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 99, 0, input); + + throw nvae; + } + switch (alt99) { + case 1 : + // InternalExpression.g:6555:4: ( (lv_writeable_1_0= 'var' ) ) + { + // InternalExpression.g:6555:4: ( (lv_writeable_1_0= 'var' ) ) + // InternalExpression.g:6556:5: (lv_writeable_1_0= 'var' ) + { + // InternalExpression.g:6556:5: (lv_writeable_1_0= 'var' ) + // InternalExpression.g:6557:6: lv_writeable_1_0= 'var' + { + lv_writeable_1_0=(Token)match(input,90,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXVariableDeclarationRule()); + } + setWithLastConsumed(current, "writeable", lv_writeable_1_0 != null, "var"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:6570:4: otherlv_2= 'val' + { + otherlv_2=(Token)match(input,91,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + + } + + } + break; + + } + + // InternalExpression.g:6575:3: ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) + int alt100=2; + int LA100_0 = input.LA(1); + + if ( (LA100_0==RULE_ID) ) { + int LA100_1 = input.LA(2); + + if ( (synpred31_InternalExpression()) ) { + alt100=1; + } + else if ( (true) ) { + alt100=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 100, 1, input); + + throw nvae; + } + } + else if ( (LA100_0==17) && (synpred31_InternalExpression())) { + alt100=1; + } + else if ( (LA100_0==76) && (synpred31_InternalExpression())) { + alt100=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 100, 0, input); + + throw nvae; + } + switch (alt100) { + case 1 : + // InternalExpression.g:6576:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) + { + // InternalExpression.g:6576:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) + // InternalExpression.g:6577:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) + { + // InternalExpression.g:6590:5: ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) + // InternalExpression.g:6591:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) + { + // InternalExpression.g:6591:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalExpression.g:6592:7: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalExpression.g:6592:7: (lv_type_3_0= ruleJvmTypeReference ) + // InternalExpression.g:6593:8: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + + } + pushFollow(FOLLOW_3); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6610:6: ( (lv_name_4_0= ruleValidID ) ) + // InternalExpression.g:6611:7: (lv_name_4_0= ruleValidID ) + { + // InternalExpression.g:6611:7: (lv_name_4_0= ruleValidID ) + // InternalExpression.g:6612:8: lv_name_4_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + + } + pushFollow(FOLLOW_80); + lv_name_4_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "name", + lv_name_4_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:6632:4: ( (lv_name_5_0= ruleValidID ) ) + { + // InternalExpression.g:6632:4: ( (lv_name_5_0= ruleValidID ) ) + // InternalExpression.g:6633:5: (lv_name_5_0= ruleValidID ) + { + // InternalExpression.g:6633:5: (lv_name_5_0= ruleValidID ) + // InternalExpression.g:6634:6: lv_name_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_80); + lv_name_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "name", + lv_name_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalExpression.g:6652:3: (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? + int alt101=2; + int LA101_0 = input.LA(1); + + if ( (LA101_0==15) ) { + alt101=1; + } + switch (alt101) { + case 1 : + // InternalExpression.g:6653:4: otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) + { + otherlv_6=(Token)match(input,15,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + + } + // InternalExpression.g:6657:4: ( (lv_right_7_0= ruleXExpression ) ) + // InternalExpression.g:6658:5: (lv_right_7_0= ruleXExpression ) + { + // InternalExpression.g:6658:5: (lv_right_7_0= ruleXExpression ) + // InternalExpression.g:6659:6: lv_right_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_2); + lv_right_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "right", + lv_right_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXVariableDeclaration" + + + // $ANTLR start "entryRuleJvmFormalParameter" + // InternalExpression.g:6681:1: entryRuleJvmFormalParameter returns [EObject current=null] : iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ; + public final EObject entryRuleJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmFormalParameter = null; + + + try { + // InternalExpression.g:6681:59: (iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ) + // InternalExpression.g:6682:2: iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmFormalParameter=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmFormalParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmFormalParameter" + + + // $ANTLR start "ruleJvmFormalParameter" + // InternalExpression.g:6688:1: ruleJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ; + public final EObject ruleJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject lv_parameterType_0_0 = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6694:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ) + // InternalExpression.g:6695:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) + { + // InternalExpression.g:6695:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) + // InternalExpression.g:6696:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) + { + // InternalExpression.g:6696:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? + int alt102=2; + int LA102_0 = input.LA(1); + + if ( (LA102_0==RULE_ID) ) { + int LA102_1 = input.LA(2); + + if ( (LA102_1==RULE_ID||LA102_1==37||LA102_1==43||LA102_1==63) ) { + alt102=1; + } + } + else if ( (LA102_0==17||LA102_0==76) ) { + alt102=1; + } + switch (alt102) { + case 1 : + // InternalExpression.g:6697:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + { + // InternalExpression.g:6697:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + // InternalExpression.g:6698:5: lv_parameterType_0_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_3); + lv_parameterType_0_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + // InternalExpression.g:6715:3: ( (lv_name_1_0= ruleValidID ) ) + // InternalExpression.g:6716:4: (lv_name_1_0= ruleValidID ) + { + // InternalExpression.g:6716:4: (lv_name_1_0= ruleValidID ) + // InternalExpression.g:6717:5: lv_name_1_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_name_1_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmFormalParameter" + + + // $ANTLR start "entryRuleFullJvmFormalParameter" + // InternalExpression.g:6738:1: entryRuleFullJvmFormalParameter returns [EObject current=null] : iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ; + public final EObject entryRuleFullJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleFullJvmFormalParameter = null; + + + try { + // InternalExpression.g:6738:63: (iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ) + // InternalExpression.g:6739:2: iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleFullJvmFormalParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFullJvmFormalParameter" + + + // $ANTLR start "ruleFullJvmFormalParameter" + // InternalExpression.g:6745:1: ruleFullJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ; + public final EObject ruleFullJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject lv_parameterType_0_0 = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6751:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ) + // InternalExpression.g:6752:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) + { + // InternalExpression.g:6752:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) + // InternalExpression.g:6753:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) + { + // InternalExpression.g:6753:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) + // InternalExpression.g:6754:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + { + // InternalExpression.g:6754:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + // InternalExpression.g:6755:5: lv_parameterType_0_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_3); + lv_parameterType_0_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6772:3: ( (lv_name_1_0= ruleValidID ) ) + // InternalExpression.g:6773:4: (lv_name_1_0= ruleValidID ) + { + // InternalExpression.g:6773:4: (lv_name_1_0= ruleValidID ) + // InternalExpression.g:6774:5: lv_name_1_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_name_1_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFullJvmFormalParameter" + + + // $ANTLR start "entryRuleXFeatureCall" + // InternalExpression.g:6795:1: entryRuleXFeatureCall returns [EObject current=null] : iv_ruleXFeatureCall= ruleXFeatureCall EOF ; + public final EObject entryRuleXFeatureCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFeatureCall = null; + + + try { + // InternalExpression.g:6795:53: (iv_ruleXFeatureCall= ruleXFeatureCall EOF ) + // InternalExpression.g:6796:2: iv_ruleXFeatureCall= ruleXFeatureCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFeatureCall=ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFeatureCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFeatureCall" + + + // $ANTLR start "ruleXFeatureCall" + // InternalExpression.g:6802:1: ruleXFeatureCall returns [EObject current=null] : ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ; + public final EObject ruleXFeatureCall() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token lv_explicitOperationCall_7_0=null; + Token otherlv_10=null; + Token otherlv_12=null; + EObject lv_typeArguments_2_0 = null; + + EObject lv_typeArguments_4_0 = null; + + EObject lv_featureCallArguments_8_0 = null; + + EObject lv_featureCallArguments_9_0 = null; + + EObject lv_featureCallArguments_11_0 = null; + + EObject lv_featureCallArguments_13_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:6808:2: ( ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ) + // InternalExpression.g:6809:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) + { + // InternalExpression.g:6809:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) + // InternalExpression.g:6810:3: () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? + { + // InternalExpression.g:6810:3: () + // InternalExpression.g:6811:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(), + current); + + } + + } + + // InternalExpression.g:6817:3: (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? + int alt104=2; + int LA104_0 = input.LA(1); + + if ( (LA104_0==37) ) { + alt104=1; + } + switch (alt104) { + case 1 : + // InternalExpression.g:6818:4: otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' + { + otherlv_1=(Token)match(input,37,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + + } + // InternalExpression.g:6822:4: ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:6823:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:6823:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:6824:6: lv_typeArguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_55); + lv_typeArguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6841:4: (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop103: + do { + int alt103=2; + int LA103_0 = input.LA(1); + + if ( (LA103_0==44) ) { + alt103=1; + } + + + switch (alt103) { + case 1 : + // InternalExpression.g:6842:5: otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,44,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + + } + // InternalExpression.g:6846:5: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:6847:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:6847:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:6848:7: lv_typeArguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_55); + lv_typeArguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop103; + } + } while (true); + + otherlv_5=(Token)match(input,36,FOLLOW_53); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + + } + + } + break; + + } + + // InternalExpression.g:6871:3: ( ( ruleIdOrSuper ) ) + // InternalExpression.g:6872:4: ( ruleIdOrSuper ) + { + // InternalExpression.g:6872:4: ( ruleIdOrSuper ) + // InternalExpression.g:6873:5: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + + } + pushFollow(FOLLOW_81); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6887:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? + int alt107=2; + alt107 = dfa107.predict(input); + switch (alt107) { + case 1 : + // InternalExpression.g:6888:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' + { + // InternalExpression.g:6888:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) + // InternalExpression.g:6889:5: ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) + { + // InternalExpression.g:6893:5: (lv_explicitOperationCall_7_0= '(' ) + // InternalExpression.g:6894:6: lv_explicitOperationCall_7_0= '(' + { + lv_explicitOperationCall_7_0=(Token)match(input,17,FOLLOW_57); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + setWithLastConsumed(current, "explicitOperationCall", lv_explicitOperationCall_7_0 != null, "("); + + } + + } + + + } + + // InternalExpression.g:6906:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? + int alt106=3; + alt106 = dfa106.predict(input); + switch (alt106) { + case 1 : + // InternalExpression.g:6907:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) + { + // InternalExpression.g:6907:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) + // InternalExpression.g:6908:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) + { + // InternalExpression.g:6933:6: (lv_featureCallArguments_8_0= ruleXShortClosure ) + // InternalExpression.g:6934:7: lv_featureCallArguments_8_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + + } + pushFollow(FOLLOW_8); + lv_featureCallArguments_8_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_8_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:6952:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) + { + // InternalExpression.g:6952:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) + // InternalExpression.g:6953:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* + { + // InternalExpression.g:6953:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) + // InternalExpression.g:6954:7: (lv_featureCallArguments_9_0= ruleXExpression ) + { + // InternalExpression.g:6954:7: (lv_featureCallArguments_9_0= ruleXExpression ) + // InternalExpression.g:6955:8: lv_featureCallArguments_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + + } + pushFollow(FOLLOW_27); + lv_featureCallArguments_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:6972:6: (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* + loop105: + do { + int alt105=2; + int LA105_0 = input.LA(1); + + if ( (LA105_0==44) ) { + alt105=1; + } + + + switch (alt105) { + case 1 : + // InternalExpression.g:6973:7: otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) + { + otherlv_10=(Token)match(input,44,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + + } + // InternalExpression.g:6977:7: ( (lv_featureCallArguments_11_0= ruleXExpression ) ) + // InternalExpression.g:6978:8: (lv_featureCallArguments_11_0= ruleXExpression ) + { + // InternalExpression.g:6978:8: (lv_featureCallArguments_11_0= ruleXExpression ) + // InternalExpression.g:6979:9: lv_featureCallArguments_11_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + + } + pushFollow(FOLLOW_27); + lv_featureCallArguments_11_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop105; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_12=(Token)match(input,18,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + + } + + } + break; + + } + + // InternalExpression.g:7004:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? + int alt108=2; + alt108 = dfa108.predict(input); + switch (alt108) { + case 1 : + // InternalExpression.g:7005:4: ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) + { + // InternalExpression.g:7011:4: (lv_featureCallArguments_13_0= ruleXClosure ) + // InternalExpression.g:7012:5: lv_featureCallArguments_13_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_2); + lv_featureCallArguments_13_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_13_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFeatureCall" + + + // $ANTLR start "entryRuleFeatureCallID" + // InternalExpression.g:7033:1: entryRuleFeatureCallID returns [String current=null] : iv_ruleFeatureCallID= ruleFeatureCallID EOF ; + public final String entryRuleFeatureCallID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleFeatureCallID = null; + + + try { + // InternalExpression.g:7033:53: (iv_ruleFeatureCallID= ruleFeatureCallID EOF ) + // InternalExpression.g:7034:2: iv_ruleFeatureCallID= ruleFeatureCallID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleFeatureCallID=ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleFeatureCallID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFeatureCallID" + + + // $ANTLR start "ruleFeatureCallID" + // InternalExpression.g:7040:1: ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ; + public final AntlrDatatypeRuleToken ruleFeatureCallID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7046:2: ( (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ) + // InternalExpression.g:7047:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) + { + // InternalExpression.g:7047:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) + int alt109=5; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt109=1; + } + break; + case 92: + { + alt109=2; + } + break; + case 93: + { + alt109=3; + } + break; + case 94: + { + alt109=4; + } + break; + case 95: + { + alt109=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 109, 0, input); + + throw nvae; + } + + switch (alt109) { + case 1 : + // InternalExpression.g:7048:3: this_ValidID_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:7059:3: kw= 'extends' + { + kw=(Token)match(input,92,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + + } + + } + break; + case 3 : + // InternalExpression.g:7065:3: kw= 'static' + { + kw=(Token)match(input,93,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + + } + + } + break; + case 4 : + // InternalExpression.g:7071:3: kw= 'import' + { + kw=(Token)match(input,94,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + + } + + } + break; + case 5 : + // InternalExpression.g:7077:3: kw= 'extension' + { + kw=(Token)match(input,95,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFeatureCallID" + + + // $ANTLR start "entryRuleIdOrSuper" + // InternalExpression.g:7086:1: entryRuleIdOrSuper returns [String current=null] : iv_ruleIdOrSuper= ruleIdOrSuper EOF ; + public final String entryRuleIdOrSuper() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleIdOrSuper = null; + + + try { + // InternalExpression.g:7086:49: (iv_ruleIdOrSuper= ruleIdOrSuper EOF ) + // InternalExpression.g:7087:2: iv_ruleIdOrSuper= ruleIdOrSuper EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_1); + iv_ruleIdOrSuper=ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleIdOrSuper.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleIdOrSuper" + + + // $ANTLR start "ruleIdOrSuper" + // InternalExpression.g:7093:1: ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ; + public final AntlrDatatypeRuleToken ruleIdOrSuper() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_FeatureCallID_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7099:2: ( (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ) + // InternalExpression.g:7100:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) + { + // InternalExpression.g:7100:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) + int alt110=2; + int LA110_0 = input.LA(1); + + if ( (LA110_0==RULE_ID||(LA110_0>=92 && LA110_0<=95)) ) { + alt110=1; + } + else if ( (LA110_0==96) ) { + alt110=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 110, 0, input); + + throw nvae; + } + switch (alt110) { + case 1 : + // InternalExpression.g:7101:3: this_FeatureCallID_0= ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_FeatureCallID_0=ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_FeatureCallID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:7112:3: kw= 'super' + { + kw=(Token)match(input,96,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleIdOrSuper" + + + // $ANTLR start "entryRuleXConstructorCall" + // InternalExpression.g:7121:1: entryRuleXConstructorCall returns [EObject current=null] : iv_ruleXConstructorCall= ruleXConstructorCall EOF ; + public final EObject entryRuleXConstructorCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXConstructorCall = null; + + + try { + // InternalExpression.g:7121:57: (iv_ruleXConstructorCall= ruleXConstructorCall EOF ) + // InternalExpression.g:7122:2: iv_ruleXConstructorCall= ruleXConstructorCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXConstructorCall=ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXConstructorCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXConstructorCall" + + + // $ANTLR start "ruleXConstructorCall" + // InternalExpression.g:7128:1: ruleXConstructorCall returns [EObject current=null] : ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ; + public final EObject ruleXConstructorCall() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token lv_explicitConstructorCall_8_0=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_typeArguments_4_0 = null; + + EObject lv_typeArguments_6_0 = null; + + EObject lv_arguments_9_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + EObject lv_arguments_14_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7134:2: ( ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ) + // InternalExpression.g:7135:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) + { + // InternalExpression.g:7135:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) + // InternalExpression.g:7136:3: () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? + { + // InternalExpression.g:7136:3: () + // InternalExpression.g:7137:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,59,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + + } + // InternalExpression.g:7147:3: ( ( ruleQualifiedName ) ) + // InternalExpression.g:7148:4: ( ruleQualifiedName ) + { + // InternalExpression.g:7148:4: ( ruleQualifiedName ) + // InternalExpression.g:7149:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + + } + pushFollow(FOLLOW_83); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:7163:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? + int alt112=2; + alt112 = dfa112.predict(input); + switch (alt112) { + case 1 : + // InternalExpression.g:7164:4: ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' + { + // InternalExpression.g:7164:4: ( ( '<' )=>otherlv_3= '<' ) + // InternalExpression.g:7165:5: ( '<' )=>otherlv_3= '<' + { + otherlv_3=(Token)match(input,37,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + + } + + } + + // InternalExpression.g:7171:4: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:7172:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:7172:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:7173:6: lv_typeArguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_55); + lv_typeArguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:7190:4: (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* + loop111: + do { + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==44) ) { + alt111=1; + } + + + switch (alt111) { + case 1 : + // InternalExpression.g:7191:5: otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_5=(Token)match(input,44,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + + } + // InternalExpression.g:7195:5: ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:7196:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:7196:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:7197:7: lv_typeArguments_6_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + + } + pushFollow(FOLLOW_55); + lv_typeArguments_6_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop111; + } + } while (true); + + otherlv_7=(Token)match(input,36,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + + } + + } + break; + + } + + // InternalExpression.g:7220:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? + int alt115=2; + alt115 = dfa115.predict(input); + switch (alt115) { + case 1 : + // InternalExpression.g:7221:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' + { + // InternalExpression.g:7221:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) + // InternalExpression.g:7222:5: ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) + { + // InternalExpression.g:7226:5: (lv_explicitConstructorCall_8_0= '(' ) + // InternalExpression.g:7227:6: lv_explicitConstructorCall_8_0= '(' + { + lv_explicitConstructorCall_8_0=(Token)match(input,17,FOLLOW_57); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + setWithLastConsumed(current, "explicitConstructorCall", lv_explicitConstructorCall_8_0 != null, "("); + + } + + } + + + } + + // InternalExpression.g:7239:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? + int alt114=3; + alt114 = dfa114.predict(input); + switch (alt114) { + case 1 : + // InternalExpression.g:7240:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) + { + // InternalExpression.g:7240:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) + // InternalExpression.g:7241:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) + { + // InternalExpression.g:7266:6: (lv_arguments_9_0= ruleXShortClosure ) + // InternalExpression.g:7267:7: lv_arguments_9_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + + } + pushFollow(FOLLOW_8); + lv_arguments_9_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:7285:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) + { + // InternalExpression.g:7285:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) + // InternalExpression.g:7286:6: ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* + { + // InternalExpression.g:7286:6: ( (lv_arguments_10_0= ruleXExpression ) ) + // InternalExpression.g:7287:7: (lv_arguments_10_0= ruleXExpression ) + { + // InternalExpression.g:7287:7: (lv_arguments_10_0= ruleXExpression ) + // InternalExpression.g:7288:8: lv_arguments_10_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + + } + pushFollow(FOLLOW_27); + lv_arguments_10_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:7305:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* + loop113: + do { + int alt113=2; + int LA113_0 = input.LA(1); + + if ( (LA113_0==44) ) { + alt113=1; + } + + + switch (alt113) { + case 1 : + // InternalExpression.g:7306:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) + { + otherlv_11=(Token)match(input,44,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + + } + // InternalExpression.g:7310:7: ( (lv_arguments_12_0= ruleXExpression ) ) + // InternalExpression.g:7311:8: (lv_arguments_12_0= ruleXExpression ) + { + // InternalExpression.g:7311:8: (lv_arguments_12_0= ruleXExpression ) + // InternalExpression.g:7312:9: lv_arguments_12_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + + } + pushFollow(FOLLOW_27); + lv_arguments_12_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop113; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_13=(Token)match(input,18,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + + } + + } + break; + + } + + // InternalExpression.g:7337:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? + int alt116=2; + alt116 = dfa116.predict(input); + switch (alt116) { + case 1 : + // InternalExpression.g:7338:4: ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) + { + // InternalExpression.g:7344:4: (lv_arguments_14_0= ruleXClosure ) + // InternalExpression.g:7345:5: lv_arguments_14_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_2); + lv_arguments_14_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_14_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXConstructorCall" + + + // $ANTLR start "entryRuleXBooleanLiteral" + // InternalExpression.g:7366:1: entryRuleXBooleanLiteral returns [EObject current=null] : iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ; + public final EObject entryRuleXBooleanLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBooleanLiteral = null; + + + try { + // InternalExpression.g:7366:56: (iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ) + // InternalExpression.g:7367:2: iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBooleanLiteral=ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBooleanLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBooleanLiteral" + + + // $ANTLR start "ruleXBooleanLiteral" + // InternalExpression.g:7373:1: ruleXBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ; + public final EObject ruleXBooleanLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_isTrue_2_0=null; + + + enterRule(); + + try { + // InternalExpression.g:7379:2: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ) + // InternalExpression.g:7380:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) + { + // InternalExpression.g:7380:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) + // InternalExpression.g:7381:3: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) + { + // InternalExpression.g:7381:3: () + // InternalExpression.g:7382:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(), + current); + + } + + } + + // InternalExpression.g:7388:3: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==56) ) { + alt117=1; + } + else if ( (LA117_0==55) ) { + alt117=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 117, 0, input); + + throw nvae; + } + switch (alt117) { + case 1 : + // InternalExpression.g:7389:4: otherlv_1= 'false' + { + otherlv_1=(Token)match(input,56,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:7394:4: ( (lv_isTrue_2_0= 'true' ) ) + { + // InternalExpression.g:7394:4: ( (lv_isTrue_2_0= 'true' ) ) + // InternalExpression.g:7395:5: (lv_isTrue_2_0= 'true' ) + { + // InternalExpression.g:7395:5: (lv_isTrue_2_0= 'true' ) + // InternalExpression.g:7396:6: lv_isTrue_2_0= 'true' + { + lv_isTrue_2_0=(Token)match(input,55,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXBooleanLiteralRule()); + } + setWithLastConsumed(current, "isTrue", lv_isTrue_2_0 != null, "true"); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBooleanLiteral" + + + // $ANTLR start "entryRuleXNullLiteral" + // InternalExpression.g:7413:1: entryRuleXNullLiteral returns [EObject current=null] : iv_ruleXNullLiteral= ruleXNullLiteral EOF ; + public final EObject entryRuleXNullLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXNullLiteral = null; + + + try { + // InternalExpression.g:7413:53: (iv_ruleXNullLiteral= ruleXNullLiteral EOF ) + // InternalExpression.g:7414:2: iv_ruleXNullLiteral= ruleXNullLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXNullLiteral=ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXNullLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXNullLiteral" + + + // $ANTLR start "ruleXNullLiteral" + // InternalExpression.g:7420:1: ruleXNullLiteral returns [EObject current=null] : ( () otherlv_1= 'null' ) ; + public final EObject ruleXNullLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalExpression.g:7426:2: ( ( () otherlv_1= 'null' ) ) + // InternalExpression.g:7427:2: ( () otherlv_1= 'null' ) + { + // InternalExpression.g:7427:2: ( () otherlv_1= 'null' ) + // InternalExpression.g:7428:3: () otherlv_1= 'null' + { + // InternalExpression.g:7428:3: () + // InternalExpression.g:7429:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXNullLiteral" + + + // $ANTLR start "entryRuleXNumberLiteral" + // InternalExpression.g:7443:1: entryRuleXNumberLiteral returns [EObject current=null] : iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ; + public final EObject entryRuleXNumberLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXNumberLiteral = null; + + + try { + // InternalExpression.g:7443:55: (iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ) + // InternalExpression.g:7444:2: iv_ruleXNumberLiteral= ruleXNumberLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXNumberLiteral=ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXNumberLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXNumberLiteral" + + + // $ANTLR start "ruleXNumberLiteral" + // InternalExpression.g:7450:1: ruleXNumberLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleNumber ) ) ) ; + public final EObject ruleXNumberLiteral() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7456:2: ( ( () ( (lv_value_1_0= ruleNumber ) ) ) ) + // InternalExpression.g:7457:2: ( () ( (lv_value_1_0= ruleNumber ) ) ) + { + // InternalExpression.g:7457:2: ( () ( (lv_value_1_0= ruleNumber ) ) ) + // InternalExpression.g:7458:3: () ( (lv_value_1_0= ruleNumber ) ) + { + // InternalExpression.g:7458:3: () + // InternalExpression.g:7459:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(), + current); + + } + + } + + // InternalExpression.g:7465:3: ( (lv_value_1_0= ruleNumber ) ) + // InternalExpression.g:7466:4: (lv_value_1_0= ruleNumber ) + { + // InternalExpression.g:7466:4: (lv_value_1_0= ruleNumber ) + // InternalExpression.g:7467:5: lv_value_1_0= ruleNumber + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_value_1_0=ruleNumber(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXNumberLiteralRule()); + } + set( + current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xbase.Number"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXNumberLiteral" + + + // $ANTLR start "entryRuleXStringLiteral" + // InternalExpression.g:7488:1: entryRuleXStringLiteral returns [EObject current=null] : iv_ruleXStringLiteral= ruleXStringLiteral EOF ; + public final EObject entryRuleXStringLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXStringLiteral = null; + + + try { + // InternalExpression.g:7488:55: (iv_ruleXStringLiteral= ruleXStringLiteral EOF ) + // InternalExpression.g:7489:2: iv_ruleXStringLiteral= ruleXStringLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXStringLiteral=ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXStringLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXStringLiteral" + + + // $ANTLR start "ruleXStringLiteral" + // InternalExpression.g:7495:1: ruleXStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ; + public final EObject ruleXStringLiteral() throws RecognitionException { + EObject current = null; + + Token lv_value_1_0=null; + + + enterRule(); + + try { + // InternalExpression.g:7501:2: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) ) + // InternalExpression.g:7502:2: ( () ( (lv_value_1_0= RULE_STRING ) ) ) + { + // InternalExpression.g:7502:2: ( () ( (lv_value_1_0= RULE_STRING ) ) ) + // InternalExpression.g:7503:3: () ( (lv_value_1_0= RULE_STRING ) ) + { + // InternalExpression.g:7503:3: () + // InternalExpression.g:7504:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(), + current); + + } + + } + + // InternalExpression.g:7510:3: ( (lv_value_1_0= RULE_STRING ) ) + // InternalExpression.g:7511:4: (lv_value_1_0= RULE_STRING ) + { + // InternalExpression.g:7511:4: (lv_value_1_0= RULE_STRING ) + // InternalExpression.g:7512:5: lv_value_1_0= RULE_STRING + { + lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXStringLiteralRule()); + } + setWithLastConsumed( + current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXStringLiteral" + + + // $ANTLR start "entryRuleXTypeLiteral" + // InternalExpression.g:7532:1: entryRuleXTypeLiteral returns [EObject current=null] : iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ; + public final EObject entryRuleXTypeLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXTypeLiteral = null; + + + try { + // InternalExpression.g:7532:53: (iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ) + // InternalExpression.g:7533:2: iv_ruleXTypeLiteral= ruleXTypeLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXTypeLiteral=ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXTypeLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXTypeLiteral" + + + // $ANTLR start "ruleXTypeLiteral" + // InternalExpression.g:7539:1: ruleXTypeLiteral returns [EObject current=null] : ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ; + public final EObject ruleXTypeLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_5=null; + AntlrDatatypeRuleToken lv_arrayDimensions_4_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7545:2: ( ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ) + // InternalExpression.g:7546:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) + { + // InternalExpression.g:7546:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) + // InternalExpression.g:7547:3: () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' + { + // InternalExpression.g:7547:3: () + // InternalExpression.g:7548:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,97,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + + } + otherlv_2=(Token)match(input,17,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + + } + // InternalExpression.g:7562:3: ( ( ruleQualifiedName ) ) + // InternalExpression.g:7563:4: ( ruleQualifiedName ) + { + // InternalExpression.g:7563:4: ( ruleQualifiedName ) + // InternalExpression.g:7564:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXTypeLiteralRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + + } + pushFollow(FOLLOW_84); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:7578:3: ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* + loop118: + do { + int alt118=2; + int LA118_0 = input.LA(1); + + if ( (LA118_0==63) ) { + alt118=1; + } + + + switch (alt118) { + case 1 : + // InternalExpression.g:7579:4: (lv_arrayDimensions_4_0= ruleArrayBrackets ) + { + // InternalExpression.g:7579:4: (lv_arrayDimensions_4_0= ruleArrayBrackets ) + // InternalExpression.g:7580:5: lv_arrayDimensions_4_0= ruleArrayBrackets + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_84); + lv_arrayDimensions_4_0=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTypeLiteralRule()); + } + add( + current, + "arrayDimensions", + lv_arrayDimensions_4_0, + "org.eclipse.xtext.xbase.Xtype.ArrayBrackets"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop118; + } + } while (true); + + otherlv_5=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXTypeLiteral" + + + // $ANTLR start "entryRuleXThrowExpression" + // InternalExpression.g:7605:1: entryRuleXThrowExpression returns [EObject current=null] : iv_ruleXThrowExpression= ruleXThrowExpression EOF ; + public final EObject entryRuleXThrowExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXThrowExpression = null; + + + try { + // InternalExpression.g:7605:57: (iv_ruleXThrowExpression= ruleXThrowExpression EOF ) + // InternalExpression.g:7606:2: iv_ruleXThrowExpression= ruleXThrowExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXThrowExpression=ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXThrowExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXThrowExpression" + + + // $ANTLR start "ruleXThrowExpression" + // InternalExpression.g:7612:1: ruleXThrowExpression returns [EObject current=null] : ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ; + public final EObject ruleXThrowExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_expression_2_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7618:2: ( ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ) + // InternalExpression.g:7619:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) + { + // InternalExpression.g:7619:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) + // InternalExpression.g:7620:3: () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) + { + // InternalExpression.g:7620:3: () + // InternalExpression.g:7621:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,98,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + + } + // InternalExpression.g:7631:3: ( (lv_expression_2_0= ruleXExpression ) ) + // InternalExpression.g:7632:4: (lv_expression_2_0= ruleXExpression ) + { + // InternalExpression.g:7632:4: (lv_expression_2_0= ruleXExpression ) + // InternalExpression.g:7633:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXThrowExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXThrowExpression" + + + // $ANTLR start "entryRuleXReturnExpression" + // InternalExpression.g:7654:1: entryRuleXReturnExpression returns [EObject current=null] : iv_ruleXReturnExpression= ruleXReturnExpression EOF ; + public final EObject entryRuleXReturnExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXReturnExpression = null; + + + try { + // InternalExpression.g:7654:58: (iv_ruleXReturnExpression= ruleXReturnExpression EOF ) + // InternalExpression.g:7655:2: iv_ruleXReturnExpression= ruleXReturnExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXReturnExpression=ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXReturnExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXReturnExpression" + + + // $ANTLR start "ruleXReturnExpression" + // InternalExpression.g:7661:1: ruleXReturnExpression returns [EObject current=null] : ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ; + public final EObject ruleXReturnExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_expression_2_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7667:2: ( ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ) + // InternalExpression.g:7668:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) + { + // InternalExpression.g:7668:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) + // InternalExpression.g:7669:3: () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? + { + // InternalExpression.g:7669:3: () + // InternalExpression.g:7670:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,99,FOLLOW_85); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + + } + // InternalExpression.g:7680:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? + int alt119=2; + alt119 = dfa119.predict(input); + switch (alt119) { + case 1 : + // InternalExpression.g:7681:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) + { + // InternalExpression.g:7682:4: (lv_expression_2_0= ruleXExpression ) + // InternalExpression.g:7683:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXReturnExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXReturnExpression" + + + // $ANTLR start "entryRuleXTryCatchFinallyExpression" + // InternalExpression.g:7704:1: entryRuleXTryCatchFinallyExpression returns [EObject current=null] : iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ; + public final EObject entryRuleXTryCatchFinallyExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXTryCatchFinallyExpression = null; + + + try { + // InternalExpression.g:7704:67: (iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ) + // InternalExpression.g:7705:2: iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXTryCatchFinallyExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXTryCatchFinallyExpression" + + + // $ANTLR start "ruleXTryCatchFinallyExpression" + // InternalExpression.g:7711:1: ruleXTryCatchFinallyExpression returns [EObject current=null] : ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ; + public final EObject ruleXTryCatchFinallyExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_expression_2_0 = null; + + EObject lv_catchClauses_3_0 = null; + + EObject lv_finallyExpression_5_0 = null; + + EObject lv_finallyExpression_7_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7717:2: ( ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ) + // InternalExpression.g:7718:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) + { + // InternalExpression.g:7718:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) + // InternalExpression.g:7719:3: () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) + { + // InternalExpression.g:7719:3: () + // InternalExpression.g:7720:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,100,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + + } + // InternalExpression.g:7730:3: ( (lv_expression_2_0= ruleXExpression ) ) + // InternalExpression.g:7731:4: (lv_expression_2_0= ruleXExpression ) + { + // InternalExpression.g:7731:4: (lv_expression_2_0= ruleXExpression ) + // InternalExpression.g:7732:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_86); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:7749:3: ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) + int alt122=2; + int LA122_0 = input.LA(1); + + if ( (LA122_0==103) ) { + alt122=1; + } + else if ( (LA122_0==101) ) { + alt122=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 122, 0, input); + + throw nvae; + } + switch (alt122) { + case 1 : + // InternalExpression.g:7750:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) + { + // InternalExpression.g:7750:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) + // InternalExpression.g:7751:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? + { + // InternalExpression.g:7751:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ + int cnt120=0; + loop120: + do { + int alt120=2; + int LA120_0 = input.LA(1); + + if ( (LA120_0==103) ) { + int LA120_2 = input.LA(2); + + if ( (synpred40_InternalExpression()) ) { + alt120=1; + } + + + } + + + switch (alt120) { + case 1 : + // InternalExpression.g:7752:6: ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) + { + // InternalExpression.g:7753:6: (lv_catchClauses_3_0= ruleXCatchClause ) + // InternalExpression.g:7754:7: lv_catchClauses_3_0= ruleXCatchClause + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + + } + pushFollow(FOLLOW_87); + lv_catchClauses_3_0=ruleXCatchClause(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + add( + current, + "catchClauses", + lv_catchClauses_3_0, + "org.eclipse.xtext.xbase.Xbase.XCatchClause"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + if ( cnt120 >= 1 ) break loop120; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(120, input); + throw eee; + } + cnt120++; + } while (true); + + // InternalExpression.g:7771:5: ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? + int alt121=2; + int LA121_0 = input.LA(1); + + if ( (LA121_0==101) ) { + int LA121_1 = input.LA(2); + + if ( (synpred41_InternalExpression()) ) { + alt121=1; + } + } + switch (alt121) { + case 1 : + // InternalExpression.g:7772:6: ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) + { + // InternalExpression.g:7772:6: ( ( 'finally' )=>otherlv_4= 'finally' ) + // InternalExpression.g:7773:7: ( 'finally' )=>otherlv_4= 'finally' + { + otherlv_4=(Token)match(input,101,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + + } + + } + + // InternalExpression.g:7779:6: ( (lv_finallyExpression_5_0= ruleXExpression ) ) + // InternalExpression.g:7780:7: (lv_finallyExpression_5_0= ruleXExpression ) + { + // InternalExpression.g:7780:7: (lv_finallyExpression_5_0= ruleXExpression ) + // InternalExpression.g:7781:8: lv_finallyExpression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_finallyExpression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "finallyExpression", + lv_finallyExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:7801:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) + { + // InternalExpression.g:7801:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) + // InternalExpression.g:7802:5: otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) + { + otherlv_6=(Token)match(input,101,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + + } + // InternalExpression.g:7806:5: ( (lv_finallyExpression_7_0= ruleXExpression ) ) + // InternalExpression.g:7807:6: (lv_finallyExpression_7_0= ruleXExpression ) + { + // InternalExpression.g:7807:6: (lv_finallyExpression_7_0= ruleXExpression ) + // InternalExpression.g:7808:7: lv_finallyExpression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_finallyExpression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "finallyExpression", + lv_finallyExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXTryCatchFinallyExpression" + + + // $ANTLR start "entryRuleXSynchronizedExpression" + // InternalExpression.g:7831:1: entryRuleXSynchronizedExpression returns [EObject current=null] : iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ; + public final EObject entryRuleXSynchronizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSynchronizedExpression = null; + + + try { + // InternalExpression.g:7831:64: (iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ) + // InternalExpression.g:7832:2: iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSynchronizedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSynchronizedExpression" + + + // $ANTLR start "ruleXSynchronizedExpression" + // InternalExpression.g:7838:1: ruleXSynchronizedExpression returns [EObject current=null] : ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXSynchronizedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_param_3_0 = null; + + EObject lv_expression_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7844:2: ( ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ) + // InternalExpression.g:7845:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) + { + // InternalExpression.g:7845:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) + // InternalExpression.g:7846:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) + { + // InternalExpression.g:7846:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) + // InternalExpression.g:7847:4: ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) + { + // InternalExpression.g:7854:4: ( () otherlv_1= 'synchronized' otherlv_2= '(' ) + // InternalExpression.g:7855:5: () otherlv_1= 'synchronized' otherlv_2= '(' + { + // InternalExpression.g:7855:5: () + // InternalExpression.g:7856:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,102,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + + } + otherlv_2=(Token)match(input,17,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + + } + + } + + + } + + // InternalExpression.g:7872:3: ( (lv_param_3_0= ruleXExpression ) ) + // InternalExpression.g:7873:4: (lv_param_3_0= ruleXExpression ) + { + // InternalExpression.g:7873:4: (lv_param_3_0= ruleXExpression ) + // InternalExpression.g:7874:5: lv_param_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_8); + lv_param_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + current, + "param", + lv_param_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,18,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + + } + // InternalExpression.g:7895:3: ( (lv_expression_5_0= ruleXExpression ) ) + // InternalExpression.g:7896:4: (lv_expression_5_0= ruleXExpression ) + { + // InternalExpression.g:7896:4: (lv_expression_5_0= ruleXExpression ) + // InternalExpression.g:7897:5: lv_expression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSynchronizedExpression" + + + // $ANTLR start "entryRuleXCatchClause" + // InternalExpression.g:7918:1: entryRuleXCatchClause returns [EObject current=null] : iv_ruleXCatchClause= ruleXCatchClause EOF ; + public final EObject entryRuleXCatchClause() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCatchClause = null; + + + try { + // InternalExpression.g:7918:53: (iv_ruleXCatchClause= ruleXCatchClause EOF ) + // InternalExpression.g:7919:2: iv_ruleXCatchClause= ruleXCatchClause EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCatchClause=ruleXCatchClause(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCatchClause; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCatchClause" + + + // $ANTLR start "ruleXCatchClause" + // InternalExpression.g:7925:1: ruleXCatchClause returns [EObject current=null] : ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ; + public final EObject ruleXCatchClause() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + EObject lv_declaredParam_2_0 = null; + + EObject lv_expression_4_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:7931:2: ( ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ) + // InternalExpression.g:7932:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) + { + // InternalExpression.g:7932:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) + // InternalExpression.g:7933:3: ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) + { + // InternalExpression.g:7933:3: ( ( 'catch' )=>otherlv_0= 'catch' ) + // InternalExpression.g:7934:4: ( 'catch' )=>otherlv_0= 'catch' + { + otherlv_0=(Token)match(input,103,FOLLOW_25); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + + } + + } + + otherlv_1=(Token)match(input,17,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + + } + // InternalExpression.g:7944:3: ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) + // InternalExpression.g:7945:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) + { + // InternalExpression.g:7945:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) + // InternalExpression.g:7946:5: lv_declaredParam_2_0= ruleFullJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_8); + lv_declaredParam_2_0=ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_2_0, + "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_3=(Token)match(input,18,FOLLOW_36); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + + } + // InternalExpression.g:7967:3: ( (lv_expression_4_0= ruleXExpression ) ) + // InternalExpression.g:7968:4: (lv_expression_4_0= ruleXExpression ) + { + // InternalExpression.g:7968:4: (lv_expression_4_0= ruleXExpression ) + // InternalExpression.g:7969:5: lv_expression_4_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_4_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + current, + "expression", + lv_expression_4_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCatchClause" + + + // $ANTLR start "entryRuleQualifiedName" + // InternalExpression.g:7990:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + public final String entryRuleQualifiedName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedName = null; + + + try { + // InternalExpression.g:7990:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalExpression.g:7991:2: iv_ruleQualifiedName= ruleQualifiedName EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedName=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedName.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // InternalExpression.g:7997:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ; + public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + AntlrDatatypeRuleToken this_ValidID_2 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8003:2: ( (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ) + // InternalExpression.g:8004:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) + { + // InternalExpression.g:8004:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) + // InternalExpression.g:8005:3: this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_24); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:8015:3: ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* + loop123: + do { + int alt123=2; + int LA123_0 = input.LA(1); + + if ( (LA123_0==43) ) { + int LA123_2 = input.LA(2); + + if ( (LA123_2==RULE_ID) ) { + int LA123_3 = input.LA(3); + + if ( (synpred44_InternalExpression()) ) { + alt123=1; + } + + + } + + + } + + + switch (alt123) { + case 1 : + // InternalExpression.g:8016:4: ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID + { + // InternalExpression.g:8016:4: ( ( '.' )=>kw= '.' ) + // InternalExpression.g:8017:5: ( '.' )=>kw= '.' + { + kw=(Token)match(input,43,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + + } + pushFollow(FOLLOW_24); + this_ValidID_2=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_2); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + + default : + break loop123; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedName" + + + // $ANTLR start "entryRuleNumber" + // InternalExpression.g:8039:1: entryRuleNumber returns [String current=null] : iv_ruleNumber= ruleNumber EOF ; + public final String entryRuleNumber() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleNumber = null; + + + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // InternalExpression.g:8041:2: (iv_ruleNumber= ruleNumber EOF ) + // InternalExpression.g:8042:2: iv_ruleNumber= ruleNumber EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_1); + iv_ruleNumber=ruleNumber(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleNumber.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + + myHiddenTokenState.restore(); + + } + return current; + } + // $ANTLR end "entryRuleNumber" + + + // $ANTLR start "ruleNumber" + // InternalExpression.g:8051:1: ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ; + public final AntlrDatatypeRuleToken ruleNumber() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_HEX_0=null; + Token this_INT_1=null; + Token this_DECIMAL_2=null; + Token kw=null; + Token this_INT_4=null; + Token this_DECIMAL_5=null; + + + enterRule(); + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // InternalExpression.g:8058:2: ( (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ) + // InternalExpression.g:8059:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) + { + // InternalExpression.g:8059:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) + int alt127=2; + int LA127_0 = input.LA(1); + + if ( (LA127_0==RULE_HEX) ) { + alt127=1; + } + else if ( (LA127_0==RULE_INT||LA127_0==RULE_DECIMAL) ) { + alt127=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 127, 0, input); + + throw nvae; + } + switch (alt127) { + case 1 : + // InternalExpression.g:8060:3: this_HEX_0= RULE_HEX + { + this_HEX_0=(Token)match(input,RULE_HEX,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_HEX_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:8068:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) + { + // InternalExpression.g:8068:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) + // InternalExpression.g:8069:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? + { + // InternalExpression.g:8069:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) + int alt124=2; + int LA124_0 = input.LA(1); + + if ( (LA124_0==RULE_INT) ) { + alt124=1; + } + else if ( (LA124_0==RULE_DECIMAL) ) { + alt124=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 124, 0, input); + + throw nvae; + } + switch (alt124) { + case 1 : + // InternalExpression.g:8070:5: this_INT_1= RULE_INT + { + this_INT_1=(Token)match(input,RULE_INT,FOLLOW_24); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_INT_1); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:8078:5: this_DECIMAL_2= RULE_DECIMAL + { + this_DECIMAL_2=(Token)match(input,RULE_DECIMAL,FOLLOW_24); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_DECIMAL_2); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + + } + + } + break; + + } + + // InternalExpression.g:8086:4: (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? + int alt126=2; + int LA126_0 = input.LA(1); + + if ( (LA126_0==43) ) { + int LA126_1 = input.LA(2); + + if ( (LA126_1==RULE_INT||LA126_1==RULE_DECIMAL) ) { + alt126=1; + } + } + switch (alt126) { + case 1 : + // InternalExpression.g:8087:5: kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) + { + kw=(Token)match(input,43,FOLLOW_88); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + + } + // InternalExpression.g:8092:5: (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==RULE_INT) ) { + alt125=1; + } + else if ( (LA125_0==RULE_DECIMAL) ) { + alt125=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 125, 0, input); + + throw nvae; + } + switch (alt125) { + case 1 : + // InternalExpression.g:8093:6: this_INT_4= RULE_INT + { + this_INT_4=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_INT_4); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + + } + + } + break; + case 2 : + // InternalExpression.g:8101:6: this_DECIMAL_5= RULE_DECIMAL + { + this_DECIMAL_5=(Token)match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_DECIMAL_5); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + + } + + } + break; + + } + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + + myHiddenTokenState.restore(); + + } + return current; + } + // $ANTLR end "ruleNumber" + + + // $ANTLR start "entryRuleJvmTypeReference" + // InternalExpression.g:8118:1: entryRuleJvmTypeReference returns [EObject current=null] : iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ; + public final EObject entryRuleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmTypeReference = null; + + + try { + // InternalExpression.g:8118:57: (iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ) + // InternalExpression.g:8119:2: iv_ruleJvmTypeReference= ruleJvmTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmTypeReference=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmTypeReference" + + + // $ANTLR start "ruleJvmTypeReference" + // InternalExpression.g:8125:1: ruleJvmTypeReference returns [EObject current=null] : ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ; + public final EObject ruleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmParameterizedTypeReference_0 = null; + + EObject this_XFunctionTypeRef_3 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8131:2: ( ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ) + // InternalExpression.g:8132:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + { + // InternalExpression.g:8132:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + int alt129=2; + int LA129_0 = input.LA(1); + + if ( (LA129_0==RULE_ID) ) { + alt129=1; + } + else if ( (LA129_0==17||LA129_0==76) ) { + alt129=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 129, 0, input); + + throw nvae; + } + switch (alt129) { + case 1 : + // InternalExpression.g:8133:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + { + // InternalExpression.g:8133:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + // InternalExpression.g:8134:4: this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_82); + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmParameterizedTypeReference_0; + afterParserOrEnumRuleCall(); + + } + // InternalExpression.g:8142:4: ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + loop128: + do { + int alt128=2; + int LA128_0 = input.LA(1); + + if ( (LA128_0==63) ) { + int LA128_2 = input.LA(2); + + if ( (LA128_2==64) ) { + int LA128_3 = input.LA(3); + + if ( (synpred45_InternalExpression()) ) { + alt128=1; + } + + + } + + + } + + + switch (alt128) { + case 1 : + // InternalExpression.g:8143:5: ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) + { + // InternalExpression.g:8149:5: ( () ruleArrayBrackets ) + // InternalExpression.g:8150:6: () ruleArrayBrackets + { + // InternalExpression.g:8150:6: () + // InternalExpression.g:8151:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + current); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + + } + pushFollow(FOLLOW_82); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop128; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalExpression.g:8168:3: this_XFunctionTypeRef_3= ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XFunctionTypeRef_3=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFunctionTypeRef_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmTypeReference" + + + // $ANTLR start "entryRuleArrayBrackets" + // InternalExpression.g:8180:1: entryRuleArrayBrackets returns [String current=null] : iv_ruleArrayBrackets= ruleArrayBrackets EOF ; + public final String entryRuleArrayBrackets() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleArrayBrackets = null; + + + try { + // InternalExpression.g:8180:53: (iv_ruleArrayBrackets= ruleArrayBrackets EOF ) + // InternalExpression.g:8181:2: iv_ruleArrayBrackets= ruleArrayBrackets EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + iv_ruleArrayBrackets=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleArrayBrackets.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArrayBrackets" + + + // $ANTLR start "ruleArrayBrackets" + // InternalExpression.g:8187:1: ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' kw= ']' ) ; + public final AntlrDatatypeRuleToken ruleArrayBrackets() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalExpression.g:8193:2: ( (kw= '[' kw= ']' ) ) + // InternalExpression.g:8194:2: (kw= '[' kw= ']' ) + { + // InternalExpression.g:8194:2: (kw= '[' kw= ']' ) + // InternalExpression.g:8195:3: kw= '[' kw= ']' + { + kw=(Token)match(input,63,FOLLOW_34); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + + } + kw=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArrayBrackets" + + + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalExpression.g:8209:1: entryRuleXFunctionTypeRef returns [EObject current=null] : iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ; + public final EObject entryRuleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFunctionTypeRef = null; + + + try { + // InternalExpression.g:8209:57: (iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ) + // InternalExpression.g:8210:2: iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFunctionTypeRef; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFunctionTypeRef" + + + // $ANTLR start "ruleXFunctionTypeRef" + // InternalExpression.g:8216:1: ruleXFunctionTypeRef returns [EObject current=null] : ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_5=null; + EObject lv_paramTypes_1_0 = null; + + EObject lv_paramTypes_3_0 = null; + + EObject lv_returnType_6_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8222:2: ( ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ) + // InternalExpression.g:8223:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + { + // InternalExpression.g:8223:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + // InternalExpression.g:8224:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + { + // InternalExpression.g:8224:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? + int alt132=2; + int LA132_0 = input.LA(1); + + if ( (LA132_0==17) ) { + alt132=1; + } + switch (alt132) { + case 1 : + // InternalExpression.g:8225:4: otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' + { + otherlv_0=(Token)match(input,17,FOLLOW_89); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + + } + // InternalExpression.g:8229:4: ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? + int alt131=2; + int LA131_0 = input.LA(1); + + if ( (LA131_0==RULE_ID||LA131_0==17||LA131_0==76) ) { + alt131=1; + } + switch (alt131) { + case 1 : + // InternalExpression.g:8230:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + { + // InternalExpression.g:8230:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8231:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8231:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + // InternalExpression.g:8232:7: lv_paramTypes_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + + } + pushFollow(FOLLOW_27); + lv_paramTypes_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8249:5: (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + loop130: + do { + int alt130=2; + int LA130_0 = input.LA(1); + + if ( (LA130_0==44) ) { + alt130=1; + } + + + switch (alt130) { + case 1 : + // InternalExpression.g:8250:6: otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + { + otherlv_2=(Token)match(input,44,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + + } + // InternalExpression.g:8254:6: ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8255:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8255:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + // InternalExpression.g:8256:8: lv_paramTypes_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + + } + pushFollow(FOLLOW_27); + lv_paramTypes_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop130; + } + } while (true); + + + } + break; + + } + + otherlv_4=(Token)match(input,18,FOLLOW_90); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + + } + + } + break; + + } + + otherlv_5=(Token)match(input,76,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + + } + // InternalExpression.g:8284:3: ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8285:4: (lv_returnType_6_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8285:4: (lv_returnType_6_0= ruleJvmTypeReference ) + // InternalExpression.g:8286:5: lv_returnType_6_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_returnType_6_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFunctionTypeRef" + + + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalExpression.g:8307:1: entryRuleJvmParameterizedTypeReference returns [EObject current=null] : iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ; + public final EObject entryRuleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmParameterizedTypeReference = null; + + + try { + // InternalExpression.g:8307:70: (iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ) + // InternalExpression.g:8308:2: iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmParameterizedTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmParameterizedTypeReference" + + + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalExpression.g:8314:1: ruleJvmParameterizedTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ; + public final EObject ruleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token otherlv_9=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_arguments_2_0 = null; + + EObject lv_arguments_4_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8320:2: ( ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ) + // InternalExpression.g:8321:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + { + // InternalExpression.g:8321:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + // InternalExpression.g:8322:3: ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + { + // InternalExpression.g:8322:3: ( ( ruleQualifiedName ) ) + // InternalExpression.g:8323:4: ( ruleQualifiedName ) + { + // InternalExpression.g:8323:4: ( ruleQualifiedName ) + // InternalExpression.g:8324:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + + } + pushFollow(FOLLOW_91); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8338:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + int alt137=2; + alt137 = dfa137.predict(input); + switch (alt137) { + case 1 : + // InternalExpression.g:8339:4: ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + { + // InternalExpression.g:8339:4: ( ( '<' )=>otherlv_1= '<' ) + // InternalExpression.g:8340:5: ( '<' )=>otherlv_1= '<' + { + otherlv_1=(Token)match(input,37,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + + } + + } + + // InternalExpression.g:8346:4: ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:8347:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:8347:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:8348:6: lv_arguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_55); + lv_arguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8365:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop133: + do { + int alt133=2; + int LA133_0 = input.LA(1); + + if ( (LA133_0==44) ) { + alt133=1; + } + + + switch (alt133) { + case 1 : + // InternalExpression.g:8366:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,44,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + + } + // InternalExpression.g:8370:5: ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:8371:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:8371:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:8372:7: lv_arguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_55); + lv_arguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop133; + } + } while (true); + + otherlv_5=(Token)match(input,36,FOLLOW_24); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + + } + // InternalExpression.g:8394:4: ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + loop136: + do { + int alt136=2; + int LA136_0 = input.LA(1); + + if ( (LA136_0==43) ) { + int LA136_2 = input.LA(2); + + if ( (LA136_2==RULE_ID) ) { + int LA136_3 = input.LA(3); + + if ( (synpred47_InternalExpression()) ) { + alt136=1; + } + + + } + + + } + + + switch (alt136) { + case 1 : + // InternalExpression.g:8395:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + { + // InternalExpression.g:8395:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) + // InternalExpression.g:8396:6: ( ( () '.' ) )=> ( () otherlv_7= '.' ) + { + // InternalExpression.g:8402:6: ( () otherlv_7= '.' ) + // InternalExpression.g:8403:7: () otherlv_7= '.' + { + // InternalExpression.g:8403:7: () + // InternalExpression.g:8404:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + current); + + } + + } + + otherlv_7=(Token)match(input,43,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + + } + + } + + + } + + // InternalExpression.g:8416:5: ( ( ruleValidID ) ) + // InternalExpression.g:8417:6: ( ruleValidID ) + { + // InternalExpression.g:8417:6: ( ruleValidID ) + // InternalExpression.g:8418:7: ruleValidID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + + } + pushFollow(FOLLOW_92); + ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8432:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + int alt135=2; + alt135 = dfa135.predict(input); + switch (alt135) { + case 1 : + // InternalExpression.g:8433:6: ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' + { + // InternalExpression.g:8433:6: ( ( '<' )=>otherlv_9= '<' ) + // InternalExpression.g:8434:7: ( '<' )=>otherlv_9= '<' + { + otherlv_9=(Token)match(input,37,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + + } + + } + + // InternalExpression.g:8440:6: ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:8441:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:8441:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:8442:8: lv_arguments_10_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + + } + pushFollow(FOLLOW_55); + lv_arguments_10_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8459:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* + loop134: + do { + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==44) ) { + alt134=1; + } + + + switch (alt134) { + case 1 : + // InternalExpression.g:8460:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_11=(Token)match(input,44,FOLLOW_54); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + + } + // InternalExpression.g:8464:7: ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalExpression.g:8465:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalExpression.g:8465:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + // InternalExpression.g:8466:9: lv_arguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + + } + pushFollow(FOLLOW_55); + lv_arguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop134; + } + } while (true); + + otherlv_13=(Token)match(input,36,FOLLOW_24); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + + } + + } + break; + + } + + + } + break; + + default : + break loop136; + } + } while (true); + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmParameterizedTypeReference" + + + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalExpression.g:8495:1: entryRuleJvmArgumentTypeReference returns [EObject current=null] : iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ; + public final EObject entryRuleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmArgumentTypeReference = null; + + + try { + // InternalExpression.g:8495:65: (iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ) + // InternalExpression.g:8496:2: iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmArgumentTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmArgumentTypeReference" + + + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalExpression.g:8502:1: ruleJvmArgumentTypeReference returns [EObject current=null] : (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ; + public final EObject ruleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmTypeReference_0 = null; + + EObject this_JvmWildcardTypeReference_1 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8508:2: ( (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ) + // InternalExpression.g:8509:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + { + // InternalExpression.g:8509:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + int alt138=2; + int LA138_0 = input.LA(1); + + if ( (LA138_0==RULE_ID||LA138_0==17||LA138_0==76) ) { + alt138=1; + } + else if ( (LA138_0==20) ) { + alt138=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 138, 0, input); + + throw nvae; + } + switch (alt138) { + case 1 : + // InternalExpression.g:8510:3: this_JvmTypeReference_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_JvmTypeReference_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmTypeReference_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalExpression.g:8519:3: this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmWildcardTypeReference_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmArgumentTypeReference" + + + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalExpression.g:8531:1: entryRuleJvmWildcardTypeReference returns [EObject current=null] : iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ; + public final EObject entryRuleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmWildcardTypeReference = null; + + + try { + // InternalExpression.g:8531:65: (iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ) + // InternalExpression.g:8532:2: iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmWildcardTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmWildcardTypeReference" + + + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalExpression.g:8538:1: ruleJvmWildcardTypeReference returns [EObject current=null] : ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ; + public final EObject ruleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_constraints_2_0 = null; + + EObject lv_constraints_3_0 = null; + + EObject lv_constraints_4_0 = null; + + EObject lv_constraints_5_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8544:2: ( ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ) + // InternalExpression.g:8545:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + { + // InternalExpression.g:8545:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + // InternalExpression.g:8546:3: () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + { + // InternalExpression.g:8546:3: () + // InternalExpression.g:8547:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,20,FOLLOW_93); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + + } + // InternalExpression.g:8557:3: ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + int alt141=3; + int LA141_0 = input.LA(1); + + if ( (LA141_0==92) ) { + alt141=1; + } + else if ( (LA141_0==96) ) { + alt141=2; + } + switch (alt141) { + case 1 : + // InternalExpression.g:8558:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + { + // InternalExpression.g:8558:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + // InternalExpression.g:8559:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + { + // InternalExpression.g:8559:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) + // InternalExpression.g:8560:6: (lv_constraints_2_0= ruleJvmUpperBound ) + { + // InternalExpression.g:8560:6: (lv_constraints_2_0= ruleJvmUpperBound ) + // InternalExpression.g:8561:7: lv_constraints_2_0= ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + + } + pushFollow(FOLLOW_94); + lv_constraints_2_0=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8578:5: ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + loop139: + do { + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==104) ) { + alt139=1; + } + + + switch (alt139) { + case 1 : + // InternalExpression.g:8579:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + { + // InternalExpression.g:8579:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + // InternalExpression.g:8580:7: lv_constraints_3_0= ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_94); + lv_constraints_3_0=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop139; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalExpression.g:8599:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + { + // InternalExpression.g:8599:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + // InternalExpression.g:8600:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + { + // InternalExpression.g:8600:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) + // InternalExpression.g:8601:6: (lv_constraints_4_0= ruleJvmLowerBound ) + { + // InternalExpression.g:8601:6: (lv_constraints_4_0= ruleJvmLowerBound ) + // InternalExpression.g:8602:7: lv_constraints_4_0= ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + + } + pushFollow(FOLLOW_94); + lv_constraints_4_0=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8619:5: ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + loop140: + do { + int alt140=2; + int LA140_0 = input.LA(1); + + if ( (LA140_0==104) ) { + alt140=1; + } + + + switch (alt140) { + case 1 : + // InternalExpression.g:8620:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + { + // InternalExpression.g:8620:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + // InternalExpression.g:8621:7: lv_constraints_5_0= ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_94); + lv_constraints_5_0=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop140; + } + } while (true); + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmWildcardTypeReference" + + + // $ANTLR start "entryRuleJvmUpperBound" + // InternalExpression.g:8644:1: entryRuleJvmUpperBound returns [EObject current=null] : iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ; + public final EObject entryRuleJvmUpperBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBound = null; + + + try { + // InternalExpression.g:8644:54: (iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ) + // InternalExpression.g:8645:2: iv_ruleJvmUpperBound= ruleJvmUpperBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBound=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBound" + + + // $ANTLR start "ruleJvmUpperBound" + // InternalExpression.g:8651:1: ruleJvmUpperBound returns [EObject current=null] : (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8657:2: ( (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExpression.g:8658:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExpression.g:8658:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExpression.g:8659:3: otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,92,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + + } + // InternalExpression.g:8663:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8664:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8664:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExpression.g:8665:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBound" + + + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalExpression.g:8686:1: entryRuleJvmUpperBoundAnded returns [EObject current=null] : iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ; + public final EObject entryRuleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBoundAnded = null; + + + try { + // InternalExpression.g:8686:59: (iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ) + // InternalExpression.g:8687:2: iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBoundAnded" + + + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalExpression.g:8693:1: ruleJvmUpperBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8699:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExpression.g:8700:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExpression.g:8700:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExpression.g:8701:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,104,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalExpression.g:8705:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8706:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8706:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExpression.g:8707:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBoundAnded" + + + // $ANTLR start "entryRuleJvmLowerBound" + // InternalExpression.g:8728:1: entryRuleJvmLowerBound returns [EObject current=null] : iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ; + public final EObject entryRuleJvmLowerBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBound = null; + + + try { + // InternalExpression.g:8728:54: (iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ) + // InternalExpression.g:8729:2: iv_ruleJvmLowerBound= ruleJvmLowerBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBound=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBound" + + + // $ANTLR start "ruleJvmLowerBound" + // InternalExpression.g:8735:1: ruleJvmLowerBound returns [EObject current=null] : (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8741:2: ( (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExpression.g:8742:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExpression.g:8742:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExpression.g:8743:3: otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,96,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + + } + // InternalExpression.g:8747:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8748:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8748:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExpression.g:8749:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBound" + + + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalExpression.g:8770:1: entryRuleJvmLowerBoundAnded returns [EObject current=null] : iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ; + public final EObject entryRuleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBoundAnded = null; + + + try { + // InternalExpression.g:8770:59: (iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ) + // InternalExpression.g:8771:2: iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBoundAnded" + + + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalExpression.g:8777:1: ruleJvmLowerBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8783:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalExpression.g:8784:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalExpression.g:8784:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalExpression.g:8785:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,104,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalExpression.g:8789:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalExpression.g:8790:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalExpression.g:8790:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalExpression.g:8791:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBoundAnded" + + + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalExpression.g:8812:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ; + public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null; + + + try { + // InternalExpression.g:8812:65: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ) + // InternalExpression.g:8813:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameWithWildcard.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameWithWildcard" + + + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalExpression.g:8819:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ; + public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_QualifiedName_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8825:2: ( (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ) + // InternalExpression.g:8826:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + { + // InternalExpression.g:8826:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + // InternalExpression.g:8827:3: this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + + } + pushFollow(FOLLOW_95); + this_QualifiedName_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_QualifiedName_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,43,FOLLOW_96); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + + } + kw=(Token)match(input,40,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameWithWildcard" + + + // $ANTLR start "entryRuleValidID" + // InternalExpression.g:8851:1: entryRuleValidID returns [String current=null] : iv_ruleValidID= ruleValidID EOF ; + public final String entryRuleValidID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleValidID = null; + + + try { + // InternalExpression.g:8851:47: (iv_ruleValidID= ruleValidID EOF ) + // InternalExpression.g:8852:2: iv_ruleValidID= ruleValidID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleValidID=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleValidID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleValidID" + + + // $ANTLR start "ruleValidID" + // InternalExpression.g:8858:1: ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ; + public final AntlrDatatypeRuleToken ruleValidID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_ID_0=null; + + + enterRule(); + + try { + // InternalExpression.g:8864:2: (this_ID_0= RULE_ID ) + // InternalExpression.g:8865:2: this_ID_0= RULE_ID + { + this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ID_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleValidID" + + + // $ANTLR start "entryRuleXImportDeclaration" + // InternalExpression.g:8875:1: entryRuleXImportDeclaration returns [EObject current=null] : iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ; + public final EObject entryRuleXImportDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXImportDeclaration = null; + + + try { + // InternalExpression.g:8875:59: (iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ) + // InternalExpression.g:8876:2: iv_ruleXImportDeclaration= ruleXImportDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXImportDeclaration=ruleXImportDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXImportDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXImportDeclaration" + + + // $ANTLR start "ruleXImportDeclaration" + // InternalExpression.g:8882:1: ruleXImportDeclaration returns [EObject current=null] : (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ; + public final EObject ruleXImportDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_static_1_0=null; + Token lv_extension_2_0=null; + Token lv_wildcard_4_0=null; + Token otherlv_8=null; + AntlrDatatypeRuleToken lv_memberName_5_0 = null; + + AntlrDatatypeRuleToken lv_importedNamespace_7_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:8888:2: ( (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ) + // InternalExpression.g:8889:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + { + // InternalExpression.g:8889:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + // InternalExpression.g:8890:3: otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? + { + otherlv_0=(Token)match(input,94,FOLLOW_97); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + + } + // InternalExpression.g:8894:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) + int alt144=3; + alt144 = dfa144.predict(input); + switch (alt144) { + case 1 : + // InternalExpression.g:8895:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + { + // InternalExpression.g:8895:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + // InternalExpression.g:8896:5: ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + { + // InternalExpression.g:8896:5: ( (lv_static_1_0= 'static' ) ) + // InternalExpression.g:8897:6: (lv_static_1_0= 'static' ) + { + // InternalExpression.g:8897:6: (lv_static_1_0= 'static' ) + // InternalExpression.g:8898:7: lv_static_1_0= 'static' + { + lv_static_1_0=(Token)match(input,93,FOLLOW_98); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "static", lv_static_1_0 != null, "static"); + + } + + } + + + } + + // InternalExpression.g:8910:5: ( (lv_extension_2_0= 'extension' ) )? + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==95) ) { + alt142=1; + } + switch (alt142) { + case 1 : + // InternalExpression.g:8911:6: (lv_extension_2_0= 'extension' ) + { + // InternalExpression.g:8911:6: (lv_extension_2_0= 'extension' ) + // InternalExpression.g:8912:7: lv_extension_2_0= 'extension' + { + lv_extension_2_0=(Token)match(input,95,FOLLOW_98); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "extension", lv_extension_2_0 != null, "extension"); + + } + + } + + + } + break; + + } + + // InternalExpression.g:8924:5: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalExpression.g:8925:6: ( ruleQualifiedNameInStaticImport ) + { + // InternalExpression.g:8925:6: ( ruleQualifiedNameInStaticImport ) + // InternalExpression.g:8926:7: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + + } + pushFollow(FOLLOW_99); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalExpression.g:8940:5: ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + int alt143=2; + int LA143_0 = input.LA(1); + + if ( (LA143_0==40) ) { + alt143=1; + } + else if ( (LA143_0==RULE_ID) ) { + alt143=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 143, 0, input); + + throw nvae; + } + switch (alt143) { + case 1 : + // InternalExpression.g:8941:6: ( (lv_wildcard_4_0= '*' ) ) + { + // InternalExpression.g:8941:6: ( (lv_wildcard_4_0= '*' ) ) + // InternalExpression.g:8942:7: (lv_wildcard_4_0= '*' ) + { + // InternalExpression.g:8942:7: (lv_wildcard_4_0= '*' ) + // InternalExpression.g:8943:8: lv_wildcard_4_0= '*' + { + lv_wildcard_4_0=(Token)match(input,40,FOLLOW_100); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "wildcard", lv_wildcard_4_0 != null, "*"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:8956:6: ( (lv_memberName_5_0= ruleValidID ) ) + { + // InternalExpression.g:8956:6: ( (lv_memberName_5_0= ruleValidID ) ) + // InternalExpression.g:8957:7: (lv_memberName_5_0= ruleValidID ) + { + // InternalExpression.g:8957:7: (lv_memberName_5_0= ruleValidID ) + // InternalExpression.g:8958:8: lv_memberName_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + + } + pushFollow(FOLLOW_100); + lv_memberName_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalExpression.g:8978:4: ( ( ruleQualifiedName ) ) + { + // InternalExpression.g:8978:4: ( ( ruleQualifiedName ) ) + // InternalExpression.g:8979:5: ( ruleQualifiedName ) + { + // InternalExpression.g:8979:5: ( ruleQualifiedName ) + // InternalExpression.g:8980:6: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + + } + pushFollow(FOLLOW_100); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 3 : + // InternalExpression.g:8995:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + { + // InternalExpression.g:8995:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + // InternalExpression.g:8996:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + { + // InternalExpression.g:8996:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + // InternalExpression.g:8997:6: lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + + } + pushFollow(FOLLOW_100); + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalExpression.g:9015:3: (otherlv_8= ';' )? + int alt145=2; + int LA145_0 = input.LA(1); + + if ( (LA145_0==86) ) { + alt145=1; + } + switch (alt145) { + case 1 : + // InternalExpression.g:9016:4: otherlv_8= ';' + { + otherlv_8=(Token)match(input,86,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + + } + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXImportDeclaration" + + + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalExpression.g:9025:1: entryRuleQualifiedNameInStaticImport returns [String current=null] : iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ; + public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null; + + + try { + // InternalExpression.g:9025:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ) + // InternalExpression.g:9026:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameInStaticImport.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameInStaticImport" + + + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalExpression.g:9032:1: ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID kw= '.' )+ ; + public final AntlrDatatypeRuleToken ruleQualifiedNameInStaticImport() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalExpression.g:9038:2: ( (this_ValidID_0= ruleValidID kw= '.' )+ ) + // InternalExpression.g:9039:2: (this_ValidID_0= ruleValidID kw= '.' )+ + { + // InternalExpression.g:9039:2: (this_ValidID_0= ruleValidID kw= '.' )+ + int cnt146=0; + loop146: + do { + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==RULE_ID) ) { + int LA146_2 = input.LA(2); + + if ( (LA146_2==43) ) { + alt146=1; + } + + + } + + + switch (alt146) { + case 1 : + // InternalExpression.g:9040:3: this_ValidID_0= ruleValidID kw= '.' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_95); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,43,FOLLOW_101); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + + } + + } + break; + + default : + if ( cnt146 >= 1 ) break loop146; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(146, input); + throw eee; + } + cnt146++; + } while (true); + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameInStaticImport" + + // $ANTLR start synpred1_InternalExpression + public final void synpred1_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:89:4: ( ruleCastedExpression ) + // InternalExpression.g:89:5: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred1_InternalExpression + + // $ANTLR start synpred2_InternalExpression + public final void synpred2_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:513:4: ( 'else' ) + // InternalExpression.g:513:5: 'else' + { + match(input,23,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred2_InternalExpression + + // $ANTLR start synpred3_InternalExpression + public final void synpred3_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:2880:6: ( ( () ( ( ruleOpMultiAssign ) ) ) ) + // InternalExpression.g:2880:7: ( () ( ( ruleOpMultiAssign ) ) ) + { + // InternalExpression.g:2880:7: ( () ( ( ruleOpMultiAssign ) ) ) + // InternalExpression.g:2881:7: () ( ( ruleOpMultiAssign ) ) + { + // InternalExpression.g:2881:7: () + // InternalExpression.g:2882:7: + { + } + + // InternalExpression.g:2883:7: ( ( ruleOpMultiAssign ) ) + // InternalExpression.g:2884:8: ( ruleOpMultiAssign ) + { + // InternalExpression.g:2884:8: ( ruleOpMultiAssign ) + // InternalExpression.g:2885:9: ruleOpMultiAssign + { + pushFollow(FOLLOW_2); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred3_InternalExpression + + // $ANTLR start synpred4_InternalExpression + public final void synpred4_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3074:5: ( ( () ( ( ruleOpOr ) ) ) ) + // InternalExpression.g:3074:6: ( () ( ( ruleOpOr ) ) ) + { + // InternalExpression.g:3074:6: ( () ( ( ruleOpOr ) ) ) + // InternalExpression.g:3075:6: () ( ( ruleOpOr ) ) + { + // InternalExpression.g:3075:6: () + // InternalExpression.g:3076:6: + { + } + + // InternalExpression.g:3077:6: ( ( ruleOpOr ) ) + // InternalExpression.g:3078:7: ( ruleOpOr ) + { + // InternalExpression.g:3078:7: ( ruleOpOr ) + // InternalExpression.g:3079:8: ruleOpOr + { + pushFollow(FOLLOW_2); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred4_InternalExpression + + // $ANTLR start synpred5_InternalExpression + public final void synpred5_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3181:5: ( ( () ( ( ruleOpAnd ) ) ) ) + // InternalExpression.g:3181:6: ( () ( ( ruleOpAnd ) ) ) + { + // InternalExpression.g:3181:6: ( () ( ( ruleOpAnd ) ) ) + // InternalExpression.g:3182:6: () ( ( ruleOpAnd ) ) + { + // InternalExpression.g:3182:6: () + // InternalExpression.g:3183:6: + { + } + + // InternalExpression.g:3184:6: ( ( ruleOpAnd ) ) + // InternalExpression.g:3185:7: ( ruleOpAnd ) + { + // InternalExpression.g:3185:7: ( ruleOpAnd ) + // InternalExpression.g:3186:8: ruleOpAnd + { + pushFollow(FOLLOW_2); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred5_InternalExpression + + // $ANTLR start synpred6_InternalExpression + public final void synpred6_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3288:5: ( ( () ( ( ruleOpEquality ) ) ) ) + // InternalExpression.g:3288:6: ( () ( ( ruleOpEquality ) ) ) + { + // InternalExpression.g:3288:6: ( () ( ( ruleOpEquality ) ) ) + // InternalExpression.g:3289:6: () ( ( ruleOpEquality ) ) + { + // InternalExpression.g:3289:6: () + // InternalExpression.g:3290:6: + { + } + + // InternalExpression.g:3291:6: ( ( ruleOpEquality ) ) + // InternalExpression.g:3292:7: ( ruleOpEquality ) + { + // InternalExpression.g:3292:7: ( ruleOpEquality ) + // InternalExpression.g:3293:8: ruleOpEquality + { + pushFollow(FOLLOW_2); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred6_InternalExpression + + // $ANTLR start synpred7_InternalExpression + public final void synpred7_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3416:6: ( ( () 'instanceof' ) ) + // InternalExpression.g:3416:7: ( () 'instanceof' ) + { + // InternalExpression.g:3416:7: ( () 'instanceof' ) + // InternalExpression.g:3417:7: () 'instanceof' + { + // InternalExpression.g:3417:7: () + // InternalExpression.g:3418:7: + { + } + + match(input,73,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred7_InternalExpression + + // $ANTLR start synpred8_InternalExpression + public final void synpred8_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3459:6: ( ( () ( ( ruleOpCompare ) ) ) ) + // InternalExpression.g:3459:7: ( () ( ( ruleOpCompare ) ) ) + { + // InternalExpression.g:3459:7: ( () ( ( ruleOpCompare ) ) ) + // InternalExpression.g:3460:7: () ( ( ruleOpCompare ) ) + { + // InternalExpression.g:3460:7: () + // InternalExpression.g:3461:7: + { + } + + // InternalExpression.g:3462:7: ( ( ruleOpCompare ) ) + // InternalExpression.g:3463:8: ( ruleOpCompare ) + { + // InternalExpression.g:3463:8: ( ruleOpCompare ) + // InternalExpression.g:3464:9: ruleOpCompare + { + pushFollow(FOLLOW_2); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred8_InternalExpression + + // $ANTLR start synpred9_InternalExpression + public final void synpred9_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3594:5: ( ( () ( ( ruleOpOther ) ) ) ) + // InternalExpression.g:3594:6: ( () ( ( ruleOpOther ) ) ) + { + // InternalExpression.g:3594:6: ( () ( ( ruleOpOther ) ) ) + // InternalExpression.g:3595:6: () ( ( ruleOpOther ) ) + { + // InternalExpression.g:3595:6: () + // InternalExpression.g:3596:6: + { + } + + // InternalExpression.g:3597:6: ( ( ruleOpOther ) ) + // InternalExpression.g:3598:7: ( ruleOpOther ) + { + // InternalExpression.g:3598:7: ( ruleOpOther ) + // InternalExpression.g:3599:8: ruleOpOther + { + pushFollow(FOLLOW_2); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred9_InternalExpression + + // $ANTLR start synpred10_InternalExpression + public final void synpred10_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3714:6: ( ( '>' '>' ) ) + // InternalExpression.g:3714:7: ( '>' '>' ) + { + // InternalExpression.g:3714:7: ( '>' '>' ) + // InternalExpression.g:3715:7: '>' '>' + { + match(input,36,FOLLOW_46); if (state.failed) return ; + match(input,36,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred10_InternalExpression + + // $ANTLR start synpred11_InternalExpression + public final void synpred11_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3749:6: ( ( '<' '<' ) ) + // InternalExpression.g:3749:7: ( '<' '<' ) + { + // InternalExpression.g:3749:7: ( '<' '<' ) + // InternalExpression.g:3750:7: '<' '<' + { + match(input,37,FOLLOW_38); if (state.failed) return ; + match(input,37,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred11_InternalExpression + + // $ANTLR start synpred12_InternalExpression + public final void synpred12_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3822:5: ( ( () ( ( ruleOpAdd ) ) ) ) + // InternalExpression.g:3822:6: ( () ( ( ruleOpAdd ) ) ) + { + // InternalExpression.g:3822:6: ( () ( ( ruleOpAdd ) ) ) + // InternalExpression.g:3823:6: () ( ( ruleOpAdd ) ) + { + // InternalExpression.g:3823:6: () + // InternalExpression.g:3824:6: + { + } + + // InternalExpression.g:3825:6: ( ( ruleOpAdd ) ) + // InternalExpression.g:3826:7: ( ruleOpAdd ) + { + // InternalExpression.g:3826:7: ( ruleOpAdd ) + // InternalExpression.g:3827:8: ruleOpAdd + { + pushFollow(FOLLOW_2); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred12_InternalExpression + + // $ANTLR start synpred13_InternalExpression + public final void synpred13_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:3937:5: ( ( () ( ( ruleOpMulti ) ) ) ) + // InternalExpression.g:3937:6: ( () ( ( ruleOpMulti ) ) ) + { + // InternalExpression.g:3937:6: ( () ( ( ruleOpMulti ) ) ) + // InternalExpression.g:3938:6: () ( ( ruleOpMulti ) ) + { + // InternalExpression.g:3938:6: () + // InternalExpression.g:3939:6: + { + } + + // InternalExpression.g:3940:6: ( ( ruleOpMulti ) ) + // InternalExpression.g:3941:7: ( ruleOpMulti ) + { + // InternalExpression.g:3941:7: ( ruleOpMulti ) + // InternalExpression.g:3942:8: ruleOpMulti + { + pushFollow(FOLLOW_2); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred13_InternalExpression + + // $ANTLR start synpred14_InternalExpression + public final void synpred14_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4172:5: ( ( () 'as' ) ) + // InternalExpression.g:4172:6: ( () 'as' ) + { + // InternalExpression.g:4172:6: ( () 'as' ) + // InternalExpression.g:4173:6: () 'as' + { + // InternalExpression.g:4173:6: () + // InternalExpression.g:4174:6: + { + } + + match(input,81,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred14_InternalExpression + + // $ANTLR start synpred15_InternalExpression + public final void synpred15_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4240:4: ( ( () ( ( ruleOpPostfix ) ) ) ) + // InternalExpression.g:4240:5: ( () ( ( ruleOpPostfix ) ) ) + { + // InternalExpression.g:4240:5: ( () ( ( ruleOpPostfix ) ) ) + // InternalExpression.g:4241:5: () ( ( ruleOpPostfix ) ) + { + // InternalExpression.g:4241:5: () + // InternalExpression.g:4242:5: + { + } + + // InternalExpression.g:4243:5: ( ( ruleOpPostfix ) ) + // InternalExpression.g:4244:6: ( ruleOpPostfix ) + { + // InternalExpression.g:4244:6: ( ruleOpPostfix ) + // InternalExpression.g:4245:7: ruleOpPostfix + { + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred15_InternalExpression + + // $ANTLR start synpred16_InternalExpression + public final void synpred16_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4336:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) + // InternalExpression.g:4336:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + { + // InternalExpression.g:4336:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + // InternalExpression.g:4337:7: () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign + { + // InternalExpression.g:4337:7: () + // InternalExpression.g:4338:7: + { + } + + // InternalExpression.g:4339:7: ( '.' | ( ( '::' ) ) ) + int alt147=2; + int LA147_0 = input.LA(1); + + if ( (LA147_0==43) ) { + alt147=1; + } + else if ( (LA147_0==65) ) { + alt147=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 147, 0, input); + + throw nvae; + } + switch (alt147) { + case 1 : + // InternalExpression.g:4340:8: '.' + { + match(input,43,FOLLOW_52); if (state.failed) return ; + + } + break; + case 2 : + // InternalExpression.g:4342:8: ( ( '::' ) ) + { + // InternalExpression.g:4342:8: ( ( '::' ) ) + // InternalExpression.g:4343:9: ( '::' ) + { + // InternalExpression.g:4343:9: ( '::' ) + // InternalExpression.g:4344:10: '::' + { + match(input,65,FOLLOW_52); if (state.failed) return ; + + } + + + } + + + } + break; + + } + + // InternalExpression.g:4348:7: ( ( ruleFeatureCallID ) ) + // InternalExpression.g:4349:8: ( ruleFeatureCallID ) + { + // InternalExpression.g:4349:8: ( ruleFeatureCallID ) + // InternalExpression.g:4350:9: ruleFeatureCallID + { + pushFollow(FOLLOW_4); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred16_InternalExpression + + // $ANTLR start synpred17_InternalExpression + public final void synpred17_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4433:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) ) + // InternalExpression.g:4433:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) + { + // InternalExpression.g:4433:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) + // InternalExpression.g:4434:7: () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) + { + // InternalExpression.g:4434:7: () + // InternalExpression.g:4435:7: + { + } + + // InternalExpression.g:4436:7: ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) + int alt148=3; + switch ( input.LA(1) ) { + case 43: + { + alt148=1; + } + break; + case 84: + { + alt148=2; + } + break; + case 65: + { + alt148=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 148, 0, input); + + throw nvae; + } + + switch (alt148) { + case 1 : + // InternalExpression.g:4437:8: '.' + { + match(input,43,FOLLOW_2); if (state.failed) return ; + + } + break; + case 2 : + // InternalExpression.g:4439:8: ( ( '?.' ) ) + { + // InternalExpression.g:4439:8: ( ( '?.' ) ) + // InternalExpression.g:4440:9: ( '?.' ) + { + // InternalExpression.g:4440:9: ( '?.' ) + // InternalExpression.g:4441:10: '?.' + { + match(input,84,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + break; + case 3 : + // InternalExpression.g:4445:8: ( ( '::' ) ) + { + // InternalExpression.g:4445:8: ( ( '::' ) ) + // InternalExpression.g:4446:9: ( '::' ) + { + // InternalExpression.g:4446:9: ( '::' ) + // InternalExpression.g:4447:10: '::' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + break; + + } + + + } + + + } + } + // $ANTLR end synpred17_InternalExpression + + // $ANTLR start synpred18_InternalExpression + public final void synpred18_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4571:7: ( ( '(' ) ) + // InternalExpression.g:4571:8: ( '(' ) + { + // InternalExpression.g:4571:8: ( '(' ) + // InternalExpression.g:4572:8: '(' + { + match(input,17,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred18_InternalExpression + + // $ANTLR start synpred19_InternalExpression + public final void synpred19_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4590:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExpression.g:4590:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExpression.g:4590:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExpression.g:4591:9: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExpression.g:4591:9: () + // InternalExpression.g:4592:9: + { + } + + // InternalExpression.g:4593:9: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt150=2; + int LA150_0 = input.LA(1); + + if ( (LA150_0==RULE_ID||LA150_0==17||LA150_0==76) ) { + alt150=1; + } + switch (alt150) { + case 1 : + // InternalExpression.g:4594:10: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExpression.g:4594:10: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:4595:11: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:4595:11: ( ruleJvmFormalParameter ) + // InternalExpression.g:4596:12: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExpression.g:4599:10: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop149: + do { + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==44) ) { + alt149=1; + } + + + switch (alt149) { + case 1 : + // InternalExpression.g:4600:11: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,44,FOLLOW_43); if (state.failed) return ; + // InternalExpression.g:4601:11: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:4602:12: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:4602:12: ( ruleJvmFormalParameter ) + // InternalExpression.g:4603:13: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop149; + } + } while (true); + + + } + break; + + } + + // InternalExpression.g:4608:9: ( ( '|' ) ) + // InternalExpression.g:4609:10: ( '|' ) + { + // InternalExpression.g:4609:10: ( '|' ) + // InternalExpression.g:4610:11: '|' + { + match(input,54,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred19_InternalExpression + + // $ANTLR start synpred20_InternalExpression + public final void synpred20_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4687:6: ( ( () '[' ) ) + // InternalExpression.g:4687:7: ( () '[' ) + { + // InternalExpression.g:4687:7: ( () '[' ) + // InternalExpression.g:4688:7: () '[' + { + // InternalExpression.g:4688:7: () + // InternalExpression.g:4689:7: + { + } + + match(input,63,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred20_InternalExpression + + // $ANTLR start synpred21_InternalExpression + public final void synpred21_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4760:4: ( ( () 'synchronized' '(' ) ) + // InternalExpression.g:4760:5: ( () 'synchronized' '(' ) + { + // InternalExpression.g:4760:5: ( () 'synchronized' '(' ) + // InternalExpression.g:4761:5: () 'synchronized' '(' + { + // InternalExpression.g:4761:5: () + // InternalExpression.g:4762:5: + { + } + + match(input,102,FOLLOW_25); if (state.failed) return ; + match(input,17,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred21_InternalExpression + + // $ANTLR start synpred22_InternalExpression + public final void synpred22_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4805:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalExpression.g:4805:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalExpression.g:4805:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalExpression.g:4806:5: () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' + { + // InternalExpression.g:4806:5: () + // InternalExpression.g:4807:5: + { + } + + match(input,87,FOLLOW_25); if (state.failed) return ; + match(input,17,FOLLOW_43); if (state.failed) return ; + // InternalExpression.g:4810:5: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:4811:6: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:4811:6: ( ruleJvmFormalParameter ) + // InternalExpression.g:4812:7: ruleJvmFormalParameter + { + pushFollow(FOLLOW_6); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,16,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred22_InternalExpression + + // $ANTLR start synpred23_InternalExpression + public final void synpred23_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:4919:4: ( ( () '[' ) ) + // InternalExpression.g:4919:5: ( () '[' ) + { + // InternalExpression.g:4919:5: ( () '[' ) + // InternalExpression.g:4920:5: () '[' + { + // InternalExpression.g:4920:5: () + // InternalExpression.g:4921:5: + { + } + + match(input,63,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred23_InternalExpression + + // $ANTLR start synpred25_InternalExpression + public final void synpred25_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:5224:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExpression.g:5224:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExpression.g:5224:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExpression.g:5225:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExpression.g:5225:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==RULE_ID||LA152_0==17||LA152_0==76) ) { + alt152=1; + } + switch (alt152) { + case 1 : + // InternalExpression.g:5226:6: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExpression.g:5226:6: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:5227:7: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:5227:7: ( ruleJvmFormalParameter ) + // InternalExpression.g:5228:8: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExpression.g:5231:6: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop151: + do { + int alt151=2; + int LA151_0 = input.LA(1); + + if ( (LA151_0==44) ) { + alt151=1; + } + + + switch (alt151) { + case 1 : + // InternalExpression.g:5232:7: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,44,FOLLOW_43); if (state.failed) return ; + // InternalExpression.g:5233:7: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:5234:8: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:5234:8: ( ruleJvmFormalParameter ) + // InternalExpression.g:5235:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop151; + } + } while (true); + + + } + break; + + } + + // InternalExpression.g:5240:5: ( ( '|' ) ) + // InternalExpression.g:5241:6: ( '|' ) + { + // InternalExpression.g:5241:6: ( '|' ) + // InternalExpression.g:5242:7: '|' + { + match(input,54,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred25_InternalExpression + + // $ANTLR start synpred27_InternalExpression + public final void synpred27_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:5633:5: ( 'else' ) + // InternalExpression.g:5633:6: 'else' + { + match(input,23,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred27_InternalExpression + + // $ANTLR start synpred28_InternalExpression + public final void synpred28_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:5692:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalExpression.g:5692:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalExpression.g:5692:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalExpression.g:5693:7: '(' ( ( ruleJvmFormalParameter ) ) ':' + { + match(input,17,FOLLOW_43); if (state.failed) return ; + // InternalExpression.g:5694:7: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:5695:8: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:5695:8: ( ruleJvmFormalParameter ) + // InternalExpression.g:5696:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_6); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,16,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred28_InternalExpression + + // $ANTLR start synpred29_InternalExpression + public final void synpred29_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:5759:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalExpression.g:5759:7: ( ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalExpression.g:5759:7: ( ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalExpression.g:5760:7: ( ( ruleJvmFormalParameter ) ) ':' + { + // InternalExpression.g:5760:7: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:5761:8: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:5761:8: ( ruleJvmFormalParameter ) + // InternalExpression.g:5762:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_6); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,16,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred29_InternalExpression + + // $ANTLR start synpred31_InternalExpression + public final void synpred31_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:6577:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) ) + // InternalExpression.g:6577:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) + { + // InternalExpression.g:6577:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) + // InternalExpression.g:6578:6: ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) + { + // InternalExpression.g:6578:6: ( ( ruleJvmTypeReference ) ) + // InternalExpression.g:6579:7: ( ruleJvmTypeReference ) + { + // InternalExpression.g:6579:7: ( ruleJvmTypeReference ) + // InternalExpression.g:6580:8: ruleJvmTypeReference + { + pushFollow(FOLLOW_3); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExpression.g:6583:6: ( ( ruleValidID ) ) + // InternalExpression.g:6584:7: ( ruleValidID ) + { + // InternalExpression.g:6584:7: ( ruleValidID ) + // InternalExpression.g:6585:8: ruleValidID + { + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred31_InternalExpression + + // $ANTLR start synpred32_InternalExpression + public final void synpred32_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:6889:5: ( ( '(' ) ) + // InternalExpression.g:6889:6: ( '(' ) + { + // InternalExpression.g:6889:6: ( '(' ) + // InternalExpression.g:6890:6: '(' + { + match(input,17,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred32_InternalExpression + + // $ANTLR start synpred33_InternalExpression + public final void synpred33_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:6908:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExpression.g:6908:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExpression.g:6908:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExpression.g:6909:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExpression.g:6909:7: () + // InternalExpression.g:6910:7: + { + } + + // InternalExpression.g:6911:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt156=2; + int LA156_0 = input.LA(1); + + if ( (LA156_0==RULE_ID||LA156_0==17||LA156_0==76) ) { + alt156=1; + } + switch (alt156) { + case 1 : + // InternalExpression.g:6912:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExpression.g:6912:8: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:6913:9: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:6913:9: ( ruleJvmFormalParameter ) + // InternalExpression.g:6914:10: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExpression.g:6917:8: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop155: + do { + int alt155=2; + int LA155_0 = input.LA(1); + + if ( (LA155_0==44) ) { + alt155=1; + } + + + switch (alt155) { + case 1 : + // InternalExpression.g:6918:9: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,44,FOLLOW_43); if (state.failed) return ; + // InternalExpression.g:6919:9: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:6920:10: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:6920:10: ( ruleJvmFormalParameter ) + // InternalExpression.g:6921:11: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop155; + } + } while (true); + + + } + break; + + } + + // InternalExpression.g:6926:7: ( ( '|' ) ) + // InternalExpression.g:6927:8: ( '|' ) + { + // InternalExpression.g:6927:8: ( '|' ) + // InternalExpression.g:6928:9: '|' + { + match(input,54,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred33_InternalExpression + + // $ANTLR start synpred34_InternalExpression + public final void synpred34_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7005:4: ( ( () '[' ) ) + // InternalExpression.g:7005:5: ( () '[' ) + { + // InternalExpression.g:7005:5: ( () '[' ) + // InternalExpression.g:7006:5: () '[' + { + // InternalExpression.g:7006:5: () + // InternalExpression.g:7007:5: + { + } + + match(input,63,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred34_InternalExpression + + // $ANTLR start synpred35_InternalExpression + public final void synpred35_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7165:5: ( '<' ) + // InternalExpression.g:7165:6: '<' + { + match(input,37,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred35_InternalExpression + + // $ANTLR start synpred36_InternalExpression + public final void synpred36_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7222:5: ( ( '(' ) ) + // InternalExpression.g:7222:6: ( '(' ) + { + // InternalExpression.g:7222:6: ( '(' ) + // InternalExpression.g:7223:6: '(' + { + match(input,17,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred36_InternalExpression + + // $ANTLR start synpred37_InternalExpression + public final void synpred37_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7241:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalExpression.g:7241:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalExpression.g:7241:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalExpression.g:7242:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalExpression.g:7242:7: () + // InternalExpression.g:7243:7: + { + } + + // InternalExpression.g:7244:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt158=2; + int LA158_0 = input.LA(1); + + if ( (LA158_0==RULE_ID||LA158_0==17||LA158_0==76) ) { + alt158=1; + } + switch (alt158) { + case 1 : + // InternalExpression.g:7245:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalExpression.g:7245:8: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:7246:9: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:7246:9: ( ruleJvmFormalParameter ) + // InternalExpression.g:7247:10: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalExpression.g:7250:8: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop157: + do { + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==44) ) { + alt157=1; + } + + + switch (alt157) { + case 1 : + // InternalExpression.g:7251:9: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,44,FOLLOW_43); if (state.failed) return ; + // InternalExpression.g:7252:9: ( ( ruleJvmFormalParameter ) ) + // InternalExpression.g:7253:10: ( ruleJvmFormalParameter ) + { + // InternalExpression.g:7253:10: ( ruleJvmFormalParameter ) + // InternalExpression.g:7254:11: ruleJvmFormalParameter + { + pushFollow(FOLLOW_63); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop157; + } + } while (true); + + + } + break; + + } + + // InternalExpression.g:7259:7: ( ( '|' ) ) + // InternalExpression.g:7260:8: ( '|' ) + { + // InternalExpression.g:7260:8: ( '|' ) + // InternalExpression.g:7261:9: '|' + { + match(input,54,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred37_InternalExpression + + // $ANTLR start synpred38_InternalExpression + public final void synpred38_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7338:4: ( ( () '[' ) ) + // InternalExpression.g:7338:5: ( () '[' ) + { + // InternalExpression.g:7338:5: ( () '[' ) + // InternalExpression.g:7339:5: () '[' + { + // InternalExpression.g:7339:5: () + // InternalExpression.g:7340:5: + { + } + + match(input,63,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred38_InternalExpression + + // $ANTLR start synpred39_InternalExpression + public final void synpred39_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7681:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING ) + // InternalExpression.g: + { + if ( input.LA(1)==RULE_INT||(input.LA(1)>=RULE_STRING && input.LA(1)<=RULE_DECIMAL)||input.LA(1)==17||input.LA(1)==21||(input.LA(1)>=24 && input.LA(1)<=25)||(input.LA(1)>=37 && input.LA(1)<=39)||input.LA(1)==42||(input.LA(1)>=55 && input.LA(1)<=57)||input.LA(1)==59||input.LA(1)==63||input.LA(1)==85||(input.LA(1)>=87 && input.LA(1)<=89)||(input.LA(1)>=92 && input.LA(1)<=100)||input.LA(1)==102 ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + } + // $ANTLR end synpred39_InternalExpression + + // $ANTLR start synpred40_InternalExpression + public final void synpred40_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7752:6: ( 'catch' ) + // InternalExpression.g:7752:7: 'catch' + { + match(input,103,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred40_InternalExpression + + // $ANTLR start synpred41_InternalExpression + public final void synpred41_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:7773:7: ( 'finally' ) + // InternalExpression.g:7773:8: 'finally' + { + match(input,101,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred41_InternalExpression + + // $ANTLR start synpred44_InternalExpression + public final void synpred44_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8017:5: ( '.' ) + // InternalExpression.g:8017:6: '.' + { + match(input,43,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred44_InternalExpression + + // $ANTLR start synpred45_InternalExpression + public final void synpred45_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8143:5: ( ( () ruleArrayBrackets ) ) + // InternalExpression.g:8143:6: ( () ruleArrayBrackets ) + { + // InternalExpression.g:8143:6: ( () ruleArrayBrackets ) + // InternalExpression.g:8144:6: () ruleArrayBrackets + { + // InternalExpression.g:8144:6: () + // InternalExpression.g:8145:6: + { + } + + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred45_InternalExpression + + // $ANTLR start synpred46_InternalExpression + public final void synpred46_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8340:5: ( '<' ) + // InternalExpression.g:8340:6: '<' + { + match(input,37,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred46_InternalExpression + + // $ANTLR start synpred47_InternalExpression + public final void synpred47_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8396:6: ( ( () '.' ) ) + // InternalExpression.g:8396:7: ( () '.' ) + { + // InternalExpression.g:8396:7: ( () '.' ) + // InternalExpression.g:8397:7: () '.' + { + // InternalExpression.g:8397:7: () + // InternalExpression.g:8398:7: + { + } + + match(input,43,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred47_InternalExpression + + // $ANTLR start synpred48_InternalExpression + public final void synpred48_InternalExpression_fragment() throws RecognitionException { + // InternalExpression.g:8434:7: ( '<' ) + // InternalExpression.g:8434:8: '<' + { + match(input,37,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred48_InternalExpression + + // Delegated rules + + public final boolean synpred28_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred28_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred2_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred2_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred29_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred29_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred1_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred1_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred27_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred27_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred3_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred4_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred4_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred8_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred8_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred10_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred10_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred35_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred35_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred36_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred36_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred9_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred9_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred11_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred11_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred6_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred6_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred7_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred7_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred5_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred5_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred38_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred38_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred39_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred39_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred37_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred37_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred31_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred31_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred34_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred34_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred33_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred33_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred32_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred32_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred15_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred15_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred41_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred41_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred44_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred44_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred40_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred40_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred18_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred18_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred13_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred13_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred12_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred12_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred14_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred14_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred19_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred19_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred16_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred16_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred17_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred17_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred48_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred48_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred22_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred22_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred23_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred23_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred21_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred21_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred25_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred25_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred46_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred46_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred20_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred20_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred45_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred45_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred47_InternalExpression() { + state.backtracking++; + int start = input.mark(); + try { + synpred47_InternalExpression_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA1 dfa1 = new DFA1(this); + protected DFA37 dfa37 = new DFA37(this); + protected DFA47 dfa47 = new DFA47(this); + protected DFA50 dfa50 = new DFA50(this); + protected DFA66 dfa66 = new DFA66(this); + protected DFA65 dfa65 = new DFA65(this); + protected DFA67 dfa67 = new DFA67(this); + protected DFA69 dfa69 = new DFA69(this); + protected DFA78 dfa78 = new DFA78(this); + protected DFA85 dfa85 = new DFA85(this); + protected DFA84 dfa84 = new DFA84(this); + protected DFA107 dfa107 = new DFA107(this); + protected DFA106 dfa106 = new DFA106(this); + protected DFA108 dfa108 = new DFA108(this); + protected DFA112 dfa112 = new DFA112(this); + protected DFA115 dfa115 = new DFA115(this); + protected DFA114 dfa114 = new DFA114(this); + protected DFA116 dfa116 = new DFA116(this); + protected DFA119 dfa119 = new DFA119(this); + protected DFA137 dfa137 = new DFA137(this); + protected DFA135 dfa135 = new DFA135(this); + protected DFA144 dfa144 = new DFA144(this); + static final String dfa_1s = "\36\uffff"; + static final String dfa_2s = "\1\4\1\uffff\1\0\33\uffff"; + static final String dfa_3s = "\1\76\1\uffff\1\0\33\uffff"; + static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; + static final String dfa_5s = "\2\uffff\1\0\33\uffff}>"; + static final String[] dfa_6s = { + "\4\3\6\uffff\1\1\2\uffff\1\2\3\uffff\1\3\2\uffff\2\3\15\uffff\1\3\2\uffff\1\3\2\uffff\11\3\1\uffff\10\3", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA1 extends DFA { + + public DFA1(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 1; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "78:2: (this_LetExpression_0= ruleLetExpression | ( ( ruleCastedExpression )=>this_CastedExpression_1= ruleCastedExpression ) | this_ChainExpression_2= ruleChainExpression )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA1_2 = input.LA(1); + + + int index1_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred1_InternalExpression()) ) {s = 29;} + + else if ( (true) ) {s = 3;} + + + input.seek(index1_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 1, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_7s = "\12\uffff"; + static final String dfa_8s = "\1\10\11\uffff"; + static final String dfa_9s = "\1\4\7\0\2\uffff"; + static final String dfa_10s = "\1\147\7\0\2\uffff"; + static final String dfa_11s = "\10\uffff\1\2\1\1"; + static final String dfa_12s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\2\uffff}>"; + static final String[] dfa_13s = { + "\1\10\1\uffff\4\10\6\uffff\4\10\1\uffff\1\10\1\uffff\10\10\1\uffff\3\10\1\uffff\1\7\1\6\7\10\12\uffff\3\10\1\uffff\1\10\3\uffff\3\10\1\1\1\2\1\3\1\4\1\5\41\10", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); + static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s); + static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); + static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s); + static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); + static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s); + static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s); + + class DFA37 extends DFA { + + public DFA37(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 37; + this.eot = dfa_7; + this.eof = dfa_8; + this.min = dfa_9; + this.max = dfa_10; + this.accept = dfa_11; + this.special = dfa_12; + this.transition = dfa_13; + } + public String getDescription() { + return "2878:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA37_1 = input.LA(1); + + + int index37_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA37_2 = input.LA(1); + + + int index37_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA37_3 = input.LA(1); + + + int index37_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA37_4 = input.LA(1); + + + int index37_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA37_5 = input.LA(1); + + + int index37_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA37_6 = input.LA(1); + + + int index37_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA37_7 = input.LA(1); + + + int index37_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred3_InternalExpression()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index37_7); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 37, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_14s = "\13\uffff"; + static final String dfa_15s = "\1\1\12\uffff"; + static final String dfa_16s = "\1\4\1\uffff\10\0\1\uffff"; + static final String dfa_17s = "\1\147\1\uffff\10\0\1\uffff"; + static final String dfa_18s = "\1\uffff\1\2\10\uffff\1\1"; + static final String dfa_19s = "\2\uffff\1\2\1\1\1\6\1\7\1\5\1\0\1\3\1\4\1\uffff}>"; + static final String[] dfa_20s = { + "\1\1\1\uffff\4\1\6\uffff\3\1\1\4\1\uffff\1\1\1\uffff\10\1\1\uffff\3\1\1\uffff\1\3\1\2\7\1\12\uffff\3\1\1\uffff\1\1\3\uffff\13\1\1\5\1\6\1\7\1\10\1\11\31\1", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "" + }; + + static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s); + static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s); + static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s); + static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s); + static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s); + static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); + static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s); + + class DFA47 extends DFA { + + public DFA47(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 47; + this.eot = dfa_14; + this.eof = dfa_15; + this.min = dfa_16; + this.max = dfa_17; + this.accept = dfa_18; + this.special = dfa_19; + this.transition = dfa_20; + } + public String getDescription() { + return "()* loopback of 3592:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA47_7 = input.LA(1); + + + int index47_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_7); + if ( s>=0 ) return s; + break; + case 1 : + int LA47_3 = input.LA(1); + + + int index47_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_3); + if ( s>=0 ) return s; + break; + case 2 : + int LA47_2 = input.LA(1); + + + int index47_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA47_8 = input.LA(1); + + + int index47_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_8); + if ( s>=0 ) return s; + break; + case 4 : + int LA47_9 = input.LA(1); + + + int index47_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_9); + if ( s>=0 ) return s; + break; + case 5 : + int LA47_6 = input.LA(1); + + + int index47_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA47_4 = input.LA(1); + + + int index47_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_4); + if ( s>=0 ) return s; + break; + case 7 : + int LA47_5 = input.LA(1); + + + int index47_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred9_InternalExpression()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index47_5); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 47, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_21s = "\1\23\2\uffff\1\44\7\uffff"; + static final String dfa_22s = "\1\116\2\uffff\1\113\7\uffff"; + static final String dfa_23s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\3\1\6"; + static final String dfa_24s = "\13\uffff}>"; + static final String[] dfa_25s = { + "\1\1\20\uffff\1\3\1\6\44\uffff\1\2\1\4\1\5\1\7\1\10", + "", + "", + "\1\12\46\uffff\1\11", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); + static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); + static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); + static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); + static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); + + class DFA50 extends DFA { + + public DFA50(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 50; + this.eot = dfa_14; + this.eof = dfa_14; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "3668:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )"; + } + } + static final String dfa_26s = "\116\uffff"; + static final String dfa_27s = "\1\2\115\uffff"; + static final String dfa_28s = "\1\4\1\0\114\uffff"; + static final String dfa_29s = "\1\147\1\0\114\uffff"; + static final String dfa_30s = "\2\uffff\1\2\112\uffff\1\1"; + static final String dfa_31s = "\1\uffff\1\0\114\uffff}>"; + static final String[] dfa_32s = { + "\1\2\1\uffff\4\2\6\uffff\1\2\1\1\2\2\1\uffff\1\2\1\uffff\10\2\1\uffff\3\2\1\uffff\11\2\12\uffff\3\2\1\uffff\1\2\3\uffff\51\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s); + static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s); + static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s); + static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s); + static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s); + static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s); + static final short[][] dfa_32 = unpackEncodedStringArray(dfa_32s); + + class DFA66 extends DFA { + + public DFA66(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 66; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "4569:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA66_1 = input.LA(1); + + + int index66_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred18_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index66_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 66, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_33s = "\44\uffff"; + static final String dfa_34s = "\1\4\2\0\41\uffff"; + static final String dfa_35s = "\1\146\2\0\41\uffff"; + static final String dfa_36s = "\3\uffff\2\1\1\2\35\uffff\1\3"; + static final String dfa_37s = "\1\0\1\1\1\2\41\uffff}>"; + static final String[] dfa_38s = { + "\1\5\1\uffff\1\5\1\1\2\5\7\uffff\1\2\1\43\2\uffff\1\5\2\uffff\2\5\13\uffff\3\5\2\uffff\1\5\13\uffff\1\4\3\5\1\uffff\1\5\3\uffff\1\5\14\uffff\1\3\10\uffff\1\5\1\uffff\3\5\2\uffff\11\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_33 = DFA.unpackEncodedString(dfa_33s); + static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s); + static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s); + static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s); + static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s); + static final short[][] dfa_38 = unpackEncodedStringArray(dfa_38s); + + class DFA65 extends DFA { + + public DFA65(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 65; + this.eot = dfa_33; + this.eof = dfa_33; + this.min = dfa_34; + this.max = dfa_35; + this.accept = dfa_36; + this.special = dfa_37; + this.transition = dfa_38; + } + public String getDescription() { + return "4588:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA65_0 = input.LA(1); + + + int index65_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA65_0==RULE_ID) ) {s = 1;} + + else if ( (LA65_0==17) ) {s = 2;} + + else if ( (LA65_0==76) && (synpred19_InternalExpression())) {s = 3;} + + else if ( (LA65_0==54) && (synpred19_InternalExpression())) {s = 4;} + + else if ( (LA65_0==RULE_INT||LA65_0==RULE_STRING||(LA65_0>=RULE_HEX && LA65_0<=RULE_DECIMAL)||LA65_0==21||(LA65_0>=24 && LA65_0<=25)||(LA65_0>=37 && LA65_0<=39)||LA65_0==42||(LA65_0>=55 && LA65_0<=57)||LA65_0==59||LA65_0==63||LA65_0==85||(LA65_0>=87 && LA65_0<=89)||(LA65_0>=92 && LA65_0<=100)||LA65_0==102) ) {s = 5;} + + else if ( (LA65_0==18) ) {s = 35;} + + + input.seek(index65_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA65_1 = input.LA(1); + + + int index65_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred19_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index65_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA65_2 = input.LA(1); + + + int index65_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred19_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index65_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 65, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_39s = { + "\1\2\1\uffff\4\2\6\uffff\4\2\1\uffff\1\2\1\uffff\10\2\1\uffff\3\2\1\uffff\11\2\12\uffff\3\2\1\uffff\1\2\3\uffff\1\1\50\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_39 = unpackEncodedStringArray(dfa_39s); + + class DFA67 extends DFA { + + public DFA67(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 67; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_39; + } + public String getDescription() { + return "4686:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA67_1 = input.LA(1); + + + int index67_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred20_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index67_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 67, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_40s = "\40\uffff"; + static final String dfa_41s = "\1\4\26\uffff\1\0\10\uffff"; + static final String dfa_42s = "\1\146\26\uffff\1\0\10\uffff"; + static final String dfa_43s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11"; + static final String dfa_44s = "\1\0\26\uffff\1\1\10\uffff}>"; + static final String[] dfa_45s = { + "\1\14\1\uffff\1\14\1\5\2\14\7\uffff\1\35\3\uffff\1\26\2\uffff\1\3\1\2\13\uffff\1\5\21\uffff\3\14\1\uffff\1\1\3\uffff\1\14\25\uffff\1\14\1\uffff\1\27\1\30\1\31\2\uffff\5\5\1\14\1\32\1\33\1\34\1\uffff\1\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s); + static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s); + static final char[] dfa_42 = DFA.unpackEncodedStringToUnsignedChars(dfa_42s); + static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s); + static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s); + static final short[][] dfa_45 = unpackEncodedStringArray(dfa_45s); + + class DFA69 extends DFA { + + public DFA69(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 69; + this.eot = dfa_40; + this.eof = dfa_40; + this.min = dfa_41; + this.max = dfa_42; + this.accept = dfa_43; + this.special = dfa_44; + this.transition = dfa_45; + } + public String getDescription() { + return "4731:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA69_0 = input.LA(1); + + + int index69_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA69_0==59) ) {s = 1;} + + else if ( (LA69_0==25) ) {s = 2;} + + else if ( (LA69_0==24) ) {s = 3;} + + else if ( (LA69_0==102) && (synpred21_InternalExpression())) {s = 4;} + + else if ( (LA69_0==RULE_ID||LA69_0==37||(LA69_0>=92 && LA69_0<=96)) ) {s = 5;} + + else if ( (LA69_0==RULE_INT||LA69_0==RULE_STRING||(LA69_0>=RULE_HEX && LA69_0<=RULE_DECIMAL)||(LA69_0>=55 && LA69_0<=57)||LA69_0==63||LA69_0==85||LA69_0==97) ) {s = 12;} + + else if ( (LA69_0==21) ) {s = 22;} + + else if ( (LA69_0==87) ) {s = 23;} + + else if ( (LA69_0==88) ) {s = 24;} + + else if ( (LA69_0==89) ) {s = 25;} + + else if ( (LA69_0==98) ) {s = 26;} + + else if ( (LA69_0==99) ) {s = 27;} + + else if ( (LA69_0==100) ) {s = 28;} + + else if ( (LA69_0==17) ) {s = 29;} + + + input.seek(index69_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA69_23 = input.LA(1); + + + int index69_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred22_InternalExpression()) ) {s = 30;} + + else if ( (true) ) {s = 31;} + + + input.seek(index69_23); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 69, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_46s = "\46\uffff"; + static final String dfa_47s = "\1\4\2\0\43\uffff"; + static final String dfa_48s = "\1\146\2\0\43\uffff"; + static final String dfa_49s = "\3\uffff\2\1\1\2\40\uffff"; + static final String dfa_50s = "\1\0\1\1\1\2\43\uffff}>"; + static final String[] dfa_51s = { + "\1\5\1\uffff\1\5\1\1\2\5\7\uffff\1\2\3\uffff\1\5\2\uffff\2\5\13\uffff\3\5\2\uffff\1\5\13\uffff\1\4\3\5\1\uffff\1\5\3\uffff\2\5\13\uffff\1\3\10\uffff\1\5\1\uffff\16\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_46 = DFA.unpackEncodedString(dfa_46s); + static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s); + static final char[] dfa_48 = DFA.unpackEncodedStringToUnsignedChars(dfa_48s); + static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s); + static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s); + static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s); + + class DFA78 extends DFA { + + public DFA78(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 78; + this.eot = dfa_46; + this.eof = dfa_46; + this.min = dfa_47; + this.max = dfa_48; + this.accept = dfa_49; + this.special = dfa_50; + this.transition = dfa_51; + } + public String getDescription() { + return "5223:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA78_0 = input.LA(1); + + + int index78_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA78_0==RULE_ID) ) {s = 1;} + + else if ( (LA78_0==17) ) {s = 2;} + + else if ( (LA78_0==76) && (synpred25_InternalExpression())) {s = 3;} + + else if ( (LA78_0==54) && (synpred25_InternalExpression())) {s = 4;} + + else if ( (LA78_0==RULE_INT||LA78_0==RULE_STRING||(LA78_0>=RULE_HEX && LA78_0<=RULE_DECIMAL)||LA78_0==21||(LA78_0>=24 && LA78_0<=25)||(LA78_0>=37 && LA78_0<=39)||LA78_0==42||(LA78_0>=55 && LA78_0<=57)||LA78_0==59||(LA78_0>=63 && LA78_0<=64)||LA78_0==85||(LA78_0>=87 && LA78_0<=100)||LA78_0==102) ) {s = 5;} + + + input.seek(index78_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA78_1 = input.LA(1); + + + int index78_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred25_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index78_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA78_2 = input.LA(1); + + + int index78_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred25_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index78_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 78, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_52s = "\43\uffff"; + static final String dfa_53s = "\1\4\1\0\41\uffff"; + static final String dfa_54s = "\1\146\1\0\41\uffff"; + static final String dfa_55s = "\2\uffff\1\2\37\uffff\1\1"; + static final String dfa_56s = "\1\uffff\1\0\41\uffff}>"; + static final String[] dfa_57s = { + "\1\2\1\uffff\4\2\7\uffff\1\1\3\uffff\1\2\2\uffff\2\2\13\uffff\3\2\2\uffff\1\2\14\uffff\3\2\1\uffff\1\2\3\uffff\1\2\14\uffff\1\2\10\uffff\1\2\1\uffff\3\2\2\uffff\11\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s); + static final char[] dfa_53 = DFA.unpackEncodedStringToUnsignedChars(dfa_53s); + static final char[] dfa_54 = DFA.unpackEncodedStringToUnsignedChars(dfa_54s); + static final short[] dfa_55 = DFA.unpackEncodedString(dfa_55s); + static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s); + static final short[][] dfa_57 = unpackEncodedStringArray(dfa_57s); + + class DFA85 extends DFA { + + public DFA85(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 85; + this.eot = dfa_52; + this.eof = dfa_52; + this.min = dfa_53; + this.max = dfa_54; + this.accept = dfa_55; + this.special = dfa_56; + this.transition = dfa_57; + } + public String getDescription() { + return "5689:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA85_1 = input.LA(1); + + + int index85_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred28_InternalExpression()) ) {s = 34;} + + else if ( (true) ) {s = 2;} + + + input.seek(index85_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 85, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_58s = "\42\uffff"; + static final String dfa_59s = "\1\4\2\0\37\uffff"; + static final String dfa_60s = "\1\146\2\0\37\uffff"; + static final String dfa_61s = "\3\uffff\1\1\1\2\35\uffff"; + static final String dfa_62s = "\1\0\1\1\1\2\37\uffff}>"; + static final String[] dfa_63s = { + "\1\4\1\uffff\1\4\1\1\2\4\7\uffff\1\2\3\uffff\1\4\2\uffff\2\4\13\uffff\3\4\2\uffff\1\4\14\uffff\3\4\1\uffff\1\4\3\uffff\1\4\14\uffff\1\3\10\uffff\1\4\1\uffff\3\4\2\uffff\11\4\1\uffff\1\4", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_58 = DFA.unpackEncodedString(dfa_58s); + static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s); + static final char[] dfa_60 = DFA.unpackEncodedStringToUnsignedChars(dfa_60s); + static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); + static final short[] dfa_62 = DFA.unpackEncodedString(dfa_62s); + static final short[][] dfa_63 = unpackEncodedStringArray(dfa_63s); + + class DFA84 extends DFA { + + public DFA84(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 84; + this.eot = dfa_58; + this.eof = dfa_58; + this.min = dfa_59; + this.max = dfa_60; + this.accept = dfa_61; + this.special = dfa_62; + this.transition = dfa_63; + } + public String getDescription() { + return "5758:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA84_0 = input.LA(1); + + + int index84_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA84_0==RULE_ID) ) {s = 1;} + + else if ( (LA84_0==17) ) {s = 2;} + + else if ( (LA84_0==76) && (synpred29_InternalExpression())) {s = 3;} + + else if ( (LA84_0==RULE_INT||LA84_0==RULE_STRING||(LA84_0>=RULE_HEX && LA84_0<=RULE_DECIMAL)||LA84_0==21||(LA84_0>=24 && LA84_0<=25)||(LA84_0>=37 && LA84_0<=39)||LA84_0==42||(LA84_0>=55 && LA84_0<=57)||LA84_0==59||LA84_0==63||LA84_0==85||(LA84_0>=87 && LA84_0<=89)||(LA84_0>=92 && LA84_0<=100)||LA84_0==102) ) {s = 4;} + + + input.seek(index84_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA84_1 = input.LA(1); + + + int index84_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred29_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index84_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA84_2 = input.LA(1); + + + int index84_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred29_InternalExpression()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index84_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 84, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA107 extends DFA { + + public DFA107(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 107; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "6887:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA107_1 = input.LA(1); + + + int index107_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred32_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index107_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 107, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA106 extends DFA { + + public DFA106(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 106; + this.eot = dfa_33; + this.eof = dfa_33; + this.min = dfa_34; + this.max = dfa_35; + this.accept = dfa_36; + this.special = dfa_37; + this.transition = dfa_38; + } + public String getDescription() { + return "6906:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA106_0 = input.LA(1); + + + int index106_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA106_0==RULE_ID) ) {s = 1;} + + else if ( (LA106_0==17) ) {s = 2;} + + else if ( (LA106_0==76) && (synpred33_InternalExpression())) {s = 3;} + + else if ( (LA106_0==54) && (synpred33_InternalExpression())) {s = 4;} + + else if ( (LA106_0==RULE_INT||LA106_0==RULE_STRING||(LA106_0>=RULE_HEX && LA106_0<=RULE_DECIMAL)||LA106_0==21||(LA106_0>=24 && LA106_0<=25)||(LA106_0>=37 && LA106_0<=39)||LA106_0==42||(LA106_0>=55 && LA106_0<=57)||LA106_0==59||LA106_0==63||LA106_0==85||(LA106_0>=87 && LA106_0<=89)||(LA106_0>=92 && LA106_0<=100)||LA106_0==102) ) {s = 5;} + + else if ( (LA106_0==18) ) {s = 35;} + + + input.seek(index106_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA106_1 = input.LA(1); + + + int index106_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred33_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index106_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA106_2 = input.LA(1); + + + int index106_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred33_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index106_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 106, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA108 extends DFA { + + public DFA108(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 108; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_39; + } + public String getDescription() { + return "7004:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA108_1 = input.LA(1); + + + int index108_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred34_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index108_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 108, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_64s = { + "\1\2\1\uffff\4\2\6\uffff\4\2\1\uffff\1\2\1\uffff\10\2\1\uffff\3\2\1\uffff\1\2\1\1\7\2\12\uffff\3\2\1\uffff\1\2\3\uffff\51\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_64 = unpackEncodedStringArray(dfa_64s); + + class DFA112 extends DFA { + + public DFA112(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 112; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_64; + } + public String getDescription() { + return "7163:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA112_1 = input.LA(1); + + + int index112_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred35_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index112_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 112, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA115 extends DFA { + + public DFA115(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 115; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "7220:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA115_1 = input.LA(1); + + + int index115_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred36_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index115_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 115, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA114 extends DFA { + + public DFA114(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 114; + this.eot = dfa_33; + this.eof = dfa_33; + this.min = dfa_34; + this.max = dfa_35; + this.accept = dfa_36; + this.special = dfa_37; + this.transition = dfa_38; + } + public String getDescription() { + return "7239:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA114_0 = input.LA(1); + + + int index114_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA114_0==RULE_ID) ) {s = 1;} + + else if ( (LA114_0==17) ) {s = 2;} + + else if ( (LA114_0==76) && (synpred37_InternalExpression())) {s = 3;} + + else if ( (LA114_0==54) && (synpred37_InternalExpression())) {s = 4;} + + else if ( (LA114_0==RULE_INT||LA114_0==RULE_STRING||(LA114_0>=RULE_HEX && LA114_0<=RULE_DECIMAL)||LA114_0==21||(LA114_0>=24 && LA114_0<=25)||(LA114_0>=37 && LA114_0<=39)||LA114_0==42||(LA114_0>=55 && LA114_0<=57)||LA114_0==59||LA114_0==63||LA114_0==85||(LA114_0>=87 && LA114_0<=89)||(LA114_0>=92 && LA114_0<=100)||LA114_0==102) ) {s = 5;} + + else if ( (LA114_0==18) ) {s = 35;} + + + input.seek(index114_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA114_1 = input.LA(1); + + + int index114_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred37_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index114_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA114_2 = input.LA(1); + + + int index114_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred37_InternalExpression()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index114_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 114, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA116 extends DFA { + + public DFA116(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 116; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_39; + } + public String getDescription() { + return "7337:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA116_1 = input.LA(1); + + + int index116_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred38_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index116_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 116, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_65s = "\1\41\115\uffff"; + static final String dfa_66s = "\1\4\40\0\55\uffff"; + static final String dfa_67s = "\1\147\40\0\55\uffff"; + static final String dfa_68s = "\41\uffff\1\2\53\uffff\1\1"; + static final String dfa_69s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>"; + static final String[] dfa_70s = { + "\1\24\1\uffff\1\27\1\1\1\23\1\25\6\uffff\1\41\1\40\2\41\1\uffff\1\31\1\uffff\1\41\1\13\1\12\5\41\1\uffff\3\41\1\uffff\1\41\1\15\1\10\1\7\2\41\1\6\2\41\12\uffff\1\22\1\21\1\26\1\uffff\1\11\3\uffff\1\20\25\41\1\17\1\41\1\32\1\33\1\34\2\41\1\2\1\3\1\4\1\5\1\16\1\30\1\35\1\36\1\37\1\41\1\14\1\41", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[] dfa_65 = DFA.unpackEncodedString(dfa_65s); + static final char[] dfa_66 = DFA.unpackEncodedStringToUnsignedChars(dfa_66s); + static final char[] dfa_67 = DFA.unpackEncodedStringToUnsignedChars(dfa_67s); + static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s); + static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s); + static final short[][] dfa_70 = unpackEncodedStringArray(dfa_70s); + + class DFA119 extends DFA { + + public DFA119(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 119; + this.eot = dfa_26; + this.eof = dfa_65; + this.min = dfa_66; + this.max = dfa_67; + this.accept = dfa_68; + this.special = dfa_69; + this.transition = dfa_70; + } + public String getDescription() { + return "7680:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA119_1 = input.LA(1); + + + int index119_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA119_2 = input.LA(1); + + + int index119_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA119_3 = input.LA(1); + + + int index119_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA119_4 = input.LA(1); + + + int index119_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA119_5 = input.LA(1); + + + int index119_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA119_6 = input.LA(1); + + + int index119_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA119_7 = input.LA(1); + + + int index119_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA119_8 = input.LA(1); + + + int index119_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA119_9 = input.LA(1); + + + int index119_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA119_10 = input.LA(1); + + + int index119_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA119_11 = input.LA(1); + + + int index119_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA119_12 = input.LA(1); + + + int index119_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA119_13 = input.LA(1); + + + int index119_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA119_14 = input.LA(1); + + + int index119_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA119_15 = input.LA(1); + + + int index119_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA119_16 = input.LA(1); + + + int index119_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA119_17 = input.LA(1); + + + int index119_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA119_18 = input.LA(1); + + + int index119_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA119_19 = input.LA(1); + + + int index119_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_19); + if ( s>=0 ) return s; + break; + case 19 : + int LA119_20 = input.LA(1); + + + int index119_20 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} - input.seek(index1_2); + input.seek(index119_20); + if ( s>=0 ) return s; + break; + case 20 : + int LA119_21 = input.LA(1); + + + int index119_21 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_21); + if ( s>=0 ) return s; + break; + case 21 : + int LA119_22 = input.LA(1); + + + int index119_22 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_22); + if ( s>=0 ) return s; + break; + case 22 : + int LA119_23 = input.LA(1); + + + int index119_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_23); + if ( s>=0 ) return s; + break; + case 23 : + int LA119_24 = input.LA(1); + + + int index119_24 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_24); + if ( s>=0 ) return s; + break; + case 24 : + int LA119_25 = input.LA(1); + + + int index119_25 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_25); + if ( s>=0 ) return s; + break; + case 25 : + int LA119_26 = input.LA(1); + + + int index119_26 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_26); + if ( s>=0 ) return s; + break; + case 26 : + int LA119_27 = input.LA(1); + + + int index119_27 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_27); + if ( s>=0 ) return s; + break; + case 27 : + int LA119_28 = input.LA(1); + + + int index119_28 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_28); + if ( s>=0 ) return s; + break; + case 28 : + int LA119_29 = input.LA(1); + + + int index119_29 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_29); + if ( s>=0 ) return s; + break; + case 29 : + int LA119_30 = input.LA(1); + + + int index119_30 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_30); + if ( s>=0 ) return s; + break; + case 30 : + int LA119_31 = input.LA(1); + + + int index119_31 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_31); + if ( s>=0 ) return s; + break; + case 31 : + int LA119_32 = input.LA(1); + + + int index119_32 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalExpression()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index119_32); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 1, _s, input); + new NoViableAltException(getDescription(), 119, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_71s = "\117\uffff"; + static final String dfa_72s = "\1\2\116\uffff"; + static final String dfa_73s = "\1\4\1\0\115\uffff"; + static final String dfa_74s = "\1\150\1\0\115\uffff"; + static final String dfa_75s = "\2\uffff\1\2\113\uffff\1\1"; + static final String dfa_76s = "\1\uffff\1\0\115\uffff}>"; + static final String[] dfa_77s = { + "\1\2\1\uffff\4\2\6\uffff\4\2\1\uffff\1\2\1\uffff\10\2\1\uffff\3\2\1\uffff\1\2\1\1\7\2\12\uffff\3\2\1\uffff\1\2\3\uffff\52\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_71 = DFA.unpackEncodedString(dfa_71s); + static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s); + static final char[] dfa_73 = DFA.unpackEncodedStringToUnsignedChars(dfa_73s); + static final char[] dfa_74 = DFA.unpackEncodedStringToUnsignedChars(dfa_74s); + static final short[] dfa_75 = DFA.unpackEncodedString(dfa_75s); + static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s); + static final short[][] dfa_77 = unpackEncodedStringArray(dfa_77s); + + class DFA137 extends DFA { + + public DFA137(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 137; + this.eot = dfa_71; + this.eof = dfa_72; + this.min = dfa_73; + this.max = dfa_74; + this.accept = dfa_75; + this.special = dfa_76; + this.transition = dfa_77; + } + public String getDescription() { + return "8338:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA137_1 = input.LA(1); + + + int index137_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred46_InternalExpression()) ) {s = 78;} + + else if ( (true) ) {s = 2;} + + + input.seek(index137_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 137, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA135 extends DFA { + + public DFA135(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 135; + this.eot = dfa_71; + this.eof = dfa_72; + this.min = dfa_73; + this.max = dfa_74; + this.accept = dfa_75; + this.special = dfa_76; + this.transition = dfa_77; + } + public String getDescription() { + return "8432:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA135_1 = input.LA(1); + + + int index135_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred48_InternalExpression()) ) {s = 78;} + + else if ( (true) ) {s = 2;} + + + input.seek(index135_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 135, _s, input); error(nvae); throw nvae; } } + static final String dfa_78s = "\7\uffff"; + static final String dfa_79s = "\2\uffff\1\4\2\uffff\1\4\1\uffff"; + static final String dfa_80s = "\1\7\1\uffff\1\53\1\7\1\uffff\1\53\1\uffff"; + static final String dfa_81s = "\1\135\1\uffff\1\126\1\50\1\uffff\1\126\1\uffff"; + static final String dfa_82s = "\1\uffff\1\1\2\uffff\1\2\1\uffff\1\3"; + static final String dfa_83s = "\7\uffff}>"; + static final String[] dfa_84s = { + "\1\2\125\uffff\1\1", + "", + "\1\3\52\uffff\1\4", + "\1\5\40\uffff\1\6", + "", + "\1\3\52\uffff\1\4", + "" + }; + + static final short[] dfa_78 = DFA.unpackEncodedString(dfa_78s); + static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s); + static final char[] dfa_80 = DFA.unpackEncodedStringToUnsignedChars(dfa_80s); + static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s); + static final short[] dfa_82 = DFA.unpackEncodedString(dfa_82s); + static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s); + static final short[][] dfa_84 = unpackEncodedStringArray(dfa_84s); + + class DFA144 extends DFA { + + public DFA144(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 144; + this.eot = dfa_78; + this.eof = dfa_79; + this.min = dfa_80; + this.max = dfa_81; + this.accept = dfa_82; + this.special = dfa_83; + this.transition = dfa_84; + } + public String getDescription() { + return "8894:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) )"; + } + } public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000080L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000002000L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x1FEFF92000C890F0L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000004000L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x1C00000000000080L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000010000L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000020002L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000040002L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000100000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000200002L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000808000L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x1FEFF920008080F0L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000005000000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000002000000L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000008000002L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000010000002L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000020000002L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000FC0000002L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000003000000002L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x000000C000000002L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000020000000002L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000008000L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x1FEFF92000C990F0L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000040000010000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000080000000000L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x000FF00000000000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0010000000000000L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x1FEFF92002C890F0L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000040002000000L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x2000000000000000L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x4000000000000000L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x8000000000000002L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x7FBFE480032240F0L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x7000000000000080L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000040000L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000080002L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000100002L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000800002L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000002020000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x7FBFE480020200F0L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000014000000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000008000000L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000020000002L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000040000002L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000080000002L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000003F00000002L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x000000C000000002L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000030000000002L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000080000000002L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000020000L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x7FBFE480032640F0L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000100000040000L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000200000000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x003FC00000000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0040000000000000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x7FBFE4800B2240F0L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000100008000000L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x8000000000000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FF3A00000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000003000000002L,0x000000000000007CL}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000002000000000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000001400000000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000400000000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000300000002L,0x0000000000000180L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000003400000002L,0x0000000000000200L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000020080L,0x0000000000001000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000003000080002L,0x0000000000007C00L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000001000000000L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000002000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000030000000002L,0x0000000000018000L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000002L,0x0000000000020000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000002L,0x00000000000C0000L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000080000000002L,0x0000000000100002L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000080L,0x00000000F0000000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000002000000080L,0x00000001F0000000L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000120080L,0x0000000000001000L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000101000000000L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x8000080000020002L,0x0000000000100002L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x8BC004E0032603D0L,0x0000005FF3A01000L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x8000080000000002L,0x0000000000100002L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x8B8004E00B2203D0L,0x0000005FF3A00000L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FF3A00001L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000100000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x8BC004E0032203D0L,0x0000005FFFA01001L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0040100000000000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FFFA00001L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x8B8004E0032203D2L,0x0000005FFFE00000L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x8B8004E0032203D2L,0x0000005FFFA00000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FF3A01000L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x000010001C030080L,0x0000000000001000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000100010010000L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000100000010000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FFFE00000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000100000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FFFA00000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x8B8004E0032203D0L,0x0000005FF3E00000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x8B8004E0032603D0L,0x0000005FF3A00000L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x8B8004E00B2203D0L,0x0000005FFFA00000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x8B8004E00B2203D0L,0x0000005FFFE00000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000008002L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x8000000000020002L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x8000000000000002L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x8000002000020002L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x8000000000040000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x8B8004E0032203D2L,0x0000005FF3A00000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x000000A000000000L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000002L,0x000000A000000000L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000210L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000060080L,0x0000000000001000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000002000000002L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000082000000002L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000002L,0x0000000110000000L}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000080000000000L}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000010000000000L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000000080L,0x0000000020000000L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000000080L,0x0000000080000000L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000010000000080L}); + public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); + public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000000000000082L}); } \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/scoping/AbstractExpressionScopeProvider.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/scoping/AbstractExpressionScopeProvider.java index 9b65913398..2eb55ed356 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/scoping/AbstractExpressionScopeProvider.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/scoping/AbstractExpressionScopeProvider.java @@ -3,7 +3,7 @@ */ package com.avaloq.tools.ddk.xtext.expression.scoping; -import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider; +import org.eclipse.xtext.xbase.scoping.batch.XbaseBatchScopeProvider; -public abstract class AbstractExpressionScopeProvider extends DelegatingScopeProvider { +public abstract class AbstractExpressionScopeProvider extends XbaseBatchScopeProvider { } diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSemanticSequencer.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSemanticSequencer.java index 72dd29c40e..c757a1117b 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSemanticSequencer.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSemanticSequencer.java @@ -32,13 +32,58 @@ import org.eclipse.xtext.Action; import org.eclipse.xtext.Parameter; import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.common.types.JvmFormalParameter; +import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference; +import org.eclipse.xtext.common.types.JvmInnerTypeReference; +import org.eclipse.xtext.common.types.JvmLowerBound; +import org.eclipse.xtext.common.types.JvmParameterizedTypeReference; +import org.eclipse.xtext.common.types.JvmTypeParameter; +import org.eclipse.xtext.common.types.JvmUpperBound; +import org.eclipse.xtext.common.types.JvmWildcardTypeReference; +import org.eclipse.xtext.common.types.TypesPackage; import org.eclipse.xtext.serializer.ISerializationContext; import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; -import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer; import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; +import org.eclipse.xtext.xbase.XAssignment; +import org.eclipse.xtext.xbase.XBasicForLoopExpression; +import org.eclipse.xtext.xbase.XBinaryOperation; +import org.eclipse.xtext.xbase.XBlockExpression; +import org.eclipse.xtext.xbase.XBooleanLiteral; +import org.eclipse.xtext.xbase.XCasePart; +import org.eclipse.xtext.xbase.XCastedExpression; +import org.eclipse.xtext.xbase.XCatchClause; +import org.eclipse.xtext.xbase.XClosure; +import org.eclipse.xtext.xbase.XConstructorCall; +import org.eclipse.xtext.xbase.XDoWhileExpression; +import org.eclipse.xtext.xbase.XFeatureCall; +import org.eclipse.xtext.xbase.XForLoopExpression; +import org.eclipse.xtext.xbase.XIfExpression; +import org.eclipse.xtext.xbase.XInstanceOfExpression; +import org.eclipse.xtext.xbase.XListLiteral; +import org.eclipse.xtext.xbase.XMemberFeatureCall; +import org.eclipse.xtext.xbase.XNullLiteral; +import org.eclipse.xtext.xbase.XNumberLiteral; +import org.eclipse.xtext.xbase.XPostfixOperation; +import org.eclipse.xtext.xbase.XReturnExpression; +import org.eclipse.xtext.xbase.XSetLiteral; +import org.eclipse.xtext.xbase.XStringLiteral; +import org.eclipse.xtext.xbase.XSwitchExpression; +import org.eclipse.xtext.xbase.XSynchronizedExpression; +import org.eclipse.xtext.xbase.XThrowExpression; +import org.eclipse.xtext.xbase.XTryCatchFinallyExpression; +import org.eclipse.xtext.xbase.XTypeLiteral; +import org.eclipse.xtext.xbase.XUnaryOperation; +import org.eclipse.xtext.xbase.XVariableDeclaration; +import org.eclipse.xtext.xbase.XWhileExpression; +import org.eclipse.xtext.xbase.XbasePackage; +import org.eclipse.xtext.xbase.serializer.XbaseSemanticSequencer; +import org.eclipse.xtext.xtype.XFunctionTypeRef; +import org.eclipse.xtext.xtype.XImportDeclaration; +import org.eclipse.xtext.xtype.XImportSection; +import org.eclipse.xtext.xtype.XtypePackage; @SuppressWarnings("all") -public abstract class AbstractExpressionSemanticSequencer extends AbstractDelegatingSemanticSequencer { +public abstract class AbstractExpressionSemanticSequencer extends XbaseSemanticSequencer { @Inject private ExpressionGrammarAccess grammarAccess; @@ -296,6 +341,245 @@ else if (rule == grammarAccess.getFeatureCallRule() } else break; } + else if (epackage == TypesPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case TypesPackage.JVM_FORMAL_PARAMETER: + if (rule == grammarAccess.getFullJvmFormalParameterRule()) { + sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmFormalParameterRule()) { + sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject); + return; + } + else break; + case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE: + sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); + return; + case TypesPackage.JVM_INNER_TYPE_REFERENCE: + sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); + return; + case TypesPackage.JVM_LOWER_BOUND: + if (rule == grammarAccess.getJvmLowerBoundAndedRule()) { + sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmLowerBoundRule()) { + sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE: + if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) { + sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmTypeReferenceRule() + || action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0() + || rule == grammarAccess.getJvmParameterizedTypeReferenceRule() + || rule == grammarAccess.getJvmArgumentTypeReferenceRule()) { + sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else break; + case TypesPackage.JVM_TYPE_PARAMETER: + sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); + return; + case TypesPackage.JVM_UPPER_BOUND: + if (rule == grammarAccess.getJvmUpperBoundAndedRule()) { + sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmUpperBoundRule()) { + sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE: + sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); + return; + } + else if (epackage == XbasePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XbasePackage.XASSIGNMENT: + sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject); + return; + case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION: + sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject); + return; + case XbasePackage.XBINARY_OPERATION: + sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject); + return; + case XbasePackage.XBLOCK_EXPRESSION: + if (rule == grammarAccess.getXExpressionRule() + || rule == grammarAccess.getXAssignmentRule() + || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOrExpressionRule() + || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAndExpressionRule() + || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXEqualityExpressionRule() + || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXRelationalExpressionRule() + || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0() + || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOtherOperatorExpressionRule() + || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAdditiveExpressionRule() + || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXMultiplicativeExpressionRule() + || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXUnaryOperationRule() + || rule == grammarAccess.getXCastedExpressionRule() + || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0() + || rule == grammarAccess.getXPostfixOperationRule() + || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0() + || rule == grammarAccess.getXMemberFeatureCallRule() + || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0() + || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0() + || rule == grammarAccess.getXPrimaryExpressionRule() + || rule == grammarAccess.getXParenthesizedExpressionRule() + || rule == grammarAccess.getXBlockExpressionRule() + || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) { + sequence_XBlockExpression(context, (XBlockExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getXExpressionInClosureRule()) { + sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject); + return; + } + else break; + case XbasePackage.XBOOLEAN_LITERAL: + sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject); + return; + case XbasePackage.XCASE_PART: + sequence_XCasePart(context, (XCasePart) semanticObject); + return; + case XbasePackage.XCASTED_EXPRESSION: + sequence_XCastedExpression(context, (XCastedExpression) semanticObject); + return; + case XbasePackage.XCATCH_CLAUSE: + sequence_XCatchClause(context, (XCatchClause) semanticObject); + return; + case XbasePackage.XCLOSURE: + if (rule == grammarAccess.getXExpressionRule() + || rule == grammarAccess.getXAssignmentRule() + || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOrExpressionRule() + || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAndExpressionRule() + || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXEqualityExpressionRule() + || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXRelationalExpressionRule() + || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0() + || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOtherOperatorExpressionRule() + || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAdditiveExpressionRule() + || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXMultiplicativeExpressionRule() + || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXUnaryOperationRule() + || rule == grammarAccess.getXCastedExpressionRule() + || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0() + || rule == grammarAccess.getXPostfixOperationRule() + || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0() + || rule == grammarAccess.getXMemberFeatureCallRule() + || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0() + || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0() + || rule == grammarAccess.getXPrimaryExpressionRule() + || rule == grammarAccess.getXLiteralRule() + || rule == grammarAccess.getXClosureRule() + || rule == grammarAccess.getXParenthesizedExpressionRule() + || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) { + sequence_XClosure(context, (XClosure) semanticObject); + return; + } + else if (rule == grammarAccess.getXShortClosureRule()) { + sequence_XShortClosure(context, (XClosure) semanticObject); + return; + } + else break; + case XbasePackage.XCONSTRUCTOR_CALL: + sequence_XConstructorCall(context, (XConstructorCall) semanticObject); + return; + case XbasePackage.XDO_WHILE_EXPRESSION: + sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject); + return; + case XbasePackage.XFEATURE_CALL: + sequence_XFeatureCall(context, (XFeatureCall) semanticObject); + return; + case XbasePackage.XFOR_LOOP_EXPRESSION: + sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject); + return; + case XbasePackage.XIF_EXPRESSION: + sequence_XIfExpression(context, (XIfExpression) semanticObject); + return; + case XbasePackage.XINSTANCE_OF_EXPRESSION: + sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject); + return; + case XbasePackage.XLIST_LITERAL: + sequence_XListLiteral(context, (XListLiteral) semanticObject); + return; + case XbasePackage.XMEMBER_FEATURE_CALL: + sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject); + return; + case XbasePackage.XNULL_LITERAL: + sequence_XNullLiteral(context, (XNullLiteral) semanticObject); + return; + case XbasePackage.XNUMBER_LITERAL: + sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject); + return; + case XbasePackage.XPOSTFIX_OPERATION: + sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject); + return; + case XbasePackage.XRETURN_EXPRESSION: + sequence_XReturnExpression(context, (XReturnExpression) semanticObject); + return; + case XbasePackage.XSET_LITERAL: + sequence_XSetLiteral(context, (XSetLiteral) semanticObject); + return; + case XbasePackage.XSTRING_LITERAL: + sequence_XStringLiteral(context, (XStringLiteral) semanticObject); + return; + case XbasePackage.XSWITCH_EXPRESSION: + sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject); + return; + case XbasePackage.XSYNCHRONIZED_EXPRESSION: + sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject); + return; + case XbasePackage.XTHROW_EXPRESSION: + sequence_XThrowExpression(context, (XThrowExpression) semanticObject); + return; + case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION: + sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject); + return; + case XbasePackage.XTYPE_LITERAL: + sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject); + return; + case XbasePackage.XUNARY_OPERATION: + sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject); + return; + case XbasePackage.XVARIABLE_DECLARATION: + sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject); + return; + case XbasePackage.XWHILE_EXPRESSION: + sequence_XWhileExpression(context, (XWhileExpression) semanticObject); + return; + } + else if (epackage == XtypePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XtypePackage.XFUNCTION_TYPE_REF: + sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); + return; + case XtypePackage.XIMPORT_DECLARATION: + sequence_XImportDeclaration(context, (XImportDeclaration) semanticObject); + return; + case XtypePackage.XIMPORT_SECTION: + sequence_XImportSection(context, (XImportSection) semanticObject); + return; + } if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); } diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSyntacticSequencer.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSyntacticSequencer.java index 5d0927d9b1..fc48dad085 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSyntacticSequencer.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/serializer/AbstractExpressionSyntacticSequencer.java @@ -11,6 +11,7 @@ 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.GroupAlias; import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; @@ -22,19 +23,56 @@ public abstract class AbstractExpressionSyntacticSequencer extends AbstractSynta protected ExpressionGrammarAccess grammarAccess; protected AbstractElementAlias match_ParanthesizedExpression_LeftParenthesisKeyword_0_a; protected AbstractElementAlias match_ParanthesizedExpression_LeftParenthesisKeyword_0_p; + protected AbstractElementAlias match_XBlockExpression_SemicolonKeyword_2_1_q; + protected AbstractElementAlias match_XExpressionInClosure_SemicolonKeyword_1_1_q; + protected AbstractElementAlias match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q; + protected AbstractElementAlias match_XImportDeclaration_SemicolonKeyword_2_q; + protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_a; + protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_p; @Inject protected void init(IGrammarAccess access) { grammarAccess = (ExpressionGrammarAccess) access; match_ParanthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); match_ParanthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + match_XBlockExpression_SemicolonKeyword_2_1_q = new TokenAlias(false, true, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + match_XExpressionInClosure_SemicolonKeyword_1_1_q = new TokenAlias(false, true, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()), new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2())); + match_XImportDeclaration_SemicolonKeyword_2_q = new TokenAlias(false, true, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + match_XParenthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + match_XParenthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } @Override protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (ruleCall.getRule() == grammarAccess.getArrayBracketsRule()) + return getArrayBracketsToken(semanticObject, ruleCall, node); + else if (ruleCall.getRule() == grammarAccess.getOpSingleAssignRule()) + return getOpSingleAssignToken(semanticObject, ruleCall, node); return ""; } + /** + * ArrayBrackets : + * '[' ']' + * ; + */ + protected String getArrayBracketsToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "[ ]"; + } + + /** + * OpSingleAssign: + * '=' + * ; + */ + protected String getOpSingleAssignToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "="; + } @Override protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { @@ -46,6 +84,18 @@ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition trans emit_ParanthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes); else if (match_ParanthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax)) emit_ParanthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XBlockExpression_SemicolonKeyword_2_1_q.equals(syntax)) + emit_XBlockExpression_SemicolonKeyword_2_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XExpressionInClosure_SemicolonKeyword_1_1_q.equals(syntax)) + emit_XExpressionInClosure_SemicolonKeyword_1_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q.equals(syntax)) + emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XImportDeclaration_SemicolonKeyword_2_q.equals(syntax)) + emit_XImportDeclaration_SemicolonKeyword_2_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_a.equals(syntax)) + emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax)) + emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes); else acceptNodes(getLastNavigableState(), syntaxNodes); } } @@ -150,4 +200,176 @@ protected void emit_ParanthesizedExpression_LeftParenthesisKeyword_0_p(EObject s acceptNodes(transition, nodes); } + /** + * 

+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' ')' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 
+	 *
+ */ + protected void emit_XBlockExpression_SemicolonKeyword_2_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 
+	 *
+ */ + protected void emit_XExpressionInClosure_SemicolonKeyword_1_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ('(' ')')?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '=>' returnType=JvmTypeReference
+	 
+	 *
+ */ + protected void emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     importedNamespace=QualifiedNameWithWildcard (ambiguity) (rule end)
+	 *     importedType=[JvmDeclaredType|QualifiedName] (ambiguity) (rule end)
+	 *     memberName=ValidID (ambiguity) (rule end)
+	 *     wildcard?='*' (ambiguity) (rule end)
+	 
+	 *
+ */ + protected void emit_XImportDeclaration_SemicolonKeyword_2_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     '('*
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' (rule start)
+	 *     (rule start) (ambiguity) 'return' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 
+	 *
+ */ + protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     '('+
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' ')' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 
+	 *
+ */ + protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + } diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/services/ExpressionGrammarAccess.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/services/ExpressionGrammarAccess.java index 274810a565..97f546c09c 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/services/ExpressionGrammarAccess.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/services/ExpressionGrammarAccess.java @@ -16,9 +16,10 @@ import org.eclipse.xtext.ParserRule; import org.eclipse.xtext.RuleCall; import org.eclipse.xtext.TerminalRule; -import org.eclipse.xtext.common.services.TerminalsGrammarAccess; import org.eclipse.xtext.service.AbstractElementFinder; import org.eclipse.xtext.service.GrammarProvider; +import org.eclipse.xtext.xbase.services.XbaseGrammarAccess; +import org.eclipse.xtext.xbase.services.XtypeGrammarAccess; @Singleton public class ExpressionGrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { @@ -1710,13 +1711,17 @@ public class IdentifierElements extends AbstractParserRuleElementFinder { private final Grammar grammar; - private final TerminalsGrammarAccess gaTerminals; + private final XbaseGrammarAccess gaXbase; + + private final XtypeGrammarAccess gaXtype; @Inject public ExpressionGrammarAccess(GrammarProvider grammarProvider, - TerminalsGrammarAccess gaTerminals) { + XbaseGrammarAccess gaXbase, + XtypeGrammarAccess gaXtype) { this.grammar = internalFindGrammar(grammarProvider); - this.gaTerminals = gaTerminals; + this.gaXbase = gaXbase; + this.gaXtype = gaXtype; this.pExpression = new ExpressionElements(); this.pSyntaxElement = new SyntaxElementElements(); this.pLetExpression = new LetExpressionElements(); @@ -1780,8 +1785,12 @@ public Grammar getGrammar() { } - public TerminalsGrammarAccess getTerminalsGrammarAccess() { - return gaTerminals; + public XbaseGrammarAccess getXbaseGrammarAccess() { + return gaXbase; + } + + public XtypeGrammarAccess getXtypeGrammarAccess() { + return gaXtype; } @@ -2275,41 +2284,976 @@ public ParserRule getIdentifierRule() { return getIdentifierAccess().getRule(); } - //terminal ID: '^'?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; - public TerminalRule getIDRule() { - return gaTerminals.getIDRule(); + //XExpression returns XExpression : + // XAssignment; + public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() { + return gaXbase.getXExpressionAccess(); + } + + public ParserRule getXExpressionRule() { + return getXExpressionAccess().getRule(); } - //terminal INT returns ecore::EInt: ('0'..'9')+; + //XAssignment returns XExpression : + // {XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | + // XOrExpression ( + // =>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign]) rightOperand=XAssignment + // )?; + public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() { + return gaXbase.getXAssignmentAccess(); + } + + public ParserRule getXAssignmentRule() { + return getXAssignmentAccess().getRule(); + } + + //OpSingleAssign: + // '=' + //; + public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() { + return gaXbase.getOpSingleAssignAccess(); + } + + public ParserRule getOpSingleAssignRule() { + return getOpSingleAssignAccess().getRule(); + } + + //OpMultiAssign: + // '+=' | '-=' | '*=' | '/=' | '%=' | + // '<' '<' '=' | + // '>' '>'? '>='; + public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() { + return gaXbase.getOpMultiAssignAccess(); + } + + public ParserRule getOpMultiAssignRule() { + return getOpMultiAssignAccess().getRule(); + } + + //XOrExpression returns XExpression: + // XAndExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr]) rightOperand=XAndExpression)*; + public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() { + return gaXbase.getXOrExpressionAccess(); + } + + public ParserRule getXOrExpressionRule() { + return getXOrExpressionAccess().getRule(); + } + + //OpOr: + // '||'; + public XbaseGrammarAccess.OpOrElements getOpOrAccess() { + return gaXbase.getOpOrAccess(); + } + + public ParserRule getOpOrRule() { + return getOpOrAccess().getRule(); + } + + //XAndExpression returns XExpression: + // XEqualityExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd]) rightOperand=XEqualityExpression)*; + public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() { + return gaXbase.getXAndExpressionAccess(); + } + + public ParserRule getXAndExpressionRule() { + return getXAndExpressionAccess().getRule(); + } + + //OpAnd: + // '&&'; + public XbaseGrammarAccess.OpAndElements getOpAndAccess() { + return gaXbase.getOpAndAccess(); + } + + public ParserRule getOpAndRule() { + return getOpAndAccess().getRule(); + } + + //XEqualityExpression returns XExpression: + // XRelationalExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality]) + // rightOperand=XRelationalExpression)*; + public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() { + return gaXbase.getXEqualityExpressionAccess(); + } + + public ParserRule getXEqualityExpressionRule() { + return getXEqualityExpressionAccess().getRule(); + } + + //OpEquality: + // '==' | '!=' | '===' | '!=='; + public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() { + return gaXbase.getOpEqualityAccess(); + } + + public ParserRule getOpEqualityRule() { + return getOpEqualityAccess().getRule(); + } + + //XRelationalExpression returns XExpression: + // XOtherOperatorExpression + // (=>({XInstanceOfExpression.expression=current} 'instanceof') type=JvmTypeReference | + // =>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare]) rightOperand=XOtherOperatorExpression)*; + public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() { + return gaXbase.getXRelationalExpressionAccess(); + } + + public ParserRule getXRelationalExpressionRule() { + return getXRelationalExpressionAccess().getRule(); + } + + //OpCompare: + // '>=' | '<' '=' | '>' | '<' ; + public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() { + return gaXbase.getOpCompareAccess(); + } + + public ParserRule getOpCompareRule() { + return getOpCompareAccess().getRule(); + } + + //XOtherOperatorExpression returns XExpression: + // XAdditiveExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther]) + // rightOperand=XAdditiveExpression)*; + public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() { + return gaXbase.getXOtherOperatorExpressionAccess(); + } + + public ParserRule getXOtherOperatorExpressionRule() { + return getXOtherOperatorExpressionAccess().getRule(); + } + + //OpOther: + // '->' + // | '..<' + // | '>' '..' + // | '..' + // | '=>' + // | '>' (=>('>' '>') | '>') + // | '<' (=>('<' '<') | '<' | '=>') + // | '<>' + // | '?:'; + public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() { + return gaXbase.getOpOtherAccess(); + } + + public ParserRule getOpOtherRule() { + return getOpOtherAccess().getRule(); + } + + //XAdditiveExpression returns XExpression: + // XMultiplicativeExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd]) + // rightOperand=XMultiplicativeExpression)*; + public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() { + return gaXbase.getXAdditiveExpressionAccess(); + } + + public ParserRule getXAdditiveExpressionRule() { + return getXAdditiveExpressionAccess().getRule(); + } + + //OpAdd: + // '+' | '-'; + public XbaseGrammarAccess.OpAddElements getOpAddAccess() { + return gaXbase.getOpAddAccess(); + } + + public ParserRule getOpAddRule() { + return getOpAddAccess().getRule(); + } + + //XMultiplicativeExpression returns XExpression: + // XUnaryOperation (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti]) rightOperand=XUnaryOperation)*; + public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() { + return gaXbase.getXMultiplicativeExpressionAccess(); + } + + public ParserRule getXMultiplicativeExpressionRule() { + return getXMultiplicativeExpressionAccess().getRule(); + } + + //OpMulti: + // '*' | '**' | '/' | '%'; + public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() { + return gaXbase.getOpMultiAccess(); + } + + public ParserRule getOpMultiRule() { + return getOpMultiAccess().getRule(); + } + + //XUnaryOperation returns XExpression: + // {XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation + // | XCastedExpression; + public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() { + return gaXbase.getXUnaryOperationAccess(); + } + + public ParserRule getXUnaryOperationRule() { + return getXUnaryOperationAccess().getRule(); + } + + //OpUnary: + // "!" | "-" | "+"; + public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() { + return gaXbase.getOpUnaryAccess(); + } + + public ParserRule getOpUnaryRule() { + return getOpUnaryAccess().getRule(); + } + + //XCastedExpression returns XExpression: + // XPostfixOperation (=>({XCastedExpression.target=current} 'as') type=JvmTypeReference)* + //; + public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() { + return gaXbase.getXCastedExpressionAccess(); + } + + public ParserRule getXCastedExpressionRule() { + return getXCastedExpressionAccess().getRule(); + } + + //XPostfixOperation returns XExpression: + // XMemberFeatureCall =>({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])? + //; + public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() { + return gaXbase.getXPostfixOperationAccess(); + } + + public ParserRule getXPostfixOperationRule() { + return getXPostfixOperationAccess().getRule(); + } + + //OpPostfix: + // "++" | "--" + //; + public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() { + return gaXbase.getOpPostfixAccess(); + } + + public ParserRule getOpPostfixRule() { + return getOpPostfixAccess().getRule(); + } + + //XMemberFeatureCall returns XExpression: + // XPrimaryExpression + // (=>({XAssignment.assignable=current} ('.'|explicitStatic?="::") feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment + // |=>({XMemberFeatureCall.memberCallTarget=current} ("."|nullSafe?="?."|explicitStatic?="::")) + // ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // feature=[types::JvmIdentifiableElement|IdOrSuper] ( + // =>explicitOperationCall?='(' + // ( + // memberCallArguments+=XShortClosure + // | memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)* + // )? + // ')')? + // memberCallArguments+=XClosure? + // )*; + public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() { + return gaXbase.getXMemberFeatureCallAccess(); + } + + public ParserRule getXMemberFeatureCallRule() { + return getXMemberFeatureCallAccess().getRule(); + } + + //XPrimaryExpression returns XExpression: + // XConstructorCall | + // XBlockExpression | + // XSwitchExpression | + // XSynchronizedExpression | + // XFeatureCall | + // XLiteral | + // XIfExpression | + // XForLoopExpression | + // XBasicForLoopExpression | + // XWhileExpression | + // XDoWhileExpression | + // XThrowExpression | + // XReturnExpression | + // XTryCatchFinallyExpression | + // XParenthesizedExpression; + public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() { + return gaXbase.getXPrimaryExpressionAccess(); + } + + public ParserRule getXPrimaryExpressionRule() { + return getXPrimaryExpressionAccess().getRule(); + } + + //XLiteral returns XExpression: + // XCollectionLiteral | + // XClosure | + // XBooleanLiteral | + // XNumberLiteral | + // XNullLiteral | + // XStringLiteral | + // XTypeLiteral + //; + public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() { + return gaXbase.getXLiteralAccess(); + } + + public ParserRule getXLiteralRule() { + return getXLiteralAccess().getRule(); + } + + //XCollectionLiteral: + // XSetLiteral | XListLiteral + //; + public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() { + return gaXbase.getXCollectionLiteralAccess(); + } + + public ParserRule getXCollectionLiteralRule() { + return getXCollectionLiteralAccess().getRule(); + } + + //XSetLiteral: + // {XSetLiteral} '#' '{' (elements+=XExpression (',' elements+=XExpression )*)? '}' + //; + public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() { + return gaXbase.getXSetLiteralAccess(); + } + + public ParserRule getXSetLiteralRule() { + return getXSetLiteralAccess().getRule(); + } + + //XListLiteral: + // {XListLiteral} '#' '[' (elements+=XExpression (',' elements+=XExpression )*)? ']' + //; + public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() { + return gaXbase.getXListLiteralAccess(); + } + + public ParserRule getXListLiteralRule() { + return getXListLiteralAccess().getRule(); + } + + //XClosure returns XExpression: + // =>({XClosure} + // '[') + // =>((declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?='|')? + // expression=XExpressionInClosure + // ']'; + public XbaseGrammarAccess.XClosureElements getXClosureAccess() { + return gaXbase.getXClosureAccess(); + } + + public ParserRule getXClosureRule() { + return getXClosureAccess().getRule(); + } + + //XExpressionInClosure returns XExpression: + // {XBlockExpression} + // (expressions+=XExpressionOrVarDeclaration ';'?)* + //; + public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() { + return gaXbase.getXExpressionInClosureAccess(); + } + + public ParserRule getXExpressionInClosureRule() { + return getXExpressionInClosureAccess().getRule(); + } + + //XShortClosure returns XExpression: + // =>({XClosure} (declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?='|') expression=XExpression; + public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() { + return gaXbase.getXShortClosureAccess(); + } + + public ParserRule getXShortClosureRule() { + return getXShortClosureAccess().getRule(); + } + + //XParenthesizedExpression returns XExpression: + // '(' XExpression ')'; + public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() { + return gaXbase.getXParenthesizedExpressionAccess(); + } + + public ParserRule getXParenthesizedExpressionRule() { + return getXParenthesizedExpressionAccess().getRule(); + } + + //XIfExpression returns XExpression: + // {XIfExpression} + // 'if' '(' if=XExpression ')' + // then=XExpression + // (=>'else' else=XExpression)?; + public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() { + return gaXbase.getXIfExpressionAccess(); + } + + public ParserRule getXIfExpressionRule() { + return getXIfExpressionAccess().getRule(); + } + + //XSwitchExpression returns XExpression: + // {XSwitchExpression} + // 'switch' (=>('(' declaredParam=JvmFormalParameter ':') switch=XExpression ')' + // | =>(declaredParam=JvmFormalParameter ':')? switch=XExpression) '{' + // (cases+=XCasePart)* + // ('default' ':' default=XExpression )? + // '}'; + public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() { + return gaXbase.getXSwitchExpressionAccess(); + } + + public ParserRule getXSwitchExpressionRule() { + return getXSwitchExpressionAccess().getRule(); + } + + //XCasePart: + // {XCasePart} + // typeGuard=JvmTypeReference? ('case' case=XExpression)? + // (':' then=XExpression | fallThrough?=',') ; + public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() { + return gaXbase.getXCasePartAccess(); + } + + public ParserRule getXCasePartRule() { + return getXCasePartAccess().getRule(); + } + + //XForLoopExpression returns XExpression: + // =>({XForLoopExpression} + // 'for' '(' declaredParam=JvmFormalParameter ':') forExpression=XExpression ')' + // eachExpression=XExpression; + public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() { + return gaXbase.getXForLoopExpressionAccess(); + } + + public ParserRule getXForLoopExpressionRule() { + return getXForLoopExpressionAccess().getRule(); + } + + //XBasicForLoopExpression returns XExpression: + // {XBasicForLoopExpression} + // 'for' '('(initExpressions+=XExpressionOrVarDeclaration (',' initExpressions+=XExpressionOrVarDeclaration)*)? ';' + // expression=XExpression? ';' + // (updateExpressions+=XExpression (',' updateExpressions+=XExpression)*)? ')' + // eachExpression=XExpression; + public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() { + return gaXbase.getXBasicForLoopExpressionAccess(); + } + + public ParserRule getXBasicForLoopExpressionRule() { + return getXBasicForLoopExpressionAccess().getRule(); + } + + //XWhileExpression returns XExpression: + // {XWhileExpression} + // 'while' '(' predicate=XExpression ')' + // body=XExpression; + public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() { + return gaXbase.getXWhileExpressionAccess(); + } + + public ParserRule getXWhileExpressionRule() { + return getXWhileExpressionAccess().getRule(); + } + + //XDoWhileExpression returns XExpression: + // {XDoWhileExpression} + // 'do' + // body=XExpression + // 'while' '(' predicate=XExpression ')'; + public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() { + return gaXbase.getXDoWhileExpressionAccess(); + } + + public ParserRule getXDoWhileExpressionRule() { + return getXDoWhileExpressionAccess().getRule(); + } + + //XBlockExpression returns XExpression: + // {XBlockExpression} + // '{' + // (expressions+=XExpressionOrVarDeclaration ';'?)* + // '}'; + public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() { + return gaXbase.getXBlockExpressionAccess(); + } + + public ParserRule getXBlockExpressionRule() { + return getXBlockExpressionAccess().getRule(); + } + + //XExpressionOrVarDeclaration returns XExpression: + // XVariableDeclaration | XExpression; + public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() { + return gaXbase.getXExpressionOrVarDeclarationAccess(); + } + + public ParserRule getXExpressionOrVarDeclarationRule() { + return getXExpressionOrVarDeclarationAccess().getRule(); + } + + //XVariableDeclaration returns XExpression: + // {XVariableDeclaration} + // (writeable?='var'|'val') (=>(type=JvmTypeReference name=ValidID) | name=ValidID) ('=' right=XExpression)?; + public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() { + return gaXbase.getXVariableDeclarationAccess(); + } + + public ParserRule getXVariableDeclarationRule() { + return getXVariableDeclarationAccess().getRule(); + } + + //JvmFormalParameter returns types::JvmFormalParameter: + // (parameterType=JvmTypeReference)? name=ValidID; + public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() { + return gaXbase.getJvmFormalParameterAccess(); + } + + public ParserRule getJvmFormalParameterRule() { + return getJvmFormalParameterAccess().getRule(); + } + + //FullJvmFormalParameter returns types::JvmFormalParameter: + // parameterType=JvmTypeReference name=ValidID; + public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() { + return gaXbase.getFullJvmFormalParameterAccess(); + } + + public ParserRule getFullJvmFormalParameterRule() { + return getFullJvmFormalParameterAccess().getRule(); + } + + //XFeatureCall returns XExpression: + // {XFeatureCall} + // ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // feature=[types::JvmIdentifiableElement|IdOrSuper] + // (=>explicitOperationCall?='(' + // ( + // featureCallArguments+=XShortClosure + // | featureCallArguments+=XExpression (',' featureCallArguments+=XExpression)* + // )? + // ')')? + // featureCallArguments+=XClosure?; + public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() { + return gaXbase.getXFeatureCallAccess(); + } + + public ParserRule getXFeatureCallRule() { + return getXFeatureCallAccess().getRule(); + } + + //FeatureCallID: + // ValidID | 'extends' | 'static' | 'import' | 'extension' + //; + public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() { + return gaXbase.getFeatureCallIDAccess(); + } + + public ParserRule getFeatureCallIDRule() { + return getFeatureCallIDAccess().getRule(); + } + + //IdOrSuper : + // FeatureCallID | 'super' + //; + public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() { + return gaXbase.getIdOrSuperAccess(); + } + + public ParserRule getIdOrSuperRule() { + return getIdOrSuperAccess().getRule(); + } + + //XConstructorCall returns XExpression: + // {XConstructorCall} + // 'new' constructor=[types::JvmConstructor|QualifiedName] + // (=>'<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // (=>explicitConstructorCall?='(' + // ( + // arguments+=XShortClosure + // | arguments+=XExpression (',' arguments+=XExpression)* + // )? + // ')')? + // arguments+=XClosure?; + public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() { + return gaXbase.getXConstructorCallAccess(); + } + + public ParserRule getXConstructorCallRule() { + return getXConstructorCallAccess().getRule(); + } + + //XBooleanLiteral returns XExpression : + // {XBooleanLiteral} ('false' | isTrue?='true'); + public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() { + return gaXbase.getXBooleanLiteralAccess(); + } + + public ParserRule getXBooleanLiteralRule() { + return getXBooleanLiteralAccess().getRule(); + } + + //XNullLiteral returns XExpression : + // {XNullLiteral} 'null'; + public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() { + return gaXbase.getXNullLiteralAccess(); + } + + public ParserRule getXNullLiteralRule() { + return getXNullLiteralAccess().getRule(); + } + + //XNumberLiteral returns XExpression : + // {XNumberLiteral} value=Number; + public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() { + return gaXbase.getXNumberLiteralAccess(); + } + + public ParserRule getXNumberLiteralRule() { + return getXNumberLiteralAccess().getRule(); + } + + //XStringLiteral returns XExpression: + // {XStringLiteral} value=STRING; + public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() { + return gaXbase.getXStringLiteralAccess(); + } + + public ParserRule getXStringLiteralRule() { + return getXStringLiteralAccess().getRule(); + } + + //XTypeLiteral returns XExpression : + // {XTypeLiteral} 'typeof' '(' type=[types::JvmType|QualifiedName] (arrayDimensions+=ArrayBrackets)* ')' + //; + public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() { + return gaXbase.getXTypeLiteralAccess(); + } + + public ParserRule getXTypeLiteralRule() { + return getXTypeLiteralAccess().getRule(); + } + + //XThrowExpression returns XExpression : + // {XThrowExpression} 'throw' expression=XExpression; + public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() { + return gaXbase.getXThrowExpressionAccess(); + } + + public ParserRule getXThrowExpressionRule() { + return getXThrowExpressionAccess().getRule(); + } + + //XReturnExpression returns XExpression : + // {XReturnExpression} 'return' (->expression=XExpression)?; + public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() { + return gaXbase.getXReturnExpressionAccess(); + } + + public ParserRule getXReturnExpressionRule() { + return getXReturnExpressionAccess().getRule(); + } + + //XTryCatchFinallyExpression returns XExpression: + // {XTryCatchFinallyExpression} + // 'try' + // expression=XExpression + // ( + // catchClauses+=XCatchClause+ + // (=>'finally' finallyExpression=XExpression)? + // | 'finally' finallyExpression=XExpression + // ); + public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() { + return gaXbase.getXTryCatchFinallyExpressionAccess(); + } + + public ParserRule getXTryCatchFinallyExpressionRule() { + return getXTryCatchFinallyExpressionAccess().getRule(); + } + + //XSynchronizedExpression returns XExpression: + // =>({XSynchronizedExpression} + // 'synchronized' '(') param=XExpression ')' expression=XExpression; + public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() { + return gaXbase.getXSynchronizedExpressionAccess(); + } + + public ParserRule getXSynchronizedExpressionRule() { + return getXSynchronizedExpressionAccess().getRule(); + } + + //XCatchClause : + // =>'catch' '(' declaredParam=FullJvmFormalParameter ')' expression=XExpression; + public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() { + return gaXbase.getXCatchClauseAccess(); + } + + public ParserRule getXCatchClauseRule() { + return getXCatchClauseAccess().getRule(); + } + + //@Override + //QualifiedName: + // ValidID (=>'.' ValidID)*; + public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() { + return gaXbase.getQualifiedNameAccess(); + } + + public ParserRule getQualifiedNameRule() { + return getQualifiedNameAccess().getRule(); + } + + //Number hidden(): + // HEX | (INT | DECIMAL) ('.' (INT | DECIMAL))?; + public XbaseGrammarAccess.NumberElements getNumberAccess() { + return gaXbase.getNumberAccess(); + } + + public ParserRule getNumberRule() { + return getNumberAccess().getRule(); + } + + ///** + // * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes, + // * which makes downstream grammars break on classloading, when a rule is removed. + // */ + //StaticQualifier: + // (ValidID '::')+ + //; + public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() { + return gaXbase.getStaticQualifierAccess(); + } + + public ParserRule getStaticQualifierRule() { + return getStaticQualifierAccess().getRule(); + } + + //terminal HEX: + // ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ + // ('#' (('b'|'B')('i'|'I') | ('l'|'L')))?; + public TerminalRule getHEXRule() { + return gaXbase.getHEXRule(); + } + + //terminal INT returns ecore::EInt: + // '0'..'9' ('0'..'9'|'_')*; public TerminalRule getINTRule() { - return gaTerminals.getINTRule(); + return gaXbase.getINTRule(); + } + + //terminal DECIMAL: + // INT + // (('e'|'E') ('+'|'-')? INT)? + // (('b'|'B')('i'|'I'|'d'|'D') | ('l'|'L'|'d'|'D'|'f'|'F'))?; + public TerminalRule getDECIMALRule() { + return gaXbase.getDECIMALRule(); + } + + //JvmTypeReference: + // JvmParameterizedTypeReference =>({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)* + // | XFunctionTypeRef; + public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() { + return gaXtype.getJvmTypeReferenceAccess(); + } + + public ParserRule getJvmTypeReferenceRule() { + return getJvmTypeReferenceAccess().getRule(); + } + + //ArrayBrackets : + // '[' ']' + //; + public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() { + return gaXtype.getArrayBracketsAccess(); + } + + public ParserRule getArrayBracketsRule() { + return getArrayBracketsAccess().getRule(); + } + + //XFunctionTypeRef: + // ('(' (paramTypes+=JvmTypeReference (',' paramTypes+=JvmTypeReference)*)? ')')? '=>' returnType=JvmTypeReference; + public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() { + return gaXtype.getXFunctionTypeRefAccess(); + } + + public ParserRule getXFunctionTypeRefRule() { + return getXFunctionTypeRefAccess().getRule(); + } + + //JvmParameterizedTypeReference: + // type=[JvmType|QualifiedName] ( + // =>'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>' + // (=>({JvmInnerTypeReference.outer=current} '.') type=[JvmType|ValidID] (=>'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>')?)* + // )?; + public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() { + return gaXtype.getJvmParameterizedTypeReferenceAccess(); + } + + public ParserRule getJvmParameterizedTypeReferenceRule() { + return getJvmParameterizedTypeReferenceAccess().getRule(); + } + + //JvmArgumentTypeReference returns JvmTypeReference: + // JvmTypeReference | JvmWildcardTypeReference; + public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() { + return gaXtype.getJvmArgumentTypeReferenceAccess(); + } + + public ParserRule getJvmArgumentTypeReferenceRule() { + return getJvmArgumentTypeReferenceAccess().getRule(); + } + + //JvmWildcardTypeReference: + // {JvmWildcardTypeReference} '?' ( + // constraints+=JvmUpperBound (constraints+=JvmUpperBoundAnded)* + // | constraints+=JvmLowerBound (constraints+=JvmLowerBoundAnded)* + // )?; + public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() { + return gaXtype.getJvmWildcardTypeReferenceAccess(); + } + + public ParserRule getJvmWildcardTypeReferenceRule() { + return getJvmWildcardTypeReferenceAccess().getRule(); + } + + //JvmUpperBound : + // 'extends' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() { + return gaXtype.getJvmUpperBoundAccess(); + } + + public ParserRule getJvmUpperBoundRule() { + return getJvmUpperBoundAccess().getRule(); + } + + //JvmUpperBoundAnded returns JvmUpperBound: + // '&' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() { + return gaXtype.getJvmUpperBoundAndedAccess(); + } + + public ParserRule getJvmUpperBoundAndedRule() { + return getJvmUpperBoundAndedAccess().getRule(); + } + + //JvmLowerBound : + // 'super' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() { + return gaXtype.getJvmLowerBoundAccess(); + } + + public ParserRule getJvmLowerBoundRule() { + return getJvmLowerBoundAccess().getRule(); + } + + //JvmLowerBoundAnded returns JvmLowerBound: + // '&' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() { + return gaXtype.getJvmLowerBoundAndedAccess(); + } + + public ParserRule getJvmLowerBoundAndedRule() { + return getJvmLowerBoundAndedAccess().getRule(); + } + + //JvmTypeParameter : + // name=ValidID + // (constraints+=JvmUpperBound (constraints+=JvmUpperBoundAnded)*)?; + public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() { + return gaXtype.getJvmTypeParameterAccess(); + } + + public ParserRule getJvmTypeParameterRule() { + return getJvmTypeParameterAccess().getRule(); + } + + //QualifiedNameWithWildcard : + // QualifiedName '.' '*'; + public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() { + return gaXtype.getQualifiedNameWithWildcardAccess(); + } + + public ParserRule getQualifiedNameWithWildcardRule() { + return getQualifiedNameWithWildcardAccess().getRule(); + } + + //ValidID: + // ID; + public XtypeGrammarAccess.ValidIDElements getValidIDAccess() { + return gaXtype.getValidIDAccess(); + } + + public ParserRule getValidIDRule() { + return getValidIDAccess().getRule(); + } + + //XImportSection: + // importDeclarations+=XImportDeclaration+; + public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() { + return gaXtype.getXImportSectionAccess(); + } + + public ParserRule getXImportSectionRule() { + return getXImportSectionAccess().getRule(); + } + + //XImportDeclaration: + // 'import' ( + // (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID)) + // | importedType=[JvmDeclaredType|QualifiedName] + // | importedNamespace=QualifiedNameWithWildcard) ';'? + //; + public XtypeGrammarAccess.XImportDeclarationElements getXImportDeclarationAccess() { + return gaXtype.getXImportDeclarationAccess(); + } + + public ParserRule getXImportDeclarationRule() { + return getXImportDeclarationAccess().getRule(); + } + + //QualifiedNameInStaticImport: + // (ValidID '.')+ + //; + public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() { + return gaXtype.getQualifiedNameInStaticImportAccess(); + } + + public ParserRule getQualifiedNameInStaticImportRule() { + return getQualifiedNameInStaticImportAccess().getRule(); + } + + //terminal ID: + // '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; + public TerminalRule getIDRule() { + return gaXtype.getIDRule(); } //terminal STRING: - // '"' ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|'"') )* '"' | - // "'" ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|"'") )* "'" - // ; + // '"' ( '\\' . /* ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') */ | !('\\'|'"') )* '"'? | + // "'" ( '\\' . /* ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') */ | !('\\'|"'") )* "'"?; public TerminalRule getSTRINGRule() { - return gaTerminals.getSTRINGRule(); + return gaXtype.getSTRINGRule(); } - //terminal ML_COMMENT : '/*' -> '*/'; + //terminal ML_COMMENT: '/*' -> '*/'; public TerminalRule getML_COMMENTRule() { - return gaTerminals.getML_COMMENTRule(); + return gaXtype.getML_COMMENTRule(); } - //terminal SL_COMMENT : '//' !('\n'|'\r')* ('\r'? '\n')?; + //terminal SL_COMMENT: '//' !('\n'|'\r')* ('\r'? '\n')?; public TerminalRule getSL_COMMENTRule() { - return gaTerminals.getSL_COMMENTRule(); + return gaXtype.getSL_COMMENTRule(); } - //terminal WS : (' '|'\t'|'\r'|'\n')+; + //terminal WS: (' '|'\t'|'\r'|'\n')+; public TerminalRule getWSRule() { - return gaTerminals.getWSRule(); + return gaXtype.getWSRule(); } //terminal ANY_OTHER: .; public TerminalRule getANY_OTHERRule() { - return gaTerminals.getANY_OTHERRule(); + return gaXtype.getANY_OTHERRule(); } } diff --git a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/validation/AbstractExpressionValidator.java b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/validation/AbstractExpressionValidator.java index 73c269b853..cb3b5bd447 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/validation/AbstractExpressionValidator.java +++ b/com.avaloq.tools.ddk.xtext.expression/src-gen/com/avaloq/tools/ddk/xtext/expression/validation/AbstractExpressionValidator.java @@ -6,14 +6,17 @@ import java.util.ArrayList; import java.util.List; import org.eclipse.emf.ecore.EPackage; -import org.eclipse.xtext.validation.AbstractDeclarativeValidator; +import org.eclipse.xtext.xbase.validation.XbaseValidator; -public abstract class AbstractExpressionValidator extends AbstractDeclarativeValidator { +public abstract class AbstractExpressionValidator extends XbaseValidator { @Override protected List getEPackages() { - List result = new ArrayList(); + List result = new ArrayList(super.getEPackages()); result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.avaloq.com/tools/ddk/xtext/expression/Expression")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xbase")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/common/JavaVMTypes")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xtype")); return result; } } diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/Expression.xtext b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/Expression.xtext index f4e88091cb..2e1a47ca1c 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/Expression.xtext +++ b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/Expression.xtext @@ -2,7 +2,7 @@ * @TODO should be EPL */ -grammar com.avaloq.tools.ddk.xtext.expression.Expression with org.eclipse.xtext.common.Terminals +grammar com.avaloq.tools.ddk.xtext.expression.Expression with org.eclipse.xtext.xbase.Xbase import "http://www.eclipse.org/emf/2002/Ecore" as ecore diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CodeGenerationX.xtend b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CodeGenerationX.xtend deleted file mode 100644 index d16ff95ab9..0000000000 --- a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CodeGenerationX.xtend +++ /dev/null @@ -1,373 +0,0 @@ - -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.expression.generator - -import com.avaloq.tools.ddk.xtext.expression.expression.Expression -import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.BooleanLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.NullLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.RealLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.Identifier -import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall -import com.avaloq.tools.ddk.xtext.expression.expression.BooleanOperation -import com.avaloq.tools.ddk.xtext.expression.expression.CollectionExpression -import com.avaloq.tools.ddk.xtext.expression.expression.TypeSelectExpression -import com.avaloq.tools.ddk.xtext.expression.expression.CastedExpression -import com.avaloq.tools.ddk.xtext.expression.expression.IfExpression -import java.util.List -import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall -import com.avaloq.tools.ddk.xtext.expression.expression.Literal - -class CodeGenerationX { - - extension ExpressionExtensionsX = new ExpressionExtensionsX - - ////////////////////////////////////////////////// - // ENTRY POINTS - ////////////////////////////////////////////////// - def boolean isCompilable(Expression it, CompilationContext ctx) { - val expr = javaExpression(ctx) - expr !== null && !expr.contains('/* NOT COMPILABLE: ') - } - - def dispatch String javaExpression(Void it, CompilationContext ctx) { - '' - } - - def dispatch String javaExpression(Expression it, CompilationContext ctx) { - notCompilable - } - - def String notCompilable(Expression it) { - '/* NOT COMPILABLE: Complex expressions like "' + serialize() + '" cannot be translated to Java. Consider rewriting the expression or using a JAVA extension. */' - } - - ////////////////////////////////////////////////// - // LITERALS - ////////////////////////////////////////////////// - def dispatch String javaExpression(StringLiteral it, CompilationContext ctx) { - '"' + javaEncode(^val) + '"' - } - - def dispatch String javaExpression(BooleanLiteral it, CompilationContext ctx) { - ^val - } - - def dispatch String javaExpression(IntegerLiteral it, CompilationContext ctx) { - ^val.toString() - } - - def dispatch String javaExpression(NullLiteral it, CompilationContext ctx) { - "null" - } - - def dispatch String javaExpression(RealLiteral it, CompilationContext ctx) { - ^val.toString() - } - - def dispatch String javaExpression(ListLiteral it, CompilationContext ctx) { - if (elements.empty) { - "java.util.Collections.<" + ctx.javaType(ctx.requiredType.name) + "> emptyList()" - } else if (elements.size == 1) { - "java.util.Collections.singletonList(" + elements.head.javaExpression(ctx) + ")" - } else { - "com.google.common.collect.Lists.newArrayList(" + ', '.join(elements.map[javaExpression(ctx)]) + ")" - } - } - - ////////////////////////////////////////////////// - // TYPES AND VARIABLES - ////////////////////////////////////////////////// - def dispatch String javaExpression(Identifier it, CompilationContext ctx) { - if (isThis()) ctx.implicitVariable else '::'.join(id) - } - - def boolean isType(FeatureCall it, CompilationContext ctx) { - name === null && type !== null && ctx.isType(type.javaExpression(ctx)) - } - - def boolean isVariable(Expression it, CompilationContext ctx) { - false - } - - def boolean isVariable(FeatureCall it, CompilationContext ctx) { - target === null && name === null && ctx.isVariable(type.javaExpression(ctx)) - } - - def String featureCallTarget(FeatureCall it, CompilationContext ctx) { - if (target === null || target.isThisCall()) - ctx.implicitVariable - else - target.javaExpression(ctx) - } - - ////////////////////////////////////////////////// - // BOOLEAN OPERATIONS - ////////////////////////////////////////////////// - def dispatch String javaExpression(BooleanOperation it, CompilationContext ctx) { - autoBracket(left.javaExpression(ctx) + ' ' + operator + ' ' + right.javaExpression(ctx), ctx) - } - - ////////////////////////////////////////////////// - // COLLECTION OPERATIONS - ////////////////////////////////////////////////// - // TODO finish - def dispatch String javaExpression(CollectionExpression it, CompilationContext ctx) { - if ('select' == name) { - 'com.google.common.collect.Iterables.filter(' + target.javaExpression(ctx) + - ', new com.google.common.base.Predicate() { public boolean apply(Object ' + - (if (^var !== null) ^var else 'e') + ') {return ' + - exp.javaExpression(ctx) + ';} })' - } else { - notCompilable() - } - } - - def dispatch String javaExpression(TypeSelectExpression it, CompilationContext ctx) { - if (isSimpleNavigation(ctx)) - 'com.google.common.collect.Iterables.filter(' + target.javaExpression(ctx) + ', ' + ctx.javaType(type.javaExpression(ctx)) + '.class)' - else notCompilable() - } - - ////////////////////////////////////////////////// - // TYPE CAST - ////////////////////////////////////////////////// - def dispatch String javaExpression(CastedExpression it, CompilationContext ctx) { - '((' + ctx.javaType(type.javaExpression(ctx)) + ') ' + target.javaExpression(ctx) + ')' - } - - ////////////////////////////////////////////////// - // IF EXPRESSIONS - ////////////////////////////////////////////////// - def dispatch String javaExpression(IfExpression it, CompilationContext ctx) { - autoBracket(condition.javaExpression(ctx) + ' ? ' + thenPart.javaExpression(ctx) + ' : ' + elsePart.javaExpression(ctx), ctx) - } - - ////////////////////////////////////////////////// - // FEATURE CALLS - ////////////////////////////////////////////////// - def dispatch String javaExpression(FeatureCall it, CompilationContext ctx) { - if (isThisCall()) { - ctx.implicitVariable - } else if (isVariable(ctx)) { - type.javaExpression(ctx) - } else if (isType(ctx)) { - ctx.javaType(type.javaExpression(ctx)) - } else if (isSimpleFeatureCall(ctx)) { - featureCallTarget(ctx) + '.' + (if (calledFeature() == 'eContainer') 'eContainer' else (if (calledFeature() == 'isEmpty') 'isEmpty' else calledFeature().toFirstUpper().featureCallName())) + '()' - } else if (isSimpleNavigation(ctx)) { - notCompilable() - } else { - featureCallTarget(ctx) + '.' + (if (calledFeature() == 'eContainer') 'eContainer' else (if (calledFeature() == 'isEmpty') 'isEmpty' else calledFeature().toFirstUpper().featureCallName())) + '()' - } - } - - // TODO: actually, we should look at the feature and return "is" only if it has a boolean value... Can this be done?? - def String featureCallName(String it) { - if (it.startsWith('^')) - it.substring(1, it.length).toFirstUpper().featureCallName() - else - (if (it.startsWith('Is')) 'is' else 'get') + it - } - - def boolean isSimpleFeatureCall(Expression it, CompilationContext ctx) { - false - } - - def boolean isSimpleFeatureCall(FeatureCall it, CompilationContext ctx) { - eClass.name.contains('FeatureCall') && name === null && type.isFeature() && (target === null || target.isVariable(ctx) || target.isThisCall()) - } - - def dispatch boolean isSimpleNavigation(Expression it, CompilationContext ctx) { - false - } - - def dispatch boolean isSimpleNavigation(TypeSelectExpression it, CompilationContext ctx) { - true - } - - def dispatch boolean isSimpleNavigation(FeatureCall it, CompilationContext ctx) { - name === null && type.isFeature() && (target === null || target.isVariable(ctx) || target.isThisCall() || target.isSimpleNavigation(ctx)) - } - - def dispatch String navigationRoot(Void it, CompilationContext ctx) { - '' - } - - def dispatch String navigationRoot(Expression it, CompilationContext ctx) { - '' - } - - def dispatch String navigationRoot(FeatureCall it, CompilationContext ctx) { - if (target !== null) target.navigationRoot(ctx) else (if (isVariable(ctx)) javaExpression(ctx) else ctx.implicitVariable) - } - - def dispatch List navigations(Void it, CompilationContext ctx) { - {} - } - - def dispatch List navigations(Expression it, CompilationContext ctx) { - {} - } - - def dispatch List navigations(FeatureCall it, CompilationContext ctx) { - val navs = target.navigations(ctx) - if (navs.isEmpty && (isThisCall() || isVariable(ctx))) #[] else { navs.add(calledFeature()); navs } - } - - def dispatch List navigations(TypeSelectExpression it, CompilationContext ctx) { - val navs = target.navigations(ctx) - navs.add("typeSelect(" + type.qualifiedTypeName(ctx) + ")") - navs - } - - ////////////////////////////////////////////////// - // OPERATION CALLS - ////////////////////////////////////////////////// - // TODO handle eClass() - // TODO work out if 'this' should be added or not - def dispatch String javaExpression(OperationCall it, CompilationContext ctx) { - if ((target === null || target.isThisCall()) && ctx.targetHasOperation(it)) { - (if (target !== null) target.javaExpression(ctx) + '.' else '') + name + '(' + ', '.join(params.map[javaExpression(ctx)]) + ')' - } else if (isJavaExtensionCall(ctx)) { - calledJavaMethod(ctx) + '(' + ', '.join((if (target !== null) { val l = newArrayList(target); l.addAll(params); l } else params).map[javaExpression(ctx)]) + ')' - } else if (isArithmeticOperatorCall(ctx)) { - autoBracket((' ' + name + ' ').join(params.map(e|e.javaExpression(ctx))), ctx) - } else if (isSimpleConcatCall()) { - (' + ').join(params.map(e|e.javaExpression(ctx))) - } else if (isPrefixExpression(ctx)) { - autoBracket(name + params.head.javaExpression(ctx), ctx) - } else if ('first' == name && params.isEmpty && target !== null) { - target.javaExpression(ctx) + '.get(0)' - } else if ('isInstance' == name && params.size == 1 && target instanceof FeatureCall && (target as FeatureCall).isType(ctx)) { - autoBracket(params.head.javaExpression(ctx) + ' instanceof ' + target.javaExpression(ctx), ctx) - } else if ('eContainer' == name && params.isEmpty) { - target.javaExpression(ctx) + '.eContainer()' - } else if (ctx.isExtension(name)) { - notCompilable() - } else { - (if (target !== null) target.javaExpression(ctx) + '.' else '') + name + '(' + (if (params.isEmpty) '' else ', '.join(params.map[javaExpression(ctx)])) + ')' - } - } - - def boolean isJavaExtensionCall(Expression it) { - false - } - - def boolean isJavaExtensionCall(OperationCall it, CompilationContext ctx) { - name != 'isInstance' && isSimpleCall(ctx) && calledJavaMethod(ctx) !== null - } - - def boolean isSimpleCall(OperationCall it, CompilationContext ctx) { - (target === null || target.isCompilable(ctx)) && params.forall(p|p.isCompilable(ctx)) - } - - def String calledJavaMethod(OperationCall it, CompilationContext ctx) { - ctx.calledJavaMethod(it) - } - - def /*cached*/ String calledJavaMethod(CompilationContext it, OperationCall call) { - getCalledJavaMethod(call) - } - - ////////////////////////////////////////////////// - // EXPRESSION BRACKETING - ////////////////////////////////////////////////// - def String autoBracket(Expression it, String javaCode, CompilationContext ctx) { - if (requiresBracketing(ctx)) '(' + javaCode + ')' else javaCode - } - - def dispatch boolean requiresBracketing(Expression it, CompilationContext ctx) { - (isPrefixExpression(ctx) || isInfixExpression(ctx)) && eContainer() !== null && requiresBracketing(it, eContainer(), ctx) - } - - def dispatch boolean requiresBracketing(Literal it, CompilationContext ctx) { - false - } - - def dispatch boolean requiresBracketing(Expression it, Object parent, CompilationContext ctx) { - false - } - - def dispatch boolean requiresBracketing(Expression it, Expression parent, CompilationContext ctx) { - isPrefixExpression(ctx) && parent.isPrefixExpression(ctx) || - (isInfixExpression(ctx) && (parent.isPrefixExpression(ctx) || parent.isInfixExpression(ctx))) - } - - def dispatch boolean requiresBracketing(OperationCall it, OperationCall parent, CompilationContext ctx) { - isPrefixExpression(ctx) && parent.isPrefixExpression(ctx) || - (isInfixExpression(ctx) && (parent.isPrefixExpression(ctx) || (parent.isInfixExpression(ctx) && name != parent.name))) - } - - def dispatch boolean requiresBracketing(BooleanOperation it, BooleanOperation parent, CompilationContext ctx) { - operator != parent.operator - } - - ////////////////////////////////////////////////// - // HELPER FUNCTIONS - ////////////////////////////////////////////////// - def dispatch boolean isThisCall(Expression it) { - false - } - - def dispatch boolean isThisCall(FeatureCall it) { - name === null && type.isThis() - } - - def boolean isFeature(Identifier it) { - id !== null && id.size == 1 - } - - def dispatch boolean isThis(Expression it) { - false - } - - def dispatch boolean isThis(Identifier it) { - id !== null && id.size == 1 && id.head == "this" - } - - def String qualifiedTypeName(Identifier it, CompilationContext ctx) { - if (id.size == 2) id.get(0) + "::" + id.get(1) else ctx.qualifiedTypeName(id.head) - } - - def /*cached*/ String qualifiedTypeName(CompilationContext it, String name) { - getQualifiedTypeName(name) - } - - def dispatch String javaEncode(Expression it) { - javaEncode(serialize()) - } - - def dispatch String javaEncode(String it) { - org.eclipse.xtext.util.Strings.convertToJavaString(it) - } - - def String join(String it, List strings) { - if (strings.isEmpty) '' else internalJoin(strings) - } - - private def String internalJoin(String it, List strings) { - org.eclipse.xtext.util.Strings.concat(it, strings) - } - - def String join(String it, String strings) { - strings - } - - def String join(String it, Void strings) { - '' - } - -} diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilationContext.java b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilationContext.java deleted file mode 100644 index b8d917e1f1..0000000000 --- a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilationContext.java +++ /dev/null @@ -1,429 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ -package com.avaloq.tools.ddk.xtext.expression.generator; - -import java.lang.reflect.Field; - -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.eclipse.emf.ecore.EClass; -import org.eclipse.internal.xtend.xtend.ast.Extension; -import org.eclipse.internal.xtend.xtend.ast.JavaExtensionStatement; -import org.eclipse.xtend.expression.ExecutionContext; -import org.eclipse.xtend.expression.ExpressionFacade; -import org.eclipse.xtend.expression.Variable; -import org.eclipse.xtend.typesystem.Operation; -import org.eclipse.xtend.typesystem.Type; -import org.eclipse.xtend.typesystem.emf.EClassType; - -import com.avaloq.tools.ddk.xtext.expression.expression.Expression; -import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall; -import com.google.common.collect.Sets; - - -/** - * The CompilationContext is used by CodeGeneration.ext to resolve types, get information about local variables, etc. It is a - * wrapper around {@link ExecutionContext}. - *

- * Note that many of these methods are called from Xtend and will thus not show up when doing a find references in Eclipse. - */ -@SuppressWarnings("nls") -public class CompilationContext { - - /** Class-wide logger. */ - private static final Logger LOGGER = LogManager.getLogger(CompilationContext.class); - - /** Xtend execution context. */ - private final ExecutionContext context; - private final GenModelUtilX genModelUtil; - /** The name of the Java variable the implicit "this" variable is bound to. */ - private final String implicitVariable; - /** The type of the implicit "this" variable. */ - private Type implicitContextType; - - /** - * Analyzes the given expression and returns the type of it. - * - * @param expression - * expression to analyze - * @return type of expression - */ - public Type analyze(final Expression expression) { - return analyze(ExpressionExtensions.serialize(expression)); - } - - /** - * Analyzes the given expression and returns the type of it. - * - * @param expression - * expression to analyze - * @return type of expression - */ - public Type analyze(final String expression) { - return new ExpressionFacade(context).analyze(expression, Sets.newHashSet()); - } - - /** - * Creates a new compilation context for the given Xtend context. - * The name of the Java variable to bind "this" is set to "obj". - * - * @param context - * xtend context to wrap - * @param genModelUtil - * the gen model utility - */ - public CompilationContext(final ExecutionContext context, final GenModelUtilX genModelUtil) { - this.context = context; - this.genModelUtil = genModelUtil; - this.implicitVariable = "obj"; //$NON-NLS-1$ - } - - /** - * Creates a new compilation context for the given Xtend context, implicit variable name, and context type. - * - * @param context - * xtend context to wrap - * @param genModelUtil - * the gen model utility - * @param implicitVar - * name of the Java variable to bind "this" to - * @param contextType - * type of the Java variable to bind "this" to - */ - public CompilationContext(final ExecutionContext context, final GenModelUtilX genModelUtil, final String implicitVar, final Type contextType) { - this.context = context; - this.genModelUtil = genModelUtil; - this.implicitVariable = implicitVar; - this.implicitContextType = contextType != null ? contextType : context.getObjectType(); - } - - /** - * Returns the execution context used by this compilation context. - * - * @return execution context - */ - public ExecutionContext getExecutionContext() { - return context; - } - - /** - * Creates a new compilation context for the given Xtend context, implicit variable name, and context type. - * - * @param implicitVar - * name of the Java variable to bind "this" to - * @param contextType - * type of the Java variable to bind "this" to - * @param variable - * string typed variable to add - * @return CompilationContext - CompilationContext - */ - public CompilationContext cloneWithString(final String implicitVar, final EClass contextType, final String variable) { - return new CompilationContext(context.cloneWithVariable(new Variable(variable, "")), genModelUtil, implicitVar, contextType != null ? findType(contextType) //$NON-NLS-1$ - : this.implicitContextType); - } - - /** - * Creates a new compilation context for the given Xtend context, implicit variable name, and context type. - * - * @param implicitVar - * name of the Java variable to bind "this" to - * @param contextType - * type of the Java variable to bind "this" to - * @param variable - * variable to add - * @param type - * type of variable to add - * @return CompilationContext - CompilationContext - */ - public CompilationContext cloneWithVariable(final String implicitVar, final EClass contextType, final String variable, final String type) { - return new CompilationContext(context.cloneWithVariable(new Variable(variable, type)), genModelUtil, implicitVar, contextType != null - ? findType(contextType) - : this.implicitContextType); - } - - /** - * Returns the name of the Java variable to bind "this" to. - * - * @return {@link #implicitVariable} - */ - public String getImplicitVariable() { - return implicitVariable; - } - - /** - * Returns the generic type to use for List expressions mapped to java.util.List<>. - * - * @return currently always returns "org.eclipse.emf.ecore.EObject" - */ - public Type getRequiredType() { - return findType("ecore::EObject"); //$NON-NLS-1$ - } - - /** - * Checks whether the given string corresponds to a variable in this context. - * - * @param var - * string to check - * @return true if the given string corresponds to a variable - */ - public Boolean isVariable(final String var) { - return context.getVariable(var) != null || context.getGlobalVariables().containsKey(var); - } - - /** - * Returns the Xtend type for the given EClass. - * - * @param eClass - * EClass to get corresponding Xtend type for - * @return corresponding Xtend type - */ - public Type findType(final EClass eClass) { - return findType(eClass.getEPackage().getName() + "::" + eClass.getName()); //$NON-NLS-1$ - } - - /** - * Returns the Xtend type with the given name. - * - * @param name - * (qualified) name of type to find - * @return corresponding Xtend type - */ - public Type findType(final String name) { - return context.getTypeForName(name); - } - - /** - * Returns the Xtend type with the given name. - * - * @param name - * (qualified) name of type to find - * @return corresponding Xtend type - */ - public boolean isType(final String name) { - return findType(name) != null; - } - - /** - * Returns the Java class name corresponding to the given Xtend type. This works both for builtin types, EMF types, and Java - * types. - * - * @param name - * the name of the Xtend type (qualified or not) - * @return the qualified Java class name - */ - public String javaType(final String name) { - Type type = findType(name); - if (type == null) { - LOGGER.warn("No type found for {}", name); - return name; - } - return javaType(type); - } - - /** - * Returns the Java class name corresponding to the given Xtend type. This works both for builtin types, EMF types, and Java - * types. - * - * @param type - * the Xtend type (qualified or not) - * @return the qualified Java class name - */ - public String javaType(final Type type) { - if (type instanceof EClassType) { - EClass eClass = getEClass(type); - return genModelUtil.instanceClassName(eClass); - } - Class clazz = type.newInstance().getClass(); - return "java.lang".equals(clazz.getPackage().getName()) ? clazz.getSimpleName() : clazz.getName(); //$NON-NLS-1$ - } - - /** - * Creates a new equivalent compilation context with the given implicit variable name. - * - * @param implicitVar - * name of implicit variable - * @return new derived compilation context - */ - public CompilationContext clone(final String implicitVar) { - return new CompilationContext(context, genModelUtil, implicitVar, implicitContextType); - } - - /** - * Creates a new equivalent compilation context with the given implicit variable name and context type. - * - * @param implicitVar - * name of implicit variable - * @param contextType - * type of implicit variable - * @return new derived compilation context - */ - public CompilationContext clone(final String implicitVar, final EClass contextType) { - return new CompilationContext(context, genModelUtil, implicitVar, contextType != null ? findType(contextType) : this.implicitContextType); - } - - /** - * Creates a new equivalent compilation context with the given implicit variable name and context type and additional variable. - * - * @param implicitVar - * name of implicit variable - * @param contextType - * type of implicit variable - * @param variable - * name of additional bound Java variable - * @return new derived compilation context - */ - public CompilationContext clone(final String implicitVar, final EClass contextType, final String variable) { - return clone(implicitVar, contextType, variable, null); - } - - /** - * Creates a new equivalent compilation context with the given implicit variable name and context type and additional variable. - * - * @param implicitVar - * name of implicit variable - * @param contextType - * type of implicit variable - * @param variable - * name of additional bound Java variable - * @param variableType - * type of additional bound Java variable - * @return new derived compilation context - */ - public CompilationContext clone(final String implicitVar, final EClass contextType, final String variable, final EClass variableType) { - return new CompilationContext(context.cloneWithVariable(new Variable(variable, variableType == null ? new Object() - : findType(variableType))), genModelUtil, implicitVar, contextType != null ? findType(contextType) : this.implicitContextType); - } - - /** - * Returns the qualified type name for the given unqualified type name. - * - * @param typeName - * unqualified (or qualified) type name - * @return qualified type name of given type - */ - public String getQualifiedTypeName(final String typeName) { - final Type type = findType(typeName); - - try { - if (type instanceof EClassType) { - EClass eClass = getEClass(type); - return eClass.getEPackage().getName() + "::" + eClass.getName(); //$NON-NLS-1$ - } - // CHECKSTYLE:OFF - } catch (final Exception e) { - LOGGER.warn("Could not determine qualified type name for {}", typeName, e); //$NON-NLS-1$ - } - // CHECKSTYLE:ON - - return type.getName(); - } - - /** - * Gets the eClass. - * - * @param type - * the type - * @return the eClass or NULL - */ - public EClass getEClass(final Type type) { - if (type instanceof EClassType) { - try { - Field field = EClassType.class.getDeclaredField("eClass"); - field.setAccessible(true); - return (EClass) field.get(type); - // CHECKSTYLE:OFF - } catch (Exception e) { - // CHECKSTYLE:ON - LOGGER.error("Could not determine EClass for {}", type, e); - } - } - return null; - } - - /** - * Gets the eClass. - * - * @param type - * the type - * @return the eClass or NULL - */ - public EClass getEClass(final Object type) { - if (type instanceof Type) { - return getEClass((Type) type); - } - return null; - } - - /** - * Heuristically test if name of extension. - * - * @param name - * the name to test - * @return true if name is an extension name - */ - // TODO fix heuristic with proper type analysis - public Boolean isExtension(final String name) { - for (final Extension e : context.getAllExtensions()) { - if (e.getName().equals(name)) { - return true; - } - } - return false; - } - - /** - * Gets the called java method. - * - * @param expression - * the expression - * @return the called java method or NULL - */ - public String getCalledJavaMethod(final OperationCall expression) { - // TODO ctx.getExtensionForTypes(expression.getName(), ...); - try { - for (final Extension e : context.getAllExtensions()) { - if (e instanceof JavaExtensionStatement) { - final JavaExtensionStatement je = (JavaExtensionStatement) e; - if (je.getName().equals(expression.getName())) { - return je.getJavaType() + "." + je.getJavaMethodName(); //$NON-NLS-1$ - } - } - } - // CHECKSTYLE:OFF - } catch (final Exception e) { - LOGGER.error(e.getMessage(), e); - } - // CHECKSTYLE:ON - - return null; - } - - /** - * Heuristically test if target has an operation. - * - * @param expression - * the operation - * @return true if the implicit context has this operation - */ - // TODO fix heuristic with proper type analysis - public boolean targetHasOperation(final OperationCall expression) { - if (implicitContextType == null) { - return false; - } - - for (final Operation operation : implicitContextType.getAllOperations()) { - if (operation.getName().equals(expression.getName()) && operation.getParameterTypes().size() == expression.getParams().size()) { - return true; - } - } - return false; - } -} diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilerX.java b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilerX.java deleted file mode 100644 index 7db027df44..0000000000 --- a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/CompilerX.java +++ /dev/null @@ -1,45 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ -package com.avaloq.tools.ddk.xtext.expression.generator; - -import com.avaloq.tools.ddk.xtext.expression.expression.Expression; - - -/** - * A wrapper class around the {@link CodeGenerationX} class which implements the partial Xtend to Java source code generation. - */ -public class CompilerX { - - private final CompilationContext context; - - /** - * Creates a new compiler with the given compilation context. - * - * @param context - * the compilation context - */ - public CompilerX(final CompilationContext context) { - this.context = context; - } - - /** - * Compiles the given expression to an equivalent Java expression. - * - * @param expression - * expression to compile - * @return Java expression as a string - */ - public String compile(final Expression expression) { - Object res = new CodeGenerationX().javaExpression(expression, context); - return res != null ? res.toString() : null; - } - -} diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/ExpressionExtensionsX.xtend b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/ExpressionExtensionsX.xtend deleted file mode 100644 index e8341936ad..0000000000 --- a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/generator/ExpressionExtensionsX.xtend +++ /dev/null @@ -1,88 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. it program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies it distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.expression.generator - -import com.avaloq.tools.ddk.xtext.expression.expression.BooleanOperation -import com.avaloq.tools.ddk.xtext.expression.expression.Expression -import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall -import com.avaloq.tools.ddk.xtext.expression.expression.IfExpression -import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral -import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall -import org.eclipse.emf.ecore.EObject - -class ExpressionExtensionsX { - - def dispatch String serialize(EObject it) { - ExpressionExtensions.serialize(it) - } - - def dispatch String serialize(Void it) { - null - } - - def dispatch boolean isEmptyList(Expression it) { - false - } - - def dispatch boolean isEmptyList(ListLiteral it) { - elements.isEmpty - } - - def boolean isSimpleConcatCall(OperationCall it) { - name == '+' && type === null && target === null && !params.isEmpty - } - - def boolean isNumber(Expression it, CompilationContext ctx) { - ctx.findType('Real').isAssignableFrom(ctx.analyze(it)) - } - - def dispatch boolean isArithmeticOperatorCall(OperationCall it, CompilationContext ctx) { - type === null && target === null && params.size > 1 && (name == '+' || name == '-' || name == '*' || name == '/') && params.forall(p|p.isNumber(ctx)) - } - - def dispatch boolean isArithmeticOperatorCall(Expression it, CompilationContext ctx) { - false - } - - def dispatch boolean isPrefixExpression(Expression it, CompilationContext ctx) { - false - } - - def dispatch boolean isPrefixExpression(OperationCall it, CompilationContext ctx) { - type === null && target === null && params.size == 1 && (name == '-' || name == '!') - } - - def dispatch boolean isInfixExpression(Void it, CompilationContext ctx) { - false - } - - def dispatch boolean isInfixExpression(Expression it, CompilationContext ctx) { - false - } - - def dispatch boolean isInfixExpression(OperationCall it, CompilationContext ctx) { - isArithmeticOperatorCall(ctx) || 'isInstance' == name - } - - def dispatch boolean isInfixExpression(IfExpression it, CompilationContext ctx) { - true - } - - def dispatch boolean isInfixExpression(BooleanOperation it, CompilationContext ctx) { - true - } - - def String calledFeature(FeatureCall it) { - type.id.head - } - -} \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/jvmmodel/ExpressionJvmModelInferrer.xtend b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/jvmmodel/ExpressionJvmModelInferrer.xtend new file mode 100644 index 0000000000..9c1d4879ea --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/jvmmodel/ExpressionJvmModelInferrer.xtend @@ -0,0 +1,62 @@ +/* + * generated by Xtext + */ +package com.avaloq.tools.ddk.xtext.expression.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import com.google.inject.Inject +import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer +import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor +import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder + +/** + *

Infers a JVM model from the source model.

+ * + *

The JVM model should contain all elements that would appear in the Java code + * which is generated from the source model. Other models link against the JVM model rather than the source model.

+ */ +class ExpressionJvmModelInferrer extends AbstractModelInferrer { + + /** + * convenience API to build and initialize JVM types and their members. + */ + @Inject extension JvmTypesBuilder + + /** + * The dispatch method {@code infer} is called for each instance of the + * given element's type that is contained in a resource. + * + * @param element + * the model to create one or more + * {@link org.eclipse.xtext.common.types.JvmDeclaredType declared + * types} from. + * @param acceptor + * each created + * {@link org.eclipse.xtext.common.types.JvmDeclaredType type} + * without a container should be passed to the acceptor in order + * get attached to the current resource. The acceptor's + * {@link IJvmDeclaredTypeAcceptor#accept(org.eclipse.xtext.common.types.JvmDeclaredType) + * accept(..)} method takes the constructed empty type for the + * pre-indexing phase. This one is further initialized in the + * indexing phase using the lambda you pass as the last argument. + * @param isPreIndexingPhase + * whether the method is called in a pre-indexing phase, i.e. + * when the global index is not yet fully updated. You must not + * rely on linking using the index if isPreIndexingPhase is + * true. + */ + def dispatch void infer(Expression element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) { + // Here you explain how your model is mapped to Java elements, by writing the actual translation code. + + // An implementation for the initial hello world example could look like this: +// acceptor.accept(element.toClass("my.company.greeting.MyGreetings")) [ +// for (greeting : element.greetings) { +// members += greeting.toMethod("hello" + greeting.name, typeRef(String)) [ +// body = ''' +// return "Hello «greeting.name»"; +// ''' +// ] +// } +// ] + } +} diff --git a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/scoping/ExpressionScopeProvider.java b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/scoping/ExpressionScopeProvider.java index 95d88a7ef9..3b65f91f71 100644 --- a/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/scoping/ExpressionScopeProvider.java +++ b/com.avaloq.tools.ddk.xtext.expression/src/com/avaloq/tools/ddk/xtext/expression/scoping/ExpressionScopeProvider.java @@ -10,13 +10,11 @@ *******************************************************************************/ package com.avaloq.tools.ddk.xtext.expression.scoping; -import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; - /** * This class contains custom scoping description for the Expression language. * Expression is a mixin grammar therefore this class in empty */ -public class ExpressionScopeProvider extends AbstractDeclarativeScopeProvider { +public class ExpressionScopeProvider extends AbstractExpressionScopeProvider { } diff --git a/com.avaloq.tools.ddk.xtext.generator.test/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.generator.test/META-INF/MANIFEST.MF index d986bbc123..ea494375fd 100644 --- a/com.avaloq.tools.ddk.xtext.generator.test/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.generator.test/META-INF/MANIFEST.MF @@ -10,8 +10,6 @@ Fragment-Host: com.avaloq.tools.ddk.xtext.generator Require-Bundle: com.avaloq.tools.ddk.test.core, com.avaloq.tools.ddk.xtext.expression, com.avaloq.tools.ddk.xtext.test.core, - org.eclipse.xtend, - org.eclipse.xtend.typesystem.emf, org.eclipse.xtext, org.mockito.mockito-core, com.avaloq.tools.ddk.xtext.ui, diff --git a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CodeGenerationXTest.java b/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CodeGenerationXTest.java deleted file mode 100644 index a75a146905..0000000000 --- a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CodeGenerationXTest.java +++ /dev/null @@ -1,207 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ -package com.avaloq.tools.ddk.xtext.generator.expression; - -import static org.junit.jupiter.api.Assertions.assertEquals; - -import java.io.IOException; - -import org.eclipse.xtend.expression.ExecutionContextImpl; -import org.eclipse.xtend.type.impl.java.JavaBeansMetaModel; -import org.eclipse.xtend.typesystem.emf.EmfRegistryMetaModel; -import org.junit.jupiter.api.Test; - -import com.avaloq.tools.ddk.xtext.expression.expression.Expression; -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext; -import com.avaloq.tools.ddk.xtext.expression.generator.CompilerX; -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX; -import com.avaloq.tools.ddk.xtext.generator.test.util.GeneratorTestUtil; -import com.avaloq.tools.ddk.xtext.test.jupiter.AbstractXtextTest; - - -/** - * Tests the code generation as implemented by CodeGenerationX wrapped by {@link CompilerX}. - */ -@SuppressWarnings({"nls", "PMD.SignatureDeclareThrowsException"}) -public class CodeGenerationXTest extends AbstractXtextTest { - - private CompilerX getCompiler() { - return (CompilerX) getTestInformation().getTestObject(CompilerX.class); - } - - @Override - protected GeneratorTestUtil getXtextTestUtil() { - return GeneratorTestUtil.getInstance(); - } - - @Override - protected void beforeAllTests() { - super.beforeAllTests(); - final ExecutionContextImpl executionContext = new ExecutionContextImpl(); - executionContext.registerMetaModel(new JavaBeansMetaModel()); - executionContext.registerMetaModel(new EmfRegistryMetaModel()); - final CompilationContext context = new CompilationContext(executionContext, new GenModelUtilX()); - getTestInformation().putTestObject(CompilerX.class, new CompilerX(context)); - } - - /** - * This test class does not have a test source file. {@inheritDoc} - */ - @Override - protected String getTestSourceFileName() { - return null; - } - - @Test - void testliterals() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("42", compile("42")); // NOPMD - assertEquals("4.2", compile("4.2")); // NOPMD - assertEquals("true", compile("true")); // NOPMD - assertEquals("null", compile("null")); // NOPMD - assertEquals("\"foo\"", compile("\"foo\"")); // NOPMD - assertEquals("\"foo\"", compile("\'foo\'")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testListLiterals() throws Exception { - assertEquals("java.util.Collections. emptyList()", compile("{}")); // NOPMD - assertEquals("java.util.Collections.singletonList(1)", compile("{1}")); // NOPMD - assertEquals("com.google.common.collect.Lists.newArrayList(1, 2, 3)", compile("{1,2,3}")); // NOPMD - } - - @Test - void testIdentifiers() throws Exception { - assertEquals("obj.getTrue()", compile("^true")); // NOPMD - } - - @Test - void testBracketing() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("(4 + 2) * 3", compile("(4 + 2) * 3")); // NOPMD - assertEquals("(4 + 2) * 3 * 4", compile("(4 + 2) * 3 * 4")); // NOPMD - assertEquals("\"x\" + 2 + 3 + 4", compile("(\'x\' + 2) + 3 + 4")); // NOPMD - assertEquals("obj.getFoo() + 2 + 3 + 4", compile("(foo + 2) + (3 + 4)")); // NOPMD - assertEquals("true && false && false", compile("(true && false) && false")); // NOPMD - assertEquals("(true || false) && false", compile("(true || false) && false")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testBooleanLogic() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("true", compile("true")); // NOPMD - assertEquals("false", compile("false")); // NOPMD - assertEquals("!true", compile("!true")); // NOPMD - assertEquals("true && false", compile("true && false")); // NOPMD - assertEquals("true || false", compile("true || false")); // NOPMD - assertEquals("true ? 1 : 2", compile("true ? 1 : 2")); // NOPMD - assertEquals("true ? 1 : 2", compile("if true then 1 else 2")); // NOPMD - assertEquals("1 == 2", compile("1 == 2")); // NOPMD - assertEquals("1 != 2", compile("1 != 2")); // NOPMD - assertEquals("1 >= 2", compile("1 >= 2")); // NOPMD - assertEquals("1 <= 2", compile("1 <= 2")); // NOPMD - assertEquals("1 > 2", compile("1 > 2")); // NOPMD - assertEquals("1 < 2", compile("1 < 2")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testArithmetics() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("4 + 2", compile("4 + 2")); // NOPMD - assertEquals("4 - 2", compile("4 - 2")); // NOPMD - assertEquals("4 / 2", compile("4 / 2")); // NOPMD - assertEquals("4 * 2", compile("4 * 2")); // NOPMD - assertEquals("-42", compile("-42")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testPrefixExpressions() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("-(4 * 2)", compile("-(4 * 2)")); // NOPMD - assertEquals("-(-42)", compile("-(-42)")); // NOPMD - assertEquals("!(!true)", compile("!(!true)")); // NOPMD - - assertEquals("!true", compile("!true")); // NOPMD - assertEquals("!true", compile("!(true)")); // NOPMD - assertEquals("!true && false", compile("!(true) && false")); // NOPMD - assertEquals("!(true && false)", compile("!(true && false)")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testInfixExpressions() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("(true ? 1 : 2) + 3", compile("(true ? 1 : 2) + 3")); // NOPMD - assertEquals("!(true ? true : false)", compile("!(true ? true : false)")); // NOPMD - assertEquals("!(obj instanceof org.eclipse.emf.ecore.EObject)", compile("!ecore::EObject.isInstance(this)")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testImplicitVariable() throws Exception { - assertEquals("obj", compile("this")); // NOPMD - } - - @Test - void testCasting() throws Exception { - assertEquals("((org.eclipse.emf.ecore.EObject) obj)", compile("(ecore::EObject) this")); // NOPMD - } - - @Test - void testTypes() throws Exception { - assertEquals("org.eclipse.emf.ecore.EObject", compile("ecore::EObject")); // NOPMD - assertEquals("String", compile("java::lang::String")); // NOPMD - } - - @Test - void testIsInstance() throws Exception { - assertEquals("obj instanceof org.eclipse.emf.ecore.EObject", compile("ecore::EObject.isInstance(this)")); // NOPMD - } - - @Test - void testEContainerNavigation() throws Exception { - // CHECKSTYLE:CONSTANTS-OFF - assertEquals("obj.eContainer()", compile("this.eContainer")); // NOPMD - assertEquals("obj.eContainer()", compile("this.eContainer()")); // NOPMD - // CHECKSTYLE:CONSTANTS-ON - } - - @Test - void testTypeSelect() throws Exception { - assertEquals(// NOPMD - "com.google.common.collect.Iterables.filter(obj.getFoos(), org.eclipse.emf.ecore.EObject.class)", compile("this.foos.typeSelect(ecore::EObject)")); - assertEquals(// NOPMD - "com.google.common.collect.Iterables.filter(java.util.Collections.singletonList(obj), org.eclipse.emf.ecore.EObject.class)", compile("{this}.typeSelect(ecore::EObject)")); - } - - @Test - void testCollectionExpression() throws Exception { - assertEquals(// NOPMD - "com.google.common.collect.Iterables.filter(java.util.Collections.singletonList(obj), new com.google.common.base.Predicate() { public boolean apply(Object e) {return true;} })", compile("{this}.select(e|true)")); - } - - @Test - void testMultipleNavigations() throws Exception { - assertEquals(// NOPMD - "/* NOT COMPILABLE: Complex expressions like \"this.eContainer.eContainer\" cannot be translated to Java. Consider rewriting the expression or using a JAVA extension. */", compile("this.eContainer.eContainer")); - assertEquals(// NOPMD - "com.google.common.collect.Iterables.filter(obj.eContainer(), org.eclipse.emf.ecore.EObject.class)", compile("this.eContainer.typeSelect(ecore::EObject)")); - } - - private String compile(final String str) throws IOException { - return getCompiler().compile((Expression) getXtextTestUtil().getModel("test.expression", str)); - } - -} diff --git a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CompilationContextTest.java b/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CompilationContextTest.java deleted file mode 100644 index 4ca8581006..0000000000 --- a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/CompilationContextTest.java +++ /dev/null @@ -1,61 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ -package com.avaloq.tools.ddk.xtext.generator.expression; - -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import java.io.InputStreamReader; -import java.nio.charset.StandardCharsets; - -import org.eclipse.internal.xtend.xtend.ast.ExtensionFile; -import org.eclipse.internal.xtend.xtend.parser.ParseFacade; -import org.eclipse.xtend.expression.ExecutionContextImpl; -import org.eclipse.xtend.type.impl.java.JavaBeansMetaModel; -import org.eclipse.xtend.typesystem.Type; -import org.junit.jupiter.api.Test; - -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext; - - -@SuppressWarnings({"nls", "PMD.SignatureDeclareThrowsException"}) -public class CompilationContextTest { - - @Test - void isExtension() { - ExecutionContextImpl executionContext = new ExecutionContextImpl(); - executionContext.registerMetaModel(new JavaBeansMetaModel()); - ExtensionFile extensionFile = ParseFacade.file(new InputStreamReader(getClass().getResourceAsStream("/com/avaloq/tools/ddk/xtext/generator/expression/TestExtensions.ext"), StandardCharsets.UTF_8), "TestExtensions.ext"); - executionContext = (ExecutionContextImpl) executionContext.cloneWithResource(extensionFile); - final CompilationContext context = new CompilationContext(executionContext, null); - - assertTrue(context.isExtension("test"), "test extension not identified"); - } - - @Test - void analyze() { - ExecutionContextImpl executionContext = new ExecutionContextImpl(); - executionContext.registerMetaModel(new JavaBeansMetaModel()); - final CompilationContext context = new CompilationContext(executionContext, null); - - Type expectedType = executionContext.getTypeForName("Integer"); - assertSame(expectedType, context.analyze("1 + 3"), "Cannot analyze Integer"); - - expectedType = executionContext.getTypeForName("Real"); - assertSame(expectedType, context.analyze("1 + 3.33"), "Cannot analyze Real"); - - expectedType = executionContext.getTypeForName("String"); - assertSame(expectedType, context.analyze("\'foo\'"), "Cannot analyse String 'foo'"); - assertSame(expectedType, context.analyze("\"foo\""), "Cannot analyse String \"foo \" "); - assertSame(expectedType, context.analyze("\"foo\" + \'bar\'"), "Cannot analyse String \"foo\" + \'bar\'"); - } - -} diff --git a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/TestExtensions.ext b/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/TestExtensions.ext deleted file mode 100644 index 7cc11f75cc..0000000000 --- a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/expression/TestExtensions.ext +++ /dev/null @@ -1,5 +0,0 @@ -import org::eclipse::emf::ecore; - -test(EObject this) : - this -; diff --git a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/test/generator/GeneratorTestSuite.java b/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/test/generator/GeneratorTestSuite.java index efbd202e46..9e2644a0a8 100644 --- a/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/test/generator/GeneratorTestSuite.java +++ b/com.avaloq.tools.ddk.xtext.generator.test/src/com/avaloq/tools/ddk/xtext/generator/test/generator/GeneratorTestSuite.java @@ -13,8 +13,6 @@ import org.junit.platform.suite.api.SelectClasses; import org.junit.platform.suite.api.Suite; -import com.avaloq.tools.ddk.xtext.generator.expression.CodeGenerationXTest; -import com.avaloq.tools.ddk.xtext.generator.expression.CompilationContextTest; import com.avaloq.tools.ddk.xtext.generator.expression.ExpressionsExtentionsTest; import com.avaloq.tools.ddk.xtext.generator.test.util.EClassComparatorTest; import com.avaloq.tools.ddk.xtext.generator.test.util.GraphTest; @@ -27,8 +25,6 @@ @Suite @SelectClasses({ // @Format-Off - CodeGenerationXTest.class, - CompilationContextTest.class, ExpressionsExtentionsTest.class, EClassComparatorTest.class, GraphTest.class, diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.scope.ide/META-INF/MANIFEST.MF index 83c4e0990a..b07519c980 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.scope.ide/META-INF/MANIFEST.MF @@ -10,5 +10,6 @@ Export-Package: com.avaloq.tools.ddk.xtext.scope.ide.contentassist.antlr, com.avaloq.tools.ddk.xtext.scope.ide.contentassist.antlr.internal Require-Bundle: org.antlr.runtime, org.eclipse.xtext.ide, - com.avaloq.tools.ddk.xtext.scope + com.avaloq.tools.ddk.xtext.scope, + org.eclipse.xtext.xbase.ide Automatic-Module-Name: com.avaloq.tools.ddk.xtext.scope.ide diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/AbstractScopeIdeModule.java b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/AbstractScopeIdeModule.java index 5f09d10938..cf798e7c70 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/AbstractScopeIdeModule.java +++ b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/AbstractScopeIdeModule.java @@ -7,18 +7,18 @@ import com.avaloq.tools.ddk.xtext.scope.ide.contentassist.antlr.internal.InternalScopeLexer; import com.google.inject.Binder; import com.google.inject.name.Names; -import org.eclipse.xtext.ide.DefaultIdeModule; import org.eclipse.xtext.ide.LexerIdeBindings; import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper; import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper; import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser; import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer; +import org.eclipse.xtext.xbase.ide.DefaultXbaseIdeModule; /** * Manual modifications go to {@link ScopeIdeModule}. */ @SuppressWarnings("all") -public abstract class AbstractScopeIdeModule extends DefaultIdeModule { +public abstract class AbstractScopeIdeModule extends DefaultXbaseIdeModule { // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 public void configureContentAssistLexer(Binder binder) { diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/ScopeParser.java b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/ScopeParser.java index 4950146c75..cdd0acc272 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/ScopeParser.java +++ b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/ScopeParser.java @@ -58,6 +58,45 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0(), "rule__CollectionExpression__NameAlternatives_0_0"); builder.put(grammarAccess.getTypeAccess().getAlternatives(), "rule__Type__Alternatives"); builder.put(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0(), "rule__CollectionType__ClAlternatives_0_0"); + builder.put(grammarAccess.getXAssignmentAccess().getAlternatives(), "rule__XAssignment__Alternatives"); + builder.put(grammarAccess.getOpMultiAssignAccess().getAlternatives(), "rule__OpMultiAssign__Alternatives"); + builder.put(grammarAccess.getOpEqualityAccess().getAlternatives(), "rule__OpEquality__Alternatives"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1(), "rule__XRelationalExpression__Alternatives_1"); + builder.put(grammarAccess.getOpCompareAccess().getAlternatives(), "rule__OpCompare__Alternatives"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives(), "rule__OpOther__Alternatives"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives_5_1(), "rule__OpOther__Alternatives_5_1"); + builder.put(grammarAccess.getOpOtherAccess().getAlternatives_6_1(), "rule__OpOther__Alternatives_6_1"); + builder.put(grammarAccess.getOpAddAccess().getAlternatives(), "rule__OpAdd__Alternatives"); + builder.put(grammarAccess.getOpMultiAccess().getAlternatives(), "rule__OpMulti__Alternatives"); + builder.put(grammarAccess.getXUnaryOperationAccess().getAlternatives(), "rule__XUnaryOperation__Alternatives"); + builder.put(grammarAccess.getOpUnaryAccess().getAlternatives(), "rule__OpUnary__Alternatives"); + builder.put(grammarAccess.getOpPostfixAccess().getAlternatives(), "rule__OpPostfix__Alternatives"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1(), "rule__XMemberFeatureCall__Alternatives_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1(), "rule__XMemberFeatureCall__Alternatives_1_1_3_1"); + builder.put(grammarAccess.getXPrimaryExpressionAccess().getAlternatives(), "rule__XPrimaryExpression__Alternatives"); + builder.put(grammarAccess.getXLiteralAccess().getAlternatives(), "rule__XLiteral__Alternatives"); + builder.put(grammarAccess.getXCollectionLiteralAccess().getAlternatives(), "rule__XCollectionLiteral__Alternatives"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2(), "rule__XSwitchExpression__Alternatives_2"); + builder.put(grammarAccess.getXCasePartAccess().getAlternatives_3(), "rule__XCasePart__Alternatives_3"); + builder.put(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives(), "rule__XExpressionOrVarDeclaration__Alternatives"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1(), "rule__XVariableDeclaration__Alternatives_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2(), "rule__XVariableDeclaration__Alternatives_2"); + builder.put(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1(), "rule__XFeatureCall__Alternatives_3_1"); + builder.put(grammarAccess.getFeatureCallIDAccess().getAlternatives(), "rule__FeatureCallID__Alternatives"); + builder.put(grammarAccess.getIdOrSuperAccess().getAlternatives(), "rule__IdOrSuper__Alternatives"); + builder.put(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1(), "rule__XConstructorCall__Alternatives_4_1"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1(), "rule__XBooleanLiteral__Alternatives_1"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3(), "rule__XTryCatchFinallyExpression__Alternatives_3"); + builder.put(grammarAccess.getNumberAccess().getAlternatives(), "rule__Number__Alternatives"); + builder.put(grammarAccess.getNumberAccess().getAlternatives_1_0(), "rule__Number__Alternatives_1_0"); + builder.put(grammarAccess.getNumberAccess().getAlternatives_1_1_1(), "rule__Number__Alternatives_1_1_1"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getAlternatives(), "rule__JvmTypeReference__Alternatives"); + builder.put(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives(), "rule__JvmArgumentTypeReference__Alternatives"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2(), "rule__JvmWildcardTypeReference__Alternatives_2"); + builder.put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1(), "rule__XImportDeclaration__Alternatives_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3(), "rule__XImportDeclaration__Alternatives_1_0_3"); builder.put(grammarAccess.getCasingAccess().getAlternatives(), "rule__Casing__Alternatives"); builder.put(grammarAccess.getScopeModelAccess().getGroup(), "rule__ScopeModel__Group__0"); builder.put(grammarAccess.getScopeModelAccess().getGroup_2(), "rule__ScopeModel__Group_2__0"); @@ -147,6 +186,185 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionTypeAccess().getGroup(), "rule__CollectionType__Group__0"); builder.put(grammarAccess.getSimpleTypeAccess().getGroup(), "rule__SimpleType__Group__0"); builder.put(grammarAccess.getSimpleTypeAccess().getGroup_1(), "rule__SimpleType__Group_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_0(), "rule__XAssignment__Group_0__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1(), "rule__XAssignment__Group_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1(), "rule__XAssignment__Group_1_1__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0(), "rule__XAssignment__Group_1_1_0__0"); + builder.put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0(), "rule__XAssignment__Group_1_1_0_0__0"); + builder.put(grammarAccess.getOpMultiAssignAccess().getGroup_5(), "rule__OpMultiAssign__Group_5__0"); + builder.put(grammarAccess.getOpMultiAssignAccess().getGroup_6(), "rule__OpMultiAssign__Group_6__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup(), "rule__XOrExpression__Group__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1(), "rule__XOrExpression__Group_1__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1_0(), "rule__XOrExpression__Group_1_0__0"); + builder.put(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0(), "rule__XOrExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup(), "rule__XAndExpression__Group__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1(), "rule__XAndExpression__Group_1__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1_0(), "rule__XAndExpression__Group_1_0__0"); + builder.put(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0(), "rule__XAndExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup(), "rule__XEqualityExpression__Group__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1(), "rule__XEqualityExpression__Group_1__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0(), "rule__XEqualityExpression__Group_1_0__0"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0(), "rule__XEqualityExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup(), "rule__XRelationalExpression__Group__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0(), "rule__XRelationalExpression__Group_1_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0(), "rule__XRelationalExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0(), "rule__XRelationalExpression__Group_1_0_0_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1(), "rule__XRelationalExpression__Group_1_1__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0(), "rule__XRelationalExpression__Group_1_1_0__0"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0(), "rule__XRelationalExpression__Group_1_1_0_0__0"); + builder.put(grammarAccess.getOpCompareAccess().getGroup_1(), "rule__OpCompare__Group_1__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup(), "rule__XOtherOperatorExpression__Group__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1(), "rule__XOtherOperatorExpression__Group_1__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0(), "rule__XOtherOperatorExpression__Group_1_0__0"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0(), "rule__XOtherOperatorExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_2(), "rule__OpOther__Group_2__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5(), "rule__OpOther__Group_5__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5_1_0(), "rule__OpOther__Group_5_1_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0(), "rule__OpOther__Group_5_1_0_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6(), "rule__OpOther__Group_6__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6_1_0(), "rule__OpOther__Group_6_1_0__0"); + builder.put(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0(), "rule__OpOther__Group_6_1_0_0__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup(), "rule__XAdditiveExpression__Group__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1(), "rule__XAdditiveExpression__Group_1__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0(), "rule__XAdditiveExpression__Group_1_0__0"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0(), "rule__XAdditiveExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup(), "rule__XMultiplicativeExpression__Group__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1(), "rule__XMultiplicativeExpression__Group_1__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0(), "rule__XMultiplicativeExpression__Group_1_0__0"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0(), "rule__XMultiplicativeExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXUnaryOperationAccess().getGroup_0(), "rule__XUnaryOperation__Group_0__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup(), "rule__XCastedExpression__Group__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1(), "rule__XCastedExpression__Group_1__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0(), "rule__XCastedExpression__Group_1_0__0"); + builder.put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0(), "rule__XCastedExpression__Group_1_0_0__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup(), "rule__XPostfixOperation__Group__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup_1(), "rule__XPostfixOperation__Group_1__0"); + builder.put(grammarAccess.getXPostfixOperationAccess().getGroup_1_0(), "rule__XPostfixOperation__Group_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup(), "rule__XMemberFeatureCall__Group__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0(), "rule__XMemberFeatureCall__Group_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0(), "rule__XMemberFeatureCall__Group_1_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0(), "rule__XMemberFeatureCall__Group_1_0_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1(), "rule__XMemberFeatureCall__Group_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0(), "rule__XMemberFeatureCall__Group_1_1_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0(), "rule__XMemberFeatureCall__Group_1_1_0_0__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2(), "rule__XMemberFeatureCall__Group_1_1_1_2__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3(), "rule__XMemberFeatureCall__Group_1_1_3__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup(), "rule__XSetLiteral__Group__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup_3(), "rule__XSetLiteral__Group_3__0"); + builder.put(grammarAccess.getXSetLiteralAccess().getGroup_3_1(), "rule__XSetLiteral__Group_3_1__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup(), "rule__XListLiteral__Group__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup_3(), "rule__XListLiteral__Group_3__0"); + builder.put(grammarAccess.getXListLiteralAccess().getGroup_3_1(), "rule__XListLiteral__Group_3_1__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup(), "rule__XClosure__Group__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_0(), "rule__XClosure__Group_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_0_0(), "rule__XClosure__Group_0_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1(), "rule__XClosure__Group_1__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0(), "rule__XClosure__Group_1_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0_0(), "rule__XClosure__Group_1_0_0__0"); + builder.put(grammarAccess.getXClosureAccess().getGroup_1_0_0_1(), "rule__XClosure__Group_1_0_0_1__0"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getGroup(), "rule__XExpressionInClosure__Group__0"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getGroup_1(), "rule__XExpressionInClosure__Group_1__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup(), "rule__XShortClosure__Group__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0(), "rule__XShortClosure__Group_0__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0(), "rule__XShortClosure__Group_0_0__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1(), "rule__XShortClosure__Group_0_0_1__0"); + builder.put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1(), "rule__XShortClosure__Group_0_0_1_1__0"); + builder.put(grammarAccess.getXParenthesizedExpressionAccess().getGroup(), "rule__XParenthesizedExpression__Group__0"); + builder.put(grammarAccess.getXIfExpressionAccess().getGroup(), "rule__XIfExpression__Group__0"); + builder.put(grammarAccess.getXIfExpressionAccess().getGroup_6(), "rule__XIfExpression__Group_6__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup(), "rule__XSwitchExpression__Group__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0(), "rule__XSwitchExpression__Group_2_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0(), "rule__XSwitchExpression__Group_2_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0(), "rule__XSwitchExpression__Group_2_0_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1(), "rule__XSwitchExpression__Group_2_1__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0(), "rule__XSwitchExpression__Group_2_1_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0(), "rule__XSwitchExpression__Group_2_1_0_0__0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getGroup_5(), "rule__XSwitchExpression__Group_5__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup(), "rule__XCasePart__Group__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup_2(), "rule__XCasePart__Group_2__0"); + builder.put(grammarAccess.getXCasePartAccess().getGroup_3_0(), "rule__XCasePart__Group_3_0__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup(), "rule__XForLoopExpression__Group__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup_0(), "rule__XForLoopExpression__Group_0__0"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0(), "rule__XForLoopExpression__Group_0_0__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup(), "rule__XBasicForLoopExpression__Group__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3(), "rule__XBasicForLoopExpression__Group_3__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1(), "rule__XBasicForLoopExpression__Group_3_1__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7(), "rule__XBasicForLoopExpression__Group_7__0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1(), "rule__XBasicForLoopExpression__Group_7_1__0"); + builder.put(grammarAccess.getXWhileExpressionAccess().getGroup(), "rule__XWhileExpression__Group__0"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getGroup(), "rule__XDoWhileExpression__Group__0"); + builder.put(grammarAccess.getXBlockExpressionAccess().getGroup(), "rule__XBlockExpression__Group__0"); + builder.put(grammarAccess.getXBlockExpressionAccess().getGroup_2(), "rule__XBlockExpression__Group_2__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup(), "rule__XVariableDeclaration__Group__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0(), "rule__XVariableDeclaration__Group_2_0__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0(), "rule__XVariableDeclaration__Group_2_0_0__0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getGroup_3(), "rule__XVariableDeclaration__Group_3__0"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getGroup(), "rule__JvmFormalParameter__Group__0"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getGroup(), "rule__FullJvmFormalParameter__Group__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup(), "rule__XFeatureCall__Group__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_1(), "rule__XFeatureCall__Group_1__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_1_2(), "rule__XFeatureCall__Group_1_2__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3(), "rule__XFeatureCall__Group_3__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1(), "rule__XFeatureCall__Group_3_1_1__0"); + builder.put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1(), "rule__XFeatureCall__Group_3_1_1_1__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup(), "rule__XConstructorCall__Group__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_3(), "rule__XConstructorCall__Group_3__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_3_2(), "rule__XConstructorCall__Group_3_2__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4(), "rule__XConstructorCall__Group_4__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1(), "rule__XConstructorCall__Group_4_1_1__0"); + builder.put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1(), "rule__XConstructorCall__Group_4_1_1_1__0"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getGroup(), "rule__XBooleanLiteral__Group__0"); + builder.put(grammarAccess.getXNullLiteralAccess().getGroup(), "rule__XNullLiteral__Group__0"); + builder.put(grammarAccess.getXNumberLiteralAccess().getGroup(), "rule__XNumberLiteral__Group__0"); + builder.put(grammarAccess.getXStringLiteralAccess().getGroup(), "rule__XStringLiteral__Group__0"); + builder.put(grammarAccess.getXTypeLiteralAccess().getGroup(), "rule__XTypeLiteral__Group__0"); + builder.put(grammarAccess.getXThrowExpressionAccess().getGroup(), "rule__XThrowExpression__Group__0"); + builder.put(grammarAccess.getXReturnExpressionAccess().getGroup(), "rule__XReturnExpression__Group__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup(), "rule__XTryCatchFinallyExpression__Group__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0(), "rule__XTryCatchFinallyExpression__Group_3_0__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1(), "rule__XTryCatchFinallyExpression__Group_3_0_1__0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1(), "rule__XTryCatchFinallyExpression__Group_3_1__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup(), "rule__XSynchronizedExpression__Group__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0(), "rule__XSynchronizedExpression__Group_0__0"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0(), "rule__XSynchronizedExpression__Group_0_0__0"); + builder.put(grammarAccess.getXCatchClauseAccess().getGroup(), "rule__XCatchClause__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup(), "rule__QualifiedName__Group__0"); + builder.put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0"); + builder.put(grammarAccess.getNumberAccess().getGroup_1(), "rule__Number__Group_1__0"); + builder.put(grammarAccess.getNumberAccess().getGroup_1_1(), "rule__Number__Group_1_1__0"); + builder.put(grammarAccess.getStaticQualifierAccess().getGroup(), "rule__StaticQualifier__Group__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0(), "rule__JvmTypeReference__Group_0__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1(), "rule__JvmTypeReference__Group_0_1__0"); + builder.put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0(), "rule__JvmTypeReference__Group_0_1_0__0"); + builder.put(grammarAccess.getArrayBracketsAccess().getGroup(), "rule__ArrayBrackets__Group__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup(), "rule__XFunctionTypeRef__Group__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0(), "rule__XFunctionTypeRef__Group_0__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1(), "rule__XFunctionTypeRef__Group_0_1__0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1(), "rule__XFunctionTypeRef__Group_0_1_1__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup(), "rule__JvmParameterizedTypeReference__Group__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1(), "rule__JvmParameterizedTypeReference__Group_1__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2(), "rule__JvmParameterizedTypeReference__Group_1_2__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4(), "rule__JvmParameterizedTypeReference__Group_1_4__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2__0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup(), "rule__JvmWildcardTypeReference__Group__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0(), "rule__JvmWildcardTypeReference__Group_2_0__0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1(), "rule__JvmWildcardTypeReference__Group_2_1__0"); + builder.put(grammarAccess.getJvmUpperBoundAccess().getGroup(), "rule__JvmUpperBound__Group__0"); + builder.put(grammarAccess.getJvmUpperBoundAndedAccess().getGroup(), "rule__JvmUpperBoundAnded__Group__0"); + builder.put(grammarAccess.getJvmLowerBoundAccess().getGroup(), "rule__JvmLowerBound__Group__0"); + builder.put(grammarAccess.getJvmLowerBoundAndedAccess().getGroup(), "rule__JvmLowerBoundAnded__Group__0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getGroup(), "rule__JvmTypeParameter__Group__0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getGroup_1(), "rule__JvmTypeParameter__Group_1__0"); + builder.put(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup(), "rule__QualifiedNameWithWildcard__Group__0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getGroup(), "rule__XImportDeclaration__Group__0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getGroup_1_0(), "rule__XImportDeclaration__Group_1_0__0"); + builder.put(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup(), "rule__QualifiedNameInStaticImport__Group__0"); builder.put(grammarAccess.getScopeModelAccess().getNameAssignment_1(), "rule__ScopeModel__NameAssignment_1"); builder.put(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1(), "rule__ScopeModel__IncludedScopesAssignment_2_1"); builder.put(grammarAccess.getScopeModelAccess().getImportsAssignment_3(), "rule__ScopeModel__ImportsAssignment_3"); @@ -263,6 +481,150 @@ private static void init(ImmutableMap.Builder builder, builder.put(grammarAccess.getCollectionTypeAccess().getId1Assignment_2(), "rule__CollectionType__Id1Assignment_2"); builder.put(grammarAccess.getSimpleTypeAccess().getIdAssignment_0(), "rule__SimpleType__IdAssignment_0"); builder.put(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1(), "rule__SimpleType__IdAssignment_1_1"); + builder.put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1(), "rule__XAssignment__FeatureAssignment_0_1"); + builder.put(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3(), "rule__XAssignment__ValueAssignment_0_3"); + builder.put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XAssignment__FeatureAssignment_1_1_0_0_1"); + builder.put(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1(), "rule__XAssignment__RightOperandAssignment_1_1_1"); + builder.put(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOrExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOrExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAndExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAndExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1(), "rule__XEqualityExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1(), "rule__XRelationalExpression__TypeAssignment_1_0_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"); + builder.put(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1(), "rule__XRelationalExpression__RightOperandAssignment_1_1_1"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAdditiveExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"); + builder.put(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1(), "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"); + builder.put(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1(), "rule__XUnaryOperation__FeatureAssignment_0_1"); + builder.put(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2(), "rule__XUnaryOperation__OperandAssignment_0_2"); + builder.put(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1(), "rule__XCastedExpression__TypeAssignment_1_1"); + builder.put(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1(), "rule__XPostfixOperation__FeatureAssignment_1_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1(), "rule__XMemberFeatureCall__ValueAssignment_1_0_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1(), "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0(), "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"); + builder.put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"); + builder.put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0(), "rule__XSetLiteral__ElementsAssignment_3_0"); + builder.put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1(), "rule__XSetLiteral__ElementsAssignment_3_1_1"); + builder.put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0(), "rule__XListLiteral__ElementsAssignment_3_0"); + builder.put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1(), "rule__XListLiteral__ElementsAssignment_3_1_1"); + builder.put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"); + builder.put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"); + builder.put(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1(), "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"); + builder.put(grammarAccess.getXClosureAccess().getExpressionAssignment_2(), "rule__XClosure__ExpressionAssignment_2"); + builder.put(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0(), "rule__XExpressionInClosure__ExpressionsAssignment_1_0"); + builder.put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"); + builder.put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"); + builder.put(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2(), "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"); + builder.put(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1(), "rule__XShortClosure__ExpressionAssignment_1"); + builder.put(grammarAccess.getXIfExpressionAccess().getIfAssignment_3(), "rule__XIfExpression__IfAssignment_3"); + builder.put(grammarAccess.getXIfExpressionAccess().getThenAssignment_5(), "rule__XIfExpression__ThenAssignment_5"); + builder.put(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1(), "rule__XIfExpression__ElseAssignment_6_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1(), "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1(), "rule__XSwitchExpression__SwitchAssignment_2_0_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0(), "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1(), "rule__XSwitchExpression__SwitchAssignment_2_1_1"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4(), "rule__XSwitchExpression__CasesAssignment_4"); + builder.put(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2(), "rule__XSwitchExpression__DefaultAssignment_5_2"); + builder.put(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1(), "rule__XCasePart__TypeGuardAssignment_1"); + builder.put(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1(), "rule__XCasePart__CaseAssignment_2_1"); + builder.put(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1(), "rule__XCasePart__ThenAssignment_3_0_1"); + builder.put(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1(), "rule__XCasePart__FallThroughAssignment_3_1"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3(), "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1(), "rule__XForLoopExpression__ForExpressionAssignment_1"); + builder.put(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3(), "rule__XForLoopExpression__EachExpressionAssignment_3"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5(), "rule__XBasicForLoopExpression__ExpressionAssignment_5"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"); + builder.put(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9(), "rule__XBasicForLoopExpression__EachExpressionAssignment_9"); + builder.put(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3(), "rule__XWhileExpression__PredicateAssignment_3"); + builder.put(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5(), "rule__XWhileExpression__BodyAssignment_5"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2(), "rule__XDoWhileExpression__BodyAssignment_2"); + builder.put(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5(), "rule__XDoWhileExpression__PredicateAssignment_5"); + builder.put(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0(), "rule__XBlockExpression__ExpressionsAssignment_2_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0(), "rule__XVariableDeclaration__WriteableAssignment_1_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0(), "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1(), "rule__XVariableDeclaration__NameAssignment_2_0_0_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1(), "rule__XVariableDeclaration__NameAssignment_2_1"); + builder.put(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1(), "rule__XVariableDeclaration__RightAssignment_3_1"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__JvmFormalParameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1(), "rule__JvmFormalParameter__NameAssignment_1"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"); + builder.put(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1(), "rule__FullJvmFormalParameter__NameAssignment_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2(), "rule__XFeatureCall__FeatureAssignment_2"); + builder.put(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0(), "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"); + builder.put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"); + builder.put(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2(), "rule__XConstructorCall__ConstructorAssignment_2"); + builder.put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0(), "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"); + builder.put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5(), "rule__XConstructorCall__ArgumentsAssignment_5"); + builder.put(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1(), "rule__XBooleanLiteral__IsTrueAssignment_1_1"); + builder.put(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1(), "rule__XNumberLiteral__ValueAssignment_1"); + builder.put(grammarAccess.getXStringLiteralAccess().getValueAssignment_1(), "rule__XStringLiteral__ValueAssignment_1"); + builder.put(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3(), "rule__XTypeLiteral__TypeAssignment_3"); + builder.put(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4(), "rule__XTypeLiteral__ArrayDimensionsAssignment_4"); + builder.put(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2(), "rule__XThrowExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2(), "rule__XReturnExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2(), "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0(), "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"); + builder.put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1(), "rule__XSynchronizedExpression__ParamAssignment_1"); + builder.put(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3(), "rule__XSynchronizedExpression__ExpressionAssignment_3"); + builder.put(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2(), "rule__XCatchClause__DeclaredParamAssignment_2"); + builder.put(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4(), "rule__XCatchClause__ExpressionAssignment_4"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"); + builder.put(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2(), "rule__XFunctionTypeRef__ReturnTypeAssignment_2"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0(), "rule__JvmParameterizedTypeReference__TypeAssignment_0"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1(), "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"); + builder.put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"); + builder.put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"); + builder.put(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBound__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBound__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getNameAssignment_0(), "rule__JvmTypeParameter__NameAssignment_0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_0(), "rule__JvmTypeParameter__ConstraintsAssignment_1_0"); + builder.put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_1(), "rule__JvmTypeParameter__ConstraintsAssignment_1_1"); + builder.put(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment(), "rule__XImportSection__ImportDeclarationsAssignment"); + builder.put(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0(), "rule__XImportDeclaration__StaticAssignment_1_0_0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1(), "rule__XImportDeclaration__ExtensionAssignment_1_0_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2(), "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2"); + builder.put(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0(), "rule__XImportDeclaration__WildcardAssignment_1_0_3_0"); + builder.put(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1(), "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1(), "rule__XImportDeclaration__ImportedTypeAssignment_1_1"); + builder.put(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2(), "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2"); } } diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.g b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.g index 2fb291f2b3..4fd95f82a3 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.g +++ b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.g @@ -1525,1341 +1525,17815 @@ finally { restoreStackSize(stackSize); } -// Rule Casing -ruleCasing +// Entry rule entryRuleXExpression +entryRuleXExpression +: +{ before(grammarAccess.getXExpressionRule()); } + ruleXExpression +{ after(grammarAccess.getXExpressionRule()); } + EOF +; + +// Rule XExpression +ruleXExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getCasingAccess().getAlternatives()); } - (rule__Casing__Alternatives) - { after(grammarAccess.getCasingAccess().getAlternatives()); } + { before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } + ruleXAssignment + { after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Alternatives_2 +// Entry rule entryRuleXAssignment +entryRuleXAssignment +: +{ before(grammarAccess.getXAssignmentRule()); } + ruleXAssignment +{ after(grammarAccess.getXAssignmentRule()); } + EOF +; + +// Rule XAssignment +ruleXAssignment @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); } - (rule__ScopeDefinition__TargetTypeAssignment_2_0) - { after(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); } - ) - | + : ( - { before(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); } - (rule__ScopeDefinition__Group_2_1__0) - { after(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); } + { before(grammarAccess.getXAssignmentAccess().getAlternatives()); } + (rule__XAssignment__Alternatives) + { after(grammarAccess.getXAssignmentAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Alternatives_0 +// Entry rule entryRuleOpSingleAssign +entryRuleOpSingleAssign +: +{ before(grammarAccess.getOpSingleAssignRule()); } + ruleOpSingleAssign +{ after(grammarAccess.getOpSingleAssignRule()); } + EOF +; + +// Rule OpSingleAssign +ruleOpSingleAssign @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); } - (rule__ScopeContext__GlobalAssignment_0_0) - { after(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); } - ) - | + : ( - { before(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); } - (rule__ScopeContext__ContextTypeAssignment_0_1) - { after(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); } + { before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } + '=' + { after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeExpression__Alternatives +// Entry rule entryRuleOpMultiAssign +entryRuleOpMultiAssign +: +{ before(grammarAccess.getOpMultiAssignRule()); } + ruleOpMultiAssign +{ after(grammarAccess.getOpMultiAssignRule()); } + EOF +; + +// Rule OpMultiAssign +ruleOpMultiAssign @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); } - ruleScopeDelegation - { after(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); } - ruleFactoryExpression - { after(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); } - ruleNamedScopeExpression - { after(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); } + { before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } + (rule__OpMultiAssign__Alternatives) + { after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Alternatives_2 +// Entry rule entryRuleXOrExpression +entryRuleXOrExpression +: +{ before(grammarAccess.getXOrExpressionRule()); } + ruleXOrExpression +{ after(grammarAccess.getXOrExpressionRule()); } + EOF +; + +// Rule XOrExpression +ruleXOrExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); } - (rule__ScopeDelegation__DelegateAssignment_2_0) - { after(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); } - ) - | + : ( - { before(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); } - (rule__ScopeDelegation__ExternalAssignment_2_1) - { after(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); } + { before(grammarAccess.getXOrExpressionAccess().getGroup()); } + (rule__XOrExpression__Group__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Alternatives_0 +// Entry rule entryRuleOpOr +entryRuleOpOr +: +{ before(grammarAccess.getOpOrRule()); } + ruleOpOr +{ after(grammarAccess.getOpOrRule()); } + EOF +; + +// Rule OpOr +ruleOpOr @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); } - ruleGlobalScopeExpression - { after(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); } - ) - | + : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); } - ruleSimpleScopeExpression - { after(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); } + { before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } + '||' + { after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Alternatives_3 +// Entry rule entryRuleXAndExpression +entryRuleXAndExpression +: +{ before(grammarAccess.getXAndExpressionRule()); } + ruleXAndExpression +{ after(grammarAccess.getXAndExpressionRule()); } + EOF +; + +// Rule XAndExpression +ruleXAndExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); } - (rule__GlobalScopeExpression__Group_3_0__0) - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); } - ) - | + : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); } - (rule__GlobalScopeExpression__Group_3_1__0) - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); } + { before(grammarAccess.getXAndExpressionAccess().getGroup()); } + (rule__XAndExpression__Group__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Alternatives_5_3 +// Entry rule entryRuleOpAnd +entryRuleOpAnd +: +{ before(grammarAccess.getOpAndRule()); } + ruleOpAnd +{ after(grammarAccess.getOpAndRule()); } + EOF +; + +// Rule OpAnd +ruleOpAnd @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); } - (rule__GlobalScopeExpression__DomainsAssignment_5_3_0) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); } - ) - | - ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); } - (rule__GlobalScopeExpression__DomainsAssignment_5_3_1) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); } - ) - | + : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); } - (rule__GlobalScopeExpression__Group_5_3_2__0) - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); } + { before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } + '&&' + { after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } ) ; finally { restoreStackSize(stackSize); } -rule__DataExpression__Alternatives +// Entry rule entryRuleXEqualityExpression +entryRuleXEqualityExpression +: +{ before(grammarAccess.getXEqualityExpressionRule()); } + ruleXEqualityExpression +{ after(grammarAccess.getXEqualityExpressionRule()); } + EOF +; + +// Rule XEqualityExpression +ruleXEqualityExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); } - ruleMatchDataExpression - { after(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); } - ) - | + : ( - { before(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); } - ruleLambdaDataExpression - { after(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); } + { before(grammarAccess.getXEqualityExpressionAccess().getGroup()); } + (rule__XEqualityExpression__Group__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__Alternatives +// Entry rule entryRuleOpEquality +entryRuleOpEquality +: +{ before(grammarAccess.getOpEqualityRule()); } + ruleOpEquality +{ after(grammarAccess.getOpEqualityRule()); } + EOF +; + +// Rule OpEquality +ruleOpEquality @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getNamingAccess().getGroup_0()); } - (rule__Naming__Group_0__0) - { after(grammarAccess.getNamingAccess().getGroup_0()); } - ) - | + : ( - { before(grammarAccess.getNamingAccess().getNamesAssignment_1()); } - (rule__Naming__NamesAssignment_1) - { after(grammarAccess.getNamingAccess().getNamesAssignment_1()); } + { before(grammarAccess.getOpEqualityAccess().getAlternatives()); } + (rule__OpEquality__Alternatives) + { after(grammarAccess.getOpEqualityAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__Alternatives +// Entry rule entryRuleXRelationalExpression +entryRuleXRelationalExpression +: +{ before(grammarAccess.getXRelationalExpressionRule()); } + ruleXRelationalExpression +{ after(grammarAccess.getXRelationalExpressionRule()); } + EOF +; + +// Rule XRelationalExpression +ruleXRelationalExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); } - (rule__NamingExpression__ExportAssignment_0) - { after(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); } - ) - | + : ( - { before(grammarAccess.getNamingExpressionAccess().getGroup_1()); } - (rule__NamingExpression__Group_1__0) - { after(grammarAccess.getNamingExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXRelationalExpressionAccess().getGroup()); } + (rule__XRelationalExpression__Group__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__Expression__Alternatives +// Entry rule entryRuleOpCompare +entryRuleOpCompare +: +{ before(grammarAccess.getOpCompareRule()); } + ruleOpCompare +{ after(grammarAccess.getOpCompareRule()); } + EOF +; + +// Rule OpCompare +ruleOpCompare @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } - ruleLetExpression - { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } - (ruleCastedExpression) - { after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } - ) - | + : ( - { before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } - ruleChainExpression - { after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + { before(grammarAccess.getOpCompareAccess().getAlternatives()); } + (rule__OpCompare__Alternatives) + { after(grammarAccess.getOpCompareAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainedExpression__Alternatives +// Entry rule entryRuleXOtherOperatorExpression +entryRuleXOtherOperatorExpression +: +{ before(grammarAccess.getXOtherOperatorExpressionRule()); } + ruleXOtherOperatorExpression +{ after(grammarAccess.getXOtherOperatorExpressionRule()); } + EOF +; + +// Rule XOtherOperatorExpression +ruleXOtherOperatorExpression @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } - ruleIfExpressionKw - { after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); } + (rule__XOtherOperatorExpression__Group__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpOther +entryRuleOpOther +: +{ before(grammarAccess.getOpOtherRule()); } + ruleOpOther +{ after(grammarAccess.getOpOtherRule()); } + EOF +; + +// Rule OpOther +ruleOpOther + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } - ruleIfExpressionTri - { after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + { before(grammarAccess.getOpOtherAccess().getAlternatives()); } + (rule__OpOther__Alternatives) + { after(grammarAccess.getOpOtherAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXAdditiveExpression +entryRuleXAdditiveExpression +: +{ before(grammarAccess.getXAdditiveExpressionRule()); } + ruleXAdditiveExpression +{ after(grammarAccess.getXAdditiveExpressionRule()); } + EOF +; + +// Rule XAdditiveExpression +ruleXAdditiveExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } - ruleSwitchExpression - { after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } + (rule__XAdditiveExpression__Group__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAlternatives_1_1_0 +// Entry rule entryRuleOpAdd +entryRuleOpAdd +: +{ before(grammarAccess.getOpAddRule()); } + ruleOpAdd +{ after(grammarAccess.getOpAddRule()); } + EOF +; + +// Rule OpAdd +ruleOpAdd @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } - '==' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } - '!=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } - '>=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } - '<=' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } - '>' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } - ) - | - ( - { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } - '<' - { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + { before(grammarAccess.getOpAddAccess().getAlternatives()); } + (rule__OpAdd__Alternatives) + { after(grammarAccess.getOpAddAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__NameAlternatives_1_1_0 +// Entry rule entryRuleXMultiplicativeExpression +entryRuleXMultiplicativeExpression +: +{ before(grammarAccess.getXMultiplicativeExpressionRule()); } + ruleXMultiplicativeExpression +{ after(grammarAccess.getXMultiplicativeExpressionRule()); } + EOF +; + +// Rule XMultiplicativeExpression +ruleXMultiplicativeExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } - '+' - { after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } - ) - | + : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } - '-' - { after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } + (rule__XMultiplicativeExpression__Group__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__NameAlternatives_1_1_0 +// Entry rule entryRuleOpMulti +entryRuleOpMulti +: +{ before(grammarAccess.getOpMultiRule()); } + ruleOpMulti +{ after(grammarAccess.getOpMultiRule()); } + EOF +; + +// Rule OpMulti +ruleOpMulti @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } - '*' - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } - ) - | + : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } - '/' - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + { before(grammarAccess.getOpMultiAccess().getAlternatives()); } + (rule__OpMulti__Alternatives) + { after(grammarAccess.getOpMultiAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryOrInfixExpression__Alternatives +// Entry rule entryRuleXUnaryOperation +entryRuleXUnaryOperation +: +{ before(grammarAccess.getXUnaryOperationRule()); } + ruleXUnaryOperation +{ after(grammarAccess.getXUnaryOperationRule()); } + EOF +; + +// Rule XUnaryOperation +ruleXUnaryOperation @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } - ruleUnaryExpression - { after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } - ) - | + : ( - { before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } - ruleInfixExpression - { after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + { before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } + (rule__XUnaryOperation__Alternatives) + { after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__NameAlternatives_0_0 +// Entry rule entryRuleOpUnary +entryRuleOpUnary +: +{ before(grammarAccess.getOpUnaryRule()); } + ruleOpUnary +{ after(grammarAccess.getOpUnaryRule()); } + EOF +; + +// Rule OpUnary +ruleOpUnary @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } - '!' - { after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } - ) - | + : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } - '-' - { after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + { before(grammarAccess.getOpUnaryAccess().getAlternatives()); } + (rule__OpUnary__Alternatives) + { after(grammarAccess.getOpUnaryAccess().getAlternatives()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Alternatives_1 +// Entry rule entryRuleXCastedExpression +entryRuleXCastedExpression +: +{ before(grammarAccess.getXCastedExpressionRule()); } + ruleXCastedExpression +{ after(grammarAccess.getXCastedExpressionRule()); } + EOF +; + +// Rule XCastedExpression +ruleXCastedExpression @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } - (rule__InfixExpression__Group_1_0__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } - (rule__InfixExpression__Group_1_1__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } - ) - | - ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } - (rule__InfixExpression__Group_1_2__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } - ) - | + : ( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } - (rule__InfixExpression__Group_1_3__0) - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + { before(grammarAccess.getXCastedExpressionAccess().getGroup()); } + (rule__XCastedExpression__Group__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAlternatives_1_3_2_0 +// Entry rule entryRuleXPostfixOperation +entryRuleXPostfixOperation +: +{ before(grammarAccess.getXPostfixOperationRule()); } + ruleXPostfixOperation +{ after(grammarAccess.getXPostfixOperationRule()); } + EOF +; + +// Rule XPostfixOperation +ruleXPostfixOperation @init { int stackSize = keepStackSize(); } -: - ( - { before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } - 'collect' - { after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } - ) - | + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } - 'select' - { after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + { before(grammarAccess.getXPostfixOperationAccess().getGroup()); } + (rule__XPostfixOperation__Group__0) + { after(grammarAccess.getXPostfixOperationAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleOpPostfix +entryRuleOpPostfix +: +{ before(grammarAccess.getOpPostfixRule()); } + ruleOpPostfix +{ after(grammarAccess.getOpPostfixRule()); } + EOF +; + +// Rule OpPostfix +ruleOpPostfix + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } - 'selectFirst' - { after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + { before(grammarAccess.getOpPostfixAccess().getAlternatives()); } + (rule__OpPostfix__Alternatives) + { after(grammarAccess.getOpPostfixAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXMemberFeatureCall +entryRuleXMemberFeatureCall +: +{ before(grammarAccess.getXMemberFeatureCallRule()); } + ruleXMemberFeatureCall +{ after(grammarAccess.getXMemberFeatureCallRule()); } + EOF +; + +// Rule XMemberFeatureCall +ruleXMemberFeatureCall + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } - 'reject' - { after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } + (rule__XMemberFeatureCall__Group__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXPrimaryExpression +entryRuleXPrimaryExpression +: +{ before(grammarAccess.getXPrimaryExpressionRule()); } + ruleXPrimaryExpression +{ after(grammarAccess.getXPrimaryExpressionRule()); } + EOF +; + +// Rule XPrimaryExpression +ruleXPrimaryExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } - 'exists' - { after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + { before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } + (rule__XPrimaryExpression__Alternatives) + { after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXLiteral +entryRuleXLiteral +: +{ before(grammarAccess.getXLiteralRule()); } + ruleXLiteral +{ after(grammarAccess.getXLiteralRule()); } + EOF +; + +// Rule XLiteral +ruleXLiteral + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } - 'notExists' - { after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + { before(grammarAccess.getXLiteralAccess().getAlternatives()); } + (rule__XLiteral__Alternatives) + { after(grammarAccess.getXLiteralAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCollectionLiteral +entryRuleXCollectionLiteral +: +{ before(grammarAccess.getXCollectionLiteralRule()); } + ruleXCollectionLiteral +{ after(grammarAccess.getXCollectionLiteralRule()); } + EOF +; + +// Rule XCollectionLiteral +ruleXCollectionLiteral + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } - 'sortBy' - { after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + { before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } + (rule__XCollectionLiteral__Alternatives) + { after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSetLiteral +entryRuleXSetLiteral +: +{ before(grammarAccess.getXSetLiteralRule()); } + ruleXSetLiteral +{ after(grammarAccess.getXSetLiteralRule()); } + EOF +; + +// Rule XSetLiteral +ruleXSetLiteral + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } - 'forAll' - { after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + { before(grammarAccess.getXSetLiteralAccess().getGroup()); } + (rule__XSetLiteral__Group__0) + { after(grammarAccess.getXSetLiteralAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__PrimaryExpression__Alternatives +// Entry rule entryRuleXListLiteral +entryRuleXListLiteral +: +{ before(grammarAccess.getXListLiteralRule()); } + ruleXListLiteral +{ after(grammarAccess.getXListLiteralRule()); } + EOF +; + +// Rule XListLiteral +ruleXListLiteral @init { int stackSize = keepStackSize(); } -: + : ( - { before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } - ruleLiteral - { after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + { before(grammarAccess.getXListLiteralAccess().getGroup()); } + (rule__XListLiteral__Group__0) + { after(grammarAccess.getXListLiteralAccess().getGroup()); } ) - | - ( - { before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } - ruleFeatureCall - { after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXClosure +entryRuleXClosure +: +{ before(grammarAccess.getXClosureRule()); } + ruleXClosure +{ after(grammarAccess.getXClosureRule()); } + EOF +; + +// Rule XClosure +ruleXClosure + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXClosureAccess().getGroup()); } + (rule__XClosure__Group__0) + { after(grammarAccess.getXClosureAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXExpressionInClosure +entryRuleXExpressionInClosure +: +{ before(grammarAccess.getXExpressionInClosureRule()); } + ruleXExpressionInClosure +{ after(grammarAccess.getXExpressionInClosureRule()); } + EOF +; + +// Rule XExpressionInClosure +ruleXExpressionInClosure + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } - ruleListLiteral - { after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + { before(grammarAccess.getXExpressionInClosureAccess().getGroup()); } + (rule__XExpressionInClosure__Group__0) + { after(grammarAccess.getXExpressionInClosureAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXShortClosure +entryRuleXShortClosure +: +{ before(grammarAccess.getXShortClosureRule()); } + ruleXShortClosure +{ after(grammarAccess.getXShortClosureRule()); } + EOF +; + +// Rule XShortClosure +ruleXShortClosure + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } - ruleConstructorCallExpression - { after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + { before(grammarAccess.getXShortClosureAccess().getGroup()); } + (rule__XShortClosure__Group__0) + { after(grammarAccess.getXShortClosureAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXParenthesizedExpression +entryRuleXParenthesizedExpression +: +{ before(grammarAccess.getXParenthesizedExpressionRule()); } + ruleXParenthesizedExpression +{ after(grammarAccess.getXParenthesizedExpressionRule()); } + EOF +; + +// Rule XParenthesizedExpression +ruleXParenthesizedExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } - ruleGlobalVarExpression - { after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + { before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } + (rule__XParenthesizedExpression__Group__0) + { after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } ) - | +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXIfExpression +entryRuleXIfExpression +: +{ before(grammarAccess.getXIfExpressionRule()); } + ruleXIfExpression +{ after(grammarAccess.getXIfExpressionRule()); } + EOF +; + +// Rule XIfExpression +ruleXIfExpression + @init { + int stackSize = keepStackSize(); + } + : ( - { before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } - ruleParanthesizedExpression - { after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + { before(grammarAccess.getXIfExpressionAccess().getGroup()); } + (rule__XIfExpression__Group__0) + { after(grammarAccess.getXIfExpressionAccess().getGroup()); } ) ; finally { restoreStackSize(stackSize); } -rule__Literal__Alternatives +// Entry rule entryRuleXSwitchExpression +entryRuleXSwitchExpression +: +{ before(grammarAccess.getXSwitchExpressionRule()); } + ruleXSwitchExpression +{ after(grammarAccess.getXSwitchExpressionRule()); } + EOF +; + +// Rule XSwitchExpression +ruleXSwitchExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup()); } + (rule__XSwitchExpression__Group__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCasePart +entryRuleXCasePart +: +{ before(grammarAccess.getXCasePartRule()); } + ruleXCasePart +{ after(grammarAccess.getXCasePartRule()); } + EOF +; + +// Rule XCasePart +ruleXCasePart + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCasePartAccess().getGroup()); } + (rule__XCasePart__Group__0) + { after(grammarAccess.getXCasePartAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXForLoopExpression +entryRuleXForLoopExpression +: +{ before(grammarAccess.getXForLoopExpressionRule()); } + ruleXForLoopExpression +{ after(grammarAccess.getXForLoopExpressionRule()); } + EOF +; + +// Rule XForLoopExpression +ruleXForLoopExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXForLoopExpressionAccess().getGroup()); } + (rule__XForLoopExpression__Group__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBasicForLoopExpression +entryRuleXBasicForLoopExpression +: +{ before(grammarAccess.getXBasicForLoopExpressionRule()); } + ruleXBasicForLoopExpression +{ after(grammarAccess.getXBasicForLoopExpressionRule()); } + EOF +; + +// Rule XBasicForLoopExpression +ruleXBasicForLoopExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + (rule__XBasicForLoopExpression__Group__0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXWhileExpression +entryRuleXWhileExpression +: +{ before(grammarAccess.getXWhileExpressionRule()); } + ruleXWhileExpression +{ after(grammarAccess.getXWhileExpressionRule()); } + EOF +; + +// Rule XWhileExpression +ruleXWhileExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXWhileExpressionAccess().getGroup()); } + (rule__XWhileExpression__Group__0) + { after(grammarAccess.getXWhileExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXDoWhileExpression +entryRuleXDoWhileExpression +: +{ before(grammarAccess.getXDoWhileExpressionRule()); } + ruleXDoWhileExpression +{ after(grammarAccess.getXDoWhileExpressionRule()); } + EOF +; + +// Rule XDoWhileExpression +ruleXDoWhileExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } + (rule__XDoWhileExpression__Group__0) + { after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBlockExpression +entryRuleXBlockExpression +: +{ before(grammarAccess.getXBlockExpressionRule()); } + ruleXBlockExpression +{ after(grammarAccess.getXBlockExpressionRule()); } + EOF +; + +// Rule XBlockExpression +ruleXBlockExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBlockExpressionAccess().getGroup()); } + (rule__XBlockExpression__Group__0) + { after(grammarAccess.getXBlockExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXExpressionOrVarDeclaration +entryRuleXExpressionOrVarDeclaration +: +{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); } + ruleXExpressionOrVarDeclaration +{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); } + EOF +; + +// Rule XExpressionOrVarDeclaration +ruleXExpressionOrVarDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } + (rule__XExpressionOrVarDeclaration__Alternatives) + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXVariableDeclaration +entryRuleXVariableDeclaration +: +{ before(grammarAccess.getXVariableDeclarationRule()); } + ruleXVariableDeclaration +{ after(grammarAccess.getXVariableDeclarationRule()); } + EOF +; + +// Rule XVariableDeclaration +ruleXVariableDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup()); } + (rule__XVariableDeclaration__Group__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmFormalParameter +entryRuleJvmFormalParameter +: +{ before(grammarAccess.getJvmFormalParameterRule()); } + ruleJvmFormalParameter +{ after(grammarAccess.getJvmFormalParameterRule()); } + EOF +; + +// Rule JvmFormalParameter +ruleJvmFormalParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmFormalParameterAccess().getGroup()); } + (rule__JvmFormalParameter__Group__0) + { after(grammarAccess.getJvmFormalParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleFullJvmFormalParameter +entryRuleFullJvmFormalParameter +: +{ before(grammarAccess.getFullJvmFormalParameterRule()); } + ruleFullJvmFormalParameter +{ after(grammarAccess.getFullJvmFormalParameterRule()); } + EOF +; + +// Rule FullJvmFormalParameter +ruleFullJvmFormalParameter + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } + (rule__FullJvmFormalParameter__Group__0) + { after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXFeatureCall +entryRuleXFeatureCall +: +{ before(grammarAccess.getXFeatureCallRule()); } + ruleXFeatureCall +{ after(grammarAccess.getXFeatureCallRule()); } + EOF +; + +// Rule XFeatureCall +ruleXFeatureCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXFeatureCallAccess().getGroup()); } + (rule__XFeatureCall__Group__0) + { after(grammarAccess.getXFeatureCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleFeatureCallID +entryRuleFeatureCallID +: +{ before(grammarAccess.getFeatureCallIDRule()); } + ruleFeatureCallID +{ after(grammarAccess.getFeatureCallIDRule()); } + EOF +; + +// Rule FeatureCallID +ruleFeatureCallID + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } + (rule__FeatureCallID__Alternatives) + { after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleIdOrSuper +entryRuleIdOrSuper +: +{ before(grammarAccess.getIdOrSuperRule()); } + ruleIdOrSuper +{ after(grammarAccess.getIdOrSuperRule()); } + EOF +; + +// Rule IdOrSuper +ruleIdOrSuper + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getIdOrSuperAccess().getAlternatives()); } + (rule__IdOrSuper__Alternatives) + { after(grammarAccess.getIdOrSuperAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXConstructorCall +entryRuleXConstructorCall +: +{ before(grammarAccess.getXConstructorCallRule()); } + ruleXConstructorCall +{ after(grammarAccess.getXConstructorCallRule()); } + EOF +; + +// Rule XConstructorCall +ruleXConstructorCall + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXConstructorCallAccess().getGroup()); } + (rule__XConstructorCall__Group__0) + { after(grammarAccess.getXConstructorCallAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXBooleanLiteral +entryRuleXBooleanLiteral +: +{ before(grammarAccess.getXBooleanLiteralRule()); } + ruleXBooleanLiteral +{ after(grammarAccess.getXBooleanLiteralRule()); } + EOF +; + +// Rule XBooleanLiteral +ruleXBooleanLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXBooleanLiteralAccess().getGroup()); } + (rule__XBooleanLiteral__Group__0) + { after(grammarAccess.getXBooleanLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXNullLiteral +entryRuleXNullLiteral +: +{ before(grammarAccess.getXNullLiteralRule()); } + ruleXNullLiteral +{ after(grammarAccess.getXNullLiteralRule()); } + EOF +; + +// Rule XNullLiteral +ruleXNullLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXNullLiteralAccess().getGroup()); } + (rule__XNullLiteral__Group__0) + { after(grammarAccess.getXNullLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXNumberLiteral +entryRuleXNumberLiteral +: +{ before(grammarAccess.getXNumberLiteralRule()); } + ruleXNumberLiteral +{ after(grammarAccess.getXNumberLiteralRule()); } + EOF +; + +// Rule XNumberLiteral +ruleXNumberLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXNumberLiteralAccess().getGroup()); } + (rule__XNumberLiteral__Group__0) + { after(grammarAccess.getXNumberLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXStringLiteral +entryRuleXStringLiteral +: +{ before(grammarAccess.getXStringLiteralRule()); } + ruleXStringLiteral +{ after(grammarAccess.getXStringLiteralRule()); } + EOF +; + +// Rule XStringLiteral +ruleXStringLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXStringLiteralAccess().getGroup()); } + (rule__XStringLiteral__Group__0) + { after(grammarAccess.getXStringLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXTypeLiteral +entryRuleXTypeLiteral +: +{ before(grammarAccess.getXTypeLiteralRule()); } + ruleXTypeLiteral +{ after(grammarAccess.getXTypeLiteralRule()); } + EOF +; + +// Rule XTypeLiteral +ruleXTypeLiteral + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXTypeLiteralAccess().getGroup()); } + (rule__XTypeLiteral__Group__0) + { after(grammarAccess.getXTypeLiteralAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXThrowExpression +entryRuleXThrowExpression +: +{ before(grammarAccess.getXThrowExpressionRule()); } + ruleXThrowExpression +{ after(grammarAccess.getXThrowExpressionRule()); } + EOF +; + +// Rule XThrowExpression +ruleXThrowExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXThrowExpressionAccess().getGroup()); } + (rule__XThrowExpression__Group__0) + { after(grammarAccess.getXThrowExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXReturnExpression +entryRuleXReturnExpression +: +{ before(grammarAccess.getXReturnExpressionRule()); } + ruleXReturnExpression +{ after(grammarAccess.getXReturnExpressionRule()); } + EOF +; + +// Rule XReturnExpression +ruleXReturnExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXReturnExpressionAccess().getGroup()); } + (rule__XReturnExpression__Group__0) + { after(grammarAccess.getXReturnExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXTryCatchFinallyExpression +entryRuleXTryCatchFinallyExpression +: +{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); } + ruleXTryCatchFinallyExpression +{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); } + EOF +; + +// Rule XTryCatchFinallyExpression +ruleXTryCatchFinallyExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } + (rule__XTryCatchFinallyExpression__Group__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXSynchronizedExpression +entryRuleXSynchronizedExpression +: +{ before(grammarAccess.getXSynchronizedExpressionRule()); } + ruleXSynchronizedExpression +{ after(grammarAccess.getXSynchronizedExpressionRule()); } + EOF +; + +// Rule XSynchronizedExpression +ruleXSynchronizedExpression + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } + (rule__XSynchronizedExpression__Group__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXCatchClause +entryRuleXCatchClause +: +{ before(grammarAccess.getXCatchClauseRule()); } + ruleXCatchClause +{ after(grammarAccess.getXCatchClauseRule()); } + EOF +; + +// Rule XCatchClause +ruleXCatchClause + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXCatchClauseAccess().getGroup()); } + (rule__XCatchClause__Group__0) + { after(grammarAccess.getXCatchClauseAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName +: +{ before(grammarAccess.getQualifiedNameRule()); } + ruleQualifiedName +{ after(grammarAccess.getQualifiedNameRule()); } + EOF +; + +// Rule QualifiedName +ruleQualifiedName + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameAccess().getGroup()); } + (rule__QualifiedName__Group__0) + { after(grammarAccess.getQualifiedNameAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleNumber +entryRuleNumber +@init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +} +: +{ before(grammarAccess.getNumberRule()); } + ruleNumber +{ after(grammarAccess.getNumberRule()); } + EOF +; +finally { + myHiddenTokenState.restore(); +} + +// Rule Number +ruleNumber + @init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getNumberAccess().getAlternatives()); } + (rule__Number__Alternatives) + { after(grammarAccess.getNumberAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); + myHiddenTokenState.restore(); +} + +// Entry rule entryRuleJvmTypeReference +entryRuleJvmTypeReference +: +{ before(grammarAccess.getJvmTypeReferenceRule()); } + ruleJvmTypeReference +{ after(grammarAccess.getJvmTypeReferenceRule()); } + EOF +; + +// Rule JvmTypeReference +ruleJvmTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } + (rule__JvmTypeReference__Alternatives) + { after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets +: +{ before(grammarAccess.getArrayBracketsRule()); } + ruleArrayBrackets +{ after(grammarAccess.getArrayBracketsRule()); } + EOF +; + +// Rule ArrayBrackets +ruleArrayBrackets + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getArrayBracketsAccess().getGroup()); } + (rule__ArrayBrackets__Group__0) + { after(grammarAccess.getArrayBracketsAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef +: +{ before(grammarAccess.getXFunctionTypeRefRule()); } + ruleXFunctionTypeRef +{ after(grammarAccess.getXFunctionTypeRefRule()); } + EOF +; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } + (rule__XFunctionTypeRef__Group__0) + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference +: +{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + ruleJvmParameterizedTypeReference +{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + EOF +; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } + (rule__JvmParameterizedTypeReference__Group__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference +: +{ before(grammarAccess.getJvmArgumentTypeReferenceRule()); } + ruleJvmArgumentTypeReference +{ after(grammarAccess.getJvmArgumentTypeReferenceRule()); } + EOF +; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } + (rule__JvmArgumentTypeReference__Alternatives) + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference +: +{ before(grammarAccess.getJvmWildcardTypeReferenceRule()); } + ruleJvmWildcardTypeReference +{ after(grammarAccess.getJvmWildcardTypeReferenceRule()); } + EOF +; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } + (rule__JvmWildcardTypeReference__Group__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound +: +{ before(grammarAccess.getJvmUpperBoundRule()); } + ruleJvmUpperBound +{ after(grammarAccess.getJvmUpperBoundRule()); } + EOF +; + +// Rule JvmUpperBound +ruleJvmUpperBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + (rule__JvmUpperBound__Group__0) + { after(grammarAccess.getJvmUpperBoundAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded +: +{ before(grammarAccess.getJvmUpperBoundAndedRule()); } + ruleJvmUpperBoundAnded +{ after(grammarAccess.getJvmUpperBoundAndedRule()); } + EOF +; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } + (rule__JvmUpperBoundAnded__Group__0) + { after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound +: +{ before(grammarAccess.getJvmLowerBoundRule()); } + ruleJvmLowerBound +{ after(grammarAccess.getJvmLowerBoundRule()); } + EOF +; + +// Rule JvmLowerBound +ruleJvmLowerBound + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmLowerBoundAccess().getGroup()); } + (rule__JvmLowerBound__Group__0) + { after(grammarAccess.getJvmLowerBoundAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded +: +{ before(grammarAccess.getJvmLowerBoundAndedRule()); } + ruleJvmLowerBoundAnded +{ after(grammarAccess.getJvmLowerBoundAndedRule()); } + EOF +; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } + (rule__JvmLowerBoundAnded__Group__0) + { after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard +: +{ before(grammarAccess.getQualifiedNameWithWildcardRule()); } + ruleQualifiedNameWithWildcard +{ after(grammarAccess.getQualifiedNameWithWildcardRule()); } + EOF +; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } + (rule__QualifiedNameWithWildcard__Group__0) + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleValidID +entryRuleValidID +: +{ before(grammarAccess.getValidIDRule()); } + ruleValidID +{ after(grammarAccess.getValidIDRule()); } + EOF +; + +// Rule ValidID +ruleValidID + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } + RULE_ID + { after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration +: +{ before(grammarAccess.getXImportDeclarationRule()); } + ruleXImportDeclaration +{ after(grammarAccess.getXImportDeclarationRule()); } + EOF +; + +// Rule XImportDeclaration +ruleXImportDeclaration + @init { + int stackSize = keepStackSize(); + } + : + ( + { before(grammarAccess.getXImportDeclarationAccess().getGroup()); } + (rule__XImportDeclaration__Group__0) + { after(grammarAccess.getXImportDeclarationAccess().getGroup()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport +: +{ before(grammarAccess.getQualifiedNameInStaticImportRule()); } + ruleQualifiedNameInStaticImport +{ after(grammarAccess.getQualifiedNameInStaticImportRule()); } + EOF +; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport + @init { + int stackSize = keepStackSize(); + } + : + ( + ( + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + (rule__QualifiedNameInStaticImport__Group__0) + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + ) + ( + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + (rule__QualifiedNameInStaticImport__Group__0)* + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + ) + ) +; +finally { + restoreStackSize(stackSize); +} + +// Rule Casing +ruleCasing + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCasingAccess().getAlternatives()); } + (rule__Casing__Alternatives) + { after(grammarAccess.getCasingAccess().getAlternatives()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); } + (rule__ScopeDefinition__TargetTypeAssignment_2_0) + { after(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); } + ) + | + ( + { before(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); } + (rule__ScopeDefinition__Group_2_1__0) + { after(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Alternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); } + (rule__ScopeContext__GlobalAssignment_0_0) + { after(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); } + ) + | + ( + { before(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); } + (rule__ScopeContext__ContextTypeAssignment_0_1) + { after(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); } + ruleScopeDelegation + { after(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); } + ruleFactoryExpression + { after(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); } + ruleNamedScopeExpression + { after(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); } + (rule__ScopeDelegation__DelegateAssignment_2_0) + { after(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); } + ) + | + ( + { before(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); } + (rule__ScopeDelegation__ExternalAssignment_2_1) + { after(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Alternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); } + ruleGlobalScopeExpression + { after(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); } + ) + | + ( + { before(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); } + ruleSimpleScopeExpression + { after(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); } + (rule__GlobalScopeExpression__Group_3_0__0) + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); } + (rule__GlobalScopeExpression__Group_3_1__0) + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Alternatives_5_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); } + (rule__GlobalScopeExpression__DomainsAssignment_5_3_0) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); } + ) + | + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); } + (rule__GlobalScopeExpression__DomainsAssignment_5_3_1) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); } + ) + | + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); } + (rule__GlobalScopeExpression__Group_5_3_2__0) + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__DataExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); } + ruleMatchDataExpression + { after(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); } + ruleLambdaDataExpression + { after(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNamingAccess().getGroup_0()); } + (rule__Naming__Group_0__0) + { after(grammarAccess.getNamingAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getNamingAccess().getNamesAssignment_1()); } + (rule__Naming__NamesAssignment_1) + { after(grammarAccess.getNamingAccess().getNamesAssignment_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); } + (rule__NamingExpression__ExportAssignment_0) + { after(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); } + ) + | + ( + { before(grammarAccess.getNamingExpressionAccess().getGroup_1()); } + (rule__NamingExpression__Group_1__0) + { after(grammarAccess.getNamingExpressionAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Expression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } + ruleLetExpression + { after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } + (ruleCastedExpression) + { after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + ruleChainExpression + { after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainedExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + ruleIfExpressionKw + { after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + ruleIfExpressionTri + { after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + ruleSwitchExpression + { after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__OperatorAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } + '==' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + '!=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } + '>=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + '<=' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + '>' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); } + ) + | + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + '<' + { after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__NameAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } + '+' + { after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + '-' + { after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__NameAlternatives_1_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + '*' + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); } + ) + | + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + '/' + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryOrInfixExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + ruleUnaryExpression + { after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + ruleInfixExpression + { after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__NameAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + '!' + { after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + '-' + { after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + (rule__InfixExpression__Group_1_0__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + (rule__InfixExpression__Group_1_1__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + (rule__InfixExpression__Group_1_2__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + (rule__InfixExpression__Group_1_3__0) + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__NameAlternatives_1_3_2_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + 'collect' + { after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + 'select' + { after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + 'selectFirst' + { after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + 'reject' + { after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + 'exists' + { after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + 'notExists' + { after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + 'sortBy' + { after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); } + ) + | + ( + { before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + 'forAll' + { after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__PrimaryExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + ruleLiteral + { after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } + ruleFeatureCall + { after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + ruleListLiteral + { after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + ruleConstructorCallExpression + { after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + ruleGlobalVarExpression + { after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + ruleParanthesizedExpression + { after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Literal__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + ruleBooleanLiteral + { after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + ruleIntegerLiteral + { after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + ruleNullLiteral + { after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + ruleRealLiteral + { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + ruleStringLiteral + { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__BooleanLiteral__ValAlternatives_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + 'true' + { after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } + ) + | + ( + { before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + 'false' + { after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__FeatureCall__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + ruleOperationCall + { after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + (rule__FeatureCall__TypeAssignment_1) + { after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + ruleCollectionExpression + { after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + ruleTypeSelectExpression + { after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__NameAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + 'collect' + { after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } + 'select' + { after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + 'selectFirst' + { after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + 'reject' + { after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + 'exists' + { after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + 'notExists' + { after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + 'sortBy' + { after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } + ) + | + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + 'forAll' + { after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Type__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } + ruleCollectionType + { after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } + ruleSimpleType + { after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__ClAlternatives_0_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } + 'Collection' + { after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } + ) + | + ( + { before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } + 'List' + { after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } + ) + | + ( + { before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } + 'Set' + { after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXAssignmentAccess().getGroup_0()); } + (rule__XAssignment__Group_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getXAssignmentAccess().getGroup_1()); } + (rule__XAssignment__Group_1__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); } + '+=' + { after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); } + '-=' + { after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); } + '*=' + { after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); } + '/=' + { after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); } + '%=' + { after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); } + (rule__OpMultiAssign__Group_5__0) + { after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); } + ) + | + ( + { before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); } + (rule__OpMultiAssign__Group_6__0) + { after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpEquality__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); } + '==' + { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); } + '!=' + { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); } + '===' + { after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); } + '!==' + { after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); } + (rule__XRelationalExpression__Group_1_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); } + (rule__XRelationalExpression__Group_1_1__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); } + '>=' + { after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getGroup_1()); } + (rule__OpCompare__Group_1__0) + { after(grammarAccess.getOpCompareAccess().getGroup_1()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); } + '>' + { after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); } + '<' + { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); } + '->' + { after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); } + '..<' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_2()); } + (rule__OpOther__Group_2__0) + { after(grammarAccess.getOpOtherAccess().getGroup_2()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); } + '..' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); } + '=>' + { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_5()); } + (rule__OpOther__Group_5__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGroup_6()); } + (rule__OpOther__Group_6__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); } + '<>' + { after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); } + '?:' + { after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives_5_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); } + (rule__OpOther__Group_5_1_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Alternatives_6_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); } + (rule__OpOther__Group_6_1_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); } + ) + | + ( + { before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); } + '=>' + { after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpAdd__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); } + '+' + { after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); } + '-' + { after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMulti__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); } + '*' + { after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); } + '**' + { after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); } + '/' + { after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); } + ) + | + ( + { before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); } + '%' + { after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); } + (rule__XUnaryOperation__Group_0__0) + { after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); } + ruleXCastedExpression + { after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpUnary__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); } + '!' + { after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); } + '-' + { after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); } + ) + | + ( + { before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); } + '+' + { after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpPostfix__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); } + '++' + { after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); } + ) + | + ( + { before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); } + '--' + { after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); } + (rule__XMemberFeatureCall__Group_1_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); } + (rule__XMemberFeatureCall__Group_1_1__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); } + '.' + { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); } + (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); } + '.' + { after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); } + (rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); } + (rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Alternatives_1_1_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); } + ) + | + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_3_1_1__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPrimaryExpression__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); } + ruleXConstructorCall + { after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); } + ruleXBlockExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); } + ruleXSwitchExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); } + (ruleXSynchronizedExpression) + { after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); } + ruleXFeatureCall + { after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); } + ruleXLiteral + { after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); } + ruleXIfExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); } + (ruleXForLoopExpression) + { after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); } + ruleXBasicForLoopExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); } + ruleXWhileExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); } + ruleXDoWhileExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); } + ruleXThrowExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); } + ruleXReturnExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); } + ruleXTryCatchFinallyExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); } + ) + | + ( + { before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); } + ruleXParenthesizedExpression + { after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XLiteral__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); } + ruleXCollectionLiteral + { after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); } + (ruleXClosure) + { after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); } + ruleXBooleanLiteral + { after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); } + ruleXNumberLiteral + { after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); } + ruleXNullLiteral + { after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); } + ruleXStringLiteral + { after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); } + ) + | + ( + { before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); } + ruleXTypeLiteral + { after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCollectionLiteral__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); } + ruleXSetLiteral + { after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); } + ruleXListLiteral + { after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); } + (rule__XSwitchExpression__Group_2_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); } + (rule__XSwitchExpression__Group_2_1__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXCasePartAccess().getGroup_3_0()); } + (rule__XCasePart__Group_3_0__0) + { after(grammarAccess.getXCasePartAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); } + (rule__XCasePart__FallThroughAssignment_3_1) + { after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionOrVarDeclaration__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); } + ruleXVariableDeclaration + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); } + ruleXExpression + { after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); } + (rule__XVariableDeclaration__WriteableAssignment_1_0) + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); } + ) + | + ( + { before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); } + 'val' + { after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XVariableDeclaration__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); } + (rule__XVariableDeclaration__Group_2_0__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); } + (rule__XVariableDeclaration__NameAssignment_2_1) + { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XFeatureCall__Alternatives_3_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); } + ) + | + ( + { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); } + (rule__XFeatureCall__Group_3_1_1__0) + { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__FeatureCallID__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); } + 'extends' + { after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); } + 'static' + { after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); } + 'import' + { after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); } + ) + | + ( + { before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); } + 'extension' + { after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__IdOrSuper__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); } + ruleFeatureCallID + { after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); } + 'super' + { after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XConstructorCall__Alternatives_4_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_0) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); } + ) + | + ( + { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); } + (rule__XConstructorCall__Group_4_1_1__0) + { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XBooleanLiteral__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); } + 'false' + { after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); } + ) + | + ( + { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); } + (rule__XBooleanLiteral__IsTrueAssignment_1_1) + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XTryCatchFinallyExpression__Alternatives_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); } + (rule__XTryCatchFinallyExpression__Group_3_0__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); } + ) + | + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); } + (rule__XTryCatchFinallyExpression__Group_3_1__0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); } + RULE_HEX + { after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getGroup_1()); } + (rule__Number__Group_1__0) + { after(grammarAccess.getNumberAccess().getGroup_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives_1_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); } + RULE_INT + { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); } + RULE_DECIMAL + { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Number__Alternatives_1_1_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); } + RULE_INT + { after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); } + ) + | + ( + { before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); } + RULE_DECIMAL + { after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmTypeReference__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); } + (rule__JvmTypeReference__Group_0__0) + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); } + ) + | + ( + { before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); } + ruleXFunctionTypeRef + { after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmArgumentTypeReference__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); } + ) + | + ( + { before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); } + ruleJvmWildcardTypeReference + { after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__JvmWildcardTypeReference__Alternatives_2 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); } + (rule__JvmWildcardTypeReference__Group_2_0__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); } + ) + | + ( + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); } + (rule__JvmWildcardTypeReference__Group_2_1__0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } + (rule__XImportDeclaration__Group_1_0__0) + { after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } + (rule__XImportDeclaration__ImportedTypeAssignment_1_1) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } + (rule__XImportDeclaration__ImportedNamespaceAssignment_1_2) + { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XImportDeclaration__Alternatives_1_0_3 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } + (rule__XImportDeclaration__WildcardAssignment_1_0_3_0) + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); } + ) + | + ( + { before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } + (rule__XImportDeclaration__MemberNameAssignment_1_0_3_1) + { after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__Casing__Alternatives + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); } + ('sensitive') + { after(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); } + ) + | + ( + { before(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); } + ('insensitive') + { after(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__0__Impl + rule__ScopeModel__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); } + 'scoping' + { after(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__1__Impl + rule__ScopeModel__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getNameAssignment_1()); } + (rule__ScopeModel__NameAssignment_1) + { after(grammarAccess.getScopeModelAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__2__Impl + rule__ScopeModel__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getGroup_2()); } + (rule__ScopeModel__Group_2__0)? + { after(grammarAccess.getScopeModelAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__3__Impl + rule__ScopeModel__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); } + (rule__ScopeModel__ImportsAssignment_3)* + { after(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__4__Impl + rule__ScopeModel__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); } + (rule__ScopeModel__ExtensionsAssignment_4)* + { after(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__5__Impl + rule__ScopeModel__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); } + (rule__ScopeModel__InjectionsAssignment_5)* + { after(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__6__Impl + rule__ScopeModel__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); } + (rule__ScopeModel__NamingAssignment_6)? + { after(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); } + (rule__ScopeModel__ScopesAssignment_7)* + { after(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeModel__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group_2__0__Impl + rule__ScopeModel__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); } + 'with' + { after(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeModel__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeModel__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); } + (rule__ScopeModel__IncludedScopesAssignment_2_1) + { after(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Import__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group__0__Impl + rule__Import__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getImportKeyword_0()); } + 'import' + { after(grammarAccess.getImportAccess().getImportKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group__1__Impl + rule__Import__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getPackageAssignment_1()); } + (rule__Import__PackageAssignment_1) + { after(grammarAccess.getImportAccess().getPackageAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getGroup_2()); } + (rule__Import__Group_2__0)? + { after(grammarAccess.getImportAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Import__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group_2__0__Impl + rule__Import__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getAsKeyword_2_0()); } + 'as' + { after(grammarAccess.getImportAccess().getAsKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Import__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Import__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImportAccess().getNameAssignment_2_1()); } + (rule__Import__NameAssignment_2_1) + { after(grammarAccess.getImportAccess().getNameAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Extension__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Extension__Group__0__Impl + rule__Extension__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Extension__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } + 'extension' + { after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Extension__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Extension__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Extension__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } + (rule__Extension__ExtensionAssignment_1) + { after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Injection__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Injection__Group__0__Impl + rule__Injection__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInjectionAccess().getInjectKeyword_0()); } + 'inject' + { after(grammarAccess.getInjectionAccess().getInjectKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Injection__Group__1__Impl + rule__Injection__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInjectionAccess().getTypeAssignment_1()); } + (rule__Injection__TypeAssignment_1) + { after(grammarAccess.getInjectionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Injection__Group__2__Impl + rule__Injection__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInjectionAccess().getAsKeyword_2()); } + 'as' + { after(grammarAccess.getInjectionAccess().getAsKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Injection__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Injection__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInjectionAccess().getNameAssignment_3()); } + (rule__Injection__NameAssignment_3) + { after(grammarAccess.getInjectionAccess().getNameAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamingSection__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group__0__Impl + rule__NamingSection__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); } + () + { after(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group__1__Impl + rule__NamingSection__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getGroup_1()); } + (rule__NamingSection__Group_1__0)? + { after(grammarAccess.getNamingSectionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group__2__Impl + rule__NamingSection__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } + 'naming' + { after(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group__3__Impl + rule__NamingSection__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); } + '{' + { after(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group__4__Impl + rule__NamingSection__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); } + (rule__NamingSection__NamingsAssignment_4)* + { after(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); } + '}' + { after(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamingSection__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group_1__0__Impl + rule__NamingSection__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); } + 'case' + { after(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingSection__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingSection__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); } + (rule__NamingSection__CasingAssignment_1_1) + { after(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamingDefinition__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingDefinition__Group__0__Impl + rule__NamingDefinition__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); } + (rule__NamingDefinition__TypeAssignment_0) + { after(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingDefinition__Group__1__Impl + rule__NamingDefinition__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); } + '=' + { after(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingDefinition__Group__2__Impl + rule__NamingDefinition__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); } + (rule__NamingDefinition__NamingAssignment_2) + { after(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingDefinition__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingDefinition__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); } + ';' + { after(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDefinition__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group__0__Impl + rule__ScopeDefinition__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); } + 'scope' + { after(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group__1__Impl + rule__ScopeDefinition__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getGroup_1()); } + (rule__ScopeDefinition__Group_1__0)? + { after(grammarAccess.getScopeDefinitionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group__2__Impl + rule__ScopeDefinition__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); } + (rule__ScopeDefinition__Alternatives_2) + { after(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group__3__Impl + rule__ScopeDefinition__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); } + '{' + { after(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group__4__Impl + rule__ScopeDefinition__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + ( + { before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } + (rule__ScopeDefinition__RulesAssignment_4) + { after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } + ) + ( + { before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } + (rule__ScopeDefinition__RulesAssignment_4)* + { after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } + ) +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); } + '}' + { after(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDefinition__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group_1__0__Impl + rule__ScopeDefinition__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); } + '(' + { after(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group_1__1__Impl + rule__ScopeDefinition__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); } + (rule__ScopeDefinition__NameAssignment_1_1) + { after(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); } + ')' + { after(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDefinition__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group_2_1__0__Impl + rule__ScopeDefinition__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); } + (rule__ScopeDefinition__ContextTypeAssignment_2_1_0) + { after(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group_2_1__1__Impl + rule__ScopeDefinition__Group_2_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); } + '#' + { after(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_2_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDefinition__Group_2_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDefinition__Group_2_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); } + (rule__ScopeDefinition__ReferenceAssignment_2_1_2) + { after(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeRule__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group__0__Impl + rule__ScopeRule__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); } + 'context' + { after(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group__1__Impl + rule__ScopeRule__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); } + (rule__ScopeRule__ContextAssignment_1) + { after(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group__2__Impl + rule__ScopeRule__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); } + '=' + { after(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group__3__Impl + rule__ScopeRule__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); } + (rule__ScopeRule__ExprsAssignment_3) + { after(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group__4__Impl + rule__ScopeRule__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getGroup_4()); } + (rule__ScopeRule__Group_4__0)* + { after(grammarAccess.getScopeRuleAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); } + ';' + { after(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeRule__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group_4__0__Impl + rule__ScopeRule__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); } + '>>' + { after(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeRule__Group_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeRule__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); } + (rule__ScopeRule__ExprsAssignment_4_1) + { after(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeContext__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeContext__Group__0__Impl + rule__ScopeContext__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeContextAccess().getAlternatives_0()); } + (rule__ScopeContext__Alternatives_0) + { after(grammarAccess.getScopeContextAccess().getAlternatives_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeContext__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeContextAccess().getGroup_1()); } + (rule__ScopeContext__Group_1__0)? + { after(grammarAccess.getScopeContextAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeContext__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeContext__Group_1__0__Impl + rule__ScopeContext__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); } + '[' + { after(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeContext__Group_1__1__Impl + rule__ScopeContext__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); } + (rule__ScopeContext__GuardAssignment_1_1) + { after(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeContext__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeContext__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); } + ']' + { after(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__FactoryExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__FactoryExpression__Group__0__Impl + rule__FactoryExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__FactoryExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); } + 'factory' + { after(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__FactoryExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__FactoryExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__FactoryExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); } + (rule__FactoryExpression__ExprAssignment_1) + { after(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDelegation__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group__0__Impl + rule__ScopeDelegation__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } + 'scopeof' + { after(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group__1__Impl + rule__ScopeDelegation__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group__2__Impl + rule__ScopeDelegation__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); } + (rule__ScopeDelegation__Alternatives_2) + { after(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group__3__Impl + rule__ScopeDelegation__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getGroup_3()); } + (rule__ScopeDelegation__Group_3__0)? + { after(grammarAccess.getScopeDelegationAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ScopeDelegation__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group_3__0__Impl + rule__ScopeDelegation__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); } + ',' + { after(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ScopeDelegation__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ScopeDelegation__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); } + (rule__ScopeDelegation__ScopeAssignment_3_1) + { after(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamedScopeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group__0__Impl + rule__NamedScopeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); } + (rule__NamedScopeExpression__Alternatives_0) + { after(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group__1__Impl + rule__NamedScopeExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); } + (rule__NamedScopeExpression__Group_1__0)? + { after(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); } + (rule__NamedScopeExpression__Group_2__0)? + { after(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamedScopeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group_1__0__Impl + rule__NamedScopeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); } + (rule__NamedScopeExpression__CaseDefAssignment_1_0) + { after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); } + (rule__NamedScopeExpression__CasingAssignment_1_1) + { after(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamedScopeExpression__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group_2__0__Impl + rule__NamedScopeExpression__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); } + 'as' + { after(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamedScopeExpression__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamedScopeExpression__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); } + (rule__NamedScopeExpression__NamingAssignment_2_1) + { after(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__0__Impl + rule__GlobalScopeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } + 'find' + { after(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__1__Impl + rule__GlobalScopeExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__2__Impl + rule__GlobalScopeExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); } + (rule__GlobalScopeExpression__TypeAssignment_2) + { after(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__3__Impl + rule__GlobalScopeExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); } + (rule__GlobalScopeExpression__Alternatives_3)? + { after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__4__Impl + rule__GlobalScopeExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); } + (rule__GlobalScopeExpression__Group_4__0)? + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__5__Impl + rule__GlobalScopeExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); } + (rule__GlobalScopeExpression__Group_5__0)? + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); } + ')' + { after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_3_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_0__0__Impl + rule__GlobalScopeExpression__Group_3_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } + ',' + { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_0__1__Impl + rule__GlobalScopeExpression__Group_3_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } + 'key' + { after(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_0__2__Impl + rule__GlobalScopeExpression__Group_3_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); } + '=' + { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); } + (rule__GlobalScopeExpression__NameAssignment_3_0_3) + { after(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_1__0__Impl + rule__GlobalScopeExpression__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_1__1__Impl + rule__GlobalScopeExpression__Group_3_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); } + (rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1)? + { after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_1__2__Impl + rule__GlobalScopeExpression__Group_3_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } + 'prefix' + { after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_1__3__Impl + rule__GlobalScopeExpression__Group_3_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); } + '=' + { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_3_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_3_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); } + (rule__GlobalScopeExpression__PrefixAssignment_3_1_4) + { after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__0__Impl + rule__GlobalScopeExpression__Group_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } + ',' + { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__1__Impl + rule__GlobalScopeExpression__Group_4__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } + 'data' + { after(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__2__Impl + rule__GlobalScopeExpression__Group_4__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } + '=' + { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__3__Impl + rule__GlobalScopeExpression__Group_4__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); } + '(' + { after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__4__Impl + rule__GlobalScopeExpression__Group_4__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); } + (rule__GlobalScopeExpression__DataAssignment_4_4) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__5__Impl + rule__GlobalScopeExpression__Group_4__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); } + (rule__GlobalScopeExpression__Group_4_5__0)* + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); } + ')' + { after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_4_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4_5__0__Impl + rule__GlobalScopeExpression__Group_4_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); } + ',' + { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_4_5__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_4_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); } + (rule__GlobalScopeExpression__DataAssignment_4_5_1) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5__0__Impl + rule__GlobalScopeExpression__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } + ',' + { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5__1__Impl + rule__GlobalScopeExpression__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } + 'domains' + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5__2__Impl + rule__GlobalScopeExpression__Group_5__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); } + '=' + { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); } + (rule__GlobalScopeExpression__Alternatives_5_3) + { after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_5_3_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5_3_2__0__Impl + rule__GlobalScopeExpression__Group_5_3_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); } + '(' + { after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5_3_2__1__Impl + rule__GlobalScopeExpression__Group_5_3_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); } + (rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5_3_2__2__Impl + rule__GlobalScopeExpression__Group_5_3_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); } + (rule__GlobalScopeExpression__Group_5_3_2_2__0)* + { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5_3_2__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); } + ')' + { after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalScopeExpression__Group_5_3_2_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl + rule__GlobalScopeExpression__Group_5_3_2_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); } + ',' + { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); } + (rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MatchDataExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MatchDataExpression__Group__0__Impl + rule__MatchDataExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MatchDataExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); } + (rule__MatchDataExpression__KeyAssignment_0) + { after(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MatchDataExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MatchDataExpression__Group__1__Impl + rule__MatchDataExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__MatchDataExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); } + '=' + { after(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MatchDataExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__MatchDataExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MatchDataExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); } + (rule__MatchDataExpression__ValueAssignment_2) + { after(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__LambdaDataExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__LambdaDataExpression__Group__0__Impl + rule__LambdaDataExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); } + '[' + { after(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__LambdaDataExpression__Group__1__Impl + rule__LambdaDataExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); } + (rule__LambdaDataExpression__DescAssignment_1) + { after(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__LambdaDataExpression__Group__2__Impl + rule__LambdaDataExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); } + '|' + { after(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__LambdaDataExpression__Group__3__Impl + rule__LambdaDataExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); } + (rule__LambdaDataExpression__ValueAssignment_3) + { after(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__LambdaDataExpression__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__LambdaDataExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); } + ']' + { after(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Naming__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getGroup_0_0()); } + (rule__Naming__Group_0_0__0) + { after(grammarAccess.getNamingAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Naming__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0_0__0__Impl + rule__Naming__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); } + '(' + { after(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0_0__1__Impl + rule__Naming__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); } + (rule__Naming__NamesAssignment_0_0_1) + { after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0_0__2__Impl + rule__Naming__Group_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getGroup_0_0_2()); } + (rule__Naming__Group_0_0_2__0)* + { after(grammarAccess.getNamingAccess().getGroup_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); } + ')' + { after(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Naming__Group_0_0_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0_0_2__0__Impl + rule__Naming__Group_0_0_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); } + ',' + { after(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Naming__Group_0_0_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Naming__Group_0_0_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); } + (rule__Naming__NamesAssignment_0_0_2_1) + { after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__NamingExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingExpression__Group_1__0__Impl + rule__NamingExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); } + (rule__NamingExpression__FactoryAssignment_1_0)? + { after(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__NamingExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__NamingExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); } + (rule__NamingExpression__ExpressionAssignment_1_1) + { after(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedID__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group__0__Impl + rule__QualifiedID__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); } + ruleIdentifier + { after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getGroup_1()); } + (rule__QualifiedID__Group_1__0)* + { after(grammarAccess.getQualifiedIDAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__QualifiedID__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group_1__0__Impl + rule__QualifiedID__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } + '::' + { after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__QualifiedID__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__QualifiedID__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); } + ruleIdentifier + { after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__DottedID__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__DottedID__Group__0__Impl + rule__DottedID__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__DottedID__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); } + ruleIdentifier + { after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__DottedID__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__DottedID__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__DottedID__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDottedIDAccess().getGroup_1()); } + (rule__DottedID__Group_1__0)* + { after(grammarAccess.getDottedIDAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__DottedID__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__DottedID__Group_1__0__Impl + rule__DottedID__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__DottedID__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); } + '.' + { after(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__DottedID__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__DottedID__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__DottedID__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); } + ruleIdentifier + { after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__LetExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__0__Impl + rule__LetExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } + 'let' + { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__1__Impl + rule__LetExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + (rule__LetExpression__IdentifierAssignment_1) + { after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__2__Impl + rule__LetExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } + '=' + { after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__3__Impl + rule__LetExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } + (rule__LetExpression__VarExprAssignment_3) + { after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__4__Impl + rule__LetExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } + ':' + { after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__LetExpression__Group__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__LetExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } + (rule__LetExpression__TargetAssignment_5) + { after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CastedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__0__Impl + rule__CastedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__1__Impl + rule__CastedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } + (rule__CastedExpression__TypeAssignment_1) + { after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__2__Impl + rule__CastedExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CastedExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CastedExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } + (rule__CastedExpression__TargetAssignment_3) + { after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ChainExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group__0__Impl + rule__ChainExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } + ruleChainedExpression + { after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getGroup_1()); } + (rule__ChainExpression__Group_1__0)* + { after(grammarAccess.getChainExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ChainExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__0__Impl + rule__ChainExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } + () + { after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__1__Impl + rule__ChainExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } + '->' + { after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ChainExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ChainExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } + (rule__ChainExpression__NextAssignment_1_2) + { after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionTri__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group__0__Impl + rule__IfExpressionTri__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } + ruleOrExpression + { after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } + (rule__IfExpressionTri__Group_1__0)? + { after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionTri__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__0__Impl + rule__IfExpressionTri__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + () + { after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__1__Impl + rule__IfExpressionTri__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } + '?' + { after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__2__Impl + rule__IfExpressionTri__Group_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } + (rule__IfExpressionTri__ThenPartAssignment_1_2) + { after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__3__Impl + rule__IfExpressionTri__Group_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } + ':' + { after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionTri__Group_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionTri__Group_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } + (rule__IfExpressionTri__ElsePartAssignment_1_4) + { after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__0__Impl + rule__IfExpressionKw__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } + 'if' + { after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__1__Impl + rule__IfExpressionKw__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } + (rule__IfExpressionKw__ConditionAssignment_1) + { after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__2__Impl + rule__IfExpressionKw__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } + 'then' + { after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__3__Impl + rule__IfExpressionKw__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } + (rule__IfExpressionKw__ThenPartAssignment_3) + { after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } + (rule__IfExpressionKw__Group_4__0)? + { after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } + (rule__IfExpressionKw__Group_4_0__0) + { after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__IfExpressionKw__Group_4_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4_0__0__Impl + rule__IfExpressionKw__Group_4_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } + 'else' + { after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__IfExpressionKw__Group_4_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__IfExpressionKw__Group_4_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } + (rule__IfExpressionKw__ElsePartAssignment_4_0_1) + { after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SwitchExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__0__Impl + rule__SwitchExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } + 'switch' + { after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__1__Impl + rule__SwitchExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } + (rule__SwitchExpression__Group_1__0)? + { after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__2__Impl + rule__SwitchExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } + '{' + { after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__3__Impl + rule__SwitchExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } + (rule__SwitchExpression__CaseAssignment_3)* + { after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__4__Impl + rule__SwitchExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } + 'default' + { after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__5__Impl + rule__SwitchExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } + ':' + { after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__6__Impl + rule__SwitchExpression__Group__7 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + (rule__SwitchExpression__DefaultExprAssignment_6) + { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__7 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group__7__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group__7__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } + '}' + { after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SwitchExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__0__Impl + rule__SwitchExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } + '(' + { after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__1__Impl + rule__SwitchExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + (rule__SwitchExpression__SwitchExprAssignment_1_1) + { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__SwitchExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SwitchExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } + ')' + { after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__Case__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__0__Impl + rule__Case__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } + 'case' + { after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__1__Impl + rule__Case__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } + (rule__Case__ConditionAssignment_1) + { after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__2__Impl + rule__Case__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getColonKeyword_2()); } + ':' + { after(grammarAccess.getCaseAccess().getColonKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__Case__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__Case__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + (rule__Case__ThenParAssignment_3) + { after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OrExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group__0__Impl + rule__OrExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + ruleAndExpression + { after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getGroup_1()); } + (rule__OrExpression__Group_1__0)* + { after(grammarAccess.getOrExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OrExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__0__Impl + rule__OrExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__1__Impl + rule__OrExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + (rule__OrExpression__OperatorAssignment_1_1) + { after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OrExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OrExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + (rule__OrExpression__RightAssignment_1_2) + { after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__AndExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group__0__Impl + rule__AndExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + ruleImpliesExpression + { after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getGroup_1()); } + (rule__AndExpression__Group_1__0)* + { after(grammarAccess.getAndExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__AndExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__0__Impl + rule__AndExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__1__Impl + rule__AndExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + (rule__AndExpression__OperatorAssignment_1_1) + { after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__AndExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AndExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + (rule__AndExpression__RightAssignment_1_2) + { after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ImpliesExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group__0__Impl + rule__ImpliesExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + ruleRelationalExpression + { after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + (rule__ImpliesExpression__Group_1__0)* + { after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ImpliesExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__0__Impl + rule__ImpliesExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__1__Impl + rule__ImpliesExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + (rule__ImpliesExpression__OperatorAssignment_1_1) + { after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ImpliesExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ImpliesExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + (rule__ImpliesExpression__RightAssignment_1_2) + { after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelationalExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group__0__Impl + rule__RelationalExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + ruleAdditiveExpression + { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + (rule__RelationalExpression__Group_1__0)* + { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__RelationalExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__0__Impl + rule__RelationalExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } + () + { after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__1__Impl + rule__RelationalExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } + (rule__RelationalExpression__OperatorAssignment_1_1) + { after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__RelationalExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__RelationalExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + (rule__RelationalExpression__RightAssignment_1_2) + { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +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 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group__1__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().getOperationCallParamsAction_1_0()); } + () + { after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group_1__1__Impl + rule__AdditiveExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + (rule__AdditiveExpression__NameAssignment_1_1) + { after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__AdditiveExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__AdditiveExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + (rule__AdditiveExpression__ParamsAssignment_1_2) + { after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MultiplicativeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group__0__Impl + rule__MultiplicativeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + ruleUnaryOrInfixExpression + { after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + (rule__MultiplicativeExpression__Group_1__0)* + { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__MultiplicativeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__0__Impl + rule__MultiplicativeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } + () + { after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__1__Impl + rule__MultiplicativeExpression__Group_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } + (rule__MultiplicativeExpression__NameAssignment_1_1) + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__MultiplicativeExpression__Group_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__MultiplicativeExpression__Group_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + (rule__MultiplicativeExpression__ParamsAssignment_1_2) + { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__UnaryExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__UnaryExpression__Group__0__Impl + rule__UnaryExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + (rule__UnaryExpression__NameAssignment_0) + { after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__UnaryExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__UnaryExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + (rule__UnaryExpression__ParamsAssignment_1) + { after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group__0__Impl + rule__InfixExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } + rulePrimaryExpression + { after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + (rule__InfixExpression__Alternatives_1)* + { after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__0__Impl + rule__InfixExpression__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__1__Impl + rule__InfixExpression__Group_1_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__2__Impl + rule__InfixExpression__Group_1_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } + (rule__InfixExpression__NameAssignment_1_0_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__3__Impl + rule__InfixExpression__Group_1_0__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__4__Impl + rule__InfixExpression__Group_1_0__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } + (rule__InfixExpression__Group_1_0_4__0)? + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4__0__Impl + rule__InfixExpression__Group_1_0_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } + (rule__InfixExpression__ParamsAssignment_1_0_4_0) + { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } + (rule__InfixExpression__Group_1_0_4_1__0)* + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_0_4_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4_1__0__Impl + rule__InfixExpression__Group_1_0_4_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } + ',' + { after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_0_4_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_0_4_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } + (rule__InfixExpression__ParamsAssignment_1_0_4_1_1) + { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__0__Impl + rule__InfixExpression__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__1__Impl + rule__InfixExpression__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_1__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } + (rule__InfixExpression__TypeAssignment_1_1_2) + { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__0__Impl + rule__InfixExpression__Group_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__1__Impl + rule__InfixExpression__Group_1_2__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__2__Impl + rule__InfixExpression__Group_1_2__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } + (rule__InfixExpression__NameAssignment_1_2_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__3__Impl + rule__InfixExpression__Group_1_2__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__4__Impl + rule__InfixExpression__Group_1_2__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } + (rule__InfixExpression__TypeAssignment_1_2_4) + { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_2__5__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_2__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__0__Impl + rule__InfixExpression__Group_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } + () + { after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__1__Impl + rule__InfixExpression__Group_1_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } + '.' + { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__2__Impl + rule__InfixExpression__Group_1_3__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } + (rule__InfixExpression__NameAssignment_1_3_2) + { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__3__Impl + rule__InfixExpression__Group_1_3__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } + '(' + { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__4__Impl + rule__InfixExpression__Group_1_3__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } + (rule__InfixExpression__Group_1_3_4__0)? + { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__5__Impl + rule__InfixExpression__Group_1_3__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } + (rule__InfixExpression__ExpAssignment_1_3_5) + { after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } + ')' + { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__InfixExpression__Group_1_3_4__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3_4__0__Impl + rule__InfixExpression__Group_1_3_4__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } + (rule__InfixExpression__VarAssignment_1_3_4_0) + { after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__InfixExpression__Group_1_3_4__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__Group_1_3_4__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } + '|' + { after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ParanthesizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__0__Impl + rule__ParanthesizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__1__Impl + rule__ParanthesizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } + ruleExpression + { after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ParanthesizedExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ParanthesizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__GlobalVarExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalVarExpression__Group__0__Impl + rule__GlobalVarExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } + 'GLOBALVAR' + { after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__GlobalVarExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__GlobalVarExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } + (rule__GlobalVarExpression__NameAssignment_1) + { after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__0__Impl + rule__OperationCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } + (rule__OperationCall__NameAssignment_0) + { after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__1__Impl + rule__OperationCall__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__2__Impl + rule__OperationCall__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getGroup_2()); } + (rule__OperationCall__Group_2__0)? + { after(grammarAccess.getOperationCallAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2__0__Impl + rule__OperationCall__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } + (rule__OperationCall__ParamsAssignment_2_0) + { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getGroup_2_1()); } + (rule__OperationCall__Group_2_1__0)* + { after(grammarAccess.getOperationCallAccess().getGroup_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OperationCall__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2_1__0__Impl + rule__OperationCall__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } + ',' + { after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OperationCall__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OperationCall__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } + (rule__OperationCall__ParamsAssignment_2_1_1) + { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__0__Impl + rule__ListLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } + () + { after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__1__Impl + rule__ListLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } + '{' + { after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__2__Impl + rule__ListLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getGroup_2()); } + (rule__ListLiteral__Group_2__0)? + { after(grammarAccess.getListLiteralAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } + '}' + { after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2__0__Impl + rule__ListLiteral__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } + (rule__ListLiteral__ElementsAssignment_2_0) + { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getGroup_2_1()); } + (rule__ListLiteral__Group_2_1__0)* + { after(grammarAccess.getListLiteralAccess().getGroup_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ListLiteral__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2_1__0__Impl + rule__ListLiteral__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } + ',' + { after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ListLiteral__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ListLiteral__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } + (rule__ListLiteral__ElementsAssignment_2_1_1) + { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__ConstructorCallExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__ConstructorCallExpression__Group__0__Impl + rule__ConstructorCallExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } + 'new' + { after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__ConstructorCallExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__ConstructorCallExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } + (rule__ConstructorCallExpression__TypeAssignment_1) + { after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__TypeSelectExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__0__Impl + rule__TypeSelectExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } + (rule__TypeSelectExpression__NameAssignment_0) + { after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__1__Impl + rule__TypeSelectExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__2__Impl + rule__TypeSelectExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } + (rule__TypeSelectExpression__TypeAssignment_2) + { after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__TypeSelectExpression__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__TypeSelectExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__0__Impl + rule__CollectionExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } + (rule__CollectionExpression__NameAssignment_0) + { after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__1__Impl + rule__CollectionExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__2__Impl + rule__CollectionExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } + (rule__CollectionExpression__Group_2__0)? + { after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__3__Impl + rule__CollectionExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } + (rule__CollectionExpression__ExpAssignment_3) + { after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionExpression__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group_2__0__Impl + rule__CollectionExpression__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } + (rule__CollectionExpression__VarAssignment_2_0) + { after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionExpression__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionExpression__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } + '|' + { after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__CollectionType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__0__Impl + rule__CollectionType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } + (rule__CollectionType__ClAssignment_0) + { after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__1__Impl + rule__CollectionType__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } + '[' + { after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__2__Impl + rule__CollectionType__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } + (rule__CollectionType__Id1Assignment_2) + { after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__CollectionType__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__CollectionType__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } + ']' + { after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SimpleType__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group__0__Impl + rule__SimpleType__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } + (rule__SimpleType__IdAssignment_0) + { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getGroup_1()); } + (rule__SimpleType__Group_1__0)* + { after(grammarAccess.getSimpleTypeAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__SimpleType__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group_1__0__Impl + rule__SimpleType__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } + '::' + { after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__SimpleType__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__SimpleType__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } + (rule__SimpleType__IdAssignment_1_1) + { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__0__Impl + rule__XAssignment__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); } + () + { after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__1__Impl + rule__XAssignment__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); } + (rule__XAssignment__FeatureAssignment_0_1) + { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__2__Impl + rule__XAssignment__Group_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); } + ruleOpSingleAssign + { after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); } + (rule__XAssignment__ValueAssignment_0_3) + { after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1__0__Impl + rule__XAssignment__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); } + ruleXOrExpression + { after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); } + (rule__XAssignment__Group_1_1__0)? + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1__0__Impl + rule__XAssignment__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); } + (rule__XAssignment__Group_1_1_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); } + (rule__XAssignment__RightOperandAssignment_1_1_1) + { after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); } + (rule__XAssignment__Group_1_1_0_0__0) + { after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAssignment__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0_0__0__Impl + rule__XAssignment__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAssignment__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAssignment__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); } + (rule__XAssignment__FeatureAssignment_1_1_0_0_1) + { after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpMultiAssign__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__0__Impl + rule__OpMultiAssign__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); } + '<' + { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__1__Impl + rule__OpMultiAssign__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); } + '<' + { after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); } + '=' + { after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpMultiAssign__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__0__Impl + rule__OpMultiAssign__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); } + '>' + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__1__Impl + rule__OpMultiAssign__Group_6__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); } + ('>')? + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpMultiAssign__Group_6__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpMultiAssign__Group_6__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); } + '>=' + { after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group__0__Impl + rule__XOrExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); } + ruleXAndExpression + { after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1()); } + (rule__XOrExpression__Group_1__0)* + { after(grammarAccess.getXOrExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1__0__Impl + rule__XOrExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); } + (rule__XOrExpression__Group_1_0__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XOrExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); } + (rule__XOrExpression__Group_1_0_0__0) + { after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOrExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0_0__0__Impl + rule__XOrExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOrExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOrExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XOrExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group__0__Impl + rule__XAndExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); } + ruleXEqualityExpression + { after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1()); } + (rule__XAndExpression__Group_1__0)* + { after(grammarAccess.getXAndExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1__0__Impl + rule__XAndExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); } + (rule__XAndExpression__Group_1_0__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XAndExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); } + (rule__XAndExpression__Group_1_0_0__0) + { after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAndExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0_0__0__Impl + rule__XAndExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAndExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAndExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XAndExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group__0__Impl + rule__XEqualityExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); } + ruleXRelationalExpression + { after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); } + (rule__XEqualityExpression__Group_1__0)* + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1__0__Impl + rule__XEqualityExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); } + (rule__XEqualityExpression__Group_1_0__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XEqualityExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); } + (rule__XEqualityExpression__Group_1_0_0__0) + { after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XEqualityExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0_0__0__Impl + rule__XEqualityExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XEqualityExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XEqualityExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XEqualityExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group__0__Impl + rule__XRelationalExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); } + ruleXOtherOperatorExpression + { after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); } + (rule__XRelationalExpression__Alternatives_1)* + { after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0__0__Impl + rule__XRelationalExpression__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); } + (rule__XRelationalExpression__Group_1_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); } + (rule__XRelationalExpression__TypeAssignment_1_0_1) + { after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); } + (rule__XRelationalExpression__Group_1_0_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0_0__0__Impl + rule__XRelationalExpression__Group_1_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); } + () + { after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_0_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); } + 'instanceof' + { after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1__0__Impl + rule__XRelationalExpression__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); } + (rule__XRelationalExpression__Group_1_1_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); } + (rule__XRelationalExpression__RightOperandAssignment_1_1_1) + { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); } + (rule__XRelationalExpression__Group_1_1_0_0__0) + { after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XRelationalExpression__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0_0__0__Impl + rule__XRelationalExpression__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XRelationalExpression__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XRelationalExpression__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); } + (rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1) + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpCompare__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpCompare__Group_1__0__Impl + rule__OpCompare__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); } + '<' + { after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpCompare__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpCompare__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); } + '=' + { after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group__0__Impl + rule__XOtherOperatorExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); } + ruleXAdditiveExpression + { after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); } + (rule__XOtherOperatorExpression__Group_1__0)* + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1__0__Impl + rule__XOtherOperatorExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); } + (rule__XOtherOperatorExpression__Group_1_0__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XOtherOperatorExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); } + (rule__XOtherOperatorExpression__Group_1_0_0__0) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XOtherOperatorExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0_0__0__Impl + rule__XOtherOperatorExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XOtherOperatorExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XOtherOperatorExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_2__0__Impl + rule__OpOther__Group_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); } + '..' + { after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5__0__Impl + rule__OpOther__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); } + (rule__OpOther__Alternatives_5_1) + { after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); } + (rule__OpOther__Group_5_1_0_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_5_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0_0__0__Impl + rule__OpOther__Group_5_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_5_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_5_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); } + '>' + { after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6__0__Impl + rule__OpOther__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); } + (rule__OpOther__Alternatives_6_1) + { after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); } + (rule__OpOther__Group_6_1_0_0__0) + { after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__OpOther__Group_6_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0_0__0__Impl + rule__OpOther__Group_6_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__OpOther__Group_6_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__OpOther__Group_6_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); } + '<' + { after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group__0__Impl + rule__XAdditiveExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); } + ruleXMultiplicativeExpression + { after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); } + (rule__XAdditiveExpression__Group_1__0)* + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1__0__Impl + rule__XAdditiveExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); } + (rule__XAdditiveExpression__Group_1_0__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XAdditiveExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); } + (rule__XAdditiveExpression__Group_1_0_0__0) + { after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XAdditiveExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0_0__0__Impl + rule__XAdditiveExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XAdditiveExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XAdditiveExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XAdditiveExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group__0__Impl + rule__XMultiplicativeExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); } + (rule__XMultiplicativeExpression__Group_1__0)* + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1__0__Impl + rule__XMultiplicativeExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); } + (rule__XMultiplicativeExpression__Group_1_0__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); } + (rule__XMultiplicativeExpression__RightOperandAssignment_1_1) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); } + (rule__XMultiplicativeExpression__Group_1_0_0__0) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMultiplicativeExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0_0__0__Impl + rule__XMultiplicativeExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } + () + { after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMultiplicativeExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMultiplicativeExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); } + (rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XUnaryOperation__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__0__Impl + rule__XUnaryOperation__Group_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); } + () + { after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__1__Impl + rule__XUnaryOperation__Group_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); } + (rule__XUnaryOperation__FeatureAssignment_0_1) + { after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XUnaryOperation__Group_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XUnaryOperation__Group_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); } + (rule__XUnaryOperation__OperandAssignment_0_2) + { after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group__0__Impl + rule__XCastedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); } + ruleXPostfixOperation + { after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); } + (rule__XCastedExpression__Group_1__0)* + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1__0__Impl + rule__XCastedExpression__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); } + (rule__XCastedExpression__Group_1_0__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); } + (rule__XCastedExpression__TypeAssignment_1_1) + { after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); } + (rule__XCastedExpression__Group_1_0_0__0) + { after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCastedExpression__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0_0__0__Impl + rule__XCastedExpression__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); } + () + { after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCastedExpression__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCastedExpression__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); } + 'as' + { after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group__0__Impl + rule__XPostfixOperation__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); } + ruleXMemberFeatureCall + { after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); } + (rule__XPostfixOperation__Group_1__0)? + { after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); } + (rule__XPostfixOperation__Group_1_0__0) + { after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XPostfixOperation__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1_0__0__Impl + rule__XPostfixOperation__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); } + () + { after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XPostfixOperation__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XPostfixOperation__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); } + (rule__XPostfixOperation__FeatureAssignment_1_0_1) + { after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group__0__Impl + rule__XMemberFeatureCall__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); } + ruleXPrimaryExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); } + (rule__XMemberFeatureCall__Alternatives_1)* + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0__0__Impl + rule__XMemberFeatureCall__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); } + (rule__XMemberFeatureCall__Group_1_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); } + (rule__XMemberFeatureCall__ValueAssignment_1_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); } + (rule__XMemberFeatureCall__Group_1_0_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); } + () + { after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); } + (rule__XMemberFeatureCall__Alternatives_1_0_0_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl + rule__XMemberFeatureCall__Group_1_0_0_0__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); } + (rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); } + ruleOpSingleAssign + { after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); } + (rule__XMemberFeatureCall__Group_1_1_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__1__Impl + rule__XMemberFeatureCall__Group_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_1__0)? + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__2__Impl + rule__XMemberFeatureCall__Group_1_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); } + (rule__XMemberFeatureCall__FeatureAssignment_1_1_2) + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__3__Impl + rule__XMemberFeatureCall__Group_1_1__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); } + (rule__XMemberFeatureCall__Group_1_1_3__0)? + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4)? + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); } + (rule__XMemberFeatureCall__Group_1_1_0_0__0) + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl + rule__XMemberFeatureCall__Group_1_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); } + () + { after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); } + (rule__XMemberFeatureCall__Alternatives_1_1_0_0_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); } + '<' + { after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__1__Impl + rule__XMemberFeatureCall__Group_1_1_1__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); } + (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__2__Impl + rule__XMemberFeatureCall__Group_1_1_1__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); } + (rule__XMemberFeatureCall__Group_1_1_1_2__0)* + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); } + '>' + { after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_1_2__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl + rule__XMemberFeatureCall__Group_1_1_1_2__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); } + ',' + { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); } + (rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__0__Impl + rule__XMemberFeatureCall__Group_1_1_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); } + (rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__1__Impl + rule__XMemberFeatureCall__Group_1_1_3__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); } + (rule__XMemberFeatureCall__Alternatives_1_1_3_1)? + { after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); } + ')' + { after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_3_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); } + (rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0)* + { after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); } + ',' + { after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); } + (rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1) + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__0__Impl + rule__XSetLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); } + () + { after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__1__Impl + rule__XSetLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); } + '#' + { after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__2__Impl + rule__XSetLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); } + '{' + { after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__3__Impl + rule__XSetLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getGroup_3()); } + (rule__XSetLiteral__Group_3__0)? + { after(grammarAccess.getXSetLiteralAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); } + '}' + { after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3__0__Impl + rule__XSetLiteral__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); } + (rule__XSetLiteral__ElementsAssignment_3_0) + { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); } + (rule__XSetLiteral__Group_3_1__0)* + { after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSetLiteral__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3_1__0__Impl + rule__XSetLiteral__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSetLiteral__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSetLiteral__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); } + (rule__XSetLiteral__ElementsAssignment_3_1_1) + { after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__0__Impl + rule__XListLiteral__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); } + () + { after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__1__Impl + rule__XListLiteral__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); } + '#' + { after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__2__Impl + rule__XListLiteral__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); } + '[' + { after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__3__Impl + rule__XListLiteral__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getGroup_3()); } + (rule__XListLiteral__Group_3__0)? + { after(grammarAccess.getXListLiteralAccess().getGroup_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group__4__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); } + ']' + { after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group_3__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3__0__Impl + rule__XListLiteral__Group_3__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); } + (rule__XListLiteral__ElementsAssignment_3_0) + { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); } + (rule__XListLiteral__Group_3_1__0)* + { after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XListLiteral__Group_3_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3_1__0__Impl + rule__XListLiteral__Group_3_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XListLiteral__Group_3_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__Group_3_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); } + (rule__XListLiteral__ElementsAssignment_3_1_1) + { after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__0__Impl + rule__XClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_0()); } + (rule__XClosure__Group_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__1__Impl + rule__XClosure__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1()); } + (rule__XClosure__Group_1__0)? + { after(grammarAccess.getXClosureAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__2__Impl + rule__XClosure__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); } + (rule__XClosure__ExpressionAssignment_2) + { after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); } + ']' + { after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_0_0()); } + (rule__XClosure__Group_0_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0_0__0__Impl + rule__XClosure__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); } + () + { after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); } + '[' + { after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0()); } + (rule__XClosure__Group_1_0__0) + { after(grammarAccess.getXClosureAccess().getGroup_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0__0__Impl + rule__XClosure__Group_1_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); } + (rule__XClosure__Group_1_0_0__0)? + { after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); } + (rule__XClosure__ExplicitSyntaxAssignment_1_0_1) + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0__0__Impl + rule__XClosure__Group_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); } + (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0) + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); } + (rule__XClosure__Group_1_0_0_1__0)* + { after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XClosure__Group_1_0_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0_1__0__Impl + rule__XClosure__Group_1_0_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); } + ',' + { after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XClosure__Group_1_0_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XClosure__Group_1_0_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); } + (rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1) + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XExpressionInClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group__0__Impl + rule__XExpressionInClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); } + () + { after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); } + (rule__XExpressionInClosure__Group_1__0)* + { after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XExpressionInClosure__Group_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group_1__0__Impl + rule__XExpressionInClosure__Group_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); } + (rule__XExpressionInClosure__ExpressionsAssignment_1_0) + { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XExpressionInClosure__Group_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XExpressionInClosure__Group_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); } + (';')? + { after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group__0__Impl + rule__XShortClosure__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0()); } + (rule__XShortClosure__Group_0__0) + { after(grammarAccess.getXShortClosureAccess().getGroup_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); } + (rule__XShortClosure__ExpressionAssignment_1) + { after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); } + (rule__XShortClosure__Group_0_0__0) + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__0__Impl + rule__XShortClosure__Group_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); } + () + { after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__1__Impl + rule__XShortClosure__Group_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); } + (rule__XShortClosure__Group_0_0_1__0)? + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); } + (rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2) + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1__0__Impl + rule__XShortClosure__Group_0_0_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); } + (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0) + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); } + (rule__XShortClosure__Group_0_0_1_1__0)* + { after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XShortClosure__Group_0_0_1_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1_1__0__Impl + rule__XShortClosure__Group_0_0_1_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); } + ',' + { after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XShortClosure__Group_0_0_1_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XShortClosure__Group_0_0_1_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); } + (rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1) + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XParenthesizedExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__0__Impl + rule__XParenthesizedExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } + '(' + { after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__1__Impl + rule__XParenthesizedExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); } + ruleXExpression + { after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XParenthesizedExpression__Group__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XParenthesizedExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XIfExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__0__Impl + rule__XIfExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); } + () + { after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__1__Impl + rule__XIfExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); } + 'if' + { after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__2__Impl + rule__XIfExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__3__Impl + rule__XIfExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); } + (rule__XIfExpression__IfAssignment_3) + { after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__4__Impl + rule__XIfExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__5__Impl + rule__XIfExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); } + (rule__XIfExpression__ThenAssignment_5) + { after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getGroup_6()); } + (rule__XIfExpression__Group_6__0)? + { after(grammarAccess.getXIfExpressionAccess().getGroup_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XIfExpression__Group_6__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group_6__0__Impl + rule__XIfExpression__Group_6__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); } + ('else') + { after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XIfExpression__Group_6__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XIfExpression__Group_6__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); } + (rule__XIfExpression__ElseAssignment_6_1) + { after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__0__Impl + rule__XSwitchExpression__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); } + () + { after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__1__Impl + rule__XSwitchExpression__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); } + 'switch' + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__2__Impl + rule__XSwitchExpression__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); } + (rule__XSwitchExpression__Alternatives_2) + { after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__3__Impl + rule__XSwitchExpression__Group__4 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__3__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); } + '{' + { after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__4 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__4__Impl + rule__XSwitchExpression__Group__5 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__4__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); } + (rule__XSwitchExpression__CasesAssignment_4)* + { after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__5 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__5__Impl + rule__XSwitchExpression__Group__6 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__5__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); } + (rule__XSwitchExpression__Group_5__0)? + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__6 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group__6__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group__6__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); } + '}' + { after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__0__Impl + rule__XSwitchExpression__Group_2_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); } + (rule__XSwitchExpression__Group_2_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__1__Impl + rule__XSwitchExpression__Group_2_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); } + (rule__XSwitchExpression__SwitchAssignment_2_0_1) + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); } + ')' + { after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); } + (rule__XSwitchExpression__Group_2_0_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_0_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__0__Impl + rule__XSwitchExpression__Group_2_0_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); } + '(' + { after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__1__Impl + rule__XSwitchExpression__Group_2_0_0_0__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); } + (rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1) + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_0_0_0__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_0_0_0__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1__0__Impl + rule__XSwitchExpression__Group_2_1__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); } + (rule__XSwitchExpression__Group_2_1_0__0)? + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); } + (rule__XSwitchExpression__SwitchAssignment_2_1_1) + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0__0__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); } + (rule__XSwitchExpression__Group_2_1_0_0__0) + { after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_2_1_0_0__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0_0__0__Impl + rule__XSwitchExpression__Group_2_1_0_0__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); } + (rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0) + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_2_1_0_0__1__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_2_1_0_0__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XSwitchExpression__Group_5__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__0__Impl + rule__XSwitchExpression__Group_5__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); } + 'default' + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__1__Impl + rule__XSwitchExpression__Group_5__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); } + ':' + { after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XSwitchExpression__Group_5__2__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XSwitchExpression__Group_5__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); } + (rule__XSwitchExpression__DefaultAssignment_5_2) + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + + +rule__XCasePart__Group__0 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__0__Impl + rule__XCasePart__Group__1 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__0__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); } + () + { after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__1 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__1__Impl + rule__XCasePart__Group__2 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__1__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); } + (rule__XCasePart__TypeGuardAssignment_1)? + { after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__2 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__2__Impl + rule__XCasePart__Group__3 +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__2__Impl + @init { + int stackSize = keepStackSize(); + } +: +( + { before(grammarAccess.getXCasePartAccess().getGroup_2()); } + (rule__XCasePart__Group_2__0)? + { after(grammarAccess.getXCasePartAccess().getGroup_2()); } +) +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__3 + @init { + int stackSize = keepStackSize(); + } +: + rule__XCasePart__Group__3__Impl +; +finally { + restoreStackSize(stackSize); +} + +rule__XCasePart__Group__3__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } - ruleBooleanLiteral - { after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } - ruleIntegerLiteral - { after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } - ruleNullLiteral - { after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } - ruleRealLiteral - { after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); } - ) - | - ( - { before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } - ruleStringLiteral - { after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); } - ) +( + { before(grammarAccess.getXCasePartAccess().getAlternatives_3()); } + (rule__XCasePart__Alternatives_3) + { after(grammarAccess.getXCasePartAccess().getAlternatives_3()); } +) ; finally { restoreStackSize(stackSize); } -rule__BooleanLiteral__ValAlternatives_0 + +rule__XCasePart__Group_2__0 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } - 'true' - { after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); } - ) - | - ( - { before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } - 'false' - { after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); } - ) + rule__XCasePart__Group_2__0__Impl + rule__XCasePart__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__FeatureCall__Alternatives +rule__XCasePart__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } - ruleOperationCall - { after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } - (rule__FeatureCall__TypeAssignment_1) - { after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); } - ) - | - ( - { before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } - ruleCollectionExpression - { after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); } - ) - | - ( - { before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } - ruleTypeSelectExpression - { after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); } - ) +( + { before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); } + 'case' + { after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); } +) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__NameAlternatives_0_0 +rule__XCasePart__Group_2__1 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } - 'collect' - { after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } - 'select' - { after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } - 'selectFirst' - { after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } - 'reject' - { after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } - 'exists' - { after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } - 'notExists' - { after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } - 'sortBy' - { after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); } - ) - | - ( - { before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } - 'forAll' - { after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); } - ) + rule__XCasePart__Group_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Type__Alternatives +rule__XCasePart__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } - ruleCollectionType - { after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); } - ) - | - ( - { before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } - ruleSimpleType - { after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); } - ) +( + { before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); } + (rule__XCasePart__CaseAssignment_2_1) + { after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); } +) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__ClAlternatives_0_0 + +rule__XCasePart__Group_3_0__0 @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } - 'Collection' - { after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); } - ) - | - ( - { before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } - 'List' - { after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); } - ) - | - ( - { before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } - 'Set' - { after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); } - ) + rule__XCasePart__Group_3_0__0__Impl + rule__XCasePart__Group_3_0__1 ; finally { restoreStackSize(stackSize); } -rule__Casing__Alternatives +rule__XCasePart__Group_3_0__0__Impl @init { int stackSize = keepStackSize(); } : - ( - { before(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); } - ('sensitive') - { after(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); } - ) - | - ( - { before(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); } - ('insensitive') - { after(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); } - ) +( + { before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); } + ':' + { after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); } +) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__0 +rule__XCasePart__Group_3_0__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__0__Impl - rule__ScopeModel__Group__1 + rule__XCasePart__Group_3_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__0__Impl +rule__XCasePart__Group_3_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); } - 'scoping' - { after(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); } + { before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); } + (rule__XCasePart__ThenAssignment_3_0_1) + { after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__1 + +rule__XForLoopExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__1__Impl - rule__ScopeModel__Group__2 + rule__XForLoopExpression__Group__0__Impl + rule__XForLoopExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__1__Impl +rule__XForLoopExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getNameAssignment_1()); } - (rule__ScopeModel__NameAssignment_1) - { after(grammarAccess.getScopeModelAccess().getNameAssignment_1()); } + { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); } + (rule__XForLoopExpression__Group_0__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__2 +rule__XForLoopExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__2__Impl - rule__ScopeModel__Group__3 + rule__XForLoopExpression__Group__1__Impl + rule__XForLoopExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__2__Impl +rule__XForLoopExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getGroup_2()); } - (rule__ScopeModel__Group_2__0)? - { after(grammarAccess.getScopeModelAccess().getGroup_2()); } + { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); } + (rule__XForLoopExpression__ForExpressionAssignment_1) + { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__3 +rule__XForLoopExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__3__Impl - rule__ScopeModel__Group__4 + rule__XForLoopExpression__Group__2__Impl + rule__XForLoopExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__3__Impl +rule__XForLoopExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); } - (rule__ScopeModel__ImportsAssignment_3)* - { after(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); } + { before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__4 +rule__XForLoopExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__4__Impl - rule__ScopeModel__Group__5 + rule__XForLoopExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__4__Impl +rule__XForLoopExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); } - (rule__ScopeModel__ExtensionsAssignment_4)* - { after(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); } + { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); } + (rule__XForLoopExpression__EachExpressionAssignment_3) + { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__5 + +rule__XForLoopExpression__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__5__Impl - rule__ScopeModel__Group__6 + rule__XForLoopExpression__Group_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__5__Impl +rule__XForLoopExpression__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); } - (rule__ScopeModel__InjectionsAssignment_5)* - { after(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); } + { before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); } + (rule__XForLoopExpression__Group_0_0__0) + { after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__6 + +rule__XForLoopExpression__Group_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__6__Impl - rule__ScopeModel__Group__7 + rule__XForLoopExpression__Group_0_0__0__Impl + rule__XForLoopExpression__Group_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__6__Impl +rule__XForLoopExpression__Group_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); } - (rule__ScopeModel__NamingAssignment_6)? - { after(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); } + { before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); } + () + { after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__7 +rule__XForLoopExpression__Group_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group__7__Impl + rule__XForLoopExpression__Group_0_0__1__Impl + rule__XForLoopExpression__Group_0_0__2 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group__7__Impl +rule__XForLoopExpression__Group_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); } - (rule__ScopeModel__ScopesAssignment_7)* - { after(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); } + { before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); } + 'for' + { after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeModel__Group_2__0 +rule__XForLoopExpression__Group_0_0__2 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group_2__0__Impl - rule__ScopeModel__Group_2__1 + rule__XForLoopExpression__Group_0_0__2__Impl + rule__XForLoopExpression__Group_0_0__3 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group_2__0__Impl +rule__XForLoopExpression__Group_0_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); } - 'with' - { after(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } + '(' + { after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group_2__1 +rule__XForLoopExpression__Group_0_0__3 @init { int stackSize = keepStackSize(); } : - rule__ScopeModel__Group_2__1__Impl + rule__XForLoopExpression__Group_0_0__3__Impl + rule__XForLoopExpression__Group_0_0__4 ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__Group_2__1__Impl +rule__XForLoopExpression__Group_0_0__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); } - (rule__ScopeModel__IncludedScopesAssignment_2_1) - { after(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); } + { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); } + (rule__XForLoopExpression__DeclaredParamAssignment_0_0_3) + { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Import__Group__0 +rule__XForLoopExpression__Group_0_0__4 @init { int stackSize = keepStackSize(); } : - rule__Import__Group__0__Impl - rule__Import__Group__1 + rule__XForLoopExpression__Group_0_0__4__Impl ; finally { restoreStackSize(stackSize); } -rule__Import__Group__0__Impl +rule__XForLoopExpression__Group_0_0__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getImportKeyword_0()); } - 'import' - { after(grammarAccess.getImportAccess().getImportKeyword_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); } + ':' + { after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__Group__1 + +rule__XBasicForLoopExpression__Group__0 @init { int stackSize = keepStackSize(); } -: - rule__Import__Group__1__Impl - rule__Import__Group__2 +: + rule__XBasicForLoopExpression__Group__0__Impl + rule__XBasicForLoopExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Import__Group__1__Impl +rule__XBasicForLoopExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getPackageAssignment_1()); } - (rule__Import__PackageAssignment_1) - { after(grammarAccess.getImportAccess().getPackageAssignment_1()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); } + () + { after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__Group__2 +rule__XBasicForLoopExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Import__Group__2__Impl + rule__XBasicForLoopExpression__Group__1__Impl + rule__XBasicForLoopExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Import__Group__2__Impl +rule__XBasicForLoopExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getGroup_2()); } - (rule__Import__Group_2__0)? - { after(grammarAccess.getImportAccess().getGroup_2()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); } + 'for' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Import__Group_2__0 +rule__XBasicForLoopExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Import__Group_2__0__Impl - rule__Import__Group_2__1 + rule__XBasicForLoopExpression__Group__2__Impl + rule__XBasicForLoopExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Import__Group_2__0__Impl +rule__XBasicForLoopExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getAsKeyword_2_0()); } - 'as' - { after(grammarAccess.getImportAccess().getAsKeyword_2_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__Group_2__1 +rule__XBasicForLoopExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Import__Group_2__1__Impl + rule__XBasicForLoopExpression__Group__3__Impl + rule__XBasicForLoopExpression__Group__4 ; finally { restoreStackSize(stackSize); } -rule__Import__Group_2__1__Impl +rule__XBasicForLoopExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getNameAssignment_2_1()); } - (rule__Import__NameAssignment_2_1) - { after(grammarAccess.getImportAccess().getNameAssignment_2_1()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); } + (rule__XBasicForLoopExpression__Group_3__0)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Extension__Group__0 +rule__XBasicForLoopExpression__Group__4 @init { int stackSize = keepStackSize(); } : - rule__Extension__Group__0__Impl - rule__Extension__Group__1 + rule__XBasicForLoopExpression__Group__4__Impl + rule__XBasicForLoopExpression__Group__5 ; finally { restoreStackSize(stackSize); } -rule__Extension__Group__0__Impl +rule__XBasicForLoopExpression__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } - 'extension' - { after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); } + ';' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__Extension__Group__1 +rule__XBasicForLoopExpression__Group__5 @init { int stackSize = keepStackSize(); } : - rule__Extension__Group__1__Impl + rule__XBasicForLoopExpression__Group__5__Impl + rule__XBasicForLoopExpression__Group__6 ; finally { restoreStackSize(stackSize); } -rule__Extension__Group__1__Impl +rule__XBasicForLoopExpression__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } - (rule__Extension__ExtensionAssignment_1) - { after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); } + (rule__XBasicForLoopExpression__ExpressionAssignment_5)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Injection__Group__0 +rule__XBasicForLoopExpression__Group__6 @init { int stackSize = keepStackSize(); } : - rule__Injection__Group__0__Impl - rule__Injection__Group__1 + rule__XBasicForLoopExpression__Group__6__Impl + rule__XBasicForLoopExpression__Group__7 ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__0__Impl +rule__XBasicForLoopExpression__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInjectionAccess().getInjectKeyword_0()); } - 'inject' - { after(grammarAccess.getInjectionAccess().getInjectKeyword_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); } + ';' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); } ) ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__1 +rule__XBasicForLoopExpression__Group__7 @init { int stackSize = keepStackSize(); } : - rule__Injection__Group__1__Impl - rule__Injection__Group__2 + rule__XBasicForLoopExpression__Group__7__Impl + rule__XBasicForLoopExpression__Group__8 ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__1__Impl +rule__XBasicForLoopExpression__Group__7__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInjectionAccess().getTypeAssignment_1()); } - (rule__Injection__TypeAssignment_1) - { after(grammarAccess.getInjectionAccess().getTypeAssignment_1()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); } + (rule__XBasicForLoopExpression__Group_7__0)? + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); } ) ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__2 +rule__XBasicForLoopExpression__Group__8 @init { int stackSize = keepStackSize(); } : - rule__Injection__Group__2__Impl - rule__Injection__Group__3 + rule__XBasicForLoopExpression__Group__8__Impl + rule__XBasicForLoopExpression__Group__9 ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__2__Impl +rule__XBasicForLoopExpression__Group__8__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInjectionAccess().getAsKeyword_2()); } - 'as' - { after(grammarAccess.getInjectionAccess().getAsKeyword_2()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); } + ')' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); } ) ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__3 +rule__XBasicForLoopExpression__Group__9 @init { int stackSize = keepStackSize(); } : - rule__Injection__Group__3__Impl + rule__XBasicForLoopExpression__Group__9__Impl ; finally { restoreStackSize(stackSize); } -rule__Injection__Group__3__Impl +rule__XBasicForLoopExpression__Group__9__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInjectionAccess().getNameAssignment_3()); } - (rule__Injection__NameAssignment_3) - { after(grammarAccess.getInjectionAccess().getNameAssignment_3()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); } + (rule__XBasicForLoopExpression__EachExpressionAssignment_9) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); } ) ; finally { @@ -2867,161 +19341,161 @@ finally { } -rule__NamingSection__Group__0 +rule__XBasicForLoopExpression__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group__0__Impl - rule__NamingSection__Group__1 + rule__XBasicForLoopExpression__Group_3__0__Impl + rule__XBasicForLoopExpression__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__0__Impl +rule__XBasicForLoopExpression__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); } - () - { after(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); } + (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__1 +rule__XBasicForLoopExpression__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group__1__Impl - rule__NamingSection__Group__2 + rule__XBasicForLoopExpression__Group_3__1__Impl ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__1__Impl +rule__XBasicForLoopExpression__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getGroup_1()); } - (rule__NamingSection__Group_1__0)? - { after(grammarAccess.getNamingSectionAccess().getGroup_1()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); } + (rule__XBasicForLoopExpression__Group_3_1__0)* + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__2 + +rule__XBasicForLoopExpression__Group_3_1__0 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group__2__Impl - rule__NamingSection__Group__3 + rule__XBasicForLoopExpression__Group_3_1__0__Impl + rule__XBasicForLoopExpression__Group_3_1__1 ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__2__Impl +rule__XBasicForLoopExpression__Group_3_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } - 'naming' - { after(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__3 +rule__XBasicForLoopExpression__Group_3_1__1 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group__3__Impl - rule__NamingSection__Group__4 + rule__XBasicForLoopExpression__Group_3_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__3__Impl +rule__XBasicForLoopExpression__Group_3_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); } + (rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__4 + +rule__XBasicForLoopExpression__Group_7__0 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group__4__Impl - rule__NamingSection__Group__5 + rule__XBasicForLoopExpression__Group_7__0__Impl + rule__XBasicForLoopExpression__Group_7__1 ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__4__Impl +rule__XBasicForLoopExpression__Group_7__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); } - (rule__NamingSection__NamingsAssignment_4)* - { after(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); } + (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__5 +rule__XBasicForLoopExpression__Group_7__1 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group__5__Impl + rule__XBasicForLoopExpression__Group_7__1__Impl ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group__5__Impl +rule__XBasicForLoopExpression__Group_7__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); } + (rule__XBasicForLoopExpression__Group_7_1__0)* + { after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); } ) ; finally { @@ -3029,53 +19503,53 @@ finally { } -rule__NamingSection__Group_1__0 +rule__XBasicForLoopExpression__Group_7_1__0 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group_1__0__Impl - rule__NamingSection__Group_1__1 + rule__XBasicForLoopExpression__Group_7_1__0__Impl + rule__XBasicForLoopExpression__Group_7_1__1 ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group_1__0__Impl +rule__XBasicForLoopExpression__Group_7_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); } - 'case' - { after(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); } + ',' + { after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group_1__1 +rule__XBasicForLoopExpression__Group_7_1__1 @init { int stackSize = keepStackSize(); } : - rule__NamingSection__Group_1__1__Impl + rule__XBasicForLoopExpression__Group_7_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__NamingSection__Group_1__1__Impl +rule__XBasicForLoopExpression__Group_7_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); } - (rule__NamingSection__CasingAssignment_1_1) - { after(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); } + (rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1) + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); } ) ; finally { @@ -3083,357 +19557,350 @@ finally { } -rule__NamingDefinition__Group__0 +rule__XWhileExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__NamingDefinition__Group__0__Impl - rule__NamingDefinition__Group__1 + rule__XWhileExpression__Group__0__Impl + rule__XWhileExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__0__Impl +rule__XWhileExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); } - (rule__NamingDefinition__TypeAssignment_0) - { after(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); } + { before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); } + () + { after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__1 +rule__XWhileExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__NamingDefinition__Group__1__Impl - rule__NamingDefinition__Group__2 + rule__XWhileExpression__Group__1__Impl + rule__XWhileExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__1__Impl +rule__XWhileExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); } - '=' - { after(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); } + { before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); } + 'while' + { after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__2 +rule__XWhileExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__NamingDefinition__Group__2__Impl - rule__NamingDefinition__Group__3 + rule__XWhileExpression__Group__2__Impl + rule__XWhileExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__2__Impl +rule__XWhileExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); } - (rule__NamingDefinition__NamingAssignment_2) - { after(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); } + { before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__3 +rule__XWhileExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__NamingDefinition__Group__3__Impl + rule__XWhileExpression__Group__3__Impl + rule__XWhileExpression__Group__4 ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__Group__3__Impl +rule__XWhileExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); } - ';' - { after(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); } + { before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); } + (rule__XWhileExpression__PredicateAssignment_3) + { after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeDefinition__Group__0 +rule__XWhileExpression__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group__0__Impl - rule__ScopeDefinition__Group__1 + rule__XWhileExpression__Group__4__Impl + rule__XWhileExpression__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__0__Impl +rule__XWhileExpression__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); } - 'scope' - { after(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); } + { before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); } + ')' + { after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__1 +rule__XWhileExpression__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group__1__Impl - rule__ScopeDefinition__Group__2 + rule__XWhileExpression__Group__5__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__1__Impl +rule__XWhileExpression__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getGroup_1()); } - (rule__ScopeDefinition__Group_1__0)? - { after(grammarAccess.getScopeDefinitionAccess().getGroup_1()); } + { before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); } + (rule__XWhileExpression__BodyAssignment_5) + { after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__2 + +rule__XDoWhileExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group__2__Impl - rule__ScopeDefinition__Group__3 + rule__XDoWhileExpression__Group__0__Impl + rule__XDoWhileExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__2__Impl +rule__XDoWhileExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); } - (rule__ScopeDefinition__Alternatives_2) - { after(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); } + () + { after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__3 +rule__XDoWhileExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group__3__Impl - rule__ScopeDefinition__Group__4 + rule__XDoWhileExpression__Group__1__Impl + rule__XDoWhileExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__3__Impl +rule__XDoWhileExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); } - '{' - { after(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); } + 'do' + { after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__4 +rule__XDoWhileExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group__4__Impl - rule__ScopeDefinition__Group__5 + rule__XDoWhileExpression__Group__2__Impl + rule__XDoWhileExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__4__Impl +rule__XDoWhileExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - ( - { before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } - (rule__ScopeDefinition__RulesAssignment_4) - { after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } - ) - ( - { before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } - (rule__ScopeDefinition__RulesAssignment_4)* - { after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } - ) + { before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); } + (rule__XDoWhileExpression__BodyAssignment_2) + { after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__5 +rule__XDoWhileExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group__5__Impl + rule__XDoWhileExpression__Group__3__Impl + rule__XDoWhileExpression__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group__5__Impl +rule__XDoWhileExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); } - '}' - { after(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); } + 'while' + { after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeDefinition__Group_1__0 +rule__XDoWhileExpression__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group_1__0__Impl - rule__ScopeDefinition__Group_1__1 + rule__XDoWhileExpression__Group__4__Impl + rule__XDoWhileExpression__Group__5 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_1__0__Impl +rule__XDoWhileExpression__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); } '(' - { after(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); } + { after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_1__1 +rule__XDoWhileExpression__Group__5 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group_1__1__Impl - rule__ScopeDefinition__Group_1__2 + rule__XDoWhileExpression__Group__5__Impl + rule__XDoWhileExpression__Group__6 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_1__1__Impl +rule__XDoWhileExpression__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); } - (rule__ScopeDefinition__NameAssignment_1_1) - { after(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); } + (rule__XDoWhileExpression__PredicateAssignment_5) + { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_1__2 +rule__XDoWhileExpression__Group__6 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group_1__2__Impl + rule__XDoWhileExpression__Group__6__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_1__2__Impl +rule__XDoWhileExpression__Group__6__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); } ')' - { after(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); } + { after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); } ) ; finally { @@ -3441,296 +19908,296 @@ finally { } -rule__ScopeDefinition__Group_2_1__0 +rule__XBlockExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group_2_1__0__Impl - rule__ScopeDefinition__Group_2_1__1 + rule__XBlockExpression__Group__0__Impl + rule__XBlockExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_2_1__0__Impl +rule__XBlockExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); } - (rule__ScopeDefinition__ContextTypeAssignment_2_1_0) - { after(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); } + { before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); } + () + { after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_2_1__1 +rule__XBlockExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group_2_1__1__Impl - rule__ScopeDefinition__Group_2_1__2 + rule__XBlockExpression__Group__1__Impl + rule__XBlockExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_2_1__1__Impl +rule__XBlockExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); } - '#' - { after(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); } + { before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); } + '{' + { after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_2_1__2 +rule__XBlockExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ScopeDefinition__Group_2_1__2__Impl + rule__XBlockExpression__Group__2__Impl + rule__XBlockExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__Group_2_1__2__Impl +rule__XBlockExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); } - (rule__ScopeDefinition__ReferenceAssignment_2_1_2) - { after(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); } + { before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); } + (rule__XBlockExpression__Group_2__0)* + { after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeRule__Group__0 +rule__XBlockExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group__0__Impl - rule__ScopeRule__Group__1 + rule__XBlockExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__0__Impl +rule__XBlockExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); } - 'context' - { after(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); } + { before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); } + '}' + { after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__1 + +rule__XBlockExpression__Group_2__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group__1__Impl - rule__ScopeRule__Group__2 + rule__XBlockExpression__Group_2__0__Impl + rule__XBlockExpression__Group_2__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__1__Impl +rule__XBlockExpression__Group_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); } - (rule__ScopeRule__ContextAssignment_1) - { after(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); } + { before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); } + (rule__XBlockExpression__ExpressionsAssignment_2_0) + { after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__2 +rule__XBlockExpression__Group_2__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group__2__Impl - rule__ScopeRule__Group__3 + rule__XBlockExpression__Group_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__2__Impl +rule__XBlockExpression__Group_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); } - '=' - { after(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); } + { before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); } + (';')? + { after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__3 + +rule__XVariableDeclaration__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group__3__Impl - rule__ScopeRule__Group__4 + rule__XVariableDeclaration__Group__0__Impl + rule__XVariableDeclaration__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__3__Impl +rule__XVariableDeclaration__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); } - (rule__ScopeRule__ExprsAssignment_3) - { after(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); } + { before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); } + () + { after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__4 +rule__XVariableDeclaration__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group__4__Impl - rule__ScopeRule__Group__5 + rule__XVariableDeclaration__Group__1__Impl + rule__XVariableDeclaration__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__4__Impl +rule__XVariableDeclaration__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getGroup_4()); } - (rule__ScopeRule__Group_4__0)* - { after(grammarAccess.getScopeRuleAccess().getGroup_4()); } + { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); } + (rule__XVariableDeclaration__Alternatives_1) + { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__5 +rule__XVariableDeclaration__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group__5__Impl + rule__XVariableDeclaration__Group__2__Impl + rule__XVariableDeclaration__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group__5__Impl +rule__XVariableDeclaration__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); } - ';' - { after(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); } + { before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); } + (rule__XVariableDeclaration__Alternatives_2) + { after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeRule__Group_4__0 +rule__XVariableDeclaration__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group_4__0__Impl - rule__ScopeRule__Group_4__1 + rule__XVariableDeclaration__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group_4__0__Impl +rule__XVariableDeclaration__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); } - '>>' - { after(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); } + (rule__XVariableDeclaration__Group_3__0)? + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group_4__1 + +rule__XVariableDeclaration__Group_2_0__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeRule__Group_4__1__Impl + rule__XVariableDeclaration__Group_2_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__Group_4__1__Impl +rule__XVariableDeclaration__Group_2_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); } - (rule__ScopeRule__ExprsAssignment_4_1) - { after(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); } + { before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); } + (rule__XVariableDeclaration__Group_2_0_0__0) + { after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); } ) ; finally { @@ -3738,53 +20205,53 @@ finally { } -rule__ScopeContext__Group__0 +rule__XVariableDeclaration__Group_2_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeContext__Group__0__Impl - rule__ScopeContext__Group__1 + rule__XVariableDeclaration__Group_2_0_0__0__Impl + rule__XVariableDeclaration__Group_2_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group__0__Impl +rule__XVariableDeclaration__Group_2_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getAlternatives_0()); } - (rule__ScopeContext__Alternatives_0) - { after(grammarAccess.getScopeContextAccess().getAlternatives_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); } + (rule__XVariableDeclaration__TypeAssignment_2_0_0_0) + { after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group__1 +rule__XVariableDeclaration__Group_2_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeContext__Group__1__Impl + rule__XVariableDeclaration__Group_2_0_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group__1__Impl +rule__XVariableDeclaration__Group_2_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getGroup_1()); } - (rule__ScopeContext__Group_1__0)? - { after(grammarAccess.getScopeContextAccess().getGroup_1()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); } + (rule__XVariableDeclaration__NameAssignment_2_0_0_1) + { after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); } ) ; finally { @@ -3792,404 +20259,404 @@ finally { } -rule__ScopeContext__Group_1__0 +rule__XVariableDeclaration__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeContext__Group_1__0__Impl - rule__ScopeContext__Group_1__1 + rule__XVariableDeclaration__Group_3__0__Impl + rule__XVariableDeclaration__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group_1__0__Impl +rule__XVariableDeclaration__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); } - '[' - { after(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); } + '=' + { after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group_1__1 +rule__XVariableDeclaration__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeContext__Group_1__1__Impl - rule__ScopeContext__Group_1__2 + rule__XVariableDeclaration__Group_3__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group_1__1__Impl +rule__XVariableDeclaration__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); } - (rule__ScopeContext__GuardAssignment_1_1) - { after(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); } + { before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); } + (rule__XVariableDeclaration__RightAssignment_3_1) + { after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group_1__2 + +rule__JvmFormalParameter__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeContext__Group_1__2__Impl + rule__JvmFormalParameter__Group__0__Impl + rule__JvmFormalParameter__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__Group_1__2__Impl +rule__JvmFormalParameter__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); } - ']' - { after(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); } + { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); } + (rule__JvmFormalParameter__ParameterTypeAssignment_0)? + { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__FactoryExpression__Group__0 +rule__JvmFormalParameter__Group__1 @init { int stackSize = keepStackSize(); } : - rule__FactoryExpression__Group__0__Impl - rule__FactoryExpression__Group__1 + rule__JvmFormalParameter__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__FactoryExpression__Group__0__Impl +rule__JvmFormalParameter__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); } - 'factory' - { after(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); } + (rule__JvmFormalParameter__NameAssignment_1) + { after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__FactoryExpression__Group__1 + +rule__FullJvmFormalParameter__Group__0 @init { int stackSize = keepStackSize(); } : - rule__FactoryExpression__Group__1__Impl + rule__FullJvmFormalParameter__Group__0__Impl + rule__FullJvmFormalParameter__Group__1 ; finally { restoreStackSize(stackSize); } -rule__FactoryExpression__Group__1__Impl +rule__FullJvmFormalParameter__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); } - (rule__FactoryExpression__ExprAssignment_1) - { after(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); } + (rule__FullJvmFormalParameter__ParameterTypeAssignment_0) + { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeDelegation__Group__0 +rule__FullJvmFormalParameter__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group__0__Impl - rule__ScopeDelegation__Group__1 + rule__FullJvmFormalParameter__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__0__Impl +rule__FullJvmFormalParameter__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } - 'scopeof' - { after(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); } + (rule__FullJvmFormalParameter__NameAssignment_1) + { after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__1 + +rule__XFeatureCall__Group__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group__1__Impl - rule__ScopeDelegation__Group__2 + rule__XFeatureCall__Group__0__Impl + rule__XFeatureCall__Group__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__1__Impl +rule__XFeatureCall__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); } + { before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); } + () + { after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__2 +rule__XFeatureCall__Group__1 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group__2__Impl - rule__ScopeDelegation__Group__3 + rule__XFeatureCall__Group__1__Impl + rule__XFeatureCall__Group__2 ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__2__Impl +rule__XFeatureCall__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); } - (rule__ScopeDelegation__Alternatives_2) - { after(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_1()); } + (rule__XFeatureCall__Group_1__0)? + { after(grammarAccess.getXFeatureCallAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__3 +rule__XFeatureCall__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group__3__Impl - rule__ScopeDelegation__Group__4 + rule__XFeatureCall__Group__2__Impl + rule__XFeatureCall__Group__3 ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__3__Impl +rule__XFeatureCall__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getGroup_3()); } - (rule__ScopeDelegation__Group_3__0)? - { after(grammarAccess.getScopeDelegationAccess().getGroup_3()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); } + (rule__XFeatureCall__FeatureAssignment_2) + { after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__4 +rule__XFeatureCall__Group__3 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group__4__Impl + rule__XFeatureCall__Group__3__Impl + rule__XFeatureCall__Group__4 ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group__4__Impl +rule__XFeatureCall__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); } - ')' - { after(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_3()); } + (rule__XFeatureCall__Group_3__0)? + { after(grammarAccess.getXFeatureCallAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeDelegation__Group_3__0 +rule__XFeatureCall__Group__4 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group_3__0__Impl - rule__ScopeDelegation__Group_3__1 + rule__XFeatureCall__Group__4__Impl ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group_3__0__Impl +rule__XFeatureCall__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); } - ',' - { after(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_4)? + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group_3__1 + +rule__XFeatureCall__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__ScopeDelegation__Group_3__1__Impl + rule__XFeatureCall__Group_1__0__Impl + rule__XFeatureCall__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__Group_3__1__Impl +rule__XFeatureCall__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); } - (rule__ScopeDelegation__ScopeAssignment_3_1) - { after(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); } + { before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); } + '<' + { after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__NamedScopeExpression__Group__0 +rule__XFeatureCall__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group__0__Impl - rule__NamedScopeExpression__Group__1 + rule__XFeatureCall__Group_1__1__Impl + rule__XFeatureCall__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group__0__Impl +rule__XFeatureCall__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); } - (rule__NamedScopeExpression__Alternatives_0) - { after(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); } + (rule__XFeatureCall__TypeArgumentsAssignment_1_1) + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group__1 +rule__XFeatureCall__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group__1__Impl - rule__NamedScopeExpression__Group__2 + rule__XFeatureCall__Group_1__2__Impl + rule__XFeatureCall__Group_1__3 ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group__1__Impl +rule__XFeatureCall__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); } - (rule__NamedScopeExpression__Group_1__0)? - { after(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); } + (rule__XFeatureCall__Group_1_2__0)* + { after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group__2 +rule__XFeatureCall__Group_1__3 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group__2__Impl + rule__XFeatureCall__Group_1__3__Impl ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group__2__Impl +rule__XFeatureCall__Group_1__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); } - (rule__NamedScopeExpression__Group_2__0)? - { after(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); } + { before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); } + '>' + { after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); } ) ; finally { @@ -4197,53 +20664,53 @@ finally { } -rule__NamedScopeExpression__Group_1__0 +rule__XFeatureCall__Group_1_2__0 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group_1__0__Impl - rule__NamedScopeExpression__Group_1__1 + rule__XFeatureCall__Group_1_2__0__Impl + rule__XFeatureCall__Group_1_2__1 ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group_1__0__Impl +rule__XFeatureCall__Group_1_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); } - (rule__NamedScopeExpression__CaseDefAssignment_1_0) - { after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); } + ',' + { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group_1__1 +rule__XFeatureCall__Group_1_2__1 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group_1__1__Impl + rule__XFeatureCall__Group_1_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group_1__1__Impl +rule__XFeatureCall__Group_1_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); } - (rule__NamedScopeExpression__CasingAssignment_1_1) - { after(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); } + (rule__XFeatureCall__TypeArgumentsAssignment_1_2_1) + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); } ) ; finally { @@ -4251,350 +20718,350 @@ finally { } -rule__NamedScopeExpression__Group_2__0 +rule__XFeatureCall__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group_2__0__Impl - rule__NamedScopeExpression__Group_2__1 + rule__XFeatureCall__Group_3__0__Impl + rule__XFeatureCall__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group_2__0__Impl +rule__XFeatureCall__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); } - 'as' - { after(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); } + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); } + (rule__XFeatureCall__ExplicitOperationCallAssignment_3_0) + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group_2__1 +rule__XFeatureCall__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__NamedScopeExpression__Group_2__1__Impl + rule__XFeatureCall__Group_3__1__Impl + rule__XFeatureCall__Group_3__2 ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__Group_2__1__Impl +rule__XFeatureCall__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); } - (rule__NamedScopeExpression__NamingAssignment_2_1) - { after(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); } + { before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); } + (rule__XFeatureCall__Alternatives_3_1)? + { after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group__0 +rule__XFeatureCall__Group_3__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__0__Impl - rule__GlobalScopeExpression__Group__1 + rule__XFeatureCall__Group_3__2__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__0__Impl +rule__XFeatureCall__Group_3__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } - 'find' - { after(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } + { before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); } + ')' + { after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__1 + +rule__XFeatureCall__Group_3_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__1__Impl - rule__GlobalScopeExpression__Group__2 + rule__XFeatureCall__Group_3_1_1__0__Impl + rule__XFeatureCall__Group_3_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__1__Impl +rule__XFeatureCall__Group_3_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__2 +rule__XFeatureCall__Group_3_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__2__Impl - rule__GlobalScopeExpression__Group__3 + rule__XFeatureCall__Group_3_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__2__Impl +rule__XFeatureCall__Group_3_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); } - (rule__GlobalScopeExpression__TypeAssignment_2) - { after(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); } + { before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); } + (rule__XFeatureCall__Group_3_1_1_1__0)* + { after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__3 + +rule__XFeatureCall__Group_3_1_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__3__Impl - rule__GlobalScopeExpression__Group__4 + rule__XFeatureCall__Group_3_1_1_1__0__Impl + rule__XFeatureCall__Group_3_1_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__3__Impl +rule__XFeatureCall__Group_3_1_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); } - (rule__GlobalScopeExpression__Alternatives_3)? - { after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); } + { before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); } + ',' + { after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__4 +rule__XFeatureCall__Group_3_1_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__4__Impl - rule__GlobalScopeExpression__Group__5 + rule__XFeatureCall__Group_3_1_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__4__Impl +rule__XFeatureCall__Group_3_1_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); } - (rule__GlobalScopeExpression__Group_4__0)? - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); } + (rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1) + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__5 + +rule__XConstructorCall__Group__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__5__Impl - rule__GlobalScopeExpression__Group__6 + rule__XConstructorCall__Group__0__Impl + rule__XConstructorCall__Group__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__5__Impl +rule__XConstructorCall__Group__0__Impl @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); } - (rule__GlobalScopeExpression__Group_5__0)? - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); } +( + { before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); } + () + { after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__6 +rule__XConstructorCall__Group__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group__6__Impl + rule__XConstructorCall__Group__1__Impl + rule__XConstructorCall__Group__2 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group__6__Impl +rule__XConstructorCall__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); } - ')' - { after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); } + { before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); } + 'new' + { after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group_3_0__0 +rule__XConstructorCall__Group__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_0__0__Impl - rule__GlobalScopeExpression__Group_3_0__1 + rule__XConstructorCall__Group__2__Impl + rule__XConstructorCall__Group__3 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__0__Impl +rule__XConstructorCall__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } - ',' - { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } + { before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); } + (rule__XConstructorCall__ConstructorAssignment_2) + { after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__1 +rule__XConstructorCall__Group__3 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_0__1__Impl - rule__GlobalScopeExpression__Group_3_0__2 + rule__XConstructorCall__Group__3__Impl + rule__XConstructorCall__Group__4 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__1__Impl +rule__XConstructorCall__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } - 'key' - { after(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_3()); } + (rule__XConstructorCall__Group_3__0)? + { after(grammarAccess.getXConstructorCallAccess().getGroup_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__2 +rule__XConstructorCall__Group__4 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_0__2__Impl - rule__GlobalScopeExpression__Group_3_0__3 + rule__XConstructorCall__Group__4__Impl + rule__XConstructorCall__Group__5 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__2__Impl +rule__XConstructorCall__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); } - '=' - { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_4()); } + (rule__XConstructorCall__Group_4__0)? + { after(grammarAccess.getXConstructorCallAccess().getGroup_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__3 +rule__XConstructorCall__Group__5 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_0__3__Impl + rule__XConstructorCall__Group__5__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_0__3__Impl +rule__XConstructorCall__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); } - (rule__GlobalScopeExpression__NameAssignment_3_0_3) - { after(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); } + (rule__XConstructorCall__ArgumentsAssignment_5)? + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); } ) ; finally { @@ -4602,728 +21069,728 @@ finally { } -rule__GlobalScopeExpression__Group_3_1__0 +rule__XConstructorCall__Group_3__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_1__0__Impl - rule__GlobalScopeExpression__Group_3_1__1 + rule__XConstructorCall__Group_3__0__Impl + rule__XConstructorCall__Group_3__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__0__Impl +rule__XConstructorCall__Group_3__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); } - ',' - { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); } + ('<') + { after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__1 +rule__XConstructorCall__Group_3__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_1__1__Impl - rule__GlobalScopeExpression__Group_3_1__2 + rule__XConstructorCall__Group_3__1__Impl + rule__XConstructorCall__Group_3__2 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__1__Impl +rule__XConstructorCall__Group_3__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); } - (rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1)? - { after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); } + (rule__XConstructorCall__TypeArgumentsAssignment_3_1) + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__2 +rule__XConstructorCall__Group_3__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_1__2__Impl - rule__GlobalScopeExpression__Group_3_1__3 + rule__XConstructorCall__Group_3__2__Impl + rule__XConstructorCall__Group_3__3 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__2__Impl +rule__XConstructorCall__Group_3__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } - 'prefix' - { after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); } + (rule__XConstructorCall__Group_3_2__0)* + { after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__3 +rule__XConstructorCall__Group_3__3 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_1__3__Impl - rule__GlobalScopeExpression__Group_3_1__4 + rule__XConstructorCall__Group_3__3__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__3__Impl +rule__XConstructorCall__Group_3__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); } - '=' - { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); } + { before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); } + '>' + { after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__4 + +rule__XConstructorCall__Group_3_2__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_3_1__4__Impl + rule__XConstructorCall__Group_3_2__0__Impl + rule__XConstructorCall__Group_3_2__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_3_1__4__Impl +rule__XConstructorCall__Group_3_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); } - (rule__GlobalScopeExpression__PrefixAssignment_3_1_4) - { after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); } + { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); } + ',' + { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group_4__0 +rule__XConstructorCall__Group_3_2__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__0__Impl - rule__GlobalScopeExpression__Group_4__1 + rule__XConstructorCall__Group_3_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__0__Impl +rule__XConstructorCall__Group_3_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } - ',' - { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); } + (rule__XConstructorCall__TypeArgumentsAssignment_3_2_1) + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__1 + +rule__XConstructorCall__Group_4__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__1__Impl - rule__GlobalScopeExpression__Group_4__2 + rule__XConstructorCall__Group_4__0__Impl + rule__XConstructorCall__Group_4__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__1__Impl +rule__XConstructorCall__Group_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } - 'data' - { after(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); } + (rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0) + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__2 +rule__XConstructorCall__Group_4__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__2__Impl - rule__GlobalScopeExpression__Group_4__3 + rule__XConstructorCall__Group_4__1__Impl + rule__XConstructorCall__Group_4__2 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__2__Impl +rule__XConstructorCall__Group_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } - '=' - { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } + { before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); } + (rule__XConstructorCall__Alternatives_4_1)? + { after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__3 +rule__XConstructorCall__Group_4__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__3__Impl - rule__GlobalScopeExpression__Group_4__4 + rule__XConstructorCall__Group_4__2__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__3__Impl +rule__XConstructorCall__Group_4__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); } - '(' - { after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); } + { before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); } + ')' + { after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__4 + +rule__XConstructorCall__Group_4_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__4__Impl - rule__GlobalScopeExpression__Group_4__5 + rule__XConstructorCall__Group_4_1_1__0__Impl + rule__XConstructorCall__Group_4_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__4__Impl +rule__XConstructorCall__Group_4_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); } - (rule__GlobalScopeExpression__DataAssignment_4_4) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_1_0) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__5 +rule__XConstructorCall__Group_4_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__5__Impl - rule__GlobalScopeExpression__Group_4__6 + rule__XConstructorCall__Group_4_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__5__Impl +rule__XConstructorCall__Group_4_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); } - (rule__GlobalScopeExpression__Group_4_5__0)* - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); } + { before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); } + (rule__XConstructorCall__Group_4_1_1_1__0)* + { after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__6 + +rule__XConstructorCall__Group_4_1_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4__6__Impl + rule__XConstructorCall__Group_4_1_1_1__0__Impl + rule__XConstructorCall__Group_4_1_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4__6__Impl +rule__XConstructorCall__Group_4_1_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); } - ')' - { after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); } + { before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); } + ',' + { after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group_4_5__0 +rule__XConstructorCall__Group_4_1_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4_5__0__Impl - rule__GlobalScopeExpression__Group_4_5__1 + rule__XConstructorCall__Group_4_1_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4_5__0__Impl +rule__XConstructorCall__Group_4_1_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); } - ',' - { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); } + (rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1) + { after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4_5__1 + +rule__XBooleanLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_4_5__1__Impl + rule__XBooleanLiteral__Group__0__Impl + rule__XBooleanLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_4_5__1__Impl +rule__XBooleanLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); } - (rule__GlobalScopeExpression__DataAssignment_4_5_1) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); } + { before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); } + () + { after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group_5__0 +rule__XBooleanLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5__0__Impl - rule__GlobalScopeExpression__Group_5__1 + rule__XBooleanLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__0__Impl +rule__XBooleanLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } - ',' - { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } + { before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); } + (rule__XBooleanLiteral__Alternatives_1) + { after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__1 + +rule__XNullLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5__1__Impl - rule__GlobalScopeExpression__Group_5__2 + rule__XNullLiteral__Group__0__Impl + rule__XNullLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__1__Impl +rule__XNullLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } - 'domains' - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } + { before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); } + () + { after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__2 +rule__XNullLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5__2__Impl - rule__GlobalScopeExpression__Group_5__3 + rule__XNullLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__2__Impl +rule__XNullLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); } - '=' - { after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); } + { before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); } + 'null' + { after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__3 + +rule__XNumberLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5__3__Impl + rule__XNumberLiteral__Group__0__Impl + rule__XNumberLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5__3__Impl +rule__XNumberLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); } - (rule__GlobalScopeExpression__Alternatives_5_3) - { after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); } + { before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); } + () + { after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group_5_3_2__0 +rule__XNumberLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5_3_2__0__Impl - rule__GlobalScopeExpression__Group_5_3_2__1 + rule__XNumberLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__0__Impl +rule__XNumberLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); } - '(' - { after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); } + { before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); } + (rule__XNumberLiteral__ValueAssignment_1) + { after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__1 + +rule__XStringLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5_3_2__1__Impl - rule__GlobalScopeExpression__Group_5_3_2__2 + rule__XStringLiteral__Group__0__Impl + rule__XStringLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__1__Impl +rule__XStringLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); } - (rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); } + { before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); } + () + { after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__2 +rule__XStringLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5_3_2__2__Impl - rule__GlobalScopeExpression__Group_5_3_2__3 + rule__XStringLiteral__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__2__Impl +rule__XStringLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); } - (rule__GlobalScopeExpression__Group_5_3_2_2__0)* - { after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); } + { before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); } + (rule__XStringLiteral__ValueAssignment_1) + { after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__3 + +rule__XTypeLiteral__Group__0 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5_3_2__3__Impl + rule__XTypeLiteral__Group__0__Impl + rule__XTypeLiteral__Group__1 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2__3__Impl +rule__XTypeLiteral__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); } - ')' - { after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); } + { before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); } + () + { after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalScopeExpression__Group_5_3_2_2__0 +rule__XTypeLiteral__Group__1 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl - rule__GlobalScopeExpression__Group_5_3_2_2__1 + rule__XTypeLiteral__Group__1__Impl + rule__XTypeLiteral__Group__2 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl +rule__XTypeLiteral__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); } - ',' - { after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); } + 'typeof' + { after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2_2__1 +rule__XTypeLiteral__Group__2 @init { int stackSize = keepStackSize(); } : - rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl + rule__XTypeLiteral__Group__2__Impl + rule__XTypeLiteral__Group__3 ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl +rule__XTypeLiteral__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); } - (rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); } + { before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); } + '(' + { after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MatchDataExpression__Group__0 +rule__XTypeLiteral__Group__3 @init { int stackSize = keepStackSize(); } : - rule__MatchDataExpression__Group__0__Impl - rule__MatchDataExpression__Group__1 + rule__XTypeLiteral__Group__3__Impl + rule__XTypeLiteral__Group__4 ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__Group__0__Impl +rule__XTypeLiteral__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); } - (rule__MatchDataExpression__KeyAssignment_0) - { after(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); } + (rule__XTypeLiteral__TypeAssignment_3) + { after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__Group__1 +rule__XTypeLiteral__Group__4 @init { int stackSize = keepStackSize(); } : - rule__MatchDataExpression__Group__1__Impl - rule__MatchDataExpression__Group__2 + rule__XTypeLiteral__Group__4__Impl + rule__XTypeLiteral__Group__5 ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__Group__1__Impl +rule__XTypeLiteral__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); } - '=' - { after(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); } + { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); } + (rule__XTypeLiteral__ArrayDimensionsAssignment_4)* + { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__Group__2 +rule__XTypeLiteral__Group__5 @init { int stackSize = keepStackSize(); } : - rule__MatchDataExpression__Group__2__Impl + rule__XTypeLiteral__Group__5__Impl ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__Group__2__Impl +rule__XTypeLiteral__Group__5__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); } - (rule__MatchDataExpression__ValueAssignment_2) - { after(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); } + { before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); } + ')' + { after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); } ) ; finally { @@ -5331,161 +21798,161 @@ finally { } -rule__LambdaDataExpression__Group__0 +rule__XThrowExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LambdaDataExpression__Group__0__Impl - rule__LambdaDataExpression__Group__1 + rule__XThrowExpression__Group__0__Impl + rule__XThrowExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__0__Impl +rule__XThrowExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); } - '[' - { after(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); } + { before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); } + () + { after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__1 +rule__XThrowExpression__Group__1 @init { int stackSize = keepStackSize(); } -: - rule__LambdaDataExpression__Group__1__Impl - rule__LambdaDataExpression__Group__2 +: + rule__XThrowExpression__Group__1__Impl + rule__XThrowExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__1__Impl +rule__XThrowExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); } - (rule__LambdaDataExpression__DescAssignment_1) - { after(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); } + { before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); } + 'throw' + { after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__2 +rule__XThrowExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__LambdaDataExpression__Group__2__Impl - rule__LambdaDataExpression__Group__3 + rule__XThrowExpression__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__2__Impl +rule__XThrowExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); } - '|' - { after(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); } + { before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); } + (rule__XThrowExpression__ExpressionAssignment_2) + { after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__3 + +rule__XReturnExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LambdaDataExpression__Group__3__Impl - rule__LambdaDataExpression__Group__4 + rule__XReturnExpression__Group__0__Impl + rule__XReturnExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__3__Impl +rule__XReturnExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); } - (rule__LambdaDataExpression__ValueAssignment_3) - { after(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); } + { before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); } + () + { after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__4 +rule__XReturnExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LambdaDataExpression__Group__4__Impl + rule__XReturnExpression__Group__1__Impl + rule__XReturnExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__Group__4__Impl +rule__XReturnExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); } - ']' - { after(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); } + { before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); } + 'return' + { after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__Naming__Group_0__0 +rule__XReturnExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0__0__Impl + rule__XReturnExpression__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0__0__Impl +rule__XReturnExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getGroup_0_0()); } - (rule__Naming__Group_0_0__0) - { after(grammarAccess.getNamingAccess().getGroup_0_0()); } + { before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); } + (rule__XReturnExpression__ExpressionAssignment_2)? + { after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); } ) ; finally { @@ -5493,107 +21960,107 @@ finally { } -rule__Naming__Group_0_0__0 +rule__XTryCatchFinallyExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0_0__0__Impl - rule__Naming__Group_0_0__1 + rule__XTryCatchFinallyExpression__Group__0__Impl + rule__XTryCatchFinallyExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__0__Impl +rule__XTryCatchFinallyExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); } - '(' - { after(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); } + () + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__1 +rule__XTryCatchFinallyExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0_0__1__Impl - rule__Naming__Group_0_0__2 + rule__XTryCatchFinallyExpression__Group__1__Impl + rule__XTryCatchFinallyExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__1__Impl +rule__XTryCatchFinallyExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); } - (rule__Naming__NamesAssignment_0_0_1) - { after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); } + 'try' + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__2 +rule__XTryCatchFinallyExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0_0__2__Impl - rule__Naming__Group_0_0__3 + rule__XTryCatchFinallyExpression__Group__2__Impl + rule__XTryCatchFinallyExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__2__Impl +rule__XTryCatchFinallyExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getGroup_0_0_2()); } - (rule__Naming__Group_0_0_2__0)* - { after(grammarAccess.getNamingAccess().getGroup_0_0_2()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); } + (rule__XTryCatchFinallyExpression__ExpressionAssignment_2) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__3 +rule__XTryCatchFinallyExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0_0__3__Impl + rule__XTryCatchFinallyExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0__3__Impl +rule__XTryCatchFinallyExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); } - ')' - { after(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); } + (rule__XTryCatchFinallyExpression__Alternatives_3) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); } ) ; finally { @@ -5601,53 +22068,60 @@ finally { } -rule__Naming__Group_0_0_2__0 +rule__XTryCatchFinallyExpression__Group_3_0__0 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0_0_2__0__Impl - rule__Naming__Group_0_0_2__1 + rule__XTryCatchFinallyExpression__Group_3_0__0__Impl + rule__XTryCatchFinallyExpression__Group_3_0__1 ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0_2__0__Impl +rule__XTryCatchFinallyExpression__Group_3_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); } - ',' - { after(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); } + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + ) + ( + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + (rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)* + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); } + ) ) ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0_2__1 +rule__XTryCatchFinallyExpression__Group_3_0__1 @init { int stackSize = keepStackSize(); } : - rule__Naming__Group_0_0_2__1__Impl + rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__Naming__Group_0_0_2__1__Impl +rule__XTryCatchFinallyExpression__Group_3_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); } - (rule__Naming__NamesAssignment_0_0_2_1) - { after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); } + (rule__XTryCatchFinallyExpression__Group_3_0_1__0)? + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); } ) ; finally { @@ -5655,53 +22129,53 @@ finally { } -rule__NamingExpression__Group_1__0 +rule__XTryCatchFinallyExpression__Group_3_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__NamingExpression__Group_1__0__Impl - rule__NamingExpression__Group_1__1 + rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl + rule__XTryCatchFinallyExpression__Group_3_0_1__1 ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__Group_1__0__Impl +rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); } - (rule__NamingExpression__FactoryAssignment_1_0)? - { after(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); } + ('finally') + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__Group_1__1 +rule__XTryCatchFinallyExpression__Group_3_0_1__1 @init { int stackSize = keepStackSize(); } : - rule__NamingExpression__Group_1__1__Impl + rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__Group_1__1__Impl +rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); } - (rule__NamingExpression__ExpressionAssignment_1_1) - { after(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); } + (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); } ) ; finally { @@ -5709,53 +22183,53 @@ finally { } -rule__QualifiedID__Group__0 +rule__XTryCatchFinallyExpression__Group_3_1__0 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group__0__Impl - rule__QualifiedID__Group__1 + rule__XTryCatchFinallyExpression__Group_3_1__0__Impl + rule__XTryCatchFinallyExpression__Group_3_1__1 ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group__0__Impl +rule__XTryCatchFinallyExpression__Group_3_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); } - ruleIdentifier - { after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); } + 'finally' + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group__1 +rule__XTryCatchFinallyExpression__Group_3_1__1 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group__1__Impl + rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group__1__Impl +rule__XTryCatchFinallyExpression__Group_3_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getGroup_1()); } - (rule__QualifiedID__Group_1__0)* - { after(grammarAccess.getQualifiedIDAccess().getGroup_1()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); } + (rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1) + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); } ) ; finally { @@ -5763,107 +22237,107 @@ finally { } -rule__QualifiedID__Group_1__0 +rule__XSynchronizedExpression__Group__0 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group_1__0__Impl - rule__QualifiedID__Group_1__1 + rule__XSynchronizedExpression__Group__0__Impl + rule__XSynchronizedExpression__Group__1 ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group_1__0__Impl +rule__XSynchronizedExpression__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } - '::' - { after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); } + (rule__XSynchronizedExpression__Group_0__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group_1__1 +rule__XSynchronizedExpression__Group__1 @init { int stackSize = keepStackSize(); } : - rule__QualifiedID__Group_1__1__Impl + rule__XSynchronizedExpression__Group__1__Impl + rule__XSynchronizedExpression__Group__2 ; finally { restoreStackSize(stackSize); } -rule__QualifiedID__Group_1__1__Impl +rule__XSynchronizedExpression__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); } - ruleIdentifier - { after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); } + (rule__XSynchronizedExpression__ParamAssignment_1) + { after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__DottedID__Group__0 +rule__XSynchronizedExpression__Group__2 @init { int stackSize = keepStackSize(); } : - rule__DottedID__Group__0__Impl - rule__DottedID__Group__1 + rule__XSynchronizedExpression__Group__2__Impl + rule__XSynchronizedExpression__Group__3 ; finally { restoreStackSize(stackSize); } -rule__DottedID__Group__0__Impl +rule__XSynchronizedExpression__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); } - ruleIdentifier - { after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); } + ')' + { after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__DottedID__Group__1 +rule__XSynchronizedExpression__Group__3 @init { int stackSize = keepStackSize(); } : - rule__DottedID__Group__1__Impl + rule__XSynchronizedExpression__Group__3__Impl ; finally { restoreStackSize(stackSize); } -rule__DottedID__Group__1__Impl +rule__XSynchronizedExpression__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getDottedIDAccess().getGroup_1()); } - (rule__DottedID__Group_1__0)* - { after(grammarAccess.getDottedIDAccess().getGroup_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); } + (rule__XSynchronizedExpression__ExpressionAssignment_3) + { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); } ) ; finally { @@ -5871,458 +22345,458 @@ finally { } -rule__DottedID__Group_1__0 +rule__XSynchronizedExpression__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__DottedID__Group_1__0__Impl - rule__DottedID__Group_1__1 + rule__XSynchronizedExpression__Group_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__DottedID__Group_1__0__Impl +rule__XSynchronizedExpression__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); } - '.' - { after(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); } + (rule__XSynchronizedExpression__Group_0_0__0) + { after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__DottedID__Group_1__1 + +rule__XSynchronizedExpression__Group_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__DottedID__Group_1__1__Impl + rule__XSynchronizedExpression__Group_0_0__0__Impl + rule__XSynchronizedExpression__Group_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__DottedID__Group_1__1__Impl +rule__XSynchronizedExpression__Group_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); } - ruleIdentifier - { after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); } + () + { after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__LetExpression__Group__0 +rule__XSynchronizedExpression__Group_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__0__Impl - rule__LetExpression__Group__1 + rule__XSynchronizedExpression__Group_0_0__1__Impl + rule__XSynchronizedExpression__Group_0_0__2 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__0__Impl +rule__XSynchronizedExpression__Group_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } - 'let' - { after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); } + 'synchronized' + { after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__1 +rule__XSynchronizedExpression__Group_0_0__2 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__1__Impl - rule__LetExpression__Group__2 + rule__XSynchronizedExpression__Group_0_0__2__Impl ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__1__Impl +rule__XSynchronizedExpression__Group_0_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } - (rule__LetExpression__IdentifierAssignment_1) - { after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } + '(' + { after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__2 + +rule__XCatchClause__Group__0 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__2__Impl - rule__LetExpression__Group__3 + rule__XCatchClause__Group__0__Impl + rule__XCatchClause__Group__1 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__2__Impl +rule__XCatchClause__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } - '=' - { after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } + { before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); } + ('catch') + { after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__3 +rule__XCatchClause__Group__1 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__3__Impl - rule__LetExpression__Group__4 + rule__XCatchClause__Group__1__Impl + rule__XCatchClause__Group__2 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__3__Impl +rule__XCatchClause__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } - (rule__LetExpression__VarExprAssignment_3) - { after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } + { before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); } + '(' + { after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__4 +rule__XCatchClause__Group__2 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__4__Impl - rule__LetExpression__Group__5 + rule__XCatchClause__Group__2__Impl + rule__XCatchClause__Group__3 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__4__Impl +rule__XCatchClause__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } - ':' - { after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } + { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); } + (rule__XCatchClause__DeclaredParamAssignment_2) + { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__5 +rule__XCatchClause__Group__3 @init { int stackSize = keepStackSize(); } : - rule__LetExpression__Group__5__Impl + rule__XCatchClause__Group__3__Impl + rule__XCatchClause__Group__4 ; finally { restoreStackSize(stackSize); } -rule__LetExpression__Group__5__Impl +rule__XCatchClause__Group__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } - (rule__LetExpression__TargetAssignment_5) - { after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } + { before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); } + ')' + { after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__CastedExpression__Group__0 +rule__XCatchClause__Group__4 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__0__Impl - rule__CastedExpression__Group__1 + rule__XCatchClause__Group__4__Impl ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__0__Impl +rule__XCatchClause__Group__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } - '(' - { after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } + { before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); } + (rule__XCatchClause__ExpressionAssignment_4) + { after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__1 + +rule__QualifiedName__Group__0 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__1__Impl - rule__CastedExpression__Group__2 + rule__QualifiedName__Group__0__Impl + rule__QualifiedName__Group__1 ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__1__Impl +rule__QualifiedName__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } - (rule__CastedExpression__TypeAssignment_1) - { after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } + { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__2 +rule__QualifiedName__Group__1 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__2__Impl - rule__CastedExpression__Group__3 + rule__QualifiedName__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__2__Impl +rule__QualifiedName__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } - ')' - { after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } + { before(grammarAccess.getQualifiedNameAccess().getGroup_1()); } + (rule__QualifiedName__Group_1__0)* + { after(grammarAccess.getQualifiedNameAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__3 + +rule__QualifiedName__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__CastedExpression__Group__3__Impl + rule__QualifiedName__Group_1__0__Impl + rule__QualifiedName__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__Group__3__Impl +rule__QualifiedName__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } - (rule__CastedExpression__TargetAssignment_3) - { after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } + { before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } + ('.') + { after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ChainExpression__Group__0 +rule__QualifiedName__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group__0__Impl - rule__ChainExpression__Group__1 + rule__QualifiedName__Group_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__0__Impl +rule__QualifiedName__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } - ruleChainedExpression - { after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } + { before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); } + ruleValidID + { after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__1 + +rule__Number__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group__1__Impl + rule__Number__Group_1__0__Impl + rule__Number__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group__1__Impl +rule__Number__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getGroup_1()); } - (rule__ChainExpression__Group_1__0)* - { after(grammarAccess.getChainExpressionAccess().getGroup_1()); } + { before(grammarAccess.getNumberAccess().getAlternatives_1_0()); } + (rule__Number__Alternatives_1_0) + { after(grammarAccess.getNumberAccess().getAlternatives_1_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ChainExpression__Group_1__0 +rule__Number__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__0__Impl - rule__ChainExpression__Group_1__1 + rule__Number__Group_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__0__Impl +rule__Number__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } - () - { after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } + { before(grammarAccess.getNumberAccess().getGroup_1_1()); } + (rule__Number__Group_1_1__0)? + { after(grammarAccess.getNumberAccess().getGroup_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__1 + +rule__Number__Group_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__1__Impl - rule__ChainExpression__Group_1__2 + rule__Number__Group_1_1__0__Impl + rule__Number__Group_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__1__Impl +rule__Number__Group_1_1__0__Impl @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } - '->' - { after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } +( + { before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); } + '.' + { after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__2 +rule__Number__Group_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__ChainExpression__Group_1__2__Impl + rule__Number__Group_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__Group_1__2__Impl +rule__Number__Group_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } - (rule__ChainExpression__NextAssignment_1_2) - { after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } + { before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); } + (rule__Number__Alternatives_1_1_1) + { after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); } ) ; finally { @@ -6330,53 +22804,53 @@ finally { } -rule__IfExpressionTri__Group__0 +rule__JvmTypeReference__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group__0__Impl - rule__IfExpressionTri__Group__1 + rule__JvmTypeReference__Group_0__0__Impl + rule__JvmTypeReference__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__0__Impl +rule__JvmTypeReference__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } - ruleOrExpression - { after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); } + ruleJvmParameterizedTypeReference + { after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__1 +rule__JvmTypeReference__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group__1__Impl + rule__JvmTypeReference__Group_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group__1__Impl +rule__JvmTypeReference__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } - (rule__IfExpressionTri__Group_1__0)? - { after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); } + (rule__JvmTypeReference__Group_0_1__0)* + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); } ) ; finally { @@ -6384,134 +22858,134 @@ finally { } -rule__IfExpressionTri__Group_1__0 +rule__JvmTypeReference__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__0__Impl - rule__IfExpressionTri__Group_1__1 + rule__JvmTypeReference__Group_0_1__0__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__0__Impl +rule__JvmTypeReference__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } - () - { after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); } + (rule__JvmTypeReference__Group_0_1_0__0) + { after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__1 + +rule__JvmTypeReference__Group_0_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__1__Impl - rule__IfExpressionTri__Group_1__2 + rule__JvmTypeReference__Group_0_1_0__0__Impl + rule__JvmTypeReference__Group_0_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__1__Impl +rule__JvmTypeReference__Group_0_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } - '?' - { after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); } + () + { after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__2 +rule__JvmTypeReference__Group_0_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__2__Impl - rule__IfExpressionTri__Group_1__3 + rule__JvmTypeReference__Group_0_1_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__2__Impl +rule__JvmTypeReference__Group_0_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } - (rule__IfExpressionTri__ThenPartAssignment_1_2) - { after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } + { before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); } + ruleArrayBrackets + { after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__3 + +rule__ArrayBrackets__Group__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__3__Impl - rule__IfExpressionTri__Group_1__4 + rule__ArrayBrackets__Group__0__Impl + rule__ArrayBrackets__Group__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__3__Impl +rule__ArrayBrackets__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } - ':' - { after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } + { before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); } + '[' + { after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__4 +rule__ArrayBrackets__Group__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionTri__Group_1__4__Impl + rule__ArrayBrackets__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__Group_1__4__Impl +rule__ArrayBrackets__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } - (rule__IfExpressionTri__ElsePartAssignment_1_4) - { after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } + { before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); } + ']' + { after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); } ) ; finally { @@ -6519,161 +22993,161 @@ finally { } -rule__IfExpressionKw__Group__0 +rule__XFunctionTypeRef__Group__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__0__Impl - rule__IfExpressionKw__Group__1 + rule__XFunctionTypeRef__Group__0__Impl + rule__XFunctionTypeRef__Group__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__0__Impl +rule__XFunctionTypeRef__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } - 'if' - { after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); } + (rule__XFunctionTypeRef__Group_0__0)? + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__1 +rule__XFunctionTypeRef__Group__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__1__Impl - rule__IfExpressionKw__Group__2 + rule__XFunctionTypeRef__Group__1__Impl + rule__XFunctionTypeRef__Group__2 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__1__Impl +rule__XFunctionTypeRef__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } - (rule__IfExpressionKw__ConditionAssignment_1) - { after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); } + '=>' + { after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__2 +rule__XFunctionTypeRef__Group__2 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__2__Impl - rule__IfExpressionKw__Group__3 + rule__XFunctionTypeRef__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__2__Impl +rule__XFunctionTypeRef__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } - 'then' - { after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); } + (rule__XFunctionTypeRef__ReturnTypeAssignment_2) + { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__3 + +rule__XFunctionTypeRef__Group_0__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__3__Impl - rule__IfExpressionKw__Group__4 + rule__XFunctionTypeRef__Group_0__0__Impl + rule__XFunctionTypeRef__Group_0__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__3__Impl +rule__XFunctionTypeRef__Group_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } - (rule__IfExpressionKw__ThenPartAssignment_3) - { after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); } + '(' + { after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__4 +rule__XFunctionTypeRef__Group_0__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group__4__Impl + rule__XFunctionTypeRef__Group_0__1__Impl + rule__XFunctionTypeRef__Group_0__2 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group__4__Impl +rule__XFunctionTypeRef__Group_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } - (rule__IfExpressionKw__Group_4__0)? - { after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); } + (rule__XFunctionTypeRef__Group_0_1__0)? + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__IfExpressionKw__Group_4__0 +rule__XFunctionTypeRef__Group_0__2 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4__0__Impl + rule__XFunctionTypeRef__Group_0__2__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4__0__Impl +rule__XFunctionTypeRef__Group_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } - (rule__IfExpressionKw__Group_4_0__0) - { after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); } + ')' + { after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); } ) ; finally { @@ -6681,53 +23155,53 @@ finally { } -rule__IfExpressionKw__Group_4_0__0 +rule__XFunctionTypeRef__Group_0_1__0 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4_0__0__Impl - rule__IfExpressionKw__Group_4_0__1 + rule__XFunctionTypeRef__Group_0_1__0__Impl + rule__XFunctionTypeRef__Group_0_1__1 ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__0__Impl +rule__XFunctionTypeRef__Group_0_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } - 'else' - { after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); } + (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0) + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__1 +rule__XFunctionTypeRef__Group_0_1__1 @init { int stackSize = keepStackSize(); } : - rule__IfExpressionKw__Group_4_0__1__Impl + rule__XFunctionTypeRef__Group_0_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__Group_4_0__1__Impl +rule__XFunctionTypeRef__Group_0_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } - (rule__IfExpressionKw__ElsePartAssignment_4_0_1) - { after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); } + (rule__XFunctionTypeRef__Group_0_1_1__0)* + { after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); } ) ; finally { @@ -6735,296 +23209,296 @@ finally { } -rule__SwitchExpression__Group__0 +rule__XFunctionTypeRef__Group_0_1_1__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__0__Impl - rule__SwitchExpression__Group__1 + rule__XFunctionTypeRef__Group_0_1_1__0__Impl + rule__XFunctionTypeRef__Group_0_1_1__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__0__Impl +rule__XFunctionTypeRef__Group_0_1_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } - 'switch' - { after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); } + ',' + { after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__1 +rule__XFunctionTypeRef__Group_0_1_1__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__1__Impl - rule__SwitchExpression__Group__2 + rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__1__Impl +rule__XFunctionTypeRef__Group_0_1_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } - (rule__SwitchExpression__Group_1__0)? - { after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); } + (rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1) + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__2 + +rule__JvmParameterizedTypeReference__Group__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__2__Impl - rule__SwitchExpression__Group__3 + rule__JvmParameterizedTypeReference__Group__0__Impl + rule__JvmParameterizedTypeReference__Group__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__2__Impl +rule__JvmParameterizedTypeReference__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } - '{' - { after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); } + (rule__JvmParameterizedTypeReference__TypeAssignment_0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__3 +rule__JvmParameterizedTypeReference__Group__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__3__Impl - rule__SwitchExpression__Group__4 + rule__JvmParameterizedTypeReference__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__3__Impl +rule__JvmParameterizedTypeReference__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } - (rule__SwitchExpression__CaseAssignment_3)* - { after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); } + (rule__JvmParameterizedTypeReference__Group_1__0)? + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__4 + +rule__JvmParameterizedTypeReference__Group_1__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__4__Impl - rule__SwitchExpression__Group__5 + rule__JvmParameterizedTypeReference__Group_1__0__Impl + rule__JvmParameterizedTypeReference__Group_1__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__4__Impl +rule__JvmParameterizedTypeReference__Group_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - 'default' - { after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); } + ('<') + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__5 +rule__JvmParameterizedTypeReference__Group_1__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__5__Impl - rule__SwitchExpression__Group__6 + rule__JvmParameterizedTypeReference__Group_1__1__Impl + rule__JvmParameterizedTypeReference__Group_1__2 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__5__Impl +rule__JvmParameterizedTypeReference__Group_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } - ':' - { after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__6 +rule__JvmParameterizedTypeReference__Group_1__2 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__6__Impl - rule__SwitchExpression__Group__7 + rule__JvmParameterizedTypeReference__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1__3 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__6__Impl +rule__JvmParameterizedTypeReference__Group_1__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } - (rule__SwitchExpression__DefaultExprAssignment_6) - { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); } + (rule__JvmParameterizedTypeReference__Group_1_2__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__7 +rule__JvmParameterizedTypeReference__Group_1__3 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group__7__Impl + rule__JvmParameterizedTypeReference__Group_1__3__Impl + rule__JvmParameterizedTypeReference__Group_1__4 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group__7__Impl +rule__JvmParameterizedTypeReference__Group_1__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } - '}' - { after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); } + '>' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); } ) ; finally { restoreStackSize(stackSize); } - -rule__SwitchExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1__4 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__0__Impl - rule__SwitchExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1__4__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1__4__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } - '(' - { after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); } + (rule__JvmParameterizedTypeReference__Group_1_4__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__1 + +rule__JvmParameterizedTypeReference__Group_1_2__0 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__1__Impl - rule__SwitchExpression__Group_1__2 + rule__JvmParameterizedTypeReference__Group_1_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_2__1 ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__1__Impl +rule__JvmParameterizedTypeReference__Group_1_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } - (rule__SwitchExpression__SwitchExprAssignment_1_1) - { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); } + ',' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__2 +rule__JvmParameterizedTypeReference__Group_1_2__1 @init { int stackSize = keepStackSize(); } : - rule__SwitchExpression__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__Group_1__2__Impl +rule__JvmParameterizedTypeReference__Group_1_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } - ')' - { after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); } ) ; finally { @@ -7032,107 +23506,107 @@ finally { } -rule__Case__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4__0 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__0__Impl - rule__Case__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4__1 ; finally { restoreStackSize(stackSize); } -rule__Case__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } - 'case' - { after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); } + (rule__JvmParameterizedTypeReference__Group_1_4_0__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__1 +rule__JvmParameterizedTypeReference__Group_1_4__1 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__1__Impl - rule__Case__Group__2 + rule__JvmParameterizedTypeReference__Group_1_4__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4__2 ; finally { restoreStackSize(stackSize); } -rule__Case__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getConditionAssignment_1()); } - (rule__Case__ConditionAssignment_1) - { after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); } + (rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__2 +rule__JvmParameterizedTypeReference__Group_1_4__2 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__2__Impl - rule__Case__Group__3 + rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; finally { restoreStackSize(stackSize); } -rule__Case__Group__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getColonKeyword_2()); } - ':' - { after(grammarAccess.getCaseAccess().getColonKeyword_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); } + (rule__JvmParameterizedTypeReference__Group_1_4_2__0)? + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__Group__3 + +rule__JvmParameterizedTypeReference__Group_1_4_0__0 @init { int stackSize = keepStackSize(); } : - rule__Case__Group__3__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; finally { restoreStackSize(stackSize); } -rule__Case__Group__3__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } - (rule__Case__ThenParAssignment_3) - { after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); } + (rule__JvmParameterizedTypeReference__Group_1_4_0_0__0) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); } ) ; finally { @@ -7140,53 +23614,53 @@ finally { } -rule__OrExpression__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group__0__Impl - rule__OrExpression__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } - ruleAndExpression - { after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); } + () + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__1 +rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getGroup_1()); } - (rule__OrExpression__Group_1__0)* - { after(grammarAccess.getOrExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); } + '.' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); } ) ; finally { @@ -7194,350 +23668,350 @@ finally { } -rule__OrExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1_4_2__0 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__0__Impl - rule__OrExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); } + ('<') + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__1 +rule__JvmParameterizedTypeReference__Group_1_4_2__1 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__1__Impl - rule__OrExpression__Group_1__2 + rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } - (rule__OrExpression__OperatorAssignment_1_1) - { after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__2 +rule__JvmParameterizedTypeReference__Group_1_4_2__2 @init { int stackSize = keepStackSize(); } : - rule__OrExpression__Group_1__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; finally { restoreStackSize(stackSize); } -rule__OrExpression__Group_1__2__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } - (rule__OrExpression__RightAssignment_1_2) - { after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); } + (rule__JvmParameterizedTypeReference__Group_1_4_2_2__0)* + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AndExpression__Group__0 +rule__JvmParameterizedTypeReference__Group_1_4_2__3 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group__0__Impl - rule__AndExpression__Group__1 + rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } - ruleImpliesExpression - { after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); } + '>' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__1 + +rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group__1__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group__1__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getGroup_1()); } - (rule__AndExpression__Group_1__0)* - { after(grammarAccess.getAndExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); } + ',' + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AndExpression__Group_1__0 +rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__0__Impl - rule__AndExpression__Group_1__1 + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__0__Impl +rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); } + (rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__1 + +rule__JvmWildcardTypeReference__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__1__Impl - rule__AndExpression__Group_1__2 + rule__JvmWildcardTypeReference__Group__0__Impl + rule__JvmWildcardTypeReference__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__1__Impl +rule__JvmWildcardTypeReference__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } - (rule__AndExpression__OperatorAssignment_1_1) - { after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); } + () + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__2 +rule__JvmWildcardTypeReference__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AndExpression__Group_1__2__Impl + rule__JvmWildcardTypeReference__Group__1__Impl + rule__JvmWildcardTypeReference__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AndExpression__Group_1__2__Impl +rule__JvmWildcardTypeReference__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } - (rule__AndExpression__RightAssignment_1_2) - { after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); } + '?' + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ImpliesExpression__Group__0 +rule__JvmWildcardTypeReference__Group__2 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group__0__Impl - rule__ImpliesExpression__Group__1 + rule__JvmWildcardTypeReference__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__0__Impl +rule__JvmWildcardTypeReference__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } - ruleRelationalExpression - { after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); } + (rule__JvmWildcardTypeReference__Alternatives_2)? + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__1 + +rule__JvmWildcardTypeReference__Group_2_0__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group__1__Impl + rule__JvmWildcardTypeReference__Group_2_0__0__Impl + rule__JvmWildcardTypeReference__Group_2_0__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group__1__Impl +rule__JvmWildcardTypeReference__Group_2_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } - (rule__ImpliesExpression__Group_1__0)* - { after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__ImpliesExpression__Group_1__0 +rule__JvmWildcardTypeReference__Group_2_0__1 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__0__Impl - rule__ImpliesExpression__Group_1__1 + rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__0__Impl +rule__JvmWildcardTypeReference__Group_2_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1)* + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__1 + +rule__JvmWildcardTypeReference__Group_2_1__0 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__1__Impl - rule__ImpliesExpression__Group_1__2 + rule__JvmWildcardTypeReference__Group_2_1__0__Impl + rule__JvmWildcardTypeReference__Group_2_1__1 ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__1__Impl +rule__JvmWildcardTypeReference__Group_2_1__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } - (rule__ImpliesExpression__OperatorAssignment_1_1) - { after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0) + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__2 +rule__JvmWildcardTypeReference__Group_2_1__1 @init { int stackSize = keepStackSize(); } : - rule__ImpliesExpression__Group_1__2__Impl + rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__Group_1__2__Impl +rule__JvmWildcardTypeReference__Group_2_1__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } - (rule__ImpliesExpression__RightAssignment_1_2) - { after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); } + (rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1)* + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); } ) ; finally { @@ -7545,53 +24019,53 @@ finally { } -rule__RelationalExpression__Group__0 +rule__JvmUpperBound__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__0__Impl - rule__RelationalExpression__Group__1 + rule__JvmUpperBound__Group__0__Impl + rule__JvmUpperBound__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__0__Impl +rule__JvmUpperBound__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); } + 'extends' + { after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1 +rule__JvmUpperBound__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group__1__Impl + rule__JvmUpperBound__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group__1__Impl +rule__JvmUpperBound__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } - (rule__RelationalExpression__Group_1__0)* - { after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); } + (rule__JvmUpperBound__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); } ) ; finally { @@ -7599,4173 +24073,4546 @@ finally { } -rule__RelationalExpression__Group_1__0 +rule__JvmUpperBoundAnded__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__0__Impl - rule__RelationalExpression__Group_1__1 + rule__JvmUpperBoundAnded__Group__0__Impl + rule__JvmUpperBoundAnded__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__0__Impl +rule__JvmUpperBoundAnded__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } - () - { after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); } + '&' + { after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1 +rule__JvmUpperBoundAnded__Group__1 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__1__Impl - rule__RelationalExpression__Group_1__2 + rule__JvmUpperBoundAnded__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__1__Impl +rule__JvmUpperBoundAnded__Group__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.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); } + (rule__JvmUpperBoundAnded__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2 + +rule__JvmLowerBound__Group__0 @init { int stackSize = keepStackSize(); } : - rule__RelationalExpression__Group_1__2__Impl + rule__JvmLowerBound__Group__0__Impl + rule__JvmLowerBound__Group__1 ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__Group_1__2__Impl +rule__JvmLowerBound__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - (rule__RelationalExpression__RightAssignment_1_2) - { after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } + { before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); } + 'super' + { after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AdditiveExpression__Group__0 +rule__JvmLowerBound__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__0__Impl - rule__AdditiveExpression__Group__1 + rule__JvmLowerBound__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__0__Impl +rule__JvmLowerBound__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } + { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); } + (rule__JvmLowerBound__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1 + +rule__JvmLowerBoundAnded__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group__1__Impl + rule__JvmLowerBoundAnded__Group__0__Impl + rule__JvmLowerBoundAnded__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group__1__Impl +rule__JvmLowerBoundAnded__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - (rule__AdditiveExpression__Group_1__0)* - { after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); } + '&' + { after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__AdditiveExpression__Group_1__0 +rule__JvmLowerBoundAnded__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__0__Impl - rule__AdditiveExpression__Group_1__1 + rule__JvmLowerBoundAnded__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__0__Impl +rule__JvmLowerBoundAnded__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } - () - { after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); } + (rule__JvmLowerBoundAnded__TypeReferenceAssignment_1) + { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1 + +rule__QualifiedNameWithWildcard__Group__0 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__1__Impl - rule__AdditiveExpression__Group_1__2 + rule__QualifiedNameWithWildcard__Group__0__Impl + rule__QualifiedNameWithWildcard__Group__1 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__1__Impl +rule__QualifiedNameWithWildcard__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } - (rule__AdditiveExpression__NameAssignment_1_1) - { after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); } + ruleQualifiedName + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2 +rule__QualifiedNameWithWildcard__Group__1 @init { int stackSize = keepStackSize(); } : - rule__AdditiveExpression__Group_1__2__Impl + rule__QualifiedNameWithWildcard__Group__1__Impl + rule__QualifiedNameWithWildcard__Group__2 ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__Group_1__2__Impl +rule__QualifiedNameWithWildcard__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } - (rule__AdditiveExpression__ParamsAssignment_1_2) - { after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MultiplicativeExpression__Group__0 +rule__QualifiedNameWithWildcard__Group__2 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__0__Impl - rule__MultiplicativeExpression__Group__1 + rule__QualifiedNameWithWildcard__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__0__Impl +rule__QualifiedNameWithWildcard__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } - ruleUnaryOrInfixExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } + { before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); } + '*' + { after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1 + +rule__XImportDeclaration__Group__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group__1__Impl + rule__XImportDeclaration__Group__0__Impl + rule__XImportDeclaration__Group__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group__1__Impl +rule__XImportDeclaration__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - (rule__MultiplicativeExpression__Group_1__0)* - { after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); } + 'import' + { after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__MultiplicativeExpression__Group_1__0 +rule__XImportDeclaration__Group__1 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__0__Impl - rule__MultiplicativeExpression__Group_1__1 + rule__XImportDeclaration__Group__1__Impl + rule__XImportDeclaration__Group__2 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__0__Impl +rule__XImportDeclaration__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } - () - { after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); } + (rule__XImportDeclaration__Alternatives_1) + { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1 +rule__XImportDeclaration__Group__2 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__1__Impl - rule__MultiplicativeExpression__Group_1__2 + rule__XImportDeclaration__Group__2__Impl ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__1__Impl +rule__XImportDeclaration__Group__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } - (rule__MultiplicativeExpression__NameAssignment_1_1) - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); } + (';')? + { after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2 + +rule__XImportDeclaration__Group_1_0__0 @init { int stackSize = keepStackSize(); } : - rule__MultiplicativeExpression__Group_1__2__Impl + rule__XImportDeclaration__Group_1_0__0__Impl + rule__XImportDeclaration__Group_1_0__1 ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__Group_1__2__Impl +rule__XImportDeclaration__Group_1_0__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } - (rule__MultiplicativeExpression__ParamsAssignment_1_2) - { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + { before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); } + (rule__XImportDeclaration__StaticAssignment_1_0_0) + { after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__UnaryExpression__Group__0 +rule__XImportDeclaration__Group_1_0__1 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group__0__Impl - rule__UnaryExpression__Group__1 + rule__XImportDeclaration__Group_1_0__1__Impl + rule__XImportDeclaration__Group_1_0__2 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__0__Impl +rule__XImportDeclaration__Group_1_0__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } - (rule__UnaryExpression__NameAssignment_0) - { after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); } + (rule__XImportDeclaration__ExtensionAssignment_1_0_1)? + { after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__1 +rule__XImportDeclaration__Group_1_0__2 @init { int stackSize = keepStackSize(); } : - rule__UnaryExpression__Group__1__Impl + rule__XImportDeclaration__Group_1_0__2__Impl + rule__XImportDeclaration__Group_1_0__3 ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__Group__1__Impl +rule__XImportDeclaration__Group_1_0__2__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } - (rule__UnaryExpression__ParamsAssignment_1) - { after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); } + (rule__XImportDeclaration__ImportedTypeAssignment_1_0_2) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); } ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group__0 +rule__XImportDeclaration__Group_1_0__3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group__0__Impl - rule__InfixExpression__Group__1 + rule__XImportDeclaration__Group_1_0__3__Impl ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__0__Impl +rule__XImportDeclaration__Group_1_0__3__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } - rulePrimaryExpression - { after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); } + (rule__XImportDeclaration__Alternatives_1_0_3) + { after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__1 + +rule__QualifiedNameInStaticImport__Group__0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group__1__Impl + rule__QualifiedNameInStaticImport__Group__0__Impl + rule__QualifiedNameInStaticImport__Group__1 ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group__1__Impl +rule__QualifiedNameInStaticImport__Group__0__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } - (rule__InfixExpression__Alternatives_1)* - { after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); } + ruleValidID + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); } ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0__0 +rule__QualifiedNameInStaticImport__Group__1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__0__Impl - rule__InfixExpression__Group_1_0__1 + rule__QualifiedNameInStaticImport__Group__1__Impl ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__0__Impl +rule__QualifiedNameInStaticImport__Group__1__Impl @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } + { before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); } + '.' + { after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__1 + +rule__ScopeModel__NameAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__1__Impl - rule__InfixExpression__Group_1_0__2 + ( + { before(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); } + ruleDottedID + { after(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__1__Impl +rule__ScopeModel__IncludedScopesAssignment_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } -) + ( + { before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); } + ( + { before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); } + ruleDottedID + { after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); } + ) + { after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__2 +rule__ScopeModel__ImportsAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__2__Impl - rule__InfixExpression__Group_1_0__3 + ( + { before(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); } + ruleImport + { after(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__2__Impl +rule__ScopeModel__ExtensionsAssignment_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } - (rule__InfixExpression__NameAssignment_1_0_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } -) + ( + { before(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); } + ruleExtension + { after(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__3 +rule__ScopeModel__InjectionsAssignment_5 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__3__Impl - rule__InfixExpression__Group_1_0__4 + ( + { before(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); } + ruleInjection + { after(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__3__Impl +rule__ScopeModel__NamingAssignment_6 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } -) + ( + { before(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); } + ruleNamingSection + { after(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__4 +rule__ScopeModel__ScopesAssignment_7 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__4__Impl - rule__InfixExpression__Group_1_0__5 + ( + { before(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); } + ruleScopeDefinition + { after(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__4__Impl +rule__Import__PackageAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } - (rule__InfixExpression__Group_1_0_4__0)? - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } -) + ( + { before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + ( + { before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } + RULE_STRING + { after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } + ) + { after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__5 +rule__Import__NameAssignment_2_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0__5__Impl + ( + { before(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); } + ruleIdentifier + { after(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0__5__Impl +rule__Extension__ExtensionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } -) + ( + { before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } + ruleQualifiedID + { after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0_4__0 +rule__Injection__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4__0__Impl - rule__InfixExpression__Group_1_0_4__1 + ( + { before(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); } + ruleDottedID + { after(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__0__Impl +rule__Injection__NameAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } - (rule__InfixExpression__ParamsAssignment_1_0_4_0) - { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } -) + ( + { before(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); } + ruleIdentifier + { after(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__1 +rule__NamingSection__CasingAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4__1__Impl + ( + { before(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); } + ruleCasing + { after(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4__1__Impl +rule__NamingSection__NamingsAssignment_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } - (rule__InfixExpression__Group_1_0_4_1__0)* - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } -) + ( + { before(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); } + ruleNamingDefinition + { after(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_0_4_1__0 +rule__NamingDefinition__TypeAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4_1__0__Impl - rule__InfixExpression__Group_1_0_4_1__1 + ( + { before(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); } + ( + { before(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } + ruleQualifiedID + { after(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__0__Impl +rule__NamingDefinition__NamingAssignment_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } - ',' - { after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } -) + ( + { before(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); } + ruleNaming + { after(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__1 +rule__ScopeDefinition__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_0_4_1__1__Impl + ( + { before(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); } + ruleIdentifier + { after(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_0_4_1__1__Impl +rule__ScopeDefinition__TargetTypeAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } - (rule__InfixExpression__ParamsAssignment_1_0_4_1_1) - { after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } -) + ( + { before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); } + ( + { before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); } + ruleQualifiedID + { after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); } + ) + { after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_1__0 +rule__ScopeDefinition__ContextTypeAssignment_2_1_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__0__Impl - rule__InfixExpression__Group_1_1__1 + ( + { before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); } + ( + { before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); } + ruleQualifiedID + { after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); } + ) + { after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__0__Impl +rule__ScopeDefinition__ReferenceAssignment_2_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } -) + ( + { before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); } + ( + { before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); } + ruleIdentifier + { after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); } + ) + { after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__1 +rule__ScopeDefinition__RulesAssignment_4 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__1__Impl - rule__InfixExpression__Group_1_1__2 + ( + { before(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); } + ruleScopeRule + { after(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__1__Impl +rule__ScopeRule__ContextAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } -) + ( + { before(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); } + ruleScopeContext + { after(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__2 +rule__ScopeRule__ExprsAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_1__2__Impl + ( + { before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); } + ruleScopeExpression + { after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_1__2__Impl +rule__ScopeRule__ExprsAssignment_4_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } - (rule__InfixExpression__TypeAssignment_1_1_2) - { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } -) + ( + { before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); } + ruleScopeExpression + { after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_2__0 +rule__ScopeContext__GlobalAssignment_0_0 @init { int stackSize = keepStackSize(); } -: - rule__InfixExpression__Group_1_2__0__Impl - rule__InfixExpression__Group_1_2__1 +: + ( + { before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } + ( + { before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } + '*' + { after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } + ) + { after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__0__Impl +rule__ScopeContext__ContextTypeAssignment_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } -) + ( + { before(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); } + ( + { before(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); } + ruleQualifiedID + { after(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__1 +rule__ScopeContext__GuardAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__1__Impl - rule__InfixExpression__Group_1_2__2 + ( + { before(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); } + ruleExpression + { after(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__1__Impl +rule__FactoryExpression__ExprAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } -) + ( + { before(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); } + ruleExpression + { after(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__2 +rule__ScopeDelegation__DelegateAssignment_2_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__2__Impl - rule__InfixExpression__Group_1_2__3 + ( + { before(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__2__Impl +rule__ScopeDelegation__ExternalAssignment_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } - (rule__InfixExpression__NameAssignment_1_2_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } -) + ( + { before(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); } + ruleGlobalScopeExpression + { after(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__3 +rule__ScopeDelegation__ScopeAssignment_3_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__3__Impl - rule__InfixExpression__Group_1_2__4 + ( + { before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); } + ( + { before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); } + ruleIdentifier + { after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); } + ) + { after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__3__Impl +rule__NamedScopeExpression__CaseDefAssignment_1_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } -) + ( + { before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } + ( + { before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } + 'case' + { after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } + ) + { after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__4 +rule__NamedScopeExpression__CasingAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__4__Impl - rule__InfixExpression__Group_1_2__5 + ( + { before(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); } + ruleCasing + { after(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__4__Impl +rule__NamedScopeExpression__NamingAssignment_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } - (rule__InfixExpression__TypeAssignment_1_2_4) - { after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } -) + ( + { before(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); } + ruleNaming + { after(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__5 +rule__GlobalScopeExpression__TypeAssignment_2 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_2__5__Impl + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); } + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } + ruleQualifiedID + { after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_2__5__Impl +rule__GlobalScopeExpression__NameAssignment_3_0_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } -) + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); } + ruleExpression + { after(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_3__0 +rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__0__Impl - rule__InfixExpression__Group_1_3__1 + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } + 'recursive' + { after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } + ) + { after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__0__Impl +rule__GlobalScopeExpression__PrefixAssignment_3_1_4 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } - () - { after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } -) + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); } + ruleExpression + { after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__1 +rule__GlobalScopeExpression__DataAssignment_4_4 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__1__Impl - rule__InfixExpression__Group_1_3__2 + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); } + ruleDataExpression + { after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__1__Impl +rule__GlobalScopeExpression__DataAssignment_4_5_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } - '.' - { after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } -) + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); } + ruleDataExpression + { after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__2 +rule__GlobalScopeExpression__DomainsAssignment_5_3_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__2__Impl - rule__InfixExpression__Group_1_3__3 + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } + '*' + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } + ) + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__2__Impl +rule__GlobalScopeExpression__DomainsAssignment_5_3_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } - (rule__InfixExpression__NameAssignment_1_3_2) - { after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } -) + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); } + ruleIdentifier + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__3 +rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__3__Impl - rule__InfixExpression__Group_1_3__4 + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); } + ruleIdentifier + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__3__Impl +rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } - '(' - { after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); } -) + ( + { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); } + ruleIdentifier + { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__4 +rule__MatchDataExpression__KeyAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__4__Impl - rule__InfixExpression__Group_1_3__5 + ( + { before(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__4__Impl +rule__MatchDataExpression__ValueAssignment_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } - (rule__InfixExpression__Group_1_3_4__0)? - { after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } -) + ( + { before(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); } + ruleExpression + { after(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__5 +rule__LambdaDataExpression__DescAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__5__Impl - rule__InfixExpression__Group_1_3__6 + ( + { before(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__5__Impl +rule__LambdaDataExpression__ValueAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } - (rule__InfixExpression__ExpAssignment_1_3_5) - { after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } -) + ( + { before(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__6 +rule__SimpleScopeExpression__ExprAssignment @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3__6__Impl + ( + { before(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); } + ruleExpression + { after(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3__6__Impl +rule__Naming__NamesAssignment_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } - ')' - { after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); } -) + ( + { before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); } + ruleNamingExpression + { after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__InfixExpression__Group_1_3_4__0 +rule__Naming__NamesAssignment_0_0_2_1 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3_4__0__Impl - rule__InfixExpression__Group_1_3_4__1 + ( + { before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); } + ruleNamingExpression + { after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__0__Impl +rule__Naming__NamesAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } - (rule__InfixExpression__VarAssignment_1_3_4_0) - { after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); } -) + ( + { before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); } + ruleNamingExpression + { after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__1 +rule__NamingExpression__ExportAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__InfixExpression__Group_1_3_4__1__Impl + ( + { before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + ( + { before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + 'export' + { after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + ) + { after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__Group_1_3_4__1__Impl +rule__NamingExpression__FactoryAssignment_1_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } - '|' - { after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); } -) + ( + { before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } + ( + { before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } + 'factory' + { after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } + ) + { after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ParanthesizedExpression__Group__0 +rule__NamingExpression__ExpressionAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__0__Impl - rule__ParanthesizedExpression__Group__1 + ( + { before(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); } + ruleExpression + { after(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__0__Impl +rule__LetExpression__IdentifierAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } - '(' - { after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } -) + ( + { before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__1 +rule__LetExpression__VarExprAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__1__Impl - rule__ParanthesizedExpression__Group__2 + ( + { before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__1__Impl +rule__LetExpression__TargetAssignment_5 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } - ruleExpression - { after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } -) + ( + { before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + ruleExpression + { after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__2 +rule__CastedExpression__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__ParanthesizedExpression__Group__2__Impl + ( + { before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + ruleType + { after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ParanthesizedExpression__Group__2__Impl +rule__CastedExpression__TargetAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } - ')' - { after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); } -) + ( + { before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__GlobalVarExpression__Group__0 +rule__ChainExpression__NextAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__GlobalVarExpression__Group__0__Impl - rule__GlobalVarExpression__Group__1 + ( + { before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + ruleChainedExpression + { after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__0__Impl +rule__IfExpressionTri__ThenPartAssignment_1_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } - 'GLOBALVAR' - { after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); } -) + ( + { before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__1 +rule__IfExpressionTri__ElsePartAssignment_1_4 @init { int stackSize = keepStackSize(); } : - rule__GlobalVarExpression__Group__1__Impl + ( + { before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__Group__1__Impl +rule__IfExpressionKw__ConditionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } - (rule__GlobalVarExpression__NameAssignment_1) - { after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); } -) + ( + { before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group__0 +rule__IfExpressionKw__ThenPartAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__0__Impl - rule__OperationCall__Group__1 + ( + { before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__0__Impl +rule__IfExpressionKw__ElsePartAssignment_4_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } - (rule__OperationCall__NameAssignment_0) - { after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + ruleChainedExpression + { after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__1 +rule__SwitchExpression__SwitchExprAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__1__Impl - rule__OperationCall__Group__2 + ( + { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + ruleOrExpression + { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__1__Impl +rule__SwitchExpression__CaseAssignment_3 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + ruleCase + { after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__2 +rule__SwitchExpression__DefaultExprAssignment_6 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__2__Impl - rule__OperationCall__Group__3 + ( + { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + ruleOrExpression + { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__2__Impl +rule__Case__ConditionAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getGroup_2()); } - (rule__OperationCall__Group_2__0)? - { after(grammarAccess.getOperationCallAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + ruleOrExpression + { after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__3 +rule__Case__ThenParAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group__3__Impl + ( + { before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + ruleOrExpression + { after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group__3__Impl +rule__OrExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } - ')' - { after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); } -) + ( + { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ( + { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + '||' + { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ) + { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group_2__0 +rule__OrExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2__0__Impl - rule__OperationCall__Group_2__1 + ( + { before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + ruleAndExpression + { after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__0__Impl +rule__AndExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } - (rule__OperationCall__ParamsAssignment_2_0) - { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); } -) + ( + { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ( + { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + '&&' + { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ) + { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__1 +rule__AndExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2__1__Impl + ( + { before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + ruleImpliesExpression + { after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2__1__Impl +rule__ImpliesExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getGroup_2_1()); } - (rule__OperationCall__Group_2_1__0)* - { after(grammarAccess.getOperationCallAccess().getGroup_2_1()); } -) + ( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ( + { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + 'implies' + { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ) + { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__OperationCall__Group_2_1__0 +rule__ImpliesExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2_1__0__Impl - rule__OperationCall__Group_2_1__1 + ( + { before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + ruleRelationalExpression + { after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__0__Impl +rule__RelationalExpression__OperatorAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } - ',' - { after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); } -) + ( + { before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + (rule__RelationalExpression__OperatorAlternatives_1_1_0) + { after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__1 +rule__RelationalExpression__RightAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__OperationCall__Group_2_1__1__Impl + ( + { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + ruleAdditiveExpression + { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__Group_2_1__1__Impl +rule__AdditiveExpression__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } - (rule__OperationCall__ParamsAssignment_2_1_1) - { after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); } -) + ( + { before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + (rule__AdditiveExpression__NameAlternatives_1_1_0) + { after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group__0 +rule__AdditiveExpression__ParamsAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__0__Impl - rule__ListLiteral__Group__1 + ( + { before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + ruleMultiplicativeExpression + { after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__0__Impl +rule__MultiplicativeExpression__NameAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } - () - { after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); } -) + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + (rule__MultiplicativeExpression__NameAlternatives_1_1_0) + { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__1 +rule__MultiplicativeExpression__ParamsAssignment_1_2 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__1__Impl - rule__ListLiteral__Group__2 + ( + { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + ruleUnaryOrInfixExpression + { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__1__Impl +rule__UnaryExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } - '{' - { after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); } -) + ( + { before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + (rule__UnaryExpression__NameAlternatives_0_0) + { after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__2 +rule__UnaryExpression__ParamsAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__2__Impl - rule__ListLiteral__Group__3 + ( + { before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + ruleInfixExpression + { after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__2__Impl +rule__InfixExpression__NameAssignment_1_0_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getGroup_2()); } - (rule__ListLiteral__Group_2__0)? - { after(grammarAccess.getListLiteralAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + ruleIdentifier + { after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__3 +rule__InfixExpression__ParamsAssignment_1_0_4_0 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group__3__Impl + ( + { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group__3__Impl +rule__InfixExpression__ParamsAssignment_1_0_4_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } - '}' - { after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group_2__0 +rule__InfixExpression__TypeAssignment_1_1_2 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2__0__Impl - rule__ListLiteral__Group_2__1 + ( + { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + ruleType + { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__0__Impl +rule__InfixExpression__NameAssignment_1_2_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } - (rule__ListLiteral__ElementsAssignment_2_0) - { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ( + { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + 'typeSelect' + { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ) + { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__1 +rule__InfixExpression__TypeAssignment_1_2_4 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2__1__Impl + ( + { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + ruleType + { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2__1__Impl +rule__InfixExpression__NameAssignment_1_3_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getGroup_2_1()); } - (rule__ListLiteral__Group_2_1__0)* - { after(grammarAccess.getListLiteralAccess().getGroup_2_1()); } -) + ( + { before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + (rule__InfixExpression__NameAlternatives_1_3_2_0) + { after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__InfixExpression__VarAssignment_1_3_4_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + ruleIdentifier + { after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ListLiteral__Group_2_1__0 +rule__InfixExpression__ExpAssignment_1_3_5 @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2_1__0__Impl - rule__ListLiteral__Group_2_1__1 + ( + { before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + ruleExpression + { after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__0__Impl +rule__BooleanLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } - ',' - { after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); } -) + ( + { before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + (rule__BooleanLiteral__ValAlternatives_0) + { after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__1 +rule__IntegerLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__ListLiteral__Group_2_1__1__Impl + ( + { before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + RULE_INT + { after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__Group_2_1__1__Impl +rule__NullLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } - (rule__ListLiteral__ElementsAssignment_2_1_1) - { after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); } -) + ( + { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ( + { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + 'null' + { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ) + { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ConstructorCallExpression__Group__0 +rule__RealLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : - rule__ConstructorCallExpression__Group__0__Impl - rule__ConstructorCallExpression__Group__1 + ( + { before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + RULE_REAL + { after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__0__Impl +rule__StringLiteral__ValAssignment @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } - 'new' - { after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); } -) + ( + { before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + RULE_STRING + { after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__1 +rule__GlobalVarExpression__NameAssignment_1 @init { int stackSize = keepStackSize(); } : - rule__ConstructorCallExpression__Group__1__Impl + ( + { before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + ruleIdentifier + { after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__Group__1__Impl +rule__FeatureCall__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } - (rule__ConstructorCallExpression__TypeAssignment_1) - { after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); } -) + ( + { before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + ruleType + { after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__TypeSelectExpression__Group__0 +rule__OperationCall__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__0__Impl - rule__TypeSelectExpression__Group__1 + ( + { before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__0__Impl +rule__OperationCall__ParamsAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } - (rule__TypeSelectExpression__NameAssignment_0) - { after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__1 +rule__OperationCall__ParamsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__1__Impl - rule__TypeSelectExpression__Group__2 + ( + { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + ruleExpression + { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__1__Impl +rule__ListLiteral__ElementsAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + ruleExpression + { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__2 +rule__ListLiteral__ElementsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__2__Impl - rule__TypeSelectExpression__Group__3 + ( + { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + ruleExpression + { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__2__Impl +rule__ConstructorCallExpression__TypeAssignment_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } - (rule__TypeSelectExpression__TypeAssignment_2) - { after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); } -) + ( + { before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + ruleSimpleType + { after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__3 +rule__TypeSelectExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__TypeSelectExpression__Group__3__Impl + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + 'typeSelect' + { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ) + { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__Group__3__Impl +rule__TypeSelectExpression__TypeAssignment_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } - ')' - { after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); } -) + ( + { before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + ruleType + { after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionExpression__Group__0 +rule__CollectionExpression__NameAssignment_0 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__0__Impl - rule__CollectionExpression__Group__1 + ( + { before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + (rule__CollectionExpression__NameAlternatives_0_0) + { after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__0__Impl +rule__CollectionExpression__VarAssignment_2_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } - (rule__CollectionExpression__NameAssignment_0) - { after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); } -) + ( + { before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + ruleIdentifier + { after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__1 +rule__CollectionExpression__ExpAssignment_3 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__1__Impl - rule__CollectionExpression__Group__2 + ( + { before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + ruleExpression + { after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__1__Impl +rule__CollectionType__ClAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } - '(' - { after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); } -) + ( + { before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + (rule__CollectionType__ClAlternatives_0_0) + { after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__2 +rule__CollectionType__Id1Assignment_2 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__2__Impl - rule__CollectionExpression__Group__3 + ( + { before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + ruleSimpleType + { after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__2__Impl +rule__SimpleType__IdAssignment_0 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } - (rule__CollectionExpression__Group_2__0)? - { after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); } -) + ( + { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + ruleIdentifier + { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__3 +rule__SimpleType__IdAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__3__Impl - rule__CollectionExpression__Group__4 + ( + { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + ruleIdentifier + { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__3__Impl +rule__XAssignment__FeatureAssignment_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } - (rule__CollectionExpression__ExpAssignment_3) - { after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); } -) + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); } + ruleFeatureCallID + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__4 +rule__XAssignment__ValueAssignment_0_3 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group__4__Impl + ( + { before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); } + ruleXAssignment + { after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group__4__Impl +rule__XAssignment__FeatureAssignment_1_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } - ')' - { after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); } -) + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); } + ruleOpMultiAssign + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionExpression__Group_2__0 +rule__XAssignment__RightOperandAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group_2__0__Impl - rule__CollectionExpression__Group_2__1 + ( + { before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); } + ruleXAssignment + { after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__0__Impl +rule__XOrExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } - (rule__CollectionExpression__VarAssignment_2_0) - { after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); } -) + ( + { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); } + ruleOpOr + { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__1 +rule__XOrExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionExpression__Group_2__1__Impl + ( + { before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); } + ruleXAndExpression + { after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__Group_2__1__Impl +rule__XAndExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } - '|' - { after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); } -) + ( + { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); } + ruleOpAnd + { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__CollectionType__Group__0 +rule__XAndExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__0__Impl - rule__CollectionType__Group__1 + ( + { before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); } + ruleXEqualityExpression + { after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__0__Impl +rule__XEqualityExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } - (rule__CollectionType__ClAssignment_0) - { after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); } -) + ( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); } + ruleOpEquality + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__1 +rule__XEqualityExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__1__Impl - rule__CollectionType__Group__2 + ( + { before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); } + ruleXRelationalExpression + { after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__1__Impl +rule__XRelationalExpression__TypeAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } - '[' - { after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); } -) + ( + { before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__2 +rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__2__Impl - rule__CollectionType__Group__3 + ( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ( + { before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); } + ruleOpCompare + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__2__Impl +rule__XRelationalExpression__RightOperandAssignment_1_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } - (rule__CollectionType__Id1Assignment_2) - { after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); } -) + ( + { before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); } + ruleXOtherOperatorExpression + { after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__3 +rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__CollectionType__Group__3__Impl + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); } + ruleOpOther + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Group__3__Impl +rule__XOtherOperatorExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } - ']' - { after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); } -) + ( + { before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); } + ruleXAdditiveExpression + { after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__SimpleType__Group__0 +rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group__0__Impl - rule__SimpleType__Group__1 + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); } + ruleOpAdd + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__0__Impl +rule__XAdditiveExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } - (rule__SimpleType__IdAssignment_0) - { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); } -) + ( + { before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); } + ruleXMultiplicativeExpression + { after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__1 +rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group__1__Impl + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); } + ruleOpMulti + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); } + ) + { after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group__1__Impl +rule__XMultiplicativeExpression__RightOperandAssignment_1_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getGroup_1()); } - (rule__SimpleType__Group_1__0)* - { after(grammarAccess.getSimpleTypeAccess().getGroup_1()); } -) + ( + { before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__SimpleType__Group_1__0 +rule__XUnaryOperation__FeatureAssignment_0_1 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group_1__0__Impl - rule__SimpleType__Group_1__1 + ( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ( + { before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); } + ruleOpUnary + { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); } + ) + { after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__0__Impl +rule__XUnaryOperation__OperandAssignment_0_2 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } - '::' - { after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); } -) + ( + { before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); } + ruleXUnaryOperation + { after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__1 +rule__XCastedExpression__TypeAssignment_1_1 @init { int stackSize = keepStackSize(); } : - rule__SimpleType__Group_1__1__Impl + ( + { before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); } + ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__Group_1__1__Impl +rule__XPostfixOperation__FeatureAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : -( - { before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } - (rule__SimpleType__IdAssignment_1_1) - { after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); } -) + ( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); } + ( + { before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); } + ruleOpPostfix + { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); } + ) + { after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); } + ) ; finally { restoreStackSize(stackSize); } - -rule__ScopeModel__NameAssignment_1 +rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); } - ruleDottedID - { after(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + '::' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__IncludedScopesAssignment_2_1 +rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); } ( - { before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); } - ruleDottedID - { after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); } + ruleFeatureCallID + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); } ) - { after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); } + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__ImportsAssignment_3 +rule__XMemberFeatureCall__ValueAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); } - ruleImport - { after(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); } + ruleXAssignment + { after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__ExtensionsAssignment_4 +rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); } - ruleExtension - { after(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + '?.' + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__InjectionsAssignment_5 +rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); } - ruleInjection - { after(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + '::' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__NamingAssignment_6 +rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); } - ruleNamingSection - { after(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeModel__ScopesAssignment_7 +rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); } - ruleScopeDefinition - { after(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__PackageAssignment_1 +rule__XMemberFeatureCall__FeatureAssignment_1_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); } ( - { before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } - RULE_STRING - { after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); } + ruleIdOrSuper + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); } ) - { after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); } + { after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Import__NameAssignment_2_1 +rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); } - ruleIdentifier - { after(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ( + { before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + '(' + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } + ) + { after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Extension__ExtensionAssignment_1 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } - ruleQualifiedID - { after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Injection__TypeAssignment_1 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); } - ruleDottedID - { after(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Injection__NameAssignment_3 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); } - ruleIdentifier - { after(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__CasingAssignment_1_1 +rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); } - ruleCasing - { after(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); } + { before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); } + ruleXClosure + { after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingSection__NamingsAssignment_4 +rule__XSetLiteral__ElementsAssignment_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); } - ruleNamingDefinition - { after(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); } + { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ruleXExpression + { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__TypeAssignment_0 +rule__XSetLiteral__ElementsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); } - ( - { before(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } - ruleQualifiedID - { after(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); } - ) - { after(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); } + { before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ) +; +finally { + restoreStackSize(stackSize); +} + +rule__XListLiteral__ElementsAssignment_3_0 + @init { + int stackSize = keepStackSize(); + } +: + ( + { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } + ruleXExpression + { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingDefinition__NamingAssignment_2 +rule__XListLiteral__ElementsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); } - ruleNaming - { after(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); } + { before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__NameAssignment_1_1 +rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); } - ruleIdentifier - { after(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); } + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__TargetTypeAssignment_2_0 +rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); } - ( - { before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); } - ruleQualifiedID - { after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); } - ) - { after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); } + { before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__ContextTypeAssignment_2_1_0 +rule__XClosure__ExplicitSyntaxAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); } + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } ( - { before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); } - ruleQualifiedID - { after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); } + { before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } + '|' + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } ) - { after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); } + { after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__ReferenceAssignment_2_1_2 +rule__XClosure__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); } - ( - { before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); } - ruleIdentifier - { after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); } - ) - { after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); } + { before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); } + ruleXExpressionInClosure + { after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDefinition__RulesAssignment_4 +rule__XExpressionInClosure__ExpressionsAssignment_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); } - ruleScopeRule - { after(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); } + { before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__ContextAssignment_1 +rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); } - ruleScopeContext - { after(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); } + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__ExprsAssignment_3 +rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); } - ruleScopeExpression - { after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeRule__ExprsAssignment_4_1 +rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); } - ruleScopeExpression - { after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); } + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + ( + { before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + '|' + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } + ) + { after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__GlobalAssignment_0_0 +rule__XShortClosure__ExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } - ( - { before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } - '*' - { after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } - ) - { after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); } + { before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__ContextTypeAssignment_0_1 +rule__XIfExpression__IfAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); } - ( - { before(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); } - ruleQualifiedID - { after(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); } - ) - { after(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); } + { before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeContext__GuardAssignment_1_1 +rule__XIfExpression__ThenAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); } - ruleExpression - { after(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); } + { before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__FactoryExpression__ExprAssignment_1 +rule__XIfExpression__ElseAssignment_6_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); } - ruleExpression - { after(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); } + ruleXExpression + { after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__DelegateAssignment_2_0 +rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__ExternalAssignment_2_1 +rule__XSwitchExpression__SwitchAssignment_2_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); } - ruleGlobalScopeExpression - { after(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ScopeDelegation__ScopeAssignment_3_1 +rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); } - ( - { before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); } - ruleIdentifier - { after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); } - ) - { after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__CaseDefAssignment_1_0 +rule__XSwitchExpression__SwitchAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } - ( - { before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } - 'case' - { after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } - ) - { after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__CasingAssignment_1_1 +rule__XSwitchExpression__CasesAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); } - ruleCasing - { after(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); } + ruleXCasePart + { after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamedScopeExpression__NamingAssignment_2_1 +rule__XSwitchExpression__DefaultAssignment_5_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); } - ruleNaming - { after(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); } + { before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); } + ruleXExpression + { after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__TypeAssignment_2 +rule__XCasePart__TypeGuardAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); } - ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } - ruleQualifiedID - { after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); } - ) - { after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); } + { before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__NameAssignment_3_0_3 +rule__XCasePart__CaseAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); } - ruleExpression - { after(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); } + { before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); } + ruleXExpression + { after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 +rule__XCasePart__ThenAssignment_3_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } - ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } - 'recursive' - { after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } - ) - { after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); } + { before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); } + ruleXExpression + { after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__PrefixAssignment_3_1_4 +rule__XCasePart__FallThroughAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); } - ruleExpression - { after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); } + { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ( + { before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ',' + { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } + ) + { after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__DataAssignment_4_4 +rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); } - ruleDataExpression - { after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); } + ruleJvmFormalParameter + { after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__DataAssignment_4_5_1 +rule__XForLoopExpression__ForExpressionAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); } - ruleDataExpression - { after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__DomainsAssignment_5_3_0 +rule__XForLoopExpression__EachExpressionAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } - ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } - '*' - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } - ) - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); } + { before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__DomainsAssignment_5_3_1 +rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); } - ruleIdentifier - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 +rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); } - ruleIdentifier - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 +rule__XBasicForLoopExpression__ExpressionAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); } - ruleIdentifier - { after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__KeyAssignment_0 +rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MatchDataExpression__ValueAssignment_2 +rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); } - ruleExpression - { after(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__DescAssignment_1 +rule__XBasicForLoopExpression__EachExpressionAssignment_9 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); } + ruleXExpression + { after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LambdaDataExpression__ValueAssignment_3 +rule__XWhileExpression__PredicateAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleScopeExpression__ExprAssignment +rule__XWhileExpression__BodyAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); } - ruleExpression - { after(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); } + { before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__NamesAssignment_0_0_1 +rule__XDoWhileExpression__BodyAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); } - ruleNamingExpression - { after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__NamesAssignment_0_0_2_1 +rule__XDoWhileExpression__PredicateAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); } - ruleNamingExpression - { after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); } + { before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); } + ruleXExpression + { after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Naming__NamesAssignment_1 +rule__XBlockExpression__ExpressionsAssignment_2_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); } - ruleNamingExpression - { after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); } + ruleXExpressionOrVarDeclaration + { after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__ExportAssignment_0 +rule__XVariableDeclaration__WriteableAssignment_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } ( - { before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } - 'export' - { after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } + 'var' + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } ) - { after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); } + { after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__FactoryAssignment_1_0 +rule__XVariableDeclaration__TypeAssignment_2_0_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } - ( - { before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } - 'factory' - { after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } - ) - { after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NamingExpression__ExpressionAssignment_1_1 +rule__XVariableDeclaration__NameAssignment_2_0_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); } - ruleExpression - { after(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); } + ruleValidID + { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__IdentifierAssignment_1 +rule__XVariableDeclaration__NameAssignment_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); } + ruleValidID + { after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__VarExprAssignment_3 +rule__XVariableDeclaration__RightAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); } + ruleXExpression + { after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__LetExpression__TargetAssignment_5 +rule__JvmFormalParameter__ParameterTypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } - ruleExpression - { after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__TypeAssignment_1 +rule__JvmFormalParameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } - ruleType - { after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } + ruleValidID + { after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CastedExpression__TargetAssignment_3 +rule__FullJvmFormalParameter__ParameterTypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ChainExpression__NextAssignment_1_2 +rule__FullJvmFormalParameter__NameAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } - ruleChainedExpression - { after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } + ruleValidID + { after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__ThenPartAssignment_1_2 +rule__XFeatureCall__TypeArgumentsAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionTri__ElsePartAssignment_1_4 +rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); } + { before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ConditionAssignment_1 +rule__XFeatureCall__FeatureAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); } + ruleIdOrSuper + { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ThenPartAssignment_3 +rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + ( + { before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + '(' + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } + ) + { after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IfExpressionKw__ElsePartAssignment_4_0_1 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } - ruleChainedExpression - { after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__SwitchExprAssignment_1_1 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } - ruleOrExpression - { after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__CaseAssignment_3 +rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } - ruleCase - { after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SwitchExpression__DefaultExprAssignment_6 +rule__XFeatureCall__FeatureCallArgumentsAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } - ruleOrExpression - { after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); } + { before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); } + ruleXClosure + { after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__ConditionAssignment_1 +rule__XConstructorCall__ConstructorAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } - ruleOrExpression - { after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); } + ( + { before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); } + ) + { after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__Case__ThenParAssignment_3 +rule__XConstructorCall__TypeArgumentsAssignment_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } - ruleOrExpression - { after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__OperatorAssignment_1_1 +rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - ( - { before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - '||' - { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } - ) - { after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OrExpression__RightAssignment_1_2 +rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } - ruleAndExpression - { after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + ( + { before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + '(' + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } + ) + { after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__OperatorAssignment_1_1 +rule__XConstructorCall__ArgumentsAssignment_4_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - ( - { before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - '&&' - { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } - ) - { after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); } + ruleXShortClosure + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AndExpression__RightAssignment_1_2 +rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } - ruleImpliesExpression - { after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); } + ruleXExpression + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__OperatorAssignment_1_1 +rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - ( - { before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - 'implies' - { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } - ) - { after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ImpliesExpression__RightAssignment_1_2 +rule__XConstructorCall__ArgumentsAssignment_5 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } - ruleRelationalExpression - { after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); } + ruleXClosure + { after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__OperatorAssignment_1_1 +rule__XBooleanLiteral__IsTrueAssignment_1_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.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + ( + { before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + 'true' + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } + ) + { after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RelationalExpression__RightAssignment_1_2 +rule__XNumberLiteral__ValueAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } - ruleAdditiveExpression - { after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); } + ruleNumber + { after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__NameAssignment_1_1 +rule__XStringLiteral__ValueAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } - (rule__AdditiveExpression__NameAlternatives_1_1_0) - { after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); } + { before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); } + RULE_STRING + { after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__AdditiveExpression__ParamsAssignment_1_2 +rule__XTypeLiteral__TypeAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } - ruleMultiplicativeExpression - { after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); } + ( + { before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); } + ) + { after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__NameAssignment_1_1 +rule__XTypeLiteral__ArrayDimensionsAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } - (rule__MultiplicativeExpression__NameAlternatives_1_1_0) - { after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); } + { before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); } + ruleArrayBrackets + { after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__MultiplicativeExpression__ParamsAssignment_1_2 +rule__XThrowExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } - ruleUnaryOrInfixExpression - { after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); } + { before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__NameAssignment_0 +rule__XReturnExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } - (rule__UnaryExpression__NameAlternatives_0_0) - { after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); } + { before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__UnaryExpression__ParamsAssignment_1 +rule__XTryCatchFinallyExpression__ExpressionAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } - ruleInfixExpression - { after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_0_2 +rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } - ruleIdentifier - { after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); } + ruleXCatchClause + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ParamsAssignment_1_0_4_0 +rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ParamsAssignment_1_0_4_1_1 +rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); } + { before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); } + ruleXExpression + { after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__TypeAssignment_1_1_2 +rule__XSynchronizedExpression__ParamAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } - ruleType - { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); } + ruleXExpression + { after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_2_2 +rule__XSynchronizedExpression__ExpressionAssignment_3 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - ( - { before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - 'typeSelect' - { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } - ) - { after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); } + { before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); } + ruleXExpression + { after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__TypeAssignment_1_2_4 +rule__XCatchClause__DeclaredParamAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } - ruleType - { after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); } + { before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); } + ruleFullJvmFormalParameter + { after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__NameAssignment_1_3_2 +rule__XCatchClause__ExpressionAssignment_4 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } - (rule__InfixExpression__NameAlternatives_1_3_2_0) - { after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); } + { before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); } + ruleXExpression + { after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__VarAssignment_1_3_4_0 +rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } - ruleIdentifier - { after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__InfixExpression__ExpAssignment_1_3_5 +rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } - ruleExpression - { after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__BooleanLiteral__ValAssignment +rule__XFunctionTypeRef__ReturnTypeAssignment_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } - (rule__BooleanLiteral__ValAlternatives_0) - { after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); } + { before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); } + ruleJvmTypeReference + { after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__IntegerLiteral__ValAssignment +rule__JvmParameterizedTypeReference__TypeAssignment_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } - RULE_INT - { after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); } + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); } + ruleQualifiedName + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); } + ) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__NullLiteral__ValAssignment +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - ( - { before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - 'null' - { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } - ) - { after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__RealLiteral__ValAssignment +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } - RULE_REAL - { after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__StringLiteral__ValAssignment +rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } - RULE_STRING - { after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); } + ( + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); } + ruleValidID + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); } + ) + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__GlobalVarExpression__NameAssignment_1 +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } - ruleIdentifier - { after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__FeatureCall__TypeAssignment_1 +rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } - ruleType - { after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); } + ruleJvmArgumentTypeReference + { after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__NameAssignment_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); } + ruleJvmUpperBound + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__ParamsAssignment_2_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); } + ruleJvmUpperBoundAnded + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__OperationCall__ParamsAssignment_2_1_1 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } - ruleExpression - { after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); } + ruleJvmLowerBound + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__ElementsAssignment_2_0 +rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } - ruleExpression - { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); } + { before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); } + ruleJvmLowerBoundAnded + { after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ListLiteral__ElementsAssignment_2_1_1 +rule__JvmUpperBound__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } - ruleExpression - { after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); } + { before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__ConstructorCallExpression__TypeAssignment_1 +rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } - ruleSimpleType - { after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); } + { before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__NameAssignment_0 +rule__JvmLowerBound__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - ( - { before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - 'typeSelect' - { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } - ) - { after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); } + { before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__TypeSelectExpression__TypeAssignment_2 +rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } - ruleType - { after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); } + { before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } + ruleJvmTypeReference + { after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__NameAssignment_0 +rule__XImportDeclaration__StaticAssignment_1_0_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } - (rule__CollectionExpression__NameAlternatives_0_0) - { after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + 'static' + { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__VarAssignment_2_0 +rule__XImportDeclaration__ExtensionAssignment_1_0_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } - ruleIdentifier - { after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + 'extension' + { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionExpression__ExpAssignment_3 +rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } - ruleExpression - { after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); } + ruleQualifiedNameInStaticImport + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__ClAssignment_0 +rule__XImportDeclaration__WildcardAssignment_1_0_3_0 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } - (rule__CollectionType__ClAlternatives_0_0) - { after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + '*' + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__CollectionType__Id1Assignment_2 +rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } - ruleSimpleType - { after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); } + ruleValidID + { after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__IdAssignment_0 +rule__XImportDeclaration__ImportedTypeAssignment_1_1 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } - ruleIdentifier - { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); } + ( + { before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); } + ruleQualifiedName + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); } + ) + { after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); } ) ; finally { restoreStackSize(stackSize); } -rule__SimpleType__IdAssignment_1_1 +rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 @init { int stackSize = keepStackSize(); } : ( - { before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } - ruleIdentifier - { after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); } + { before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); } + ruleQualifiedNameWithWildcard + { after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); } ) ; finally { @@ -11774,11 +28621,15 @@ finally { RULE_REAL : ('0'..'9')* '.' ('0'..'9')*; -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; +RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?; + +RULE_INT : '0'..'9' ('0'..'9'|'_')*; + +RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?; -RULE_INT : ('0'..'9')+; +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.tokens b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.tokens index 4a24a3f83c..3c99a99b7f 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.tokens +++ b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScope.tokens @@ -1,88 +1,145 @@ -'!'=22 -'!='=13 -'#'=53 -'&&'=83 -'('=51 -')'=52 -'*'=20 -'+'=18 -','=60 -'-'=19 -'->'=71 -'.'=68 -'/'=21 -':'=70 -'::'=67 -';'=49 -'<'=17 -'<='=15 -'='=48 -'=='=12 -'>'=16 -'>='=14 -'>>'=55 -'?'=72 -'Collection'=33 -'GLOBALVAR'=78 -'List'=34 -'Set'=35 -'['=56 -']'=57 -'as'=41 -'case'=47 -'collect'=23 -'context'=54 -'data'=64 -'default'=77 -'domains'=65 -'else'=75 -'exists'=27 -'export'=81 -'extension'=42 -'factory'=58 -'false'=32 -'find'=61 -'forAll'=30 -'if'=73 -'implies'=84 -'import'=40 -'inject'=43 -'insensitive'=37 -'key'=62 -'let'=69 -'naming'=44 -'new'=79 -'notExists'=28 -'null'=86 -'prefix'=63 -'recursive'=80 -'reject'=26 -'scope'=50 -'scopeof'=59 -'scoping'=38 -'select'=24 -'selectFirst'=25 -'sensitive'=36 -'sortBy'=29 -'switch'=76 -'then'=74 -'true'=31 -'typeSelect'=85 -'with'=39 -'{'=45 -'|'=66 -'||'=82 -'}'=46 -RULE_ANY_OTHER=11 +'!'=27 +'!='=18 +'!=='=47 +'#'=79 +'%'=55 +'%='=45 +'&&'=16 +'&'=116 +'('=77 +')'=78 +'*'=25 +'**'=54 +'*='=43 +'+'=23 +'++'=56 +'+='=41 +','=86 +'-'=24 +'--'=57 +'-='=42 +'->'=48 +'.'=58 +'..'=50 +'..<'=49 +'/'=26 +'/='=44 +':'=95 +'::'=93 +';'=75 +'<'=22 +'<='=20 +'<>'=52 +'='=14 +'=='=17 +'==='=46 +'=>'=51 +'>'=21 +'>='=19 +'>>'=81 +'?'=96 +'?.'=121 +'?:'=53 +'Collection'=38 +'GLOBALVAR'=102 +'List'=39 +'Set'=40 +'['=82 +']'=83 +'as'=69 +'case'=74 +'catch'=115 +'collect'=28 +'context'=80 +'data'=90 +'default'=101 +'do'=107 +'domains'=91 +'else'=99 +'exists'=32 +'export'=118 +'extends'=60 +'extension'=63 +'factory'=84 +'false'=37 +'finally'=113 +'find'=87 +'for'=105 +'forAll'=35 +'if'=97 +'implies'=119 +'import'=62 +'inject'=70 +'insensitive'=66 +'instanceof'=104 +'key'=88 +'let'=94 +'naming'=71 +'new'=103 +'notExists'=33 +'null'=108 +'prefix'=89 +'recursive'=117 +'reject'=31 +'return'=111 +'scope'=76 +'scopeof'=85 +'scoping'=67 +'select'=29 +'selectFirst'=30 +'sensitive'=65 +'sortBy'=34 +'static'=61 +'super'=64 +'switch'=100 +'synchronized'=114 +'then'=98 +'throw'=110 +'true'=36 +'try'=112 +'typeSelect'=120 +'typeof'=109 +'val'=59 +'var'=122 +'while'=106 +'with'=68 +'{'=72 +'|'=92 +'||'=15 +'}'=73 +RULE_ANY_OTHER=13 +RULE_DECIMAL=7 +RULE_HEX=5 RULE_ID=4 RULE_INT=6 -RULE_ML_COMMENT=8 -RULE_REAL=7 -RULE_SL_COMMENT=9 -RULE_STRING=5 -RULE_WS=10 -T__12=12 -T__13=13 +RULE_ML_COMMENT=10 +RULE_REAL=9 +RULE_SL_COMMENT=11 +RULE_STRING=8 +RULE_WS=12 +T__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 +T__105=105 +T__106=106 +T__107=107 +T__108=108 +T__109=109 +T__110=110 +T__111=111 +T__112=112 +T__113=113 +T__114=114 +T__115=115 +T__116=116 +T__117=117 +T__118=118 +T__119=119 +T__120=120 +T__121=121 +T__122=122 T__14=14 T__15=15 T__16=16 @@ -156,3 +213,16 @@ T__83=83 T__84=84 T__85=85 T__86=86 +T__87=87 +T__88=88 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeLexer.java b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeLexer.java index 0e64c818ed..0a4527d8fb 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeLexer.java +++ b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeLexer.java @@ -12,19 +12,12 @@ @SuppressWarnings("all") public class InternalScopeLexer extends Lexer { + public static final int RULE_HEX=5; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -33,56 +26,27 @@ public class InternalScopeLexer extends Lexer { public static final int T__60=60; public static final int T__61=61; public static final int RULE_ID=4; - public static final int RULE_REAL=7; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; + public static final int RULE_REAL=9; public static final int RULE_INT=6; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=5; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int T__82=82; - public static final int T__83=83; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -90,12 +54,84 @@ public class InternalScopeLexer extends Lexer { public static final int T__46=46; public static final int T__47=47; public static final int T__40=40; - public static final int T__84=84; public static final int T__41=41; - public static final int T__85=85; public static final int T__42=42; - public static final int T__86=86; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__122=122; + public static final int T__70=70; + public static final int T__121=121; + public static final int T__71=71; + public static final int T__72=72; + public static final int T__120=120; + public static final int RULE_STRING=8; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__119=119; + public static final int T__78=78; + public static final int T__118=118; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -110,58 +146,15 @@ public InternalScopeLexer(CharStream input, RecognizerSharedState state) { } public String getGrammarFileName() { return "InternalScope.g"; } - // $ANTLR start "T__12" - public final void mT__12() throws RecognitionException { - try { - int _type = T__12; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11:7: ( '==' ) - // InternalScope.g:11:9: '==' - { - match("=="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__12" - - // $ANTLR start "T__13" - public final void mT__13() throws RecognitionException { - try { - int _type = T__13; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:12:7: ( '!=' ) - // InternalScope.g:12:9: '!=' - { - match("!="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__13" - // $ANTLR start "T__14" public final void mT__14() throws RecognitionException { try { int _type = T__14; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:13:7: ( '>=' ) - // InternalScope.g:13:9: '>=' + // InternalScope.g:11:7: ( '=' ) + // InternalScope.g:11:9: '=' { - match(">="); - + match('='); } @@ -178,10 +171,10 @@ public final void mT__15() throws RecognitionException { try { int _type = T__15; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:14:7: ( '<=' ) - // InternalScope.g:14:9: '<=' + // InternalScope.g:12:7: ( '||' ) + // InternalScope.g:12:9: '||' { - match("<="); + match("||"); } @@ -199,10 +192,11 @@ public final void mT__16() throws RecognitionException { try { int _type = T__16; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:15:7: ( '>' ) - // InternalScope.g:15:9: '>' + // InternalScope.g:13:7: ( '&&' ) + // InternalScope.g:13:9: '&&' { - match('>'); + match("&&"); + } @@ -219,10 +213,11 @@ public final void mT__17() throws RecognitionException { try { int _type = T__17; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:16:7: ( '<' ) - // InternalScope.g:16:9: '<' + // InternalScope.g:14:7: ( '==' ) + // InternalScope.g:14:9: '==' { - match('<'); + match("=="); + } @@ -239,10 +234,11 @@ public final void mT__18() throws RecognitionException { try { int _type = T__18; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:17:7: ( '+' ) - // InternalScope.g:17:9: '+' + // InternalScope.g:15:7: ( '!=' ) + // InternalScope.g:15:9: '!=' { - match('+'); + match("!="); + } @@ -259,10 +255,11 @@ public final void mT__19() throws RecognitionException { try { int _type = T__19; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:18:7: ( '-' ) - // InternalScope.g:18:9: '-' + // InternalScope.g:16:7: ( '>=' ) + // InternalScope.g:16:9: '>=' { - match('-'); + match(">="); + } @@ -279,10 +276,11 @@ public final void mT__20() throws RecognitionException { try { int _type = T__20; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:19:7: ( '*' ) - // InternalScope.g:19:9: '*' + // InternalScope.g:17:7: ( '<=' ) + // InternalScope.g:17:9: '<=' { - match('*'); + match("<="); + } @@ -299,10 +297,10 @@ public final void mT__21() throws RecognitionException { try { int _type = T__21; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:20:7: ( '/' ) - // InternalScope.g:20:9: '/' + // InternalScope.g:18:7: ( '>' ) + // InternalScope.g:18:9: '>' { - match('/'); + match('>'); } @@ -319,10 +317,10 @@ public final void mT__22() throws RecognitionException { try { int _type = T__22; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:21:7: ( '!' ) - // InternalScope.g:21:9: '!' + // InternalScope.g:19:7: ( '<' ) + // InternalScope.g:19:9: '<' { - match('!'); + match('<'); } @@ -339,11 +337,10 @@ public final void mT__23() throws RecognitionException { try { int _type = T__23; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:22:7: ( 'collect' ) - // InternalScope.g:22:9: 'collect' + // InternalScope.g:20:7: ( '+' ) + // InternalScope.g:20:9: '+' { - match("collect"); - + match('+'); } @@ -360,11 +357,10 @@ public final void mT__24() throws RecognitionException { try { int _type = T__24; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:23:7: ( 'select' ) - // InternalScope.g:23:9: 'select' + // InternalScope.g:21:7: ( '-' ) + // InternalScope.g:21:9: '-' { - match("select"); - + match('-'); } @@ -381,11 +377,10 @@ public final void mT__25() throws RecognitionException { try { int _type = T__25; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:24:7: ( 'selectFirst' ) - // InternalScope.g:24:9: 'selectFirst' + // InternalScope.g:22:7: ( '*' ) + // InternalScope.g:22:9: '*' { - match("selectFirst"); - + match('*'); } @@ -402,11 +397,10 @@ public final void mT__26() throws RecognitionException { try { int _type = T__26; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:25:7: ( 'reject' ) - // InternalScope.g:25:9: 'reject' + // InternalScope.g:23:7: ( '/' ) + // InternalScope.g:23:9: '/' { - match("reject"); - + match('/'); } @@ -423,11 +417,10 @@ public final void mT__27() throws RecognitionException { try { int _type = T__27; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:26:7: ( 'exists' ) - // InternalScope.g:26:9: 'exists' + // InternalScope.g:24:7: ( '!' ) + // InternalScope.g:24:9: '!' { - match("exists"); - + match('!'); } @@ -444,10 +437,10 @@ public final void mT__28() throws RecognitionException { try { int _type = T__28; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:27:7: ( 'notExists' ) - // InternalScope.g:27:9: 'notExists' + // InternalScope.g:25:7: ( 'collect' ) + // InternalScope.g:25:9: 'collect' { - match("notExists"); + match("collect"); } @@ -465,10 +458,10 @@ public final void mT__29() throws RecognitionException { try { int _type = T__29; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:28:7: ( 'sortBy' ) - // InternalScope.g:28:9: 'sortBy' + // InternalScope.g:26:7: ( 'select' ) + // InternalScope.g:26:9: 'select' { - match("sortBy"); + match("select"); } @@ -486,10 +479,10 @@ public final void mT__30() throws RecognitionException { try { int _type = T__30; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:29:7: ( 'forAll' ) - // InternalScope.g:29:9: 'forAll' + // InternalScope.g:27:7: ( 'selectFirst' ) + // InternalScope.g:27:9: 'selectFirst' { - match("forAll"); + match("selectFirst"); } @@ -507,10 +500,10 @@ public final void mT__31() throws RecognitionException { try { int _type = T__31; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:30:7: ( 'true' ) - // InternalScope.g:30:9: 'true' + // InternalScope.g:28:7: ( 'reject' ) + // InternalScope.g:28:9: 'reject' { - match("true"); + match("reject"); } @@ -528,10 +521,10 @@ public final void mT__32() throws RecognitionException { try { int _type = T__32; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:31:7: ( 'false' ) - // InternalScope.g:31:9: 'false' + // InternalScope.g:29:7: ( 'exists' ) + // InternalScope.g:29:9: 'exists' { - match("false"); + match("exists"); } @@ -549,10 +542,10 @@ public final void mT__33() throws RecognitionException { try { int _type = T__33; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:32:7: ( 'Collection' ) - // InternalScope.g:32:9: 'Collection' + // InternalScope.g:30:7: ( 'notExists' ) + // InternalScope.g:30:9: 'notExists' { - match("Collection"); + match("notExists"); } @@ -570,10 +563,10 @@ public final void mT__34() throws RecognitionException { try { int _type = T__34; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:33:7: ( 'List' ) - // InternalScope.g:33:9: 'List' + // InternalScope.g:31:7: ( 'sortBy' ) + // InternalScope.g:31:9: 'sortBy' { - match("List"); + match("sortBy"); } @@ -591,10 +584,10 @@ public final void mT__35() throws RecognitionException { try { int _type = T__35; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:34:7: ( 'Set' ) - // InternalScope.g:34:9: 'Set' + // InternalScope.g:32:7: ( 'forAll' ) + // InternalScope.g:32:9: 'forAll' { - match("Set"); + match("forAll"); } @@ -612,10 +605,10 @@ public final void mT__36() throws RecognitionException { try { int _type = T__36; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:35:7: ( 'sensitive' ) - // InternalScope.g:35:9: 'sensitive' + // InternalScope.g:33:7: ( 'true' ) + // InternalScope.g:33:9: 'true' { - match("sensitive"); + match("true"); } @@ -633,10 +626,10 @@ public final void mT__37() throws RecognitionException { try { int _type = T__37; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:36:7: ( 'insensitive' ) - // InternalScope.g:36:9: 'insensitive' + // InternalScope.g:34:7: ( 'false' ) + // InternalScope.g:34:9: 'false' { - match("insensitive"); + match("false"); } @@ -654,10 +647,10 @@ public final void mT__38() throws RecognitionException { try { int _type = T__38; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:37:7: ( 'scoping' ) - // InternalScope.g:37:9: 'scoping' + // InternalScope.g:35:7: ( 'Collection' ) + // InternalScope.g:35:9: 'Collection' { - match("scoping"); + match("Collection"); } @@ -675,10 +668,10 @@ public final void mT__39() throws RecognitionException { try { int _type = T__39; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:38:7: ( 'with' ) - // InternalScope.g:38:9: 'with' + // InternalScope.g:36:7: ( 'List' ) + // InternalScope.g:36:9: 'List' { - match("with"); + match("List"); } @@ -696,10 +689,10 @@ public final void mT__40() throws RecognitionException { try { int _type = T__40; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:39:7: ( 'import' ) - // InternalScope.g:39:9: 'import' + // InternalScope.g:37:7: ( 'Set' ) + // InternalScope.g:37:9: 'Set' { - match("import"); + match("Set"); } @@ -717,10 +710,10 @@ public final void mT__41() throws RecognitionException { try { int _type = T__41; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:40:7: ( 'as' ) - // InternalScope.g:40:9: 'as' + // InternalScope.g:38:7: ( '+=' ) + // InternalScope.g:38:9: '+=' { - match("as"); + match("+="); } @@ -738,10 +731,10 @@ public final void mT__42() throws RecognitionException { try { int _type = T__42; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:41:7: ( 'extension' ) - // InternalScope.g:41:9: 'extension' + // InternalScope.g:39:7: ( '-=' ) + // InternalScope.g:39:9: '-=' { - match("extension"); + match("-="); } @@ -759,10 +752,10 @@ public final void mT__43() throws RecognitionException { try { int _type = T__43; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:42:7: ( 'inject' ) - // InternalScope.g:42:9: 'inject' + // InternalScope.g:40:7: ( '*=' ) + // InternalScope.g:40:9: '*=' { - match("inject"); + match("*="); } @@ -780,10 +773,10 @@ public final void mT__44() throws RecognitionException { try { int _type = T__44; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:43:7: ( 'naming' ) - // InternalScope.g:43:9: 'naming' + // InternalScope.g:41:7: ( '/=' ) + // InternalScope.g:41:9: '/=' { - match("naming"); + match("/="); } @@ -801,10 +794,11 @@ public final void mT__45() throws RecognitionException { try { int _type = T__45; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:44:7: ( '{' ) - // InternalScope.g:44:9: '{' + // InternalScope.g:42:7: ( '%=' ) + // InternalScope.g:42:9: '%=' { - match('{'); + match("%="); + } @@ -821,10 +815,11 @@ public final void mT__46() throws RecognitionException { try { int _type = T__46; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:45:7: ( '}' ) - // InternalScope.g:45:9: '}' + // InternalScope.g:43:7: ( '===' ) + // InternalScope.g:43:9: '===' { - match('}'); + match("==="); + } @@ -841,10 +836,10 @@ public final void mT__47() throws RecognitionException { try { int _type = T__47; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:46:7: ( 'case' ) - // InternalScope.g:46:9: 'case' + // InternalScope.g:44:7: ( '!==' ) + // InternalScope.g:44:9: '!==' { - match("case"); + match("!=="); } @@ -862,10 +857,11 @@ public final void mT__48() throws RecognitionException { try { int _type = T__48; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:47:7: ( '=' ) - // InternalScope.g:47:9: '=' + // InternalScope.g:45:7: ( '->' ) + // InternalScope.g:45:9: '->' { - match('='); + match("->"); + } @@ -882,10 +878,11 @@ public final void mT__49() throws RecognitionException { try { int _type = T__49; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:48:7: ( ';' ) - // InternalScope.g:48:9: ';' + // InternalScope.g:46:7: ( '..<' ) + // InternalScope.g:46:9: '..<' { - match(';'); + match("..<"); + } @@ -902,10 +899,10 @@ public final void mT__50() throws RecognitionException { try { int _type = T__50; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:49:7: ( 'scope' ) - // InternalScope.g:49:9: 'scope' + // InternalScope.g:47:7: ( '..' ) + // InternalScope.g:47:9: '..' { - match("scope"); + match(".."); } @@ -923,10 +920,11 @@ public final void mT__51() throws RecognitionException { try { int _type = T__51; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:50:7: ( '(' ) - // InternalScope.g:50:9: '(' + // InternalScope.g:48:7: ( '=>' ) + // InternalScope.g:48:9: '=>' { - match('('); + match("=>"); + } @@ -943,10 +941,11 @@ public final void mT__52() throws RecognitionException { try { int _type = T__52; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:51:7: ( ')' ) - // InternalScope.g:51:9: ')' + // InternalScope.g:49:7: ( '<>' ) + // InternalScope.g:49:9: '<>' { - match(')'); + match("<>"); + } @@ -963,10 +962,11 @@ public final void mT__53() throws RecognitionException { try { int _type = T__53; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:52:7: ( '#' ) - // InternalScope.g:52:9: '#' + // InternalScope.g:50:7: ( '?:' ) + // InternalScope.g:50:9: '?:' { - match('#'); + match("?:"); + } @@ -983,10 +983,10 @@ public final void mT__54() throws RecognitionException { try { int _type = T__54; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:53:7: ( 'context' ) - // InternalScope.g:53:9: 'context' + // InternalScope.g:51:7: ( '**' ) + // InternalScope.g:51:9: '**' { - match("context"); + match("**"); } @@ -1004,11 +1004,10 @@ public final void mT__55() throws RecognitionException { try { int _type = T__55; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:54:7: ( '>>' ) - // InternalScope.g:54:9: '>>' + // InternalScope.g:52:7: ( '%' ) + // InternalScope.g:52:9: '%' { - match(">>"); - + match('%'); } @@ -1025,10 +1024,11 @@ public final void mT__56() throws RecognitionException { try { int _type = T__56; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:55:7: ( '[' ) - // InternalScope.g:55:9: '[' + // InternalScope.g:53:7: ( '++' ) + // InternalScope.g:53:9: '++' { - match('['); + match("++"); + } @@ -1045,10 +1045,11 @@ public final void mT__57() throws RecognitionException { try { int _type = T__57; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:56:7: ( ']' ) - // InternalScope.g:56:9: ']' + // InternalScope.g:54:7: ( '--' ) + // InternalScope.g:54:9: '--' { - match(']'); + match("--"); + } @@ -1065,11 +1066,10 @@ public final void mT__58() throws RecognitionException { try { int _type = T__58; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:57:7: ( 'factory' ) - // InternalScope.g:57:9: 'factory' + // InternalScope.g:55:7: ( '.' ) + // InternalScope.g:55:9: '.' { - match("factory"); - + match('.'); } @@ -1086,10 +1086,10 @@ public final void mT__59() throws RecognitionException { try { int _type = T__59; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:58:7: ( 'scopeof' ) - // InternalScope.g:58:9: 'scopeof' + // InternalScope.g:56:7: ( 'val' ) + // InternalScope.g:56:9: 'val' { - match("scopeof"); + match("val"); } @@ -1107,10 +1107,11 @@ public final void mT__60() throws RecognitionException { try { int _type = T__60; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:59:7: ( ',' ) - // InternalScope.g:59:9: ',' + // InternalScope.g:57:7: ( 'extends' ) + // InternalScope.g:57:9: 'extends' { - match(','); + match("extends"); + } @@ -1127,10 +1128,10 @@ public final void mT__61() throws RecognitionException { try { int _type = T__61; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:60:7: ( 'find' ) - // InternalScope.g:60:9: 'find' + // InternalScope.g:58:7: ( 'static' ) + // InternalScope.g:58:9: 'static' { - match("find"); + match("static"); } @@ -1148,10 +1149,10 @@ public final void mT__62() throws RecognitionException { try { int _type = T__62; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:61:7: ( 'key' ) - // InternalScope.g:61:9: 'key' + // InternalScope.g:59:7: ( 'import' ) + // InternalScope.g:59:9: 'import' { - match("key"); + match("import"); } @@ -1169,10 +1170,10 @@ public final void mT__63() throws RecognitionException { try { int _type = T__63; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:62:7: ( 'prefix' ) - // InternalScope.g:62:9: 'prefix' + // InternalScope.g:60:7: ( 'extension' ) + // InternalScope.g:60:9: 'extension' { - match("prefix"); + match("extension"); } @@ -1190,10 +1191,10 @@ public final void mT__64() throws RecognitionException { try { int _type = T__64; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:63:7: ( 'data' ) - // InternalScope.g:63:9: 'data' + // InternalScope.g:61:7: ( 'super' ) + // InternalScope.g:61:9: 'super' { - match("data"); + match("super"); } @@ -1211,10 +1212,10 @@ public final void mT__65() throws RecognitionException { try { int _type = T__65; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:64:7: ( 'domains' ) - // InternalScope.g:64:9: 'domains' + // InternalScope.g:62:7: ( 'sensitive' ) + // InternalScope.g:62:9: 'sensitive' { - match("domains"); + match("sensitive"); } @@ -1232,10 +1233,11 @@ public final void mT__66() throws RecognitionException { try { int _type = T__66; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:65:7: ( '|' ) - // InternalScope.g:65:9: '|' + // InternalScope.g:63:7: ( 'insensitive' ) + // InternalScope.g:63:9: 'insensitive' { - match('|'); + match("insensitive"); + } @@ -1252,10 +1254,10 @@ public final void mT__67() throws RecognitionException { try { int _type = T__67; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:66:7: ( '::' ) - // InternalScope.g:66:9: '::' + // InternalScope.g:64:7: ( 'scoping' ) + // InternalScope.g:64:9: 'scoping' { - match("::"); + match("scoping"); } @@ -1273,10 +1275,11 @@ public final void mT__68() throws RecognitionException { try { int _type = T__68; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:67:7: ( '.' ) - // InternalScope.g:67:9: '.' + // InternalScope.g:65:7: ( 'with' ) + // InternalScope.g:65:9: 'with' { - match('.'); + match("with"); + } @@ -1293,10 +1296,10 @@ public final void mT__69() throws RecognitionException { try { int _type = T__69; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:68:7: ( 'let' ) - // InternalScope.g:68:9: 'let' + // InternalScope.g:66:7: ( 'as' ) + // InternalScope.g:66:9: 'as' { - match("let"); + match("as"); } @@ -1314,10 +1317,11 @@ public final void mT__70() throws RecognitionException { try { int _type = T__70; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:69:7: ( ':' ) - // InternalScope.g:69:9: ':' + // InternalScope.g:67:7: ( 'inject' ) + // InternalScope.g:67:9: 'inject' { - match(':'); + match("inject"); + } @@ -1334,10 +1338,10 @@ public final void mT__71() throws RecognitionException { try { int _type = T__71; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:70:7: ( '->' ) - // InternalScope.g:70:9: '->' + // InternalScope.g:68:7: ( 'naming' ) + // InternalScope.g:68:9: 'naming' { - match("->"); + match("naming"); } @@ -1355,10 +1359,10 @@ public final void mT__72() throws RecognitionException { try { int _type = T__72; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:71:7: ( '?' ) - // InternalScope.g:71:9: '?' + // InternalScope.g:69:7: ( '{' ) + // InternalScope.g:69:9: '{' { - match('?'); + match('{'); } @@ -1375,11 +1379,10 @@ public final void mT__73() throws RecognitionException { try { int _type = T__73; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:72:7: ( 'if' ) - // InternalScope.g:72:9: 'if' + // InternalScope.g:70:7: ( '}' ) + // InternalScope.g:70:9: '}' { - match("if"); - + match('}'); } @@ -1396,10 +1399,10 @@ public final void mT__74() throws RecognitionException { try { int _type = T__74; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:73:7: ( 'then' ) - // InternalScope.g:73:9: 'then' + // InternalScope.g:71:7: ( 'case' ) + // InternalScope.g:71:9: 'case' { - match("then"); + match("case"); } @@ -1417,11 +1420,10 @@ public final void mT__75() throws RecognitionException { try { int _type = T__75; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:74:7: ( 'else' ) - // InternalScope.g:74:9: 'else' + // InternalScope.g:72:7: ( ';' ) + // InternalScope.g:72:9: ';' { - match("else"); - + match(';'); } @@ -1438,10 +1440,10 @@ public final void mT__76() throws RecognitionException { try { int _type = T__76; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:75:7: ( 'switch' ) - // InternalScope.g:75:9: 'switch' + // InternalScope.g:73:7: ( 'scope' ) + // InternalScope.g:73:9: 'scope' { - match("switch"); + match("scope"); } @@ -1459,11 +1461,10 @@ public final void mT__77() throws RecognitionException { try { int _type = T__77; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:76:7: ( 'default' ) - // InternalScope.g:76:9: 'default' + // InternalScope.g:74:7: ( '(' ) + // InternalScope.g:74:9: '(' { - match("default"); - + match('('); } @@ -1480,11 +1481,10 @@ public final void mT__78() throws RecognitionException { try { int _type = T__78; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:77:7: ( 'GLOBALVAR' ) - // InternalScope.g:77:9: 'GLOBALVAR' + // InternalScope.g:75:7: ( ')' ) + // InternalScope.g:75:9: ')' { - match("GLOBALVAR"); - + match(')'); } @@ -1501,11 +1501,10 @@ public final void mT__79() throws RecognitionException { try { int _type = T__79; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:78:7: ( 'new' ) - // InternalScope.g:78:9: 'new' + // InternalScope.g:76:7: ( '#' ) + // InternalScope.g:76:9: '#' { - match("new"); - + match('#'); } @@ -1522,10 +1521,10 @@ public final void mT__80() throws RecognitionException { try { int _type = T__80; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:79:7: ( 'recursive' ) - // InternalScope.g:79:9: 'recursive' + // InternalScope.g:77:7: ( 'context' ) + // InternalScope.g:77:9: 'context' { - match("recursive"); + match("context"); } @@ -1543,10 +1542,10 @@ public final void mT__81() throws RecognitionException { try { int _type = T__81; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:80:7: ( 'export' ) - // InternalScope.g:80:9: 'export' + // InternalScope.g:78:7: ( '>>' ) + // InternalScope.g:78:9: '>>' { - match("export"); + match(">>"); } @@ -1564,11 +1563,10 @@ public final void mT__82() throws RecognitionException { try { int _type = T__82; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:81:7: ( '||' ) - // InternalScope.g:81:9: '||' + // InternalScope.g:79:7: ( '[' ) + // InternalScope.g:79:9: '[' { - match("||"); - + match('['); } @@ -1585,11 +1583,10 @@ public final void mT__83() throws RecognitionException { try { int _type = T__83; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:82:7: ( '&&' ) - // InternalScope.g:82:9: '&&' + // InternalScope.g:80:7: ( ']' ) + // InternalScope.g:80:9: ']' { - match("&&"); - + match(']'); } @@ -1606,10 +1603,10 @@ public final void mT__84() throws RecognitionException { try { int _type = T__84; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:83:7: ( 'implies' ) - // InternalScope.g:83:9: 'implies' + // InternalScope.g:81:7: ( 'factory' ) + // InternalScope.g:81:9: 'factory' { - match("implies"); + match("factory"); } @@ -1627,10 +1624,10 @@ public final void mT__85() throws RecognitionException { try { int _type = T__85; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:84:7: ( 'typeSelect' ) - // InternalScope.g:84:9: 'typeSelect' + // InternalScope.g:82:7: ( 'scopeof' ) + // InternalScope.g:82:9: 'scopeof' { - match("typeSelect"); + match("scopeof"); } @@ -1648,10 +1645,698 @@ public final void mT__86() throws RecognitionException { try { int _type = T__86; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:85:7: ( 'null' ) - // InternalScope.g:85:9: 'null' + // InternalScope.g:83:7: ( ',' ) + // InternalScope.g:83:9: ',' { - match("null"); + match(','); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__86" + + // $ANTLR start "T__87" + public final void mT__87() throws RecognitionException { + try { + int _type = T__87; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:84:7: ( 'find' ) + // InternalScope.g:84:9: 'find' + { + match("find"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__87" + + // $ANTLR start "T__88" + public final void mT__88() throws RecognitionException { + try { + int _type = T__88; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:85:7: ( 'key' ) + // InternalScope.g:85:9: 'key' + { + match("key"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:86:7: ( 'prefix' ) + // InternalScope.g:86:9: 'prefix' + { + match("prefix"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" + + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:87:7: ( 'data' ) + // InternalScope.g:87:9: 'data' + { + match("data"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__90" + + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { + try { + int _type = T__91; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:88:7: ( 'domains' ) + // InternalScope.g:88:9: 'domains' + { + match("domains"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" + + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:89:7: ( '|' ) + // InternalScope.g:89:9: '|' + { + match('|'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" + + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:90:7: ( '::' ) + // InternalScope.g:90:9: '::' + { + match("::"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:91:7: ( 'let' ) + // InternalScope.g:91:9: 'let' + { + match("let"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:92:7: ( ':' ) + // InternalScope.g:92:9: ':' + { + match(':'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__95" + + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { + try { + int _type = T__96; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:93:7: ( '?' ) + // InternalScope.g:93:9: '?' + { + match('?'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" + + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:94:7: ( 'if' ) + // InternalScope.g:94:9: 'if' + { + match("if"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__97" + + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { + try { + int _type = T__98; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:95:7: ( 'then' ) + // InternalScope.g:95:9: 'then' + { + match("then"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:96:7: ( 'else' ) + // InternalScope.g:96:9: 'else' + { + match("else"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:97:8: ( 'switch' ) + // InternalScope.g:97:10: 'switch' + { + match("switch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:98:8: ( 'default' ) + // InternalScope.g:98:10: 'default' + { + match("default"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:99:8: ( 'GLOBALVAR' ) + // InternalScope.g:99:10: 'GLOBALVAR' + { + match("GLOBALVAR"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:100:8: ( 'new' ) + // InternalScope.g:100:10: 'new' + { + match("new"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:101:8: ( 'instanceof' ) + // InternalScope.g:101:10: 'instanceof' + { + match("instanceof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "T__105" + public final void mT__105() throws RecognitionException { + try { + int _type = T__105; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:102:8: ( 'for' ) + // InternalScope.g:102:10: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__105" + + // $ANTLR start "T__106" + public final void mT__106() throws RecognitionException { + try { + int _type = T__106; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:103:8: ( 'while' ) + // InternalScope.g:103:10: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__106" + + // $ANTLR start "T__107" + public final void mT__107() throws RecognitionException { + try { + int _type = T__107; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:104:8: ( 'do' ) + // InternalScope.g:104:10: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__107" + + // $ANTLR start "T__108" + public final void mT__108() throws RecognitionException { + try { + int _type = T__108; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:105:8: ( 'null' ) + // InternalScope.g:105:10: 'null' + { + match("null"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__108" + + // $ANTLR start "T__109" + public final void mT__109() throws RecognitionException { + try { + int _type = T__109; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:106:8: ( 'typeof' ) + // InternalScope.g:106:10: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__109" + + // $ANTLR start "T__110" + public final void mT__110() throws RecognitionException { + try { + int _type = T__110; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:107:8: ( 'throw' ) + // InternalScope.g:107:10: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__110" + + // $ANTLR start "T__111" + public final void mT__111() throws RecognitionException { + try { + int _type = T__111; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:108:8: ( 'return' ) + // InternalScope.g:108:10: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__111" + + // $ANTLR start "T__112" + public final void mT__112() throws RecognitionException { + try { + int _type = T__112; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:109:8: ( 'try' ) + // InternalScope.g:109:10: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__112" + + // $ANTLR start "T__113" + public final void mT__113() throws RecognitionException { + try { + int _type = T__113; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:110:8: ( 'finally' ) + // InternalScope.g:110:10: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__113" + + // $ANTLR start "T__114" + public final void mT__114() throws RecognitionException { + try { + int _type = T__114; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:111:8: ( 'synchronized' ) + // InternalScope.g:111:10: 'synchronized' + { + match("synchronized"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__114" + + // $ANTLR start "T__115" + public final void mT__115() throws RecognitionException { + try { + int _type = T__115; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:112:8: ( 'catch' ) + // InternalScope.g:112:10: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__115" + + // $ANTLR start "T__116" + public final void mT__116() throws RecognitionException { + try { + int _type = T__116; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:113:8: ( '&' ) + // InternalScope.g:113:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__116" + + // $ANTLR start "T__117" + public final void mT__117() throws RecognitionException { + try { + int _type = T__117; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:114:8: ( 'recursive' ) + // InternalScope.g:114:10: 'recursive' + { + match("recursive"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__117" + + // $ANTLR start "T__118" + public final void mT__118() throws RecognitionException { + try { + int _type = T__118; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:115:8: ( 'export' ) + // InternalScope.g:115:10: 'export' + { + match("export"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__118" + + // $ANTLR start "T__119" + public final void mT__119() throws RecognitionException { + try { + int _type = T__119; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:116:8: ( 'implies' ) + // InternalScope.g:116:10: 'implies' + { + match("implies"); } @@ -1662,17 +2347,80 @@ public final void mT__86() throws RecognitionException { finally { } } - // $ANTLR end "T__86" + // $ANTLR end "T__119" + + // $ANTLR start "T__120" + public final void mT__120() throws RecognitionException { + try { + int _type = T__120; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:117:8: ( 'typeSelect' ) + // InternalScope.g:117:10: 'typeSelect' + { + match("typeSelect"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__120" + + // $ANTLR start "T__121" + public final void mT__121() throws RecognitionException { + try { + int _type = T__121; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:118:8: ( '?.' ) + // InternalScope.g:118:10: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__121" + + // $ANTLR start "T__122" + public final void mT__122() throws RecognitionException { + try { + int _type = T__122; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:119:8: ( 'var' ) + // InternalScope.g:119:10: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__122" // $ANTLR start "RULE_REAL" public final void mRULE_REAL() throws RecognitionException { try { int _type = RULE_REAL; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11775:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) - // InternalScope.g:11775:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + // InternalScope.g:28622:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) + // InternalScope.g:28622:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* { - // InternalScope.g:11775:13: ( '0' .. '9' )* + // InternalScope.g:28622:13: ( '0' .. '9' )* loop1: do { int alt1=2; @@ -1685,7 +2433,7 @@ public final void mRULE_REAL() throws RecognitionException { switch (alt1) { case 1 : - // InternalScope.g:11775:14: '0' .. '9' + // InternalScope.g:28622:14: '0' .. '9' { matchRange('0','9'); @@ -1698,7 +2446,7 @@ public final void mRULE_REAL() throws RecognitionException { } while (true); match('.'); - // InternalScope.g:11775:29: ( '0' .. '9' )* + // InternalScope.g:28622:29: ( '0' .. '9' )* loop2: do { int alt2=2; @@ -1711,7 +2459,7 @@ public final void mRULE_REAL() throws RecognitionException { switch (alt2) { case 1 : - // InternalScope.g:11775:30: '0' .. '9' + // InternalScope.g:28622:30: '0' .. '9' { matchRange('0','9'); @@ -1732,26 +2480,385 @@ public final void mRULE_REAL() throws RecognitionException { finally { } } - // $ANTLR end "RULE_REAL" + // $ANTLR end "RULE_REAL" + + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:28624:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // InternalScope.g:28624:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // InternalScope.g:28624:12: ( '0x' | '0X' ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='0') ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1=='x') ) { + alt3=1; + } + else if ( (LA3_1=='X') ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalScope.g:28624:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // InternalScope.g:28624:18: '0X' + { + match("0X"); + + + } + break; + + } + + // InternalScope.g:28624:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ + int cnt4=0; + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='f')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalScope.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt4 >= 1 ) break loop4; + EarlyExitException eee = + new EarlyExitException(4, input); + throw eee; + } + cnt4++; + } while (true); + + // InternalScope.g:28624:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='#') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalScope.g:28624:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // InternalScope.g:28624:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='B'||LA5_0=='b') ) { + alt5=1; + } + else if ( (LA5_0=='L'||LA5_0=='l') ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalScope.g:28624:64: ( 'b' | 'B' ) ( 'i' | 'I' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='I'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalScope.g:28624:84: ( 'l' | 'L' ) + { + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_HEX" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:28626:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // InternalScope.g:28626:12: '0' .. '9' ( '0' .. '9' | '_' )* + { + matchRange('0','9'); + // InternalScope.g:28626:21: ( '0' .. '9' | '_' )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||LA7_0=='_') ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalScope.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_DECIMAL" + public final void mRULE_DECIMAL() throws RecognitionException { + try { + int _type = RULE_DECIMAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:28628:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // InternalScope.g:28628:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // InternalScope.g:28628:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='E'||LA9_0=='e') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalScope.g:28628:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalScope.g:28628:36: ( '+' | '-' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='+'||LA8_0=='-') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalScope.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_INT(); + + } + break; + + } + + // InternalScope.g:28628:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='B'||LA10_0=='b') ) { + alt10=1; + } + else if ( (LA10_0=='D'||LA10_0=='F'||LA10_0=='L'||LA10_0=='d'||LA10_0=='f'||LA10_0=='l') ) { + alt10=2; + } + switch (alt10) { + case 1 : + // InternalScope.g:28628:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalScope.g:28628:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) + { + if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECIMAL" // $ANTLR start "RULE_ID" public final void mRULE_ID() throws RecognitionException { try { int _type = RULE_ID; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11777:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalScope.g:11777:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalScope.g:28630:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalScope.g:28630:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* { - // InternalScope.g:11777:11: ( '^' )? - int alt3=2; - int LA3_0 = input.LA(1); + // InternalScope.g:28630:11: ( '^' )? + int alt11=2; + int LA11_0 = input.LA(1); - if ( (LA3_0=='^') ) { - alt3=1; + if ( (LA11_0=='^') ) { + alt11=1; } - switch (alt3) { + switch (alt11) { case 1 : - // InternalScope.g:11777:11: '^' + // InternalScope.g:28630:11: '^' { match('^'); @@ -1760,7 +2867,7 @@ public final void mRULE_ID() throws RecognitionException { } - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { input.consume(); } @@ -1769,22 +2876,22 @@ public final void mRULE_ID() throws RecognitionException { recover(mse); throw mse;} - // InternalScope.g:11777:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop4: + // InternalScope.g:28630:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop12: do { - int alt4=2; - int LA4_0 = input.LA(1); + int alt12=2; + int LA12_0 = input.LA(1); - if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { - alt4=1; + if ( (LA12_0=='$'||(LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) { + alt12=1; } - switch (alt4) { + switch (alt12) { case 1 : // InternalScope.g: { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { input.consume(); } @@ -1798,7 +2905,7 @@ public final void mRULE_ID() throws RecognitionException { break; default : - break loop4; + break loop12; } } while (true); @@ -1813,101 +2920,52 @@ public final void mRULE_ID() throws RecognitionException { } // $ANTLR end "RULE_ID" - // $ANTLR start "RULE_INT" - public final void mRULE_INT() throws RecognitionException { - try { - int _type = RULE_INT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11779:10: ( ( '0' .. '9' )+ ) - // InternalScope.g:11779:12: ( '0' .. '9' )+ - { - // InternalScope.g:11779:12: ( '0' .. '9' )+ - int cnt5=0; - loop5: - do { - int alt5=2; - int LA5_0 = input.LA(1); - - if ( ((LA5_0>='0' && LA5_0<='9')) ) { - alt5=1; - } - - - switch (alt5) { - case 1 : - // InternalScope.g:11779:13: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - if ( cnt5 >= 1 ) break loop5; - EarlyExitException eee = - new EarlyExitException(5, input); - throw eee; - } - cnt5++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_INT" - // $ANTLR start "RULE_STRING" public final void mRULE_STRING() throws RecognitionException { try { int _type = RULE_STRING; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11781:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalScope.g:11781:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalScope.g:28632:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalScope.g:28632:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) { - // InternalScope.g:11781:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt8=2; - int LA8_0 = input.LA(1); + // InternalScope.g:28632:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt17=2; + int LA17_0 = input.LA(1); - if ( (LA8_0=='\"') ) { - alt8=1; + if ( (LA17_0=='\"') ) { + alt17=1; } - else if ( (LA8_0=='\'') ) { - alt8=2; + else if ( (LA17_0=='\'') ) { + alt17=2; } else { NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); + new NoViableAltException("", 17, 0, input); throw nvae; } - switch (alt8) { + switch (alt17) { case 1 : - // InternalScope.g:11781:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' + // InternalScope.g:28632:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? { match('\"'); - // InternalScope.g:11781:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop6: + // InternalScope.g:28632:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop13: do { - int alt6=3; - int LA6_0 = input.LA(1); + int alt13=3; + int LA13_0 = input.LA(1); - if ( (LA6_0=='\\') ) { - alt6=1; + if ( (LA13_0=='\\') ) { + alt13=1; } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; + else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) { + alt13=2; } - switch (alt6) { + switch (alt13) { case 1 : - // InternalScope.g:11781:21: '\\\\' . + // InternalScope.g:28632:21: '\\\\' . { match('\\'); matchAny(); @@ -1915,7 +2973,7 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= } break; case 2 : - // InternalScope.g:11781:28: ~ ( ( '\\\\' | '\"' ) ) + // InternalScope.g:28632:28: ~ ( ( '\\\\' | '\"' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1931,35 +2989,52 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= break; default : - break loop6; + break loop13; } } while (true); - match('\"'); + // InternalScope.g:28632:44: ( '\"' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\"') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalScope.g:28632:44: '\"' + { + match('\"'); + + } + break; + + } + } break; case 2 : - // InternalScope.g:11781:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + // InternalScope.g:28632:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? { match('\''); - // InternalScope.g:11781:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop7: + // InternalScope.g:28632:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop15: do { - int alt7=3; - int LA7_0 = input.LA(1); + int alt15=3; + int LA15_0 = input.LA(1); - if ( (LA7_0=='\\') ) { - alt7=1; + if ( (LA15_0=='\\') ) { + alt15=1; } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; + else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) { + alt15=2; } - switch (alt7) { + switch (alt15) { case 1 : - // InternalScope.g:11781:54: '\\\\' . + // InternalScope.g:28632:55: '\\\\' . { match('\\'); matchAny(); @@ -1967,7 +3042,7 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= } break; case 2 : - // InternalScope.g:11781:61: ~ ( ( '\\\\' | '\\'' ) ) + // InternalScope.g:28632:62: ~ ( ( '\\\\' | '\\'' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1983,11 +3058,28 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= break; default : - break loop7; + break loop15; } } while (true); - match('\''); + // InternalScope.g:28632:79: ( '\\'' )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalScope.g:28632:79: '\\'' + { + match('\''); + + } + break; + + } + } break; @@ -2010,37 +3102,37 @@ public final void mRULE_ML_COMMENT() throws RecognitionException { try { int _type = RULE_ML_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11783:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalScope.g:11783:19: '/*' ( options {greedy=false; } : . )* '*/' + // InternalScope.g:28634:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalScope.g:28634:19: '/*' ( options {greedy=false; } : . )* '*/' { match("/*"); - // InternalScope.g:11783:24: ( options {greedy=false; } : . )* - loop9: + // InternalScope.g:28634:24: ( options {greedy=false; } : . )* + loop18: do { - int alt9=2; - int LA9_0 = input.LA(1); + int alt18=2; + int LA18_0 = input.LA(1); - if ( (LA9_0=='*') ) { - int LA9_1 = input.LA(2); + if ( (LA18_0=='*') ) { + int LA18_1 = input.LA(2); - if ( (LA9_1=='/') ) { - alt9=2; + if ( (LA18_1=='/') ) { + alt18=2; } - else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) { + alt18=1; } } - else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) { + alt18=1; } - switch (alt9) { + switch (alt18) { case 1 : - // InternalScope.g:11783:52: . + // InternalScope.g:28634:52: . { matchAny(); @@ -2048,7 +3140,7 @@ else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { break; default : - break loop9; + break loop18; } } while (true); @@ -2070,25 +3162,25 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { try { int _type = RULE_SL_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11785:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalScope.g:11785:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + // InternalScope.g:28636:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalScope.g:28636:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? { match("//"); - // InternalScope.g:11785:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop10: + // InternalScope.g:28636:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop19: do { - int alt10=2; - int LA10_0 = input.LA(1); + int alt19=2; + int LA19_0 = input.LA(1); - if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\uFFFF')) ) { - alt10=1; + if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { + alt19=1; } - switch (alt10) { + switch (alt19) { case 1 : - // InternalScope.g:11785:24: ~ ( ( '\\n' | '\\r' ) ) + // InternalScope.g:28636:24: ~ ( ( '\\n' | '\\r' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -2104,31 +3196,31 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { break; default : - break loop10; + break loop19; } } while (true); - // InternalScope.g:11785:40: ( ( '\\r' )? '\\n' )? - int alt12=2; - int LA12_0 = input.LA(1); + // InternalScope.g:28636:40: ( ( '\\r' )? '\\n' )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA12_0=='\n'||LA12_0=='\r') ) { - alt12=1; + if ( (LA21_0=='\n'||LA21_0=='\r') ) { + alt21=1; } - switch (alt12) { + switch (alt21) { case 1 : - // InternalScope.g:11785:41: ( '\\r' )? '\\n' + // InternalScope.g:28636:41: ( '\\r' )? '\\n' { - // InternalScope.g:11785:41: ( '\\r' )? - int alt11=2; - int LA11_0 = input.LA(1); + // InternalScope.g:28636:41: ( '\\r' )? + int alt20=2; + int LA20_0 = input.LA(1); - if ( (LA11_0=='\r') ) { - alt11=1; + if ( (LA20_0=='\r') ) { + alt20=1; } - switch (alt11) { + switch (alt20) { case 1 : - // InternalScope.g:11785:41: '\\r' + // InternalScope.g:28636:41: '\\r' { match('\r'); @@ -2155,664 +3247,916 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { } // $ANTLR end "RULE_SL_COMMENT" - // $ANTLR start "RULE_WS" - public final void mRULE_WS() throws RecognitionException { - try { - int _type = RULE_WS; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11787:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalScope.g:11787:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - { - // InternalScope.g:11787:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt13=0; - loop13: - do { - int alt13=2; - int LA13_0 = input.LA(1); + // $ANTLR start "RULE_WS" + public final void mRULE_WS() throws RecognitionException { + try { + int _type = RULE_WS; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:28638:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalScope.g:28638:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + { + // InternalScope.g:28638:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt22=0; + loop22: + do { + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='\t' && LA22_0<='\n')||LA22_0=='\r'||LA22_0==' ') ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalScope.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:28640:16: ( . ) + // InternalScope.g:28640:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalScope.g:1:8: ( T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | T__115 | T__116 | T__117 | T__118 | T__119 | T__120 | T__121 | T__122 | RULE_REAL | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt23=119; + alt23 = dfa23.predict(input); + switch (alt23) { + case 1 : + // InternalScope.g:1:10: T__14 + { + mT__14(); + + } + break; + case 2 : + // InternalScope.g:1:16: T__15 + { + mT__15(); + + } + break; + case 3 : + // InternalScope.g:1:22: T__16 + { + mT__16(); + + } + break; + case 4 : + // InternalScope.g:1:28: T__17 + { + mT__17(); + + } + break; + case 5 : + // InternalScope.g:1:34: T__18 + { + mT__18(); + + } + break; + case 6 : + // InternalScope.g:1:40: T__19 + { + mT__19(); + + } + break; + case 7 : + // InternalScope.g:1:46: T__20 + { + mT__20(); + + } + break; + case 8 : + // InternalScope.g:1:52: T__21 + { + mT__21(); + + } + break; + case 9 : + // InternalScope.g:1:58: T__22 + { + mT__22(); + + } + break; + case 10 : + // InternalScope.g:1:64: T__23 + { + mT__23(); + + } + break; + case 11 : + // InternalScope.g:1:70: T__24 + { + mT__24(); + + } + break; + case 12 : + // InternalScope.g:1:76: T__25 + { + mT__25(); + + } + break; + case 13 : + // InternalScope.g:1:82: T__26 + { + mT__26(); + + } + break; + case 14 : + // InternalScope.g:1:88: T__27 + { + mT__27(); + + } + break; + case 15 : + // InternalScope.g:1:94: T__28 + { + mT__28(); + + } + break; + case 16 : + // InternalScope.g:1:100: T__29 + { + mT__29(); + + } + break; + case 17 : + // InternalScope.g:1:106: T__30 + { + mT__30(); + + } + break; + case 18 : + // InternalScope.g:1:112: T__31 + { + mT__31(); + + } + break; + case 19 : + // InternalScope.g:1:118: T__32 + { + mT__32(); + + } + break; + case 20 : + // InternalScope.g:1:124: T__33 + { + mT__33(); + + } + break; + case 21 : + // InternalScope.g:1:130: T__34 + { + mT__34(); + + } + break; + case 22 : + // InternalScope.g:1:136: T__35 + { + mT__35(); - if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) { - alt13=1; } + break; + case 23 : + // InternalScope.g:1:142: T__36 + { + mT__36(); + } + break; + case 24 : + // InternalScope.g:1:148: T__37 + { + mT__37(); - switch (alt13) { - case 1 : - // InternalScope.g: - { - if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { - input.consume(); + } + break; + case 25 : + // InternalScope.g:1:154: T__38 + { + mT__38(); - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + } + break; + case 26 : + // InternalScope.g:1:160: T__39 + { + mT__39(); + } + break; + case 27 : + // InternalScope.g:1:166: T__40 + { + mT__40(); - } - break; + } + break; + case 28 : + // InternalScope.g:1:172: T__41 + { + mT__41(); - default : - if ( cnt13 >= 1 ) break loop13; - EarlyExitException eee = - new EarlyExitException(13, input); - throw eee; } - cnt13++; - } while (true); + break; + case 29 : + // InternalScope.g:1:178: T__42 + { + mT__42(); + } + break; + case 30 : + // InternalScope.g:1:184: T__43 + { + mT__43(); - } + } + break; + case 31 : + // InternalScope.g:1:190: T__44 + { + mT__44(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_WS" + } + break; + case 32 : + // InternalScope.g:1:196: T__45 + { + mT__45(); - // $ANTLR start "RULE_ANY_OTHER" - public final void mRULE_ANY_OTHER() throws RecognitionException { - try { - int _type = RULE_ANY_OTHER; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11789:16: ( . ) - // InternalScope.g:11789:18: . - { - matchAny(); + } + break; + case 33 : + // InternalScope.g:1:202: T__46 + { + mT__46(); - } + } + break; + case 34 : + // InternalScope.g:1:208: T__47 + { + mT__47(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ANY_OTHER" + } + break; + case 35 : + // InternalScope.g:1:214: T__48 + { + mT__48(); - public void mTokens() throws RecognitionException { - // InternalScope.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | RULE_REAL | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt14=83; - alt14 = dfa14.predict(input); - switch (alt14) { - case 1 : - // InternalScope.g:1:10: T__12 + } + break; + case 36 : + // InternalScope.g:1:220: T__49 { - mT__12(); + mT__49(); } break; - case 2 : - // InternalScope.g:1:16: T__13 + case 37 : + // InternalScope.g:1:226: T__50 { - mT__13(); + mT__50(); } break; - case 3 : - // InternalScope.g:1:22: T__14 + case 38 : + // InternalScope.g:1:232: T__51 { - mT__14(); + mT__51(); } break; - case 4 : - // InternalScope.g:1:28: T__15 + case 39 : + // InternalScope.g:1:238: T__52 { - mT__15(); + mT__52(); } break; - case 5 : - // InternalScope.g:1:34: T__16 + case 40 : + // InternalScope.g:1:244: T__53 { - mT__16(); + mT__53(); } break; - case 6 : - // InternalScope.g:1:40: T__17 + case 41 : + // InternalScope.g:1:250: T__54 { - mT__17(); + mT__54(); } break; - case 7 : - // InternalScope.g:1:46: T__18 + case 42 : + // InternalScope.g:1:256: T__55 { - mT__18(); + mT__55(); } break; - case 8 : - // InternalScope.g:1:52: T__19 + case 43 : + // InternalScope.g:1:262: T__56 { - mT__19(); + mT__56(); } break; - case 9 : - // InternalScope.g:1:58: T__20 + case 44 : + // InternalScope.g:1:268: T__57 { - mT__20(); + mT__57(); } break; - case 10 : - // InternalScope.g:1:64: T__21 + case 45 : + // InternalScope.g:1:274: T__58 { - mT__21(); + mT__58(); } break; - case 11 : - // InternalScope.g:1:70: T__22 + case 46 : + // InternalScope.g:1:280: T__59 { - mT__22(); + mT__59(); } break; - case 12 : - // InternalScope.g:1:76: T__23 + case 47 : + // InternalScope.g:1:286: T__60 { - mT__23(); + mT__60(); } break; - case 13 : - // InternalScope.g:1:82: T__24 + case 48 : + // InternalScope.g:1:292: T__61 { - mT__24(); + mT__61(); } break; - case 14 : - // InternalScope.g:1:88: T__25 + case 49 : + // InternalScope.g:1:298: T__62 { - mT__25(); + mT__62(); } break; - case 15 : - // InternalScope.g:1:94: T__26 + case 50 : + // InternalScope.g:1:304: T__63 { - mT__26(); + mT__63(); } break; - case 16 : - // InternalScope.g:1:100: T__27 + case 51 : + // InternalScope.g:1:310: T__64 { - mT__27(); + mT__64(); } break; - case 17 : - // InternalScope.g:1:106: T__28 + case 52 : + // InternalScope.g:1:316: T__65 { - mT__28(); + mT__65(); } break; - case 18 : - // InternalScope.g:1:112: T__29 + case 53 : + // InternalScope.g:1:322: T__66 { - mT__29(); + mT__66(); } break; - case 19 : - // InternalScope.g:1:118: T__30 + case 54 : + // InternalScope.g:1:328: T__67 { - mT__30(); + mT__67(); } break; - case 20 : - // InternalScope.g:1:124: T__31 + case 55 : + // InternalScope.g:1:334: T__68 { - mT__31(); + mT__68(); } break; - case 21 : - // InternalScope.g:1:130: T__32 + case 56 : + // InternalScope.g:1:340: T__69 { - mT__32(); + mT__69(); } break; - case 22 : - // InternalScope.g:1:136: T__33 + case 57 : + // InternalScope.g:1:346: T__70 { - mT__33(); + mT__70(); } break; - case 23 : - // InternalScope.g:1:142: T__34 + case 58 : + // InternalScope.g:1:352: T__71 { - mT__34(); + mT__71(); } break; - case 24 : - // InternalScope.g:1:148: T__35 + case 59 : + // InternalScope.g:1:358: T__72 { - mT__35(); + mT__72(); } break; - case 25 : - // InternalScope.g:1:154: T__36 + case 60 : + // InternalScope.g:1:364: T__73 { - mT__36(); + mT__73(); } break; - case 26 : - // InternalScope.g:1:160: T__37 + case 61 : + // InternalScope.g:1:370: T__74 { - mT__37(); + mT__74(); } break; - case 27 : - // InternalScope.g:1:166: T__38 + case 62 : + // InternalScope.g:1:376: T__75 { - mT__38(); + mT__75(); } break; - case 28 : - // InternalScope.g:1:172: T__39 + case 63 : + // InternalScope.g:1:382: T__76 { - mT__39(); + mT__76(); } break; - case 29 : - // InternalScope.g:1:178: T__40 + case 64 : + // InternalScope.g:1:388: T__77 { - mT__40(); + mT__77(); } break; - case 30 : - // InternalScope.g:1:184: T__41 + case 65 : + // InternalScope.g:1:394: T__78 { - mT__41(); + mT__78(); } break; - case 31 : - // InternalScope.g:1:190: T__42 + case 66 : + // InternalScope.g:1:400: T__79 { - mT__42(); + mT__79(); } break; - case 32 : - // InternalScope.g:1:196: T__43 + case 67 : + // InternalScope.g:1:406: T__80 { - mT__43(); + mT__80(); } break; - case 33 : - // InternalScope.g:1:202: T__44 + case 68 : + // InternalScope.g:1:412: T__81 { - mT__44(); + mT__81(); } break; - case 34 : - // InternalScope.g:1:208: T__45 + case 69 : + // InternalScope.g:1:418: T__82 + { + mT__82(); + + } + break; + case 70 : + // InternalScope.g:1:424: T__83 { - mT__45(); + mT__83(); } break; - case 35 : - // InternalScope.g:1:214: T__46 + case 71 : + // InternalScope.g:1:430: T__84 { - mT__46(); + mT__84(); } break; - case 36 : - // InternalScope.g:1:220: T__47 + case 72 : + // InternalScope.g:1:436: T__85 { - mT__47(); + mT__85(); } break; - case 37 : - // InternalScope.g:1:226: T__48 + case 73 : + // InternalScope.g:1:442: T__86 { - mT__48(); + mT__86(); } break; - case 38 : - // InternalScope.g:1:232: T__49 + case 74 : + // InternalScope.g:1:448: T__87 { - mT__49(); + mT__87(); } break; - case 39 : - // InternalScope.g:1:238: T__50 + case 75 : + // InternalScope.g:1:454: T__88 { - mT__50(); + mT__88(); } break; - case 40 : - // InternalScope.g:1:244: T__51 + case 76 : + // InternalScope.g:1:460: T__89 { - mT__51(); + mT__89(); } break; - case 41 : - // InternalScope.g:1:250: T__52 + case 77 : + // InternalScope.g:1:466: T__90 { - mT__52(); + mT__90(); } break; - case 42 : - // InternalScope.g:1:256: T__53 + case 78 : + // InternalScope.g:1:472: T__91 { - mT__53(); + mT__91(); } break; - case 43 : - // InternalScope.g:1:262: T__54 + case 79 : + // InternalScope.g:1:478: T__92 { - mT__54(); + mT__92(); } break; - case 44 : - // InternalScope.g:1:268: T__55 + case 80 : + // InternalScope.g:1:484: T__93 { - mT__55(); + mT__93(); } break; - case 45 : - // InternalScope.g:1:274: T__56 + case 81 : + // InternalScope.g:1:490: T__94 { - mT__56(); + mT__94(); } break; - case 46 : - // InternalScope.g:1:280: T__57 + case 82 : + // InternalScope.g:1:496: T__95 { - mT__57(); + mT__95(); } break; - case 47 : - // InternalScope.g:1:286: T__58 + case 83 : + // InternalScope.g:1:502: T__96 { - mT__58(); + mT__96(); } break; - case 48 : - // InternalScope.g:1:292: T__59 + case 84 : + // InternalScope.g:1:508: T__97 { - mT__59(); + mT__97(); } break; - case 49 : - // InternalScope.g:1:298: T__60 + case 85 : + // InternalScope.g:1:514: T__98 { - mT__60(); + mT__98(); } break; - case 50 : - // InternalScope.g:1:304: T__61 + case 86 : + // InternalScope.g:1:520: T__99 { - mT__61(); + mT__99(); } break; - case 51 : - // InternalScope.g:1:310: T__62 + case 87 : + // InternalScope.g:1:526: T__100 { - mT__62(); + mT__100(); } break; - case 52 : - // InternalScope.g:1:316: T__63 + case 88 : + // InternalScope.g:1:533: T__101 { - mT__63(); + mT__101(); } break; - case 53 : - // InternalScope.g:1:322: T__64 + case 89 : + // InternalScope.g:1:540: T__102 { - mT__64(); + mT__102(); } break; - case 54 : - // InternalScope.g:1:328: T__65 + case 90 : + // InternalScope.g:1:547: T__103 { - mT__65(); + mT__103(); } break; - case 55 : - // InternalScope.g:1:334: T__66 + case 91 : + // InternalScope.g:1:554: T__104 { - mT__66(); + mT__104(); } break; - case 56 : - // InternalScope.g:1:340: T__67 + case 92 : + // InternalScope.g:1:561: T__105 { - mT__67(); + mT__105(); } break; - case 57 : - // InternalScope.g:1:346: T__68 + case 93 : + // InternalScope.g:1:568: T__106 { - mT__68(); + mT__106(); } break; - case 58 : - // InternalScope.g:1:352: T__69 + case 94 : + // InternalScope.g:1:575: T__107 { - mT__69(); + mT__107(); } break; - case 59 : - // InternalScope.g:1:358: T__70 + case 95 : + // InternalScope.g:1:582: T__108 { - mT__70(); + mT__108(); } break; - case 60 : - // InternalScope.g:1:364: T__71 + case 96 : + // InternalScope.g:1:589: T__109 { - mT__71(); + mT__109(); } break; - case 61 : - // InternalScope.g:1:370: T__72 + case 97 : + // InternalScope.g:1:596: T__110 { - mT__72(); + mT__110(); } break; - case 62 : - // InternalScope.g:1:376: T__73 + case 98 : + // InternalScope.g:1:603: T__111 { - mT__73(); + mT__111(); } break; - case 63 : - // InternalScope.g:1:382: T__74 + case 99 : + // InternalScope.g:1:610: T__112 { - mT__74(); + mT__112(); } break; - case 64 : - // InternalScope.g:1:388: T__75 + case 100 : + // InternalScope.g:1:617: T__113 { - mT__75(); + mT__113(); } break; - case 65 : - // InternalScope.g:1:394: T__76 + case 101 : + // InternalScope.g:1:624: T__114 { - mT__76(); + mT__114(); } break; - case 66 : - // InternalScope.g:1:400: T__77 + case 102 : + // InternalScope.g:1:631: T__115 { - mT__77(); + mT__115(); } break; - case 67 : - // InternalScope.g:1:406: T__78 + case 103 : + // InternalScope.g:1:638: T__116 { - mT__78(); + mT__116(); } break; - case 68 : - // InternalScope.g:1:412: T__79 + case 104 : + // InternalScope.g:1:645: T__117 { - mT__79(); + mT__117(); } break; - case 69 : - // InternalScope.g:1:418: T__80 + case 105 : + // InternalScope.g:1:652: T__118 { - mT__80(); + mT__118(); } break; - case 70 : - // InternalScope.g:1:424: T__81 + case 106 : + // InternalScope.g:1:659: T__119 { - mT__81(); + mT__119(); } break; - case 71 : - // InternalScope.g:1:430: T__82 + case 107 : + // InternalScope.g:1:666: T__120 { - mT__82(); + mT__120(); } break; - case 72 : - // InternalScope.g:1:436: T__83 + case 108 : + // InternalScope.g:1:673: T__121 { - mT__83(); + mT__121(); } break; - case 73 : - // InternalScope.g:1:442: T__84 + case 109 : + // InternalScope.g:1:680: T__122 { - mT__84(); + mT__122(); } break; - case 74 : - // InternalScope.g:1:448: T__85 + case 110 : + // InternalScope.g:1:687: RULE_REAL { - mT__85(); + mRULE_REAL(); } break; - case 75 : - // InternalScope.g:1:454: T__86 + case 111 : + // InternalScope.g:1:697: RULE_HEX { - mT__86(); + mRULE_HEX(); } break; - case 76 : - // InternalScope.g:1:460: RULE_REAL + case 112 : + // InternalScope.g:1:706: RULE_INT { - mRULE_REAL(); + mRULE_INT(); } break; - case 77 : - // InternalScope.g:1:470: RULE_ID + case 113 : + // InternalScope.g:1:715: RULE_DECIMAL { - mRULE_ID(); + mRULE_DECIMAL(); } break; - case 78 : - // InternalScope.g:1:478: RULE_INT + case 114 : + // InternalScope.g:1:728: RULE_ID { - mRULE_INT(); + mRULE_ID(); } break; - case 79 : - // InternalScope.g:1:487: RULE_STRING + case 115 : + // InternalScope.g:1:736: RULE_STRING { mRULE_STRING(); } break; - case 80 : - // InternalScope.g:1:499: RULE_ML_COMMENT + case 116 : + // InternalScope.g:1:748: RULE_ML_COMMENT { mRULE_ML_COMMENT(); } break; - case 81 : - // InternalScope.g:1:515: RULE_SL_COMMENT + case 117 : + // InternalScope.g:1:764: RULE_SL_COMMENT { mRULE_SL_COMMENT(); } break; - case 82 : - // InternalScope.g:1:531: RULE_WS + case 118 : + // InternalScope.g:1:780: RULE_WS { mRULE_WS(); } break; - case 83 : - // InternalScope.g:1:539: RULE_ANY_OTHER + case 119 : + // InternalScope.g:1:788: RULE_ANY_OTHER { mRULE_ANY_OTHER(); @@ -2824,112 +4168,86 @@ public void mTokens() throws RecognitionException { } - protected DFA14 dfa14 = new DFA14(this); - static final String DFA14_eotS = - "\1\uffff\1\61\1\63\1\66\1\70\1\uffff\1\73\1\uffff\1\77\15\102\11\uffff\3\102\1\153\1\155\1\156\1\102\1\uffff\1\102\1\57\1\164\1\57\1\uffff\2\57\22\uffff\2\102\1\uffff\26\102\1\u0097\1\102\1\u0099\11\uffff\5\102\6\uffff\1\102\1\uffff\1\102\2\uffff\1\164\2\uffff\20\102\1\u00b1\12\102\1\u00bc\3\102\1\uffff\1\102\1\uffff\1\u00c2\4\102\1\u00c7\3\102\1\u00cb\12\102\1\u00d7\2\102\1\uffff\1\u00da\3\102\1\u00de\1\u00df\1\u00e0\2\102\1\u00e3\1\uffff\4\102\1\u00e8\1\uffff\1\102\1\u00ea\2\102\1\uffff\3\102\1\uffff\4\102\1\u00f5\6\102\1\uffff\2\102\1\uffff\1\102\1\u00ff\1\102\3\uffff\2\102\1\uffff\4\102\1\uffff\1\102\1\uffff\5\102\1\u010e\1\102\1\u0110\2\102\1\uffff\1\u0113\1\u0114\1\102\1\u0116\1\102\1\u0118\1\102\1\u011a\1\u011b\1\uffff\4\102\1\u0120\1\u0121\1\102\1\u0123\3\102\1\u0127\1\u0128\1\102\1\uffff\1\102\1\uffff\1\u012b\1\u012c\2\uffff\1\102\1\uffff\1\102\1\uffff\1\102\2\uffff\1\u0130\3\102\2\uffff\1\u0134\1\uffff\1\u0135\1\u0136\1\102\2\uffff\2\102\2\uffff\3\102\1\uffff\3\102\3\uffff\2\102\1\u0142\1\u0143\1\u0144\1\u0145\3\102\1\u0149\1\102\4\uffff\1\u014b\1\u014c\1\102\1\uffff\1\u014e\2\uffff\1\u014f\2\uffff"; - static final String DFA14_eofS = - "\u0150\uffff"; - static final String DFA14_minS = - "\1\0\4\75\1\uffff\1\76\1\uffff\1\52\1\141\1\143\1\145\1\154\2\141\1\150\1\157\1\151\1\145\1\146\1\151\1\163\11\uffff\1\145\1\162\1\141\1\174\1\72\1\60\1\145\1\uffff\1\114\1\46\1\56\1\101\1\uffff\2\0\22\uffff\1\154\1\163\1\uffff\1\154\1\162\1\157\1\151\1\143\1\151\1\163\1\164\1\155\1\167\1\154\1\162\1\143\1\156\1\165\1\145\1\160\1\154\1\163\1\164\1\152\1\160\1\60\1\164\1\60\11\uffff\1\171\1\145\1\164\1\155\1\146\6\uffff\1\164\1\uffff\1\117\2\uffff\1\56\2\uffff\1\154\1\164\2\145\1\163\1\164\1\160\1\164\1\145\1\165\1\163\1\145\1\157\1\145\1\105\1\151\1\60\1\154\1\101\1\163\1\164\1\144\1\145\1\156\1\145\1\154\1\164\1\60\2\145\1\154\1\uffff\1\150\1\uffff\1\60\1\146\3\141\1\60\1\102\2\145\1\60\1\143\1\151\1\102\1\145\2\143\1\162\1\164\1\156\1\162\1\60\1\170\1\156\1\uffff\1\60\1\154\1\145\1\157\3\60\1\123\1\145\1\60\1\uffff\1\156\1\143\1\162\1\151\1\60\1\uffff\1\151\1\60\1\151\1\165\1\uffff\1\101\1\143\1\170\1\uffff\2\164\1\171\1\156\1\60\1\150\1\164\3\163\1\164\1\uffff\1\151\1\147\1\uffff\1\154\1\60\1\162\3\uffff\1\145\1\143\1\uffff\1\163\2\164\1\145\1\uffff\1\170\1\uffff\1\156\1\154\1\114\2\164\1\60\1\151\1\60\1\147\1\146\1\uffff\2\60\1\151\1\60\1\151\1\60\1\163\2\60\1\uffff\1\171\1\154\1\164\1\151\2\60\1\163\1\60\1\163\1\164\1\126\2\60\1\151\1\uffff\1\166\1\uffff\2\60\2\uffff\1\166\1\uffff\1\157\1\uffff\1\164\2\uffff\1\60\1\145\1\151\1\164\2\uffff\1\60\1\uffff\2\60\1\101\2\uffff\1\162\1\145\2\uffff\1\145\1\156\1\163\1\uffff\1\143\1\157\1\151\3\uffff\1\122\1\163\4\60\1\164\1\156\1\166\1\60\1\164\4\uffff\2\60\1\145\1\uffff\1\60\2\uffff\1\60\2\uffff"; - static final String DFA14_maxS = - "\1\uffff\2\75\1\76\1\75\1\uffff\1\76\1\uffff\1\57\1\157\1\167\1\145\1\170\1\165\1\157\1\171\1\157\1\151\1\145\1\156\1\151\1\163\11\uffff\1\145\1\162\1\157\1\174\1\72\1\71\1\145\1\uffff\1\114\1\46\1\71\1\172\1\uffff\2\uffff\22\uffff\1\156\1\163\1\uffff\1\156\1\162\1\157\1\151\1\152\1\164\1\163\1\164\1\155\1\167\1\154\1\162\1\154\1\156\1\165\1\145\1\160\1\154\1\163\1\164\1\163\1\160\1\172\1\164\1\172\11\uffff\1\171\1\145\1\164\1\155\1\146\6\uffff\1\164\1\uffff\1\117\2\uffff\1\71\2\uffff\1\154\1\164\2\145\1\163\1\164\1\160\1\164\1\145\1\165\1\163\1\145\1\157\1\145\1\105\1\151\1\172\1\154\1\101\1\163\1\164\1\144\1\145\1\156\1\145\1\154\1\164\1\172\2\145\1\157\1\uffff\1\150\1\uffff\1\172\1\146\3\141\1\172\1\102\2\145\1\172\1\143\1\151\1\102\1\151\2\143\1\162\1\164\1\156\1\162\1\172\1\170\1\156\1\uffff\1\172\1\154\1\145\1\157\3\172\1\123\1\145\1\172\1\uffff\1\156\1\143\1\162\1\151\1\172\1\uffff\1\151\1\172\1\151\1\165\1\uffff\1\101\1\143\1\170\1\uffff\2\164\1\171\1\156\1\172\1\150\1\164\3\163\1\164\1\uffff\1\151\1\147\1\uffff\1\154\1\172\1\162\3\uffff\1\145\1\143\1\uffff\1\163\2\164\1\145\1\uffff\1\170\1\uffff\1\156\1\154\1\114\2\164\1\172\1\151\1\172\1\147\1\146\1\uffff\2\172\1\151\1\172\1\151\1\172\1\163\2\172\1\uffff\1\171\1\154\1\164\1\151\2\172\1\163\1\172\1\163\1\164\1\126\2\172\1\151\1\uffff\1\166\1\uffff\2\172\2\uffff\1\166\1\uffff\1\157\1\uffff\1\164\2\uffff\1\172\1\145\1\151\1\164\2\uffff\1\172\1\uffff\2\172\1\101\2\uffff\1\162\1\145\2\uffff\1\145\1\156\1\163\1\uffff\1\143\1\157\1\151\3\uffff\1\122\1\163\4\172\1\164\1\156\1\166\1\172\1\164\4\uffff\2\172\1\145\1\uffff\1\172\2\uffff\1\172\2\uffff"; - static final String DFA14_acceptS = - "\5\uffff\1\7\1\uffff\1\11\16\uffff\1\42\1\43\1\46\1\50\1\51\1\52\1\55\1\56\1\61\7\uffff\1\75\4\uffff\1\115\2\uffff\1\122\1\123\1\1\1\45\1\2\1\13\1\3\1\54\1\5\1\4\1\6\1\7\1\74\1\10\1\11\1\120\1\121\1\12\2\uffff\1\115\31\uffff\1\42\1\43\1\46\1\50\1\51\1\52\1\55\1\56\1\61\5\uffff\1\107\1\67\1\70\1\73\1\71\1\114\1\uffff\1\75\1\uffff\1\110\1\116\1\uffff\1\117\1\122\37\uffff\1\76\1\uffff\1\36\27\uffff\1\104\12\uffff\1\30\5\uffff\1\63\4\uffff\1\72\3\uffff\1\44\13\uffff\1\100\2\uffff\1\113\3\uffff\1\62\1\24\1\77\2\uffff\1\27\4\uffff\1\34\1\uffff\1\65\12\uffff\1\47\11\uffff\1\25\16\uffff\1\15\1\uffff\1\22\2\uffff\1\101\1\17\1\uffff\1\20\1\uffff\1\106\1\uffff\1\41\1\23\4\uffff\1\40\1\35\1\uffff\1\64\3\uffff\1\14\1\53\2\uffff\1\33\1\60\3\uffff\1\57\3\uffff\1\111\1\66\1\102\13\uffff\1\31\1\105\1\37\1\21\3\uffff\1\103\1\uffff\1\112\1\26\1\uffff\1\16\1\32"; - static final String DFA14_specialS = - "\1\1\53\uffff\1\0\1\2\u0122\uffff}>"; - static final String[] DFA14_transitionS = { - "\11\57\2\56\2\57\1\56\22\57\1\56\1\2\1\54\1\33\2\57\1\50\1\55\1\31\1\32\1\7\1\5\1\36\1\6\1\44\1\10\12\51\1\43\1\30\1\4\1\1\1\3\1\46\1\57\2\53\1\20\3\53\1\47\4\53\1\21\6\53\1\22\7\53\1\34\1\57\1\35\1\52\1\53\1\57\1\25\1\53\1\11\1\41\1\14\1\16\2\53\1\23\1\53\1\37\1\45\1\53\1\15\1\53\1\40\1\53\1\13\1\12\1\17\2\53\1\24\3\53\1\26\1\42\1\27\uff82\57", - "\1\60", - "\1\62", - "\1\64\1\65", - "\1\67", - "", + protected DFA23 dfa23 = new DFA23(this); + static final String DFA23_eotS = + "\1\uffff\1\65\1\67\1\71\1\73\1\76\1\101\1\104\1\110\1\113\1\117\12\122\1\153\1\155\1\161\4\122\11\uffff\3\122\1\u0088\2\122\2\u008d\1\62\5\uffff\1\u0093\6\uffff\1\u0095\25\uffff\2\122\1\uffff\27\122\2\uffff\1\u00ba\5\uffff\3\122\1\u00c0\2\122\1\u00c3\11\uffff\3\122\1\u00c8\1\122\2\uffff\2\122\1\uffff\1\u008d\2\uffff\1\u008d\6\uffff\25\122\1\u00e1\1\122\1\u00e4\4\122\1\u00ea\5\122\1\u00f0\2\uffff\1\u00f1\1\u00f2\3\122\1\uffff\2\122\1\uffff\1\u00fa\3\122\1\uffff\1\122\1\u00ff\3\122\1\u0103\17\122\1\u0114\2\122\1\uffff\1\u0117\1\122\1\uffff\2\122\1\u011b\1\122\1\u011d\1\uffff\1\u011e\3\122\1\u0123\3\uffff\5\122\1\u0129\1\122\1\uffff\1\122\1\u012c\2\122\1\uffff\3\122\1\uffff\1\u0132\4\122\1\u0137\1\122\1\u013a\10\122\1\uffff\2\122\1\uffff\1\122\1\u0147\1\122\1\uffff\1\122\2\uffff\1\u014a\3\122\1\uffff\5\122\1\uffff\1\u0153\1\122\1\uffff\5\122\1\uffff\1\u015b\1\122\1\u015d\1\u015e\1\uffff\2\122\1\uffff\1\u0161\1\122\1\u0163\1\u0164\1\122\1\u0166\2\122\1\u0169\1\122\1\u016b\1\u016c\1\uffff\2\122\1\uffff\1\u016f\2\122\1\u0172\3\122\1\u0176\1\uffff\1\u0177\3\122\1\u017b\1\u017c\1\122\1\uffff\1\122\2\uffff\1\u017f\1\u0180\1\uffff\1\122\2\uffff\1\122\1\uffff\1\u0183\1\122\1\uffff\1\122\2\uffff\1\u0186\1\u0187\1\uffff\2\122\1\uffff\1\u018a\2\122\2\uffff\1\u018d\1\u018e\1\122\2\uffff\2\122\2\uffff\2\122\1\uffff\2\122\2\uffff\2\122\1\uffff\2\122\2\uffff\2\122\1\u019c\1\122\1\u019e\1\u019f\1\u01a0\4\122\1\u01a5\1\122\1\uffff\1\122\3\uffff\1\u01a8\1\u01a9\1\122\1\u01ab\1\uffff\1\u01ac\1\122\2\uffff\1\u01ae\2\uffff\1\u01af\2\uffff"; + static final String DFA23_eofS = + "\u01b0\uffff"; + static final String DFA23_minS = + "\1\0\1\75\1\174\1\46\3\75\1\53\1\55\2\52\1\141\1\143\1\145\1\154\2\141\1\150\1\157\1\151\1\145\1\75\2\56\1\141\1\146\1\150\1\163\11\uffff\1\145\1\162\1\141\1\72\1\145\1\114\2\56\1\44\5\uffff\1\75\6\uffff\1\75\25\uffff\1\154\1\163\1\uffff\1\154\1\162\1\141\1\160\1\157\1\151\1\156\1\143\1\151\1\163\1\164\1\155\1\167\1\154\1\162\1\143\1\156\1\165\1\145\1\160\1\154\1\163\1\164\2\uffff\1\74\5\uffff\1\154\1\160\1\152\1\44\1\164\1\151\1\44\11\uffff\1\171\1\145\1\164\1\44\1\146\2\uffff\1\164\1\117\1\uffff\1\56\2\uffff\1\60\6\uffff\1\154\1\164\1\145\1\143\1\145\1\163\2\164\1\145\1\160\1\164\1\143\1\145\2\165\1\163\1\145\1\157\1\145\1\105\1\151\1\44\1\154\1\44\1\163\1\164\1\141\1\145\1\44\1\156\1\157\1\145\1\154\1\164\1\44\2\uffff\2\44\1\154\2\145\1\uffff\1\150\1\154\1\uffff\1\44\1\146\2\141\1\uffff\1\141\1\44\1\102\2\145\1\44\1\150\1\143\1\151\1\102\1\151\1\162\1\145\1\143\1\150\1\143\2\162\1\164\1\156\1\162\1\44\1\170\1\156\1\uffff\1\44\1\154\1\uffff\1\145\1\157\1\44\1\154\1\44\1\uffff\1\44\1\167\1\123\1\145\1\44\3\uffff\1\162\1\151\1\156\1\141\1\143\1\44\1\145\1\uffff\1\151\1\44\1\151\1\165\1\uffff\1\101\1\143\1\170\1\uffff\1\44\2\164\1\171\1\143\1\44\1\156\1\44\1\150\1\162\1\164\1\156\2\163\1\144\1\164\1\uffff\1\151\1\147\1\uffff\1\154\1\44\1\162\1\uffff\1\154\2\uffff\1\44\1\146\1\145\1\143\1\uffff\1\164\1\145\1\163\1\156\1\164\1\uffff\1\44\1\170\1\uffff\1\156\1\154\1\114\2\164\1\uffff\1\44\1\151\2\44\1\uffff\1\147\1\146\1\uffff\1\44\1\157\2\44\1\151\1\44\1\163\1\151\1\44\1\163\2\44\1\uffff\2\171\1\uffff\1\44\1\154\1\164\1\44\1\163\1\151\1\143\1\44\1\uffff\1\44\1\163\1\164\1\126\2\44\1\151\1\uffff\1\166\2\uffff\2\44\1\uffff\1\156\2\uffff\1\166\1\uffff\1\44\1\157\1\uffff\1\164\2\uffff\2\44\1\uffff\1\145\1\151\1\uffff\1\44\1\164\1\145\2\uffff\2\44\1\101\2\uffff\1\162\1\145\2\uffff\1\151\1\145\1\uffff\1\156\1\163\2\uffff\1\143\1\157\1\uffff\1\151\1\157\2\uffff\1\122\1\163\1\44\1\172\3\44\1\164\1\156\1\166\1\146\1\44\1\164\1\uffff\1\145\3\uffff\2\44\1\145\1\44\1\uffff\1\44\1\144\2\uffff\1\44\2\uffff\1\44\2\uffff"; + static final String DFA23_maxS = + "\1\uffff\1\76\1\174\1\46\1\75\2\76\1\75\1\76\2\75\1\157\1\171\1\145\1\170\1\165\1\157\1\171\1\157\1\151\1\145\1\75\1\71\1\72\1\141\1\156\1\151\1\163\11\uffff\1\145\1\162\1\157\1\72\1\145\1\114\1\170\1\154\1\172\5\uffff\1\75\6\uffff\1\75\25\uffff\1\156\1\164\1\uffff\1\156\1\162\1\141\1\160\1\157\1\151\1\156\2\164\1\163\1\164\1\155\1\167\1\154\1\162\1\154\1\156\1\171\1\162\1\160\1\154\1\163\1\164\2\uffff\1\74\5\uffff\1\162\1\160\1\163\1\172\1\164\1\151\1\172\11\uffff\1\171\1\145\1\164\1\172\1\146\2\uffff\1\164\1\117\1\uffff\1\154\2\uffff\1\154\6\uffff\1\154\1\164\1\145\1\143\1\145\1\163\2\164\1\145\1\160\1\164\1\143\1\145\2\165\1\163\1\145\1\157\1\145\1\105\1\151\1\172\1\154\1\172\1\163\1\164\1\144\1\145\1\172\1\156\1\157\1\145\1\154\1\164\1\172\2\uffff\2\172\1\157\1\164\1\145\1\uffff\1\150\1\154\1\uffff\1\172\1\146\2\141\1\uffff\1\141\1\172\1\102\2\145\1\172\1\150\1\143\1\151\1\102\1\151\1\162\1\151\1\143\1\150\1\143\2\162\1\164\1\156\1\162\1\172\1\170\1\156\1\uffff\1\172\1\154\1\uffff\1\145\1\157\1\172\1\154\1\172\1\uffff\1\172\1\167\1\157\1\145\1\172\3\uffff\1\162\1\151\1\156\1\141\1\143\1\172\1\145\1\uffff\1\151\1\172\1\151\1\165\1\uffff\1\101\1\143\1\170\1\uffff\1\172\2\164\1\171\1\143\1\172\1\156\1\172\1\150\1\162\1\164\1\156\3\163\1\164\1\uffff\1\151\1\147\1\uffff\1\154\1\172\1\162\1\uffff\1\154\2\uffff\1\172\1\146\1\145\1\143\1\uffff\1\164\1\145\1\163\1\156\1\164\1\uffff\1\172\1\170\1\uffff\1\156\1\154\1\114\2\164\1\uffff\1\172\1\151\2\172\1\uffff\1\147\1\146\1\uffff\1\172\1\157\2\172\1\151\1\172\1\163\1\151\1\172\1\163\2\172\1\uffff\2\171\1\uffff\1\172\1\154\1\164\1\172\1\163\1\151\1\143\1\172\1\uffff\1\172\1\163\1\164\1\126\2\172\1\151\1\uffff\1\166\2\uffff\2\172\1\uffff\1\156\2\uffff\1\166\1\uffff\1\172\1\157\1\uffff\1\164\2\uffff\2\172\1\uffff\1\145\1\151\1\uffff\1\172\1\164\1\145\2\uffff\2\172\1\101\2\uffff\1\162\1\145\2\uffff\1\151\1\145\1\uffff\1\156\1\163\2\uffff\1\143\1\157\1\uffff\1\151\1\157\2\uffff\1\122\1\163\5\172\1\164\1\156\1\166\1\146\1\172\1\164\1\uffff\1\145\3\uffff\2\172\1\145\1\172\1\uffff\1\172\1\144\2\uffff\1\172\2\uffff\1\172\2\uffff"; + static final String DFA23_acceptS = + "\34\uffff\1\73\1\74\1\76\1\100\1\101\1\102\1\105\1\106\1\111\11\uffff\1\162\2\163\1\166\1\167\1\uffff\1\46\1\1\1\2\1\117\1\3\1\147\1\uffff\1\16\1\6\1\104\1\10\1\7\1\47\1\11\1\34\1\53\1\12\1\35\1\43\1\54\1\13\1\36\1\51\1\14\1\37\1\164\1\165\1\15\2\uffff\1\162\27\uffff\1\40\1\52\1\uffff\1\55\1\156\1\50\1\154\1\123\7\uffff\1\73\1\74\1\76\1\100\1\101\1\102\1\105\1\106\1\111\5\uffff\1\120\1\122\2\uffff\1\157\1\uffff\1\160\1\161\1\uffff\1\163\1\166\1\41\1\4\1\42\1\5\43\uffff\1\44\1\45\5\uffff\1\124\2\uffff\1\70\4\uffff\1\136\30\uffff\1\132\2\uffff\1\134\5\uffff\1\143\5\uffff\1\33\1\56\1\155\7\uffff\1\113\4\uffff\1\121\3\uffff\1\75\20\uffff\1\126\2\uffff\1\137\3\uffff\1\112\1\uffff\1\27\1\125\4\uffff\1\32\5\uffff\1\67\2\uffff\1\115\5\uffff\1\146\4\uffff\1\63\2\uffff\1\77\14\uffff\1\30\2\uffff\1\141\10\uffff\1\135\7\uffff\1\20\1\uffff\1\25\1\60\2\uffff\1\127\1\uffff\1\22\1\142\1\uffff\1\23\2\uffff\1\151\1\uffff\1\72\1\26\2\uffff\1\140\2\uffff\1\61\3\uffff\1\71\1\114\3\uffff\1\17\1\103\2\uffff\1\66\1\110\2\uffff\1\57\2\uffff\1\107\1\144\2\uffff\1\152\2\uffff\1\116\1\130\15\uffff\1\64\1\uffff\1\150\1\62\1\24\4\uffff\1\131\2\uffff\1\153\1\31\1\uffff\1\133\1\21\1\uffff\1\65\1\145"; + static final String DFA23_specialS = + "\1\0\u01af\uffff}>"; + static final String[] DFA23_transitionS = { + "\11\62\2\61\2\62\1\61\22\62\1\61\1\4\1\57\1\41\1\56\1\25\1\3\1\60\1\37\1\40\1\11\1\7\1\44\1\10\1\26\1\12\1\53\11\54\1\50\1\36\1\6\1\1\1\5\1\27\1\62\2\56\1\22\3\56\1\52\4\56\1\23\6\56\1\24\7\56\1\42\1\62\1\43\1\55\1\56\1\62\1\33\1\56\1\13\1\47\1\16\1\20\2\56\1\31\1\56\1\45\1\51\1\56\1\17\1\56\1\46\1\56\1\15\1\14\1\21\1\56\1\30\1\32\3\56\1\34\1\2\1\35\uff82\62", + "\1\63\1\64", + "\1\66", + "\1\70", "\1\72", - "", - "\1\75\4\uffff\1\76", - "\1\101\15\uffff\1\100", - "\1\105\1\uffff\1\103\11\uffff\1\104\7\uffff\1\106", - "\1\107", - "\1\111\13\uffff\1\110", - "\1\113\3\uffff\1\114\11\uffff\1\112\5\uffff\1\115", - "\1\117\7\uffff\1\120\5\uffff\1\116", - "\1\122\11\uffff\1\121\6\uffff\1\123", - "\1\124", - "\1\125", - "\1\126", - "\1\131\6\uffff\1\130\1\127", + "\1\74\1\75", + "\1\77\1\100", + "\1\103\21\uffff\1\102", + "\1\107\17\uffff\1\105\1\106", + "\1\112\22\uffff\1\111", + "\1\115\4\uffff\1\116\15\uffff\1\114", + "\1\121\15\uffff\1\120", + "\1\127\1\uffff\1\123\11\uffff\1\124\4\uffff\1\125\1\126\1\uffff\1\130\1\uffff\1\131", "\1\132", - "\1\133", - "", - "", - "", + "\1\134\13\uffff\1\133", + "\1\136\3\uffff\1\137\11\uffff\1\135\5\uffff\1\140", + "\1\142\7\uffff\1\143\5\uffff\1\141", + "\1\145\11\uffff\1\144\6\uffff\1\146", + "\1\147", + "\1\150", + "\1\151", + "\1\152", + "\1\154\1\uffff\12\156", + "\1\160\13\uffff\1\157", + "\1\162", + "\1\165\6\uffff\1\163\1\164", + "\1\167\1\166", + "\1\170", "", "", "", "", "", "", - "\1\145", - "\1\146", - "\1\147\3\uffff\1\151\11\uffff\1\150", - "\1\152", - "\1\154", - "\12\157", - "\1\160", "", - "\1\162", - "\1\163", - "\1\157\1\uffff\12\165", - "\32\102\4\uffff\1\102\1\uffff\32\102", "", - "\0\166", - "\0\166", "", + "\1\u0082", + "\1\u0083", + "\1\u0084\3\uffff\1\u0086\11\uffff\1\u0085", + "\1\u0087", + "\1\u0089", + "\1\u008a", + "\1\156\1\uffff\12\u008c\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\13\uffff\1\u008b\6\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\13\uffff\1\u008b", + "\1\156\1\uffff\12\u008c\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\22\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e", + "\1\122\34\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "", "", "", "", "", + "\1\u0092", "", "", "", "", "", "", + "\1\u0094", "", "", "", "", "", "", - "\1\170\1\uffff\1\171", - "\1\172", "", - "\1\173\1\uffff\1\174", - "\1\175", - "\1\176", - "\1\177", - "\1\u0081\6\uffff\1\u0080", - "\1\u0082\6\uffff\1\u0084\3\uffff\1\u0083", - "\1\u0085", - "\1\u0086", - "\1\u0087", - "\1\u0088", - "\1\u0089", - "\1\u008a", - "\1\u008c\10\uffff\1\u008b", - "\1\u008d", - "\1\u008e", - "\1\u008f", - "\1\u0090", - "\1\u0091", - "\1\u0092", - "\1\u0093", - "\1\u0095\10\uffff\1\u0094", - "\1\u0096", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u0098", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", "", "", "", @@ -2939,402 +4257,510 @@ public void mTokens() throws RecognitionException { "", "", "", - "\1\u009a", - "\1\u009b", - "\1\u009c", - "\1\u009d", - "\1\u009e", "", "", "", "", "", + "\1\u0096\1\uffff\1\u0097", + "\1\u0098\1\u0099", "", + "\1\u009a\1\uffff\1\u009b", + "\1\u009c", + "\1\u009d", + "\1\u009e", "\1\u009f", - "", "\1\u00a0", - "", - "", - "\1\157\1\uffff\12\165", - "", - "", "\1\u00a1", - "\1\u00a2", - "\1\u00a3", - "\1\u00a4", - "\1\u00a5", - "\1\u00a6", - "\1\u00a7", + "\1\u00a4\6\uffff\1\u00a2\11\uffff\1\u00a3", + "\1\u00a5\6\uffff\1\u00a7\3\uffff\1\u00a6", "\1\u00a8", "\1\u00a9", "\1\u00aa", "\1\u00ab", "\1\u00ac", "\1\u00ad", - "\1\u00ae", - "\1\u00af", + "\1\u00af\10\uffff\1\u00ae", "\1\u00b0", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u00b2", - "\1\u00b3", - "\1\u00b4", + "\1\u00b1\3\uffff\1\u00b2", + "\1\u00b3\14\uffff\1\u00b4", "\1\u00b5", "\1\u00b6", "\1\u00b7", "\1\u00b8", + "", + "", "\1\u00b9", - "\1\u00ba", - "\1\u00bb", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u00bd", - "\1\u00be", - "\1\u00c0\2\uffff\1\u00bf", "", + "", + "", + "", + "", + "\1\u00bb\5\uffff\1\u00bc", + "\1\u00bd", + "\1\u00bf\10\uffff\1\u00be", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u00c1", + "\1\u00c2", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "", + "", + "", + "", + "", + "", + "", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u00c3", "\1\u00c4", "\1\u00c5", "\1\u00c6", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u00c8", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\14\122\1\u00c7\15\122", "\1\u00c9", + "", + "", "\1\u00ca", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u00cb", + "", + "\1\156\1\uffff\12\u008c\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\22\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e", + "", + "", + "\12\u008f\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\22\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e", + "", + "", + "", + "", + "", + "", "\1\u00cc", "\1\u00cd", "\1\u00ce", - "\1\u00d0\3\uffff\1\u00cf", + "\1\u00cf", + "\1\u00d0", "\1\u00d1", "\1\u00d2", "\1\u00d3", "\1\u00d4", "\1\u00d5", "\1\u00d6", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u00d7", "\1\u00d8", "\1\u00d9", - "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u00da", "\1\u00db", "\1\u00dc", "\1\u00dd", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u00e1", + "\1\u00de", + "\1\u00df", + "\1\u00e0", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u00e2", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "", - "\1\u00e4", + "\1\122\13\uffff\12\122\7\uffff\1\u00e3\31\122\4\uffff\1\122\1\uffff\32\122", "\1\u00e5", "\1\u00e6", - "\1\u00e7", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "", + "\1\u00e8\2\uffff\1\u00e7", "\1\u00e9", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u00eb", "\1\u00ec", - "", "\1\u00ed", "\1\u00ee", "\1\u00ef", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", "", - "\1\u00f0", - "\1\u00f1", - "\1\u00f2", - "\1\u00f3", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\16\102\1\u00f4\13\102", - "\1\u00f6", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u00f4\2\uffff\1\u00f3", + "\1\u00f5\16\uffff\1\u00f6", "\1\u00f7", + "", "\1\u00f8", "\1\u00f9", - "\1\u00fa", - "\1\u00fb", "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u00fb", "\1\u00fc", "\1\u00fd", "", "\1\u00fe", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u0100", - "", - "", - "", "\1\u0101", "\1\u0102", - "", - "\1\u0103", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u0104", "\1\u0105", "\1\u0106", - "", "\1\u0107", - "", "\1\u0108", "\1\u0109", - "\1\u010a", - "\1\u010b", + "\1\u010b\3\uffff\1\u010a", "\1\u010c", - "\12\102\7\uffff\5\102\1\u010d\24\102\4\uffff\1\102\1\uffff\32\102", + "\1\u010d", + "\1\u010e", "\1\u010f", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0110", "\1\u0111", "\1\u0112", - "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0113", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u0115", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u0117", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u0119", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0116", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0118", "", + "\1\u0119", + "\1\u011a", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u011c", - "\1\u011d", - "\1\u011e", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u011f", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0121\33\uffff\1\u0120", "\1\u0122", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "", + "", "\1\u0124", "\1\u0125", "\1\u0126", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u0129", - "", + "\1\u0127", + "\1\u0128", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u012a", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "", - "", + "\1\u012b", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u012d", - "", "\1\u012e", "", "\1\u012f", - "", - "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0130", "\1\u0131", - "\1\u0132", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "\1\u0133", + "\1\u0134", + "\1\u0135", + "\1\u0136", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0138", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\16\122\1\u0139\13\122", + "\1\u013b", + "\1\u013c", + "\1\u013d", + "\1\u013e", + "\1\u013f", + "\1\u0140", + "\1\u0141\16\uffff\1\u0142", + "\1\u0143", "", + "\1\u0144", + "\1\u0145", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0146", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0148", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u0137", + "\1\u0149", "", "", - "\1\u0138", - "\1\u0139", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u014b", + "\1\u014c", + "\1\u014d", "", + "\1\u014e", + "\1\u014f", + "\1\u0150", + "\1\u0151", + "\1\u0152", "", - "\1\u013a", - "\1\u013b", - "\1\u013c", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0154", "", - "\1\u013d", - "\1\u013e", - "\1\u013f", + "\1\u0155", + "\1\u0156", + "\1\u0157", + "\1\u0158", + "\1\u0159", "", + "\1\122\13\uffff\12\122\7\uffff\5\122\1\u015a\24\122\4\uffff\1\122\1\uffff\32\122", + "\1\u015c", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "", + "\1\u015f", + "\1\u0160", "", - "\1\u0140", - "\1\u0141", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u0146", - "\1\u0147", - "\1\u0148", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u014a", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0162", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0165", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0167", + "\1\u0168", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u016a", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "", + "\1\u016d", + "\1\u016e", "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0170", + "\1\u0171", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0173", + "\1\u0174", + "\1\u0175", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0178", + "\1\u0179", + "\1\u017a", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u017d", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", - "\1\u014d", + "\1\u017e", + "", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "\1\u0181", + "", + "", + "\1\u0182", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u0184", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\u0185", "", "", - "\12\102\7\uffff\32\102\4\uffff\1\102\1\uffff\32\102", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "\1\u0188", + "\1\u0189", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u018b", + "\1\u018c", + "", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u018f", + "", + "", + "\1\u0190", + "\1\u0191", + "", + "", + "\1\u0192", + "\1\u0193", + "", + "\1\u0194", + "\1\u0195", + "", + "", + "\1\u0196", + "\1\u0197", + "", + "\1\u0198", + "\1\u0199", + "", + "", + "\1\u019a", + "\1\u019b", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u019d", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u01a1", + "\1\u01a2", + "\1\u01a3", + "\1\u01a4", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u01a6", + "", + "\1\u01a7", + "", + "", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u01aa", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "\1\u01ad", + "", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", + "", + "", + "\1\122\13\uffff\12\122\7\uffff\32\122\4\uffff\1\122\1\uffff\32\122", "", "" }; - static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); - static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); - static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); - static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); - static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); - static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); - static final short[][] DFA14_transition; + static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); + static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); + static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); + static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); + static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); + static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); + static final short[][] DFA23_transition; static { - int numStates = DFA14_transitionS.length; - DFA14_transition = new short[numStates][]; + int numStates = DFA23_transitionS.length; + DFA23_transition = new short[numStates][]; for (int i=0; i='\u0000' && LA14_44<='\uFFFF')) ) {s = 118;} - - else s = 47; - - if ( s>=0 ) return s; - break; - case 1 : - int LA14_0 = input.LA(1); + int LA23_0 = input.LA(1); s = -1; - if ( (LA14_0=='=') ) {s = 1;} + if ( (LA23_0=='=') ) {s = 1;} - else if ( (LA14_0=='!') ) {s = 2;} + else if ( (LA23_0=='|') ) {s = 2;} - else if ( (LA14_0=='>') ) {s = 3;} + else if ( (LA23_0=='&') ) {s = 3;} - else if ( (LA14_0=='<') ) {s = 4;} + else if ( (LA23_0=='!') ) {s = 4;} - else if ( (LA14_0=='+') ) {s = 5;} + else if ( (LA23_0=='>') ) {s = 5;} - else if ( (LA14_0=='-') ) {s = 6;} + else if ( (LA23_0=='<') ) {s = 6;} - else if ( (LA14_0=='*') ) {s = 7;} + else if ( (LA23_0=='+') ) {s = 7;} - else if ( (LA14_0=='/') ) {s = 8;} + else if ( (LA23_0=='-') ) {s = 8;} - else if ( (LA14_0=='c') ) {s = 9;} + else if ( (LA23_0=='*') ) {s = 9;} - else if ( (LA14_0=='s') ) {s = 10;} + else if ( (LA23_0=='/') ) {s = 10;} - else if ( (LA14_0=='r') ) {s = 11;} + else if ( (LA23_0=='c') ) {s = 11;} - else if ( (LA14_0=='e') ) {s = 12;} + else if ( (LA23_0=='s') ) {s = 12;} - else if ( (LA14_0=='n') ) {s = 13;} + else if ( (LA23_0=='r') ) {s = 13;} - else if ( (LA14_0=='f') ) {s = 14;} + else if ( (LA23_0=='e') ) {s = 14;} - else if ( (LA14_0=='t') ) {s = 15;} + else if ( (LA23_0=='n') ) {s = 15;} - else if ( (LA14_0=='C') ) {s = 16;} + else if ( (LA23_0=='f') ) {s = 16;} - else if ( (LA14_0=='L') ) {s = 17;} + else if ( (LA23_0=='t') ) {s = 17;} - else if ( (LA14_0=='S') ) {s = 18;} + else if ( (LA23_0=='C') ) {s = 18;} - else if ( (LA14_0=='i') ) {s = 19;} + else if ( (LA23_0=='L') ) {s = 19;} - else if ( (LA14_0=='w') ) {s = 20;} + else if ( (LA23_0=='S') ) {s = 20;} - else if ( (LA14_0=='a') ) {s = 21;} + else if ( (LA23_0=='%') ) {s = 21;} - else if ( (LA14_0=='{') ) {s = 22;} + else if ( (LA23_0=='.') ) {s = 22;} - else if ( (LA14_0=='}') ) {s = 23;} + else if ( (LA23_0=='?') ) {s = 23;} - else if ( (LA14_0==';') ) {s = 24;} + else if ( (LA23_0=='v') ) {s = 24;} - else if ( (LA14_0=='(') ) {s = 25;} + else if ( (LA23_0=='i') ) {s = 25;} - else if ( (LA14_0==')') ) {s = 26;} + else if ( (LA23_0=='w') ) {s = 26;} - else if ( (LA14_0=='#') ) {s = 27;} + else if ( (LA23_0=='a') ) {s = 27;} - else if ( (LA14_0=='[') ) {s = 28;} + else if ( (LA23_0=='{') ) {s = 28;} - else if ( (LA14_0==']') ) {s = 29;} + else if ( (LA23_0=='}') ) {s = 29;} - else if ( (LA14_0==',') ) {s = 30;} + else if ( (LA23_0==';') ) {s = 30;} - else if ( (LA14_0=='k') ) {s = 31;} + else if ( (LA23_0=='(') ) {s = 31;} - else if ( (LA14_0=='p') ) {s = 32;} + else if ( (LA23_0==')') ) {s = 32;} - else if ( (LA14_0=='d') ) {s = 33;} + else if ( (LA23_0=='#') ) {s = 33;} - else if ( (LA14_0=='|') ) {s = 34;} + else if ( (LA23_0=='[') ) {s = 34;} - else if ( (LA14_0==':') ) {s = 35;} + else if ( (LA23_0==']') ) {s = 35;} - else if ( (LA14_0=='.') ) {s = 36;} + else if ( (LA23_0==',') ) {s = 36;} - else if ( (LA14_0=='l') ) {s = 37;} + else if ( (LA23_0=='k') ) {s = 37;} - else if ( (LA14_0=='?') ) {s = 38;} + else if ( (LA23_0=='p') ) {s = 38;} - else if ( (LA14_0=='G') ) {s = 39;} + else if ( (LA23_0=='d') ) {s = 39;} - else if ( (LA14_0=='&') ) {s = 40;} + else if ( (LA23_0==':') ) {s = 40;} - else if ( ((LA14_0>='0' && LA14_0<='9')) ) {s = 41;} + else if ( (LA23_0=='l') ) {s = 41;} - else if ( (LA14_0=='^') ) {s = 42;} + else if ( (LA23_0=='G') ) {s = 42;} - else if ( ((LA14_0>='A' && LA14_0<='B')||(LA14_0>='D' && LA14_0<='F')||(LA14_0>='H' && LA14_0<='K')||(LA14_0>='M' && LA14_0<='R')||(LA14_0>='T' && LA14_0<='Z')||LA14_0=='_'||LA14_0=='b'||(LA14_0>='g' && LA14_0<='h')||LA14_0=='j'||LA14_0=='m'||LA14_0=='o'||LA14_0=='q'||(LA14_0>='u' && LA14_0<='v')||(LA14_0>='x' && LA14_0<='z')) ) {s = 43;} + else if ( (LA23_0=='0') ) {s = 43;} - else if ( (LA14_0=='\"') ) {s = 44;} + else if ( ((LA23_0>='1' && LA23_0<='9')) ) {s = 44;} - else if ( (LA14_0=='\'') ) {s = 45;} + else if ( (LA23_0=='^') ) {s = 45;} - else if ( ((LA14_0>='\t' && LA14_0<='\n')||LA14_0=='\r'||LA14_0==' ') ) {s = 46;} + else if ( (LA23_0=='$'||(LA23_0>='A' && LA23_0<='B')||(LA23_0>='D' && LA23_0<='F')||(LA23_0>='H' && LA23_0<='K')||(LA23_0>='M' && LA23_0<='R')||(LA23_0>='T' && LA23_0<='Z')||LA23_0=='_'||LA23_0=='b'||(LA23_0>='g' && LA23_0<='h')||LA23_0=='j'||LA23_0=='m'||LA23_0=='o'||LA23_0=='q'||LA23_0=='u'||(LA23_0>='x' && LA23_0<='z')) ) {s = 46;} - else if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||(LA14_0>='$' && LA14_0<='%')||LA14_0=='@'||LA14_0=='\\'||LA14_0=='`'||(LA14_0>='~' && LA14_0<='\uFFFF')) ) {s = 47;} + else if ( (LA23_0=='\"') ) {s = 47;} - if ( s>=0 ) return s; - break; - case 2 : - int LA14_45 = input.LA(1); + else if ( (LA23_0=='\'') ) {s = 48;} - s = -1; - if ( ((LA14_45>='\u0000' && LA14_45<='\uFFFF')) ) {s = 118;} + else if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {s = 49;} - else s = 47; + else if ( ((LA23_0>='\u0000' && LA23_0<='\b')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\u001F')||LA23_0=='@'||LA23_0=='\\'||LA23_0=='`'||(LA23_0>='~' && LA23_0<='\uFFFF')) ) {s = 50;} if ( s>=0 ) return s; break; } NoViableAltException nvae = - new NoViableAltException(getDescription(), 14, _s, input); + new NoViableAltException(getDescription(), 23, _s, input); error(nvae); throw nvae; } diff --git a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeParser.java b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeParser.java index 5d87d59fed..33c95c1a13 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeParser.java +++ b/com.avaloq.tools.ddk.xtext.scope.ide/src-gen/com/avaloq/tools/ddk/xtext/scope/ide/contentassist/antlr/internal/InternalScopeParser.java @@ -23,21 +23,14 @@ @SuppressWarnings("all") public class InternalScopeParser extends AbstractInternalContentAssistParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_ID", "RULE_STRING", "RULE_INT", "RULE_REAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'Collection'", "'List'", "'Set'", "'sensitive'", "'insensitive'", "'scoping'", "'with'", "'import'", "'as'", "'extension'", "'inject'", "'naming'", "'{'", "'}'", "'case'", "'='", "';'", "'scope'", "'('", "')'", "'#'", "'context'", "'>>'", "'['", "']'", "'factory'", "'scopeof'", "','", "'find'", "'key'", "'prefix'", "'data'", "'domains'", "'|'", "'::'", "'.'", "'let'", "':'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'GLOBALVAR'", "'new'", "'recursive'", "'export'", "'||'", "'&&'", "'implies'", "'typeSelect'", "'null'" + "", "", "", "", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_STRING", "RULE_REAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'='", "'||'", "'&&'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'*'", "'/'", "'!'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'Collection'", "'List'", "'Set'", "'+='", "'-='", "'*='", "'/='", "'%='", "'==='", "'!=='", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'**'", "'%'", "'++'", "'--'", "'.'", "'val'", "'extends'", "'static'", "'import'", "'extension'", "'super'", "'sensitive'", "'insensitive'", "'scoping'", "'with'", "'as'", "'inject'", "'naming'", "'{'", "'}'", "'case'", "';'", "'scope'", "'('", "')'", "'#'", "'context'", "'>>'", "'['", "']'", "'factory'", "'scopeof'", "','", "'find'", "'key'", "'prefix'", "'data'", "'domains'", "'|'", "'::'", "'let'", "':'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'GLOBALVAR'", "'new'", "'instanceof'", "'for'", "'while'", "'do'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'&'", "'recursive'", "'export'", "'implies'", "'typeSelect'", "'?.'", "'var'" }; + public static final int RULE_HEX=5; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -46,56 +39,27 @@ public class InternalScopeParser extends AbstractInternalContentAssistParser { public static final int T__60=60; public static final int T__61=61; public static final int RULE_ID=4; - public static final int RULE_REAL=7; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; + public static final int RULE_REAL=9; public static final int RULE_INT=6; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=5; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int T__82=82; - public static final int T__83=83; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -103,12 +67,84 @@ public class InternalScopeParser extends AbstractInternalContentAssistParser { public static final int T__46=46; public static final int T__47=47; public static final int T__40=40; - public static final int T__84=84; public static final int T__41=41; - public static final int T__85=85; public static final int T__42=42; - public static final int T__86=86; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=7; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__122=122; + public static final int T__70=70; + public static final int T__121=121; + public static final int T__71=71; + public static final int T__72=72; + public static final int T__120=120; + public static final int RULE_STRING=8; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__119=119; + public static final int T__78=78; + public static final int T__118=118; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -5150,35 +5186,63 @@ public final void ruleIdentifier() throws RecognitionException { // $ANTLR end "ruleIdentifier" - // $ANTLR start "ruleCasing" - // InternalScope.g:1529:1: ruleCasing : ( ( rule__Casing__Alternatives ) ) ; - public final void ruleCasing() throws RecognitionException { + // $ANTLR start "entryRuleXExpression" + // InternalScope.g:1529:1: entryRuleXExpression : ruleXExpression EOF ; + public final void entryRuleXExpression() throws RecognitionException { + try { + // InternalScope.g:1530:1: ( ruleXExpression EOF ) + // InternalScope.g:1531:1: ruleXExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXExpression" + + + // $ANTLR start "ruleXExpression" + // InternalScope.g:1538:1: ruleXExpression : ( ruleXAssignment ) ; + public final void ruleXExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1533:1: ( ( ( rule__Casing__Alternatives ) ) ) - // InternalScope.g:1534:2: ( ( rule__Casing__Alternatives ) ) + // InternalScope.g:1542:2: ( ( ruleXAssignment ) ) + // InternalScope.g:1543:2: ( ruleXAssignment ) { - // InternalScope.g:1534:2: ( ( rule__Casing__Alternatives ) ) - // InternalScope.g:1535:3: ( rule__Casing__Alternatives ) + // InternalScope.g:1543:2: ( ruleXAssignment ) + // InternalScope.g:1544:3: ruleXAssignment { if ( state.backtracking==0 ) { - before(grammarAccess.getCasingAccess().getAlternatives()); + before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } - // InternalScope.g:1536:3: ( rule__Casing__Alternatives ) - // InternalScope.g:1536:4: rule__Casing__Alternatives - { pushFollow(FOLLOW_2); - rule__Casing__Alternatives(); + ruleXAssignment(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getCasingAccess().getAlternatives()); + after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); } } @@ -5198,80 +5262,79 @@ public final void ruleCasing() throws RecognitionException { } return ; } - // $ANTLR end "ruleCasing" - + // $ANTLR end "ruleXExpression" - // $ANTLR start "rule__ScopeDefinition__Alternatives_2" - // InternalScope.g:1544:1: rule__ScopeDefinition__Alternatives_2 : ( ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) | ( ( rule__ScopeDefinition__Group_2_1__0 ) ) ); - public final void rule__ScopeDefinition__Alternatives_2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXAssignment" + // InternalScope.g:1554:1: entryRuleXAssignment : ruleXAssignment EOF ; + public final void entryRuleXAssignment() throws RecognitionException { try { - // InternalScope.g:1548:1: ( ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) | ( ( rule__ScopeDefinition__Group_2_1__0 ) ) ) - int alt1=2; - alt1 = dfa1.predict(input); - switch (alt1) { - case 1 : - // InternalScope.g:1549:2: ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) - { - // InternalScope.g:1549:2: ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) - // InternalScope.g:1550:3: ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); - } - // InternalScope.g:1551:3: ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) - // InternalScope.g:1551:4: rule__ScopeDefinition__TargetTypeAssignment_2_0 - { - pushFollow(FOLLOW_2); - rule__ScopeDefinition__TargetTypeAssignment_2_0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:1555:1: ( ruleXAssignment EOF ) + // InternalScope.g:1556:1: ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_1); + ruleXAssignment(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXAssignment" - } - break; - case 2 : - // InternalScope.g:1555:2: ( ( rule__ScopeDefinition__Group_2_1__0 ) ) - { - // InternalScope.g:1555:2: ( ( rule__ScopeDefinition__Group_2_1__0 ) ) - // InternalScope.g:1556:3: ( rule__ScopeDefinition__Group_2_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); - } - // InternalScope.g:1557:3: ( rule__ScopeDefinition__Group_2_1__0 ) - // InternalScope.g:1557:4: rule__ScopeDefinition__Group_2_1__0 - { - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_2_1__0(); + // $ANTLR start "ruleXAssignment" + // InternalScope.g:1563:1: ruleXAssignment : ( ( rule__XAssignment__Alternatives ) ) ; + public final void ruleXAssignment() throws RecognitionException { - state._fsp--; - if (state.failed) return ; + int stackSize = keepStackSize(); + + try { + // InternalScope.g:1567:2: ( ( ( rule__XAssignment__Alternatives ) ) ) + // InternalScope.g:1568:2: ( ( rule__XAssignment__Alternatives ) ) + { + // InternalScope.g:1568:2: ( ( rule__XAssignment__Alternatives ) ) + // InternalScope.g:1569:3: ( rule__XAssignment__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getAlternatives()); + } + // InternalScope.g:1570:3: ( rule__XAssignment__Alternatives ) + // InternalScope.g:1570:4: rule__XAssignment__Alternatives + { + pushFollow(FOLLOW_2); + rule__XAssignment__Alternatives(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -5284,853 +5347,644 @@ public final void rule__ScopeDefinition__Alternatives_2() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Alternatives_2" - + // $ANTLR end "ruleXAssignment" - // $ANTLR start "rule__ScopeContext__Alternatives_0" - // InternalScope.g:1565:1: rule__ScopeContext__Alternatives_0 : ( ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) | ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) ); - public final void rule__ScopeContext__Alternatives_0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpSingleAssign" + // InternalScope.g:1579:1: entryRuleOpSingleAssign : ruleOpSingleAssign EOF ; + public final void entryRuleOpSingleAssign() throws RecognitionException { try { - // InternalScope.g:1569:1: ( ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) | ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) ) - int alt2=2; - int LA2_0 = input.LA(1); - - if ( (LA2_0==20) ) { - alt2=1; + // InternalScope.g:1580:1: ( ruleOpSingleAssign EOF ) + // InternalScope.g:1581:1: ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignRule()); } - else if ( (LA2_0==RULE_ID) ) { - alt2=2; + pushFollow(FOLLOW_1); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 2, 0, input); + match(input,EOF,FOLLOW_2); if (state.failed) return ; - throw nvae; } - switch (alt2) { - case 1 : - // InternalScope.g:1570:2: ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) - { - // InternalScope.g:1570:2: ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) - // InternalScope.g:1571:3: ( rule__ScopeContext__GlobalAssignment_0_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); - } - // InternalScope.g:1572:3: ( rule__ScopeContext__GlobalAssignment_0_0 ) - // InternalScope.g:1572:4: rule__ScopeContext__GlobalAssignment_0_0 - { - pushFollow(FOLLOW_2); - rule__ScopeContext__GlobalAssignment_0_0(); - state._fsp--; - if (state.failed) return ; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpSingleAssign" - } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); - } + // $ANTLR start "ruleOpSingleAssign" + // InternalScope.g:1588:1: ruleOpSingleAssign : ( '=' ) ; + public final void ruleOpSingleAssign() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalScope.g:1592:2: ( ( '=' ) ) + // InternalScope.g:1593:2: ( '=' ) + { + // InternalScope.g:1593:2: ( '=' ) + // InternalScope.g:1594:3: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } + } - } - break; - case 2 : - // InternalScope.g:1576:2: ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) - { - // InternalScope.g:1576:2: ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) - // InternalScope.g:1577:3: ( rule__ScopeContext__ContextTypeAssignment_0_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); - } - // InternalScope.g:1578:3: ( rule__ScopeContext__ContextTypeAssignment_0_1 ) - // InternalScope.g:1578:4: rule__ScopeContext__ContextTypeAssignment_0_1 - { - pushFollow(FOLLOW_2); - rule__ScopeContext__ContextTypeAssignment_0_1(); - state._fsp--; - if (state.failed) return ; + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleOpSingleAssign" - } - break; + // $ANTLR start "entryRuleOpMultiAssign" + // InternalScope.g:1604:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ; + public final void entryRuleOpMultiAssign() throws RecognitionException { + try { + // InternalScope.g:1605:1: ( ruleOpMultiAssign EOF ) + // InternalScope.g:1606:1: ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_1); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeContext__Alternatives_0" + // $ANTLR end "entryRuleOpMultiAssign" - // $ANTLR start "rule__ScopeExpression__Alternatives" - // InternalScope.g:1586:1: rule__ScopeExpression__Alternatives : ( ( ruleScopeDelegation ) | ( ruleFactoryExpression ) | ( ruleNamedScopeExpression ) ); - public final void rule__ScopeExpression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleOpMultiAssign" + // InternalScope.g:1613:1: ruleOpMultiAssign : ( ( rule__OpMultiAssign__Alternatives ) ) ; + public final void ruleOpMultiAssign() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1590:1: ( ( ruleScopeDelegation ) | ( ruleFactoryExpression ) | ( ruleNamedScopeExpression ) ) - int alt3=3; - switch ( input.LA(1) ) { - case 59: - { - alt3=1; - } - break; - case 58: - { - alt3=2; - } - break; - case RULE_ID: - case RULE_STRING: - case RULE_INT: - case RULE_REAL: - case 19: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 45: - case 51: - case 61: - case 69: - case 73: - case 76: - case 78: - case 79: - case 85: - case 86: - { - alt3=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 3, 0, input); - - throw nvae; + // InternalScope.g:1617:2: ( ( ( rule__OpMultiAssign__Alternatives ) ) ) + // InternalScope.g:1618:2: ( ( rule__OpMultiAssign__Alternatives ) ) + { + // InternalScope.g:1618:2: ( ( rule__OpMultiAssign__Alternatives ) ) + // InternalScope.g:1619:3: ( rule__OpMultiAssign__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); } + // InternalScope.g:1620:3: ( rule__OpMultiAssign__Alternatives ) + // InternalScope.g:1620:4: rule__OpMultiAssign__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Alternatives(); - switch (alt3) { - case 1 : - // InternalScope.g:1591:2: ( ruleScopeDelegation ) - { - // InternalScope.g:1591:2: ( ruleScopeDelegation ) - // InternalScope.g:1592:3: ruleScopeDelegation - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleScopeDelegation(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); + } - } - break; - case 2 : - // InternalScope.g:1597:2: ( ruleFactoryExpression ) - { - // InternalScope.g:1597:2: ( ruleFactoryExpression ) - // InternalScope.g:1598:3: ruleFactoryExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleFactoryExpression(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 3 : - // InternalScope.g:1603:2: ( ruleNamedScopeExpression ) - { - // InternalScope.g:1603:2: ( ruleNamedScopeExpression ) - // InternalScope.g:1604:3: ruleNamedScopeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleNamedScopeExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); - } + } + return ; + } + // $ANTLR end "ruleOpMultiAssign" - } + // $ANTLR start "entryRuleXOrExpression" + // InternalScope.g:1629:1: entryRuleXOrExpression : ruleXOrExpression EOF ; + public final void entryRuleXOrExpression() throws RecognitionException { + try { + // InternalScope.g:1630:1: ( ruleXOrExpression EOF ) + // InternalScope.g:1631:1: ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXOrExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeExpression__Alternatives" + // $ANTLR end "entryRuleXOrExpression" - // $ANTLR start "rule__ScopeDelegation__Alternatives_2" - // InternalScope.g:1613:1: rule__ScopeDelegation__Alternatives_2 : ( ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) | ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) ); - public final void rule__ScopeDelegation__Alternatives_2() throws RecognitionException { + // $ANTLR start "ruleXOrExpression" + // InternalScope.g:1638:1: ruleXOrExpression : ( ( rule__XOrExpression__Group__0 ) ) ; + public final void ruleXOrExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1617:1: ( ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) | ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) ) - int alt4=2; - int LA4_0 = input.LA(1); - - if ( ((LA4_0>=RULE_ID && LA4_0<=RULE_REAL)||LA4_0==19||(LA4_0>=22 && LA4_0<=35)||LA4_0==45||LA4_0==51||LA4_0==69||LA4_0==73||LA4_0==76||(LA4_0>=78 && LA4_0<=79)||(LA4_0>=85 && LA4_0<=86)) ) { - alt4=1; - } - else if ( (LA4_0==61) ) { - alt4=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 4, 0, input); - - throw nvae; + // InternalScope.g:1642:2: ( ( ( rule__XOrExpression__Group__0 ) ) ) + // InternalScope.g:1643:2: ( ( rule__XOrExpression__Group__0 ) ) + { + // InternalScope.g:1643:2: ( ( rule__XOrExpression__Group__0 ) ) + // InternalScope.g:1644:3: ( rule__XOrExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup()); } - switch (alt4) { - case 1 : - // InternalScope.g:1618:2: ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) - { - // InternalScope.g:1618:2: ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) - // InternalScope.g:1619:3: ( rule__ScopeDelegation__DelegateAssignment_2_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); - } - // InternalScope.g:1620:3: ( rule__ScopeDelegation__DelegateAssignment_2_0 ) - // InternalScope.g:1620:4: rule__ScopeDelegation__DelegateAssignment_2_0 - { - pushFollow(FOLLOW_2); - rule__ScopeDelegation__DelegateAssignment_2_0(); + // InternalScope.g:1645:3: ( rule__XOrExpression__Group__0 ) + // InternalScope.g:1645:4: rule__XOrExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup()); + } - } + } - } - break; - case 2 : - // InternalScope.g:1624:2: ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) - { - // InternalScope.g:1624:2: ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) - // InternalScope.g:1625:3: ( rule__ScopeDelegation__ExternalAssignment_2_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); - } - // InternalScope.g:1626:3: ( rule__ScopeDelegation__ExternalAssignment_2_1 ) - // InternalScope.g:1626:4: rule__ScopeDelegation__ExternalAssignment_2_1 - { - pushFollow(FOLLOW_2); - rule__ScopeDelegation__ExternalAssignment_2_1(); + } - state._fsp--; - if (state.failed) return ; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); - } + } + return ; + } + // $ANTLR end "ruleXOrExpression" - } + // $ANTLR start "entryRuleOpOr" + // InternalScope.g:1654:1: entryRuleOpOr : ruleOpOr EOF ; + public final void entryRuleOpOr() throws RecognitionException { + try { + // InternalScope.g:1655:1: ( ruleOpOr EOF ) + // InternalScope.g:1656:1: ruleOpOr EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_1); + ruleOpOr(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDelegation__Alternatives_2" + // $ANTLR end "entryRuleOpOr" - // $ANTLR start "rule__NamedScopeExpression__Alternatives_0" - // InternalScope.g:1634:1: rule__NamedScopeExpression__Alternatives_0 : ( ( ruleGlobalScopeExpression ) | ( ruleSimpleScopeExpression ) ); - public final void rule__NamedScopeExpression__Alternatives_0() throws RecognitionException { + // $ANTLR start "ruleOpOr" + // InternalScope.g:1663:1: ruleOpOr : ( '||' ) ; + public final void ruleOpOr() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1638:1: ( ( ruleGlobalScopeExpression ) | ( ruleSimpleScopeExpression ) ) - int alt5=2; - int LA5_0 = input.LA(1); - - if ( (LA5_0==61) ) { - alt5=1; + // InternalScope.g:1667:2: ( ( '||' ) ) + // InternalScope.g:1668:2: ( '||' ) + { + // InternalScope.g:1668:2: ( '||' ) + // InternalScope.g:1669:3: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } - else if ( ((LA5_0>=RULE_ID && LA5_0<=RULE_REAL)||LA5_0==19||(LA5_0>=22 && LA5_0<=35)||LA5_0==45||LA5_0==51||LA5_0==69||LA5_0==73||LA5_0==76||(LA5_0>=78 && LA5_0<=79)||(LA5_0>=85 && LA5_0<=86)) ) { - alt5=2; + match(input,15,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 5, 0, input); - throw nvae; } - switch (alt5) { - case 1 : - // InternalScope.g:1639:2: ( ruleGlobalScopeExpression ) - { - // InternalScope.g:1639:2: ( ruleGlobalScopeExpression ) - // InternalScope.g:1640:3: ruleGlobalScopeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); - } - pushFollow(FOLLOW_2); - ruleGlobalScopeExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalScope.g:1645:2: ( ruleSimpleScopeExpression ) - { - // InternalScope.g:1645:2: ( ruleSimpleScopeExpression ) - // InternalScope.g:1646:3: ruleSimpleScopeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); - } - pushFollow(FOLLOW_2); - ruleSimpleScopeExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); - } + } + return ; + } + // $ANTLR end "ruleOpOr" - } + // $ANTLR start "entryRuleXAndExpression" + // InternalScope.g:1679:1: entryRuleXAndExpression : ruleXAndExpression EOF ; + public final void entryRuleXAndExpression() throws RecognitionException { + try { + // InternalScope.g:1680:1: ( ruleXAndExpression EOF ) + // InternalScope.g:1681:1: ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXAndExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamedScopeExpression__Alternatives_0" + // $ANTLR end "entryRuleXAndExpression" - // $ANTLR start "rule__GlobalScopeExpression__Alternatives_3" - // InternalScope.g:1655:1: rule__GlobalScopeExpression__Alternatives_3 : ( ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) | ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) ); - public final void rule__GlobalScopeExpression__Alternatives_3() throws RecognitionException { + // $ANTLR start "ruleXAndExpression" + // InternalScope.g:1688:1: ruleXAndExpression : ( ( rule__XAndExpression__Group__0 ) ) ; + public final void ruleXAndExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1659:1: ( ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) | ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) ) - int alt6=2; - int LA6_0 = input.LA(1); - - if ( (LA6_0==60) ) { - int LA6_1 = input.LA(2); + // InternalScope.g:1692:2: ( ( ( rule__XAndExpression__Group__0 ) ) ) + // InternalScope.g:1693:2: ( ( rule__XAndExpression__Group__0 ) ) + { + // InternalScope.g:1693:2: ( ( rule__XAndExpression__Group__0 ) ) + // InternalScope.g:1694:3: ( rule__XAndExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup()); + } + // InternalScope.g:1695:3: ( rule__XAndExpression__Group__0 ) + // InternalScope.g:1695:4: rule__XAndExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__0(); - if ( (LA6_1==63||LA6_1==80) ) { - alt6=2; - } - else if ( (LA6_1==62) ) { - alt6=1; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 6, 1, input); + state._fsp--; + if (state.failed) return ; - throw nvae; - } } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 6, 0, input); - throw nvae; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup()); } - switch (alt6) { - case 1 : - // InternalScope.g:1660:2: ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) - { - // InternalScope.g:1660:2: ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) - // InternalScope.g:1661:3: ( rule__GlobalScopeExpression__Group_3_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); - } - // InternalScope.g:1662:3: ( rule__GlobalScopeExpression__Group_3_0__0 ) - // InternalScope.g:1662:4: rule__GlobalScopeExpression__Group_3_0__0 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_0__0(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); - } - } + } - } - break; - case 2 : - // InternalScope.g:1666:2: ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) - { - // InternalScope.g:1666:2: ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) - // InternalScope.g:1667:3: ( rule__GlobalScopeExpression__Group_3_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); - } - // InternalScope.g:1668:3: ( rule__GlobalScopeExpression__Group_3_1__0 ) - // InternalScope.g:1668:4: rule__GlobalScopeExpression__Group_3_1__0 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_1__0(); + } - state._fsp--; - if (state.failed) return ; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); - } + } + return ; + } + // $ANTLR end "ruleXAndExpression" - } + // $ANTLR start "entryRuleOpAnd" + // InternalScope.g:1704:1: entryRuleOpAnd : ruleOpAnd EOF ; + public final void entryRuleOpAnd() throws RecognitionException { + try { + // InternalScope.g:1705:1: ( ruleOpAnd EOF ) + // InternalScope.g:1706:1: ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_1); + ruleOpAnd(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Alternatives_3" + // $ANTLR end "entryRuleOpAnd" - // $ANTLR start "rule__GlobalScopeExpression__Alternatives_5_3" - // InternalScope.g:1676:1: rule__GlobalScopeExpression__Alternatives_5_3 : ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) | ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) | ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) ); - public final void rule__GlobalScopeExpression__Alternatives_5_3() throws RecognitionException { + // $ANTLR start "ruleOpAnd" + // InternalScope.g:1713:1: ruleOpAnd : ( '&&' ) ; + public final void ruleOpAnd() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1680:1: ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) | ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) | ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) ) - int alt7=3; - switch ( input.LA(1) ) { - case 20: - { - alt7=1; - } - break; - case RULE_ID: - { - alt7=2; - } - break; - case 51: - { - alt7=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 7, 0, input); - - throw nvae; + // InternalScope.g:1717:2: ( ( '&&' ) ) + // InternalScope.g:1718:2: ( '&&' ) + { + // InternalScope.g:1718:2: ( '&&' ) + // InternalScope.g:1719:3: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } + match(input,16,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); } - switch (alt7) { - case 1 : - // InternalScope.g:1681:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) - { - // InternalScope.g:1681:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) - // InternalScope.g:1682:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); - } - // InternalScope.g:1683:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) - // InternalScope.g:1683:4: rule__GlobalScopeExpression__DomainsAssignment_5_3_0 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__DomainsAssignment_5_3_0(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); - } - - } - - - } - break; - case 2 : - // InternalScope.g:1687:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) - { - // InternalScope.g:1687:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) - // InternalScope.g:1688:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); - } - // InternalScope.g:1689:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) - // InternalScope.g:1689:4: rule__GlobalScopeExpression__DomainsAssignment_5_3_1 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__DomainsAssignment_5_3_1(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); - } - - } + } - } - break; - case 3 : - // InternalScope.g:1693:2: ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) - { - // InternalScope.g:1693:2: ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) - // InternalScope.g:1694:3: ( rule__GlobalScopeExpression__Group_5_3_2__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); - } - // InternalScope.g:1695:3: ( rule__GlobalScopeExpression__Group_5_3_2__0 ) - // InternalScope.g:1695:4: rule__GlobalScopeExpression__Group_5_3_2__0 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2__0(); + } - state._fsp--; - if (state.failed) return ; + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); - } + } + return ; + } + // $ANTLR end "ruleOpAnd" - } + // $ANTLR start "entryRuleXEqualityExpression" + // InternalScope.g:1729:1: entryRuleXEqualityExpression : ruleXEqualityExpression EOF ; + public final void entryRuleXEqualityExpression() throws RecognitionException { + try { + // InternalScope.g:1730:1: ( ruleXEqualityExpression EOF ) + // InternalScope.g:1731:1: ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXEqualityExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Alternatives_5_3" + // $ANTLR end "entryRuleXEqualityExpression" - // $ANTLR start "rule__DataExpression__Alternatives" - // InternalScope.g:1703:1: rule__DataExpression__Alternatives : ( ( ruleMatchDataExpression ) | ( ruleLambdaDataExpression ) ); - public final void rule__DataExpression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXEqualityExpression" + // InternalScope.g:1738:1: ruleXEqualityExpression : ( ( rule__XEqualityExpression__Group__0 ) ) ; + public final void ruleXEqualityExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1707:1: ( ( ruleMatchDataExpression ) | ( ruleLambdaDataExpression ) ) - int alt8=2; - int LA8_0 = input.LA(1); + // InternalScope.g:1742:2: ( ( ( rule__XEqualityExpression__Group__0 ) ) ) + // InternalScope.g:1743:2: ( ( rule__XEqualityExpression__Group__0 ) ) + { + // InternalScope.g:1743:2: ( ( rule__XEqualityExpression__Group__0 ) ) + // InternalScope.g:1744:3: ( rule__XEqualityExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup()); + } + // InternalScope.g:1745:3: ( rule__XEqualityExpression__Group__0 ) + // InternalScope.g:1745:4: rule__XEqualityExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( (LA8_0==RULE_ID) ) { - alt8=1; } - else if ( (LA8_0==56) ) { - alt8=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); - throw nvae; } - switch (alt8) { - case 1 : - // InternalScope.g:1708:2: ( ruleMatchDataExpression ) - { - // InternalScope.g:1708:2: ( ruleMatchDataExpression ) - // InternalScope.g:1709:3: ruleMatchDataExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleMatchDataExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalScope.g:1714:2: ( ruleLambdaDataExpression ) - { - // InternalScope.g:1714:2: ( ruleLambdaDataExpression ) - // InternalScope.g:1715:3: ruleLambdaDataExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleLambdaDataExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); - } + } + return ; + } + // $ANTLR end "ruleXEqualityExpression" - } + // $ANTLR start "entryRuleOpEquality" + // InternalScope.g:1754:1: entryRuleOpEquality : ruleOpEquality EOF ; + public final void entryRuleOpEquality() throws RecognitionException { + try { + // InternalScope.g:1755:1: ( ruleOpEquality EOF ) + // InternalScope.g:1756:1: ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_1); + ruleOpEquality(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__DataExpression__Alternatives" + // $ANTLR end "entryRuleOpEquality" - // $ANTLR start "rule__Naming__Alternatives" - // InternalScope.g:1724:1: rule__Naming__Alternatives : ( ( ( rule__Naming__Group_0__0 ) ) | ( ( rule__Naming__NamesAssignment_1 ) ) ); - public final void rule__Naming__Alternatives() throws RecognitionException { + // $ANTLR start "ruleOpEquality" + // InternalScope.g:1763:1: ruleOpEquality : ( ( rule__OpEquality__Alternatives ) ) ; + public final void ruleOpEquality() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1728:1: ( ( ( rule__Naming__Group_0__0 ) ) | ( ( rule__Naming__NamesAssignment_1 ) ) ) - int alt9=2; - alt9 = dfa9.predict(input); - switch (alt9) { - case 1 : - // InternalScope.g:1729:2: ( ( rule__Naming__Group_0__0 ) ) - { - // InternalScope.g:1729:2: ( ( rule__Naming__Group_0__0 ) ) - // InternalScope.g:1730:3: ( rule__Naming__Group_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getGroup_0()); - } - // InternalScope.g:1731:3: ( rule__Naming__Group_0__0 ) - // InternalScope.g:1731:4: rule__Naming__Group_0__0 - { - pushFollow(FOLLOW_2); - rule__Naming__Group_0__0(); - - state._fsp--; - if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getGroup_0()); - } - - } - - - } - break; - case 2 : - // InternalScope.g:1735:2: ( ( rule__Naming__NamesAssignment_1 ) ) - { - // InternalScope.g:1735:2: ( ( rule__Naming__NamesAssignment_1 ) ) - // InternalScope.g:1736:3: ( rule__Naming__NamesAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getNamesAssignment_1()); - } - // InternalScope.g:1737:3: ( rule__Naming__NamesAssignment_1 ) - // InternalScope.g:1737:4: rule__Naming__NamesAssignment_1 - { - pushFollow(FOLLOW_2); - rule__Naming__NamesAssignment_1(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:1767:2: ( ( ( rule__OpEquality__Alternatives ) ) ) + // InternalScope.g:1768:2: ( ( rule__OpEquality__Alternatives ) ) + { + // InternalScope.g:1768:2: ( ( rule__OpEquality__Alternatives ) ) + // InternalScope.g:1769:3: ( rule__OpEquality__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getAlternatives()); + } + // InternalScope.g:1770:3: ( rule__OpEquality__Alternatives ) + // InternalScope.g:1770:4: rule__OpEquality__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpEquality__Alternatives(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getNamesAssignment_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6143,94 +5997,79 @@ public final void rule__Naming__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Alternatives" + // $ANTLR end "ruleOpEquality" - // $ANTLR start "rule__NamingExpression__Alternatives" - // InternalScope.g:1745:1: rule__NamingExpression__Alternatives : ( ( ( rule__NamingExpression__ExportAssignment_0 ) ) | ( ( rule__NamingExpression__Group_1__0 ) ) ); - public final void rule__NamingExpression__Alternatives() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXRelationalExpression" + // InternalScope.g:1779:1: entryRuleXRelationalExpression : ruleXRelationalExpression EOF ; + public final void entryRuleXRelationalExpression() throws RecognitionException { try { - // InternalScope.g:1749:1: ( ( ( rule__NamingExpression__ExportAssignment_0 ) ) | ( ( rule__NamingExpression__Group_1__0 ) ) ) - int alt10=2; - int LA10_0 = input.LA(1); - - if ( (LA10_0==81) ) { - alt10=1; - } - else if ( ((LA10_0>=RULE_ID && LA10_0<=RULE_REAL)||LA10_0==19||(LA10_0>=22 && LA10_0<=35)||LA10_0==45||LA10_0==51||LA10_0==58||LA10_0==69||LA10_0==73||LA10_0==76||(LA10_0>=78 && LA10_0<=79)||(LA10_0>=85 && LA10_0<=86)) ) { - alt10=2; + // InternalScope.g:1780:1: ( ruleXRelationalExpression EOF ) + // InternalScope.g:1781:1: ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 10, 0, input); + pushFollow(FOLLOW_1); + ruleXRelationalExpression(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionRule()); } - switch (alt10) { - case 1 : - // InternalScope.g:1750:2: ( ( rule__NamingExpression__ExportAssignment_0 ) ) - { - // InternalScope.g:1750:2: ( ( rule__NamingExpression__ExportAssignment_0 ) ) - // InternalScope.g:1751:3: ( rule__NamingExpression__ExportAssignment_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); - } - // InternalScope.g:1752:3: ( rule__NamingExpression__ExportAssignment_0 ) - // InternalScope.g:1752:4: rule__NamingExpression__ExportAssignment_0 - { - pushFollow(FOLLOW_2); - rule__NamingExpression__ExportAssignment_0(); - - state._fsp--; - if (state.failed) return ; - - } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXRelationalExpression" - } - break; - case 2 : - // InternalScope.g:1756:2: ( ( rule__NamingExpression__Group_1__0 ) ) - { - // InternalScope.g:1756:2: ( ( rule__NamingExpression__Group_1__0 ) ) - // InternalScope.g:1757:3: ( rule__NamingExpression__Group_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getGroup_1()); - } - // InternalScope.g:1758:3: ( rule__NamingExpression__Group_1__0 ) - // InternalScope.g:1758:4: rule__NamingExpression__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__NamingExpression__Group_1__0(); + // $ANTLR start "ruleXRelationalExpression" + // InternalScope.g:1788:1: ruleXRelationalExpression : ( ( rule__XRelationalExpression__Group__0 ) ) ; + public final void ruleXRelationalExpression() throws RecognitionException { - state._fsp--; - if (state.failed) return ; + int stackSize = keepStackSize(); + + try { + // InternalScope.g:1792:2: ( ( ( rule__XRelationalExpression__Group__0 ) ) ) + // InternalScope.g:1793:2: ( ( rule__XRelationalExpression__Group__0 ) ) + { + // InternalScope.g:1793:2: ( ( rule__XRelationalExpression__Group__0 ) ) + // InternalScope.g:1794:3: ( rule__XRelationalExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup()); + } + // InternalScope.g:1795:3: ( rule__XRelationalExpression__Group__0 ) + // InternalScope.g:1795:4: rule__XRelationalExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__0(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getGroup_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6243,97 +6082,79 @@ else if ( ((LA10_0>=RULE_ID && LA10_0<=RULE_REAL)||LA10_0==19||(LA10_0>=22 && LA } return ; } - // $ANTLR end "rule__NamingExpression__Alternatives" - + // $ANTLR end "ruleXRelationalExpression" - // $ANTLR start "rule__Expression__Alternatives" - // InternalScope.g:1766:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ); - public final void rule__Expression__Alternatives() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpCompare" + // InternalScope.g:1804:1: entryRuleOpCompare : ruleOpCompare EOF ; + public final void entryRuleOpCompare() throws RecognitionException { try { - // InternalScope.g:1770:1: ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ) - int alt11=3; - alt11 = dfa11.predict(input); - switch (alt11) { - case 1 : - // InternalScope.g:1771:2: ( ruleLetExpression ) - { - // InternalScope.g:1771:2: ( ruleLetExpression ) - // InternalScope.g:1772:3: ruleLetExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleLetExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); - } - - } - + // InternalScope.g:1805:1: ( ruleOpCompare EOF ) + // InternalScope.g:1806:1: ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_1); + ruleOpCompare(); - } - break; - case 2 : - // InternalScope.g:1777:2: ( ( ruleCastedExpression ) ) - { - // InternalScope.g:1777:2: ( ( ruleCastedExpression ) ) - // InternalScope.g:1778:3: ( ruleCastedExpression ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - // InternalScope.g:1779:3: ( ruleCastedExpression ) - // InternalScope.g:1779:4: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpCompare" - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - } + // $ANTLR start "ruleOpCompare" + // InternalScope.g:1813:1: ruleOpCompare : ( ( rule__OpCompare__Alternatives ) ) ; + public final void ruleOpCompare() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalScope.g:1817:2: ( ( ( rule__OpCompare__Alternatives ) ) ) + // InternalScope.g:1818:2: ( ( rule__OpCompare__Alternatives ) ) + { + // InternalScope.g:1818:2: ( ( rule__OpCompare__Alternatives ) ) + // InternalScope.g:1819:3: ( rule__OpCompare__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getAlternatives()); + } + // InternalScope.g:1820:3: ( rule__OpCompare__Alternatives ) + // InternalScope.g:1820:4: rule__OpCompare__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpCompare__Alternatives(); - } - break; - case 3 : - // InternalScope.g:1783:2: ( ruleChainExpression ) - { - // InternalScope.g:1783:2: ( ruleChainExpression ) - // InternalScope.g:1784:3: ruleChainExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleChainExpression(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6346,138 +6167,79 @@ public final void rule__Expression__Alternatives() throws RecognitionException { } return ; } - // $ANTLR end "rule__Expression__Alternatives" + // $ANTLR end "ruleOpCompare" - // $ANTLR start "rule__ChainedExpression__Alternatives" - // InternalScope.g:1793:1: rule__ChainedExpression__Alternatives : ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ); - public final void rule__ChainedExpression__Alternatives() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXOtherOperatorExpression" + // InternalScope.g:1829:1: entryRuleXOtherOperatorExpression : ruleXOtherOperatorExpression EOF ; + public final void entryRuleXOtherOperatorExpression() throws RecognitionException { try { - // InternalScope.g:1797:1: ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ) - int alt12=3; - switch ( input.LA(1) ) { - case 73: - { - alt12=1; - } - break; - case RULE_ID: - case RULE_STRING: - case RULE_INT: - case RULE_REAL: - case 19: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 45: - case 51: - case 78: - case 79: - case 85: - case 86: - { - alt12=2; - } - break; - case 76: - { - alt12=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 12, 0, input); - - throw nvae; + // InternalScope.g:1830:1: ( ruleXOtherOperatorExpression EOF ) + // InternalScope.g:1831:1: ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionRule()); } + pushFollow(FOLLOW_1); + ruleXOtherOperatorExpression(); - switch (alt12) { - case 1 : - // InternalScope.g:1798:2: ( ruleIfExpressionKw ) - { - // InternalScope.g:1798:2: ( ruleIfExpressionKw ) - // InternalScope.g:1799:3: ruleIfExpressionKw - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleIfExpressionKw(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); - } - - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 2 : - // InternalScope.g:1804:2: ( ruleIfExpressionTri ) - { - // InternalScope.g:1804:2: ( ruleIfExpressionTri ) - // InternalScope.g:1805:3: ruleIfExpressionTri - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleIfExpressionTri(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); - } - } + // $ANTLR start "ruleXOtherOperatorExpression" + // InternalScope.g:1838:1: ruleXOtherOperatorExpression : ( ( rule__XOtherOperatorExpression__Group__0 ) ) ; + public final void ruleXOtherOperatorExpression() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalScope.g:1842:2: ( ( ( rule__XOtherOperatorExpression__Group__0 ) ) ) + // InternalScope.g:1843:2: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + { + // InternalScope.g:1843:2: ( ( rule__XOtherOperatorExpression__Group__0 ) ) + // InternalScope.g:1844:3: ( rule__XOtherOperatorExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } + // InternalScope.g:1845:3: ( rule__XOtherOperatorExpression__Group__0 ) + // InternalScope.g:1845:4: rule__XOtherOperatorExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__0(); - } - break; - case 3 : - // InternalScope.g:1810:2: ( ruleSwitchExpression ) - { - // InternalScope.g:1810:2: ( ruleSwitchExpression ) - // InternalScope.g:1811:3: ruleSwitchExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleSwitchExpression(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6490,334 +6252,249 @@ public final void rule__ChainedExpression__Alternatives() throws RecognitionExce } return ; } - // $ANTLR end "rule__ChainedExpression__Alternatives" - + // $ANTLR end "ruleXOtherOperatorExpression" - // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // InternalScope.g:1820:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ); - public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleOpOther" + // InternalScope.g:1854:1: entryRuleOpOther : ruleOpOther EOF ; + public final void entryRuleOpOther() throws RecognitionException { try { - // InternalScope.g:1824:1: ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ) - int alt13=6; - switch ( input.LA(1) ) { - case 12: - { - alt13=1; - } - break; - case 13: - { - alt13=2; - } - break; - case 14: - { - alt13=3; - } - break; - case 15: - { - alt13=4; - } - break; - case 16: - { - alt13=5; - } - break; - case 17: - { - alt13=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 13, 0, input); - - throw nvae; + // InternalScope.g:1855:1: ( ruleOpOther EOF ) + // InternalScope.g:1856:1: ruleOpOther EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherRule()); } + pushFollow(FOLLOW_1); + ruleOpOther(); - switch (alt13) { - case 1 : - // InternalScope.g:1825:2: ( '==' ) - { - // InternalScope.g:1825:2: ( '==' ) - // InternalScope.g:1826:3: '==' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); - } - match(input,12,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); - } - - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 2 : - // InternalScope.g:1831:2: ( '!=' ) - { - // InternalScope.g:1831:2: ( '!=' ) - // InternalScope.g:1832:3: '!=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } - match(input,13,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpOther" - } + // $ANTLR start "ruleOpOther" + // InternalScope.g:1863:1: ruleOpOther : ( ( rule__OpOther__Alternatives ) ) ; + public final void ruleOpOther() throws RecognitionException { - } - break; - case 3 : - // InternalScope.g:1837:2: ( '>=' ) - { - // InternalScope.g:1837:2: ( '>=' ) - // InternalScope.g:1838:3: '>=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); - } - match(input,14,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); - } + int stackSize = keepStackSize(); + + try { + // InternalScope.g:1867:2: ( ( ( rule__OpOther__Alternatives ) ) ) + // InternalScope.g:1868:2: ( ( rule__OpOther__Alternatives ) ) + { + // InternalScope.g:1868:2: ( ( rule__OpOther__Alternatives ) ) + // InternalScope.g:1869:3: ( rule__OpOther__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives()); + } + // InternalScope.g:1870:3: ( rule__OpOther__Alternatives ) + // InternalScope.g:1870:4: rule__OpOther__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives(); - } + state._fsp--; + if (state.failed) return ; + } - } - break; - case 4 : - // InternalScope.g:1843:2: ( '<=' ) - { - // InternalScope.g:1843:2: ( '<=' ) - // InternalScope.g:1844:3: '<=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - } - match(input,15,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives()); + } - } + } - } - break; - case 5 : - // InternalScope.g:1849:2: ( '>' ) - { - // InternalScope.g:1849:2: ( '>' ) - // InternalScope.g:1850:3: '>' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } - match(input,16,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + restoreStackSize(stackSize); - } - break; - case 6 : - // InternalScope.g:1855:2: ( '<' ) - { - // InternalScope.g:1855:2: ( '<' ) - // InternalScope.g:1856:3: '<' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); - } - match(input,17,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); - } + } + return ; + } + // $ANTLR end "ruleOpOther" - } + // $ANTLR start "entryRuleXAdditiveExpression" + // InternalScope.g:1879:1: entryRuleXAdditiveExpression : ruleXAdditiveExpression EOF ; + public final void entryRuleXAdditiveExpression() throws RecognitionException { + try { + // InternalScope.g:1880:1: ( ruleXAdditiveExpression EOF ) + // InternalScope.g:1881:1: ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXAdditiveExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // $ANTLR end "entryRuleXAdditiveExpression" - // $ANTLR start "rule__AdditiveExpression__NameAlternatives_1_1_0" - // InternalScope.g:1865:1: rule__AdditiveExpression__NameAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) ); - public final void rule__AdditiveExpression__NameAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "ruleXAdditiveExpression" + // InternalScope.g:1888:1: ruleXAdditiveExpression : ( ( rule__XAdditiveExpression__Group__0 ) ) ; + public final void ruleXAdditiveExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1869:1: ( ( '+' ) | ( '-' ) ) - int alt14=2; - int LA14_0 = input.LA(1); + // InternalScope.g:1892:2: ( ( ( rule__XAdditiveExpression__Group__0 ) ) ) + // InternalScope.g:1893:2: ( ( rule__XAdditiveExpression__Group__0 ) ) + { + // InternalScope.g:1893:2: ( ( rule__XAdditiveExpression__Group__0 ) ) + // InternalScope.g:1894:3: ( rule__XAdditiveExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); + } + // InternalScope.g:1895:3: ( rule__XAdditiveExpression__Group__0 ) + // InternalScope.g:1895:4: rule__XAdditiveExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( (LA14_0==18) ) { - alt14=1; } - else if ( (LA14_0==19) ) { - alt14=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 14, 0, input); - throw nvae; } - switch (alt14) { - case 1 : - // InternalScope.g:1870:2: ( '+' ) - { - // InternalScope.g:1870:2: ( '+' ) - // InternalScope.g:1871:3: '+' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); - } - match(input,18,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); - } - } + } - } - break; - case 2 : - // InternalScope.g:1876:2: ( '-' ) - { - // InternalScope.g:1876:2: ( '-' ) - // InternalScope.g:1877:3: '-' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); - } - match(input,19,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXAdditiveExpression" - } - break; + + // $ANTLR start "entryRuleOpAdd" + // InternalScope.g:1904:1: entryRuleOpAdd : ruleOpAdd EOF ; + public final void entryRuleOpAdd() throws RecognitionException { + try { + // InternalScope.g:1905:1: ( ruleOpAdd EOF ) + // InternalScope.g:1906:1: ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_1); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__AdditiveExpression__NameAlternatives_1_1_0" + // $ANTLR end "entryRuleOpAdd" - // $ANTLR start "rule__MultiplicativeExpression__NameAlternatives_1_1_0" - // InternalScope.g:1886:1: rule__MultiplicativeExpression__NameAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) ); - public final void rule__MultiplicativeExpression__NameAlternatives_1_1_0() throws RecognitionException { + // $ANTLR start "ruleOpAdd" + // InternalScope.g:1913:1: ruleOpAdd : ( ( rule__OpAdd__Alternatives ) ) ; + public final void ruleOpAdd() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1890:1: ( ( '*' ) | ( '/' ) ) - int alt15=2; - int LA15_0 = input.LA(1); - - if ( (LA15_0==20) ) { - alt15=1; - } - else if ( (LA15_0==21) ) { - alt15=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 15, 0, input); - - throw nvae; + // InternalScope.g:1917:2: ( ( ( rule__OpAdd__Alternatives ) ) ) + // InternalScope.g:1918:2: ( ( rule__OpAdd__Alternatives ) ) + { + // InternalScope.g:1918:2: ( ( rule__OpAdd__Alternatives ) ) + // InternalScope.g:1919:3: ( rule__OpAdd__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getAlternatives()); } - switch (alt15) { - case 1 : - // InternalScope.g:1891:2: ( '*' ) - { - // InternalScope.g:1891:2: ( '*' ) - // InternalScope.g:1892:3: '*' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); - } - match(input,20,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); - } - - } + // InternalScope.g:1920:3: ( rule__OpAdd__Alternatives ) + // InternalScope.g:1920:4: rule__OpAdd__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpAdd__Alternatives(); + state._fsp--; + if (state.failed) return ; - } - break; - case 2 : - // InternalScope.g:1897:2: ( '/' ) - { - // InternalScope.g:1897:2: ( '/' ) - // InternalScope.g:1898:3: '/' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); - } - match(input,21,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -6830,817 +6507,589 @@ else if ( (LA15_0==21) ) { } return ; } - // $ANTLR end "rule__MultiplicativeExpression__NameAlternatives_1_1_0" + // $ANTLR end "ruleOpAdd" - // $ANTLR start "rule__UnaryOrInfixExpression__Alternatives" - // InternalScope.g:1907:1: rule__UnaryOrInfixExpression__Alternatives : ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ); - public final void rule__UnaryOrInfixExpression__Alternatives() throws RecognitionException { + // $ANTLR start "entryRuleXMultiplicativeExpression" + // InternalScope.g:1929:1: entryRuleXMultiplicativeExpression : ruleXMultiplicativeExpression EOF ; + public final void entryRuleXMultiplicativeExpression() throws RecognitionException { + try { + // InternalScope.g:1930:1: ( ruleXMultiplicativeExpression EOF ) + // InternalScope.g:1931:1: ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // InternalScope.g:1938:1: ruleXMultiplicativeExpression : ( ( rule__XMultiplicativeExpression__Group__0 ) ) ; + public final void ruleXMultiplicativeExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1911:1: ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ) - int alt16=2; - int LA16_0 = input.LA(1); + // InternalScope.g:1942:2: ( ( ( rule__XMultiplicativeExpression__Group__0 ) ) ) + // InternalScope.g:1943:2: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + { + // InternalScope.g:1943:2: ( ( rule__XMultiplicativeExpression__Group__0 ) ) + // InternalScope.g:1944:3: ( rule__XMultiplicativeExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); + } + // InternalScope.g:1945:3: ( rule__XMultiplicativeExpression__Group__0 ) + // InternalScope.g:1945:4: rule__XMultiplicativeExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; - if ( (LA16_0==19||LA16_0==22) ) { - alt16=1; } - else if ( ((LA16_0>=RULE_ID && LA16_0<=RULE_REAL)||(LA16_0>=23 && LA16_0<=35)||LA16_0==45||LA16_0==51||(LA16_0>=78 && LA16_0<=79)||(LA16_0>=85 && LA16_0<=86)) ) { - alt16=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 16, 0, input); - throw nvae; } - switch (alt16) { - case 1 : - // InternalScope.g:1912:2: ( ruleUnaryExpression ) - { - // InternalScope.g:1912:2: ( ruleUnaryExpression ) - // InternalScope.g:1913:3: ruleUnaryExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleUnaryExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalScope.g:1918:2: ( ruleInfixExpression ) - { - // InternalScope.g:1918:2: ( ruleInfixExpression ) - // InternalScope.g:1919:3: ruleInfixExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleInfixExpression(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); - } + } + return ; + } + // $ANTLR end "ruleXMultiplicativeExpression" - } + // $ANTLR start "entryRuleOpMulti" + // InternalScope.g:1954:1: entryRuleOpMulti : ruleOpMulti EOF ; + public final void entryRuleOpMulti() throws RecognitionException { + try { + // InternalScope.g:1955:1: ( ruleOpMulti EOF ) + // InternalScope.g:1956:1: ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_1); + ruleOpMulti(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__UnaryOrInfixExpression__Alternatives" + // $ANTLR end "entryRuleOpMulti" - // $ANTLR start "rule__UnaryExpression__NameAlternatives_0_0" - // InternalScope.g:1928:1: rule__UnaryExpression__NameAlternatives_0_0 : ( ( '!' ) | ( '-' ) ); - public final void rule__UnaryExpression__NameAlternatives_0_0() throws RecognitionException { + // $ANTLR start "ruleOpMulti" + // InternalScope.g:1963:1: ruleOpMulti : ( ( rule__OpMulti__Alternatives ) ) ; + public final void ruleOpMulti() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1932:1: ( ( '!' ) | ( '-' ) ) - int alt17=2; - int LA17_0 = input.LA(1); + // InternalScope.g:1967:2: ( ( ( rule__OpMulti__Alternatives ) ) ) + // InternalScope.g:1968:2: ( ( rule__OpMulti__Alternatives ) ) + { + // InternalScope.g:1968:2: ( ( rule__OpMulti__Alternatives ) ) + // InternalScope.g:1969:3: ( rule__OpMulti__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAlternatives()); + } + // InternalScope.g:1970:3: ( rule__OpMulti__Alternatives ) + // InternalScope.g:1970:4: rule__OpMulti__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpMulti__Alternatives(); + + state._fsp--; + if (state.failed) return ; - if ( (LA17_0==22) ) { - alt17=1; } - else if ( (LA17_0==19) ) { - alt17=2; + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAlternatives()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 17, 0, input); - throw nvae; } - switch (alt17) { - case 1 : - // InternalScope.g:1933:2: ( '!' ) - { - // InternalScope.g:1933:2: ( '!' ) - // InternalScope.g:1934:3: '!' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); - } - match(input,22,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); - } - } + } - } - break; - case 2 : - // InternalScope.g:1939:2: ( '-' ) - { - // InternalScope.g:1939:2: ( '-' ) - // InternalScope.g:1940:3: '-' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); - } - match(input,19,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "ruleOpMulti" - } - break; + // $ANTLR start "entryRuleXUnaryOperation" + // InternalScope.g:1979:1: entryRuleXUnaryOperation : ruleXUnaryOperation EOF ; + public final void entryRuleXUnaryOperation() throws RecognitionException { + try { + // InternalScope.g:1980:1: ( ruleXUnaryOperation EOF ) + // InternalScope.g:1981:1: ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_1); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__UnaryExpression__NameAlternatives_0_0" + // $ANTLR end "entryRuleXUnaryOperation" - // $ANTLR start "rule__InfixExpression__Alternatives_1" - // InternalScope.g:1949:1: rule__InfixExpression__Alternatives_1 : ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ); - public final void rule__InfixExpression__Alternatives_1() throws RecognitionException { + // $ANTLR start "ruleXUnaryOperation" + // InternalScope.g:1988:1: ruleXUnaryOperation : ( ( rule__XUnaryOperation__Alternatives ) ) ; + public final void ruleXUnaryOperation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1953:1: ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ) - int alt18=4; - int LA18_0 = input.LA(1); - - if ( (LA18_0==68) ) { - switch ( input.LA(2) ) { - case RULE_ID: - { - int LA18_2 = input.LA(3); - - if ( (LA18_2==51) ) { - alt18=1; - } - else if ( (LA18_2==EOF||(LA18_2>=12 && LA18_2<=21)||LA18_2==41||(LA18_2>=46 && LA18_2<=47)||LA18_2==49||LA18_2==52||LA18_2==55||LA18_2==57||LA18_2==60||(LA18_2>=67 && LA18_2<=68)||(LA18_2>=70 && LA18_2<=72)||(LA18_2>=74 && LA18_2<=75)||LA18_2==77||(LA18_2>=82 && LA18_2<=84)) ) { - alt18=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 18, 2, input); + // InternalScope.g:1992:2: ( ( ( rule__XUnaryOperation__Alternatives ) ) ) + // InternalScope.g:1993:2: ( ( rule__XUnaryOperation__Alternatives ) ) + { + // InternalScope.g:1993:2: ( ( rule__XUnaryOperation__Alternatives ) ) + // InternalScope.g:1994:3: ( rule__XUnaryOperation__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); + } + // InternalScope.g:1995:3: ( rule__XUnaryOperation__Alternatives ) + // InternalScope.g:1995:4: rule__XUnaryOperation__Alternatives + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Alternatives(); - throw nvae; - } - } - break; - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - { - alt18=4; - } - break; - case 33: - case 34: - case 35: - { - alt18=2; - } - break; - case 85: - { - alt18=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 18, 1, input); + state._fsp--; + if (state.failed) return ; - throw nvae; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 18, 0, input); - throw nvae; } - switch (alt18) { - case 1 : - // InternalScope.g:1954:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) - { - // InternalScope.g:1954:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) - // InternalScope.g:1955:3: ( rule__InfixExpression__Group_1_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); - } - // InternalScope.g:1956:3: ( rule__InfixExpression__Group_1_0__0 ) - // InternalScope.g:1956:4: rule__InfixExpression__Group_1_0__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__0(); - state._fsp--; - if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXUnaryOperation" - } - break; - case 2 : - // InternalScope.g:1960:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) - { - // InternalScope.g:1960:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) - // InternalScope.g:1961:3: ( rule__InfixExpression__Group_1_1__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); - } - // InternalScope.g:1962:3: ( rule__InfixExpression__Group_1_1__0 ) - // InternalScope.g:1962:4: rule__InfixExpression__Group_1_1__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__0(); - state._fsp--; - if (state.failed) return ; + // $ANTLR start "entryRuleOpUnary" + // InternalScope.g:2004:1: entryRuleOpUnary : ruleOpUnary EOF ; + public final void entryRuleOpUnary() throws RecognitionException { + try { + // InternalScope.g:2005:1: ( ruleOpUnary EOF ) + // InternalScope.g:2006:1: ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_1); + ruleOpUnary(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpUnary" - } - break; - case 3 : - // InternalScope.g:1966:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) - { - // InternalScope.g:1966:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) - // InternalScope.g:1967:3: ( rule__InfixExpression__Group_1_2__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); - } - // InternalScope.g:1968:3: ( rule__InfixExpression__Group_1_2__0 ) - // InternalScope.g:1968:4: rule__InfixExpression__Group_1_2__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__0(); + // $ANTLR start "ruleOpUnary" + // InternalScope.g:2013:1: ruleOpUnary : ( ( rule__OpUnary__Alternatives ) ) ; + public final void ruleOpUnary() throws RecognitionException { - state._fsp--; - if (state.failed) return ; + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2017:2: ( ( ( rule__OpUnary__Alternatives ) ) ) + // InternalScope.g:2018:2: ( ( rule__OpUnary__Alternatives ) ) + { + // InternalScope.g:2018:2: ( ( rule__OpUnary__Alternatives ) ) + // InternalScope.g:2019:3: ( rule__OpUnary__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getAlternatives()); + } + // InternalScope.g:2020:3: ( rule__OpUnary__Alternatives ) + // InternalScope.g:2020:4: rule__OpUnary__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpUnary__Alternatives(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getAlternatives()); + } + } - } - break; - case 4 : - // InternalScope.g:1972:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) - { - // InternalScope.g:1972:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) - // InternalScope.g:1973:3: ( rule__InfixExpression__Group_1_3__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); - } - // InternalScope.g:1974:3: ( rule__InfixExpression__Group_1_3__0 ) - // InternalScope.g:1974:4: rule__InfixExpression__Group_1_3__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__0(); - state._fsp--; - if (state.failed) return ; + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleOpUnary" - } - break; + // $ANTLR start "entryRuleXCastedExpression" + // InternalScope.g:2029:1: entryRuleXCastedExpression : ruleXCastedExpression EOF ; + public final void entryRuleXCastedExpression() throws RecognitionException { + try { + // InternalScope.g:2030:1: ( ruleXCastedExpression EOF ) + // InternalScope.g:2031:1: ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InfixExpression__Alternatives_1" + // $ANTLR end "entryRuleXCastedExpression" - // $ANTLR start "rule__InfixExpression__NameAlternatives_1_3_2_0" - // InternalScope.g:1982:1: rule__InfixExpression__NameAlternatives_1_3_2_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); - public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws RecognitionException { + // $ANTLR start "ruleXCastedExpression" + // InternalScope.g:2038:1: ruleXCastedExpression : ( ( rule__XCastedExpression__Group__0 ) ) ; + public final void ruleXCastedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:1986:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) - int alt19=8; - switch ( input.LA(1) ) { - case 23: - { - alt19=1; - } - break; - case 24: - { - alt19=2; - } - break; - case 25: - { - alt19=3; - } - break; - case 26: - { - alt19=4; - } - break; - case 27: - { - alt19=5; - } - break; - case 28: - { - alt19=6; - } - break; - case 29: - { - alt19=7; - } - break; - case 30: - { - alt19=8; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 19, 0, input); - - throw nvae; + // InternalScope.g:2042:2: ( ( ( rule__XCastedExpression__Group__0 ) ) ) + // InternalScope.g:2043:2: ( ( rule__XCastedExpression__Group__0 ) ) + { + // InternalScope.g:2043:2: ( ( rule__XCastedExpression__Group__0 ) ) + // InternalScope.g:2044:3: ( rule__XCastedExpression__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup()); } + // InternalScope.g:2045:3: ( rule__XCastedExpression__Group__0 ) + // InternalScope.g:2045:4: rule__XCastedExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__0(); - switch (alt19) { - case 1 : - // InternalScope.g:1987:2: ( 'collect' ) - { - // InternalScope.g:1987:2: ( 'collect' ) - // InternalScope.g:1988:3: 'collect' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); - } - match(input,23,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup()); + } - } - break; - case 2 : - // InternalScope.g:1993:2: ( 'select' ) - { - // InternalScope.g:1993:2: ( 'select' ) - // InternalScope.g:1994:3: 'select' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); - } - match(input,24,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); - } + } - } + } - } - break; - case 3 : - // InternalScope.g:1999:2: ( 'selectFirst' ) - { - // InternalScope.g:1999:2: ( 'selectFirst' ) - // InternalScope.g:2000:3: 'selectFirst' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); - } - match(input,25,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXCastedExpression" - } - break; - case 4 : - // InternalScope.g:2005:2: ( 'reject' ) - { - // InternalScope.g:2005:2: ( 'reject' ) - // InternalScope.g:2006:3: 'reject' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); - } - match(input,26,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); - } - } + // $ANTLR start "entryRuleXPostfixOperation" + // InternalScope.g:2054:1: entryRuleXPostfixOperation : ruleXPostfixOperation EOF ; + public final void entryRuleXPostfixOperation() throws RecognitionException { + try { + // InternalScope.g:2055:1: ( ruleXPostfixOperation EOF ) + // InternalScope.g:2056:1: ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationRule()); + } + pushFollow(FOLLOW_1); + ruleXPostfixOperation(); - - } - break; - case 5 : - // InternalScope.g:2011:2: ( 'exists' ) - { - // InternalScope.g:2011:2: ( 'exists' ) - // InternalScope.g:2012:3: 'exists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); - } - match(input,27,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); - } - - } - - - } - break; - case 6 : - // InternalScope.g:2017:2: ( 'notExists' ) - { - // InternalScope.g:2017:2: ( 'notExists' ) - // InternalScope.g:2018:3: 'notExists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); - } - match(input,28,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); - } - - } - - - } - break; - case 7 : - // InternalScope.g:2023:2: ( 'sortBy' ) - { - // InternalScope.g:2023:2: ( 'sortBy' ) - // InternalScope.g:2024:3: 'sortBy' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); - } - match(input,29,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); - } - - } - - - } - break; - case 8 : - // InternalScope.g:2029:2: ( 'forAll' ) - { - // InternalScope.g:2029:2: ( 'forAll' ) - // InternalScope.g:2030:3: 'forAll' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); - } - match(input,30,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); - } - - } - - - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__InfixExpression__NameAlternatives_1_3_2_0" + // $ANTLR end "entryRuleXPostfixOperation" - // $ANTLR start "rule__PrimaryExpression__Alternatives" - // InternalScope.g:2039:1: rule__PrimaryExpression__Alternatives : ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ); - public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXPostfixOperation" + // InternalScope.g:2063:1: ruleXPostfixOperation : ( ( rule__XPostfixOperation__Group__0 ) ) ; + public final void ruleXPostfixOperation() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2043:1: ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ) - int alt20=6; - switch ( input.LA(1) ) { - case RULE_STRING: - case RULE_INT: - case RULE_REAL: - case 31: - case 32: - case 86: - { - alt20=1; - } - break; - case RULE_ID: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 33: - case 34: - case 35: - case 85: - { - alt20=2; - } - break; - case 45: - { - alt20=3; - } - break; - case 79: - { - alt20=4; - } - break; - case 78: - { - alt20=5; - } - break; - case 51: - { - alt20=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 20, 0, input); - - throw nvae; + // InternalScope.g:2067:2: ( ( ( rule__XPostfixOperation__Group__0 ) ) ) + // InternalScope.g:2068:2: ( ( rule__XPostfixOperation__Group__0 ) ) + { + // InternalScope.g:2068:2: ( ( rule__XPostfixOperation__Group__0 ) ) + // InternalScope.g:2069:3: ( rule__XPostfixOperation__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup()); } + // InternalScope.g:2070:3: ( rule__XPostfixOperation__Group__0 ) + // InternalScope.g:2070:4: rule__XPostfixOperation__Group__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__0(); - switch (alt20) { - case 1 : - // InternalScope.g:2044:2: ( ruleLiteral ) - { - // InternalScope.g:2044:2: ( ruleLiteral ) - // InternalScope.g:2045:3: ruleLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleLiteral(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); - } - - } - + state._fsp--; + if (state.failed) return ; - } - break; - case 2 : - // InternalScope.g:2050:2: ( ruleFeatureCall ) - { - // InternalScope.g:2050:2: ( ruleFeatureCall ) - // InternalScope.g:2051:3: ruleFeatureCall - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleFeatureCall(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup()); + } - } + } - } - break; - case 3 : - // InternalScope.g:2056:2: ( ruleListLiteral ) - { - // InternalScope.g:2056:2: ( ruleListLiteral ) - // InternalScope.g:2057:3: ruleListLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleListLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } + restoreStackSize(stackSize); + } + return ; + } + // $ANTLR end "ruleXPostfixOperation" - } - break; - case 4 : - // InternalScope.g:2062:2: ( ruleConstructorCallExpression ) - { - // InternalScope.g:2062:2: ( ruleConstructorCallExpression ) - // InternalScope.g:2063:3: ruleConstructorCallExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleConstructorCallExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); - } + // $ANTLR start "entryRuleOpPostfix" + // InternalScope.g:2079:1: entryRuleOpPostfix : ruleOpPostfix EOF ; + public final void entryRuleOpPostfix() throws RecognitionException { + try { + // InternalScope.g:2080:1: ( ruleOpPostfix EOF ) + // InternalScope.g:2081:1: ruleOpPostfix EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_1); + ruleOpPostfix(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 5 : - // InternalScope.g:2068:2: ( ruleGlobalVarExpression ) - { - // InternalScope.g:2068:2: ( ruleGlobalVarExpression ) - // InternalScope.g:2069:3: ruleGlobalVarExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); - } - pushFollow(FOLLOW_2); - ruleGlobalVarExpression(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleOpPostfix" - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); - } - } + // $ANTLR start "ruleOpPostfix" + // InternalScope.g:2088:1: ruleOpPostfix : ( ( rule__OpPostfix__Alternatives ) ) ; + public final void ruleOpPostfix() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2092:2: ( ( ( rule__OpPostfix__Alternatives ) ) ) + // InternalScope.g:2093:2: ( ( rule__OpPostfix__Alternatives ) ) + { + // InternalScope.g:2093:2: ( ( rule__OpPostfix__Alternatives ) ) + // InternalScope.g:2094:3: ( rule__OpPostfix__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getAlternatives()); + } + // InternalScope.g:2095:3: ( rule__OpPostfix__Alternatives ) + // InternalScope.g:2095:4: rule__OpPostfix__Alternatives + { + pushFollow(FOLLOW_2); + rule__OpPostfix__Alternatives(); - } - break; - case 6 : - // InternalScope.g:2074:2: ( ruleParanthesizedExpression ) - { - // InternalScope.g:2074:2: ( ruleParanthesizedExpression ) - // InternalScope.g:2075:3: ruleParanthesizedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); - } - pushFollow(FOLLOW_2); - ruleParanthesizedExpression(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -7653,251 +7102,164 @@ public final void rule__PrimaryExpression__Alternatives() throws RecognitionExce } return ; } - // $ANTLR end "rule__PrimaryExpression__Alternatives" - + // $ANTLR end "ruleOpPostfix" - // $ANTLR start "rule__Literal__Alternatives" - // InternalScope.g:2084:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ); - public final void rule__Literal__Alternatives() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXMemberFeatureCall" + // InternalScope.g:2104:1: entryRuleXMemberFeatureCall : ruleXMemberFeatureCall EOF ; + public final void entryRuleXMemberFeatureCall() throws RecognitionException { try { - // InternalScope.g:2088:1: ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ) - int alt21=5; - switch ( input.LA(1) ) { - case 31: - case 32: - { - alt21=1; - } - break; - case RULE_INT: - { - alt21=2; - } - break; - case 86: - { - alt21=3; - } - break; - case RULE_REAL: - { - alt21=4; - } - break; - case RULE_STRING: - { - alt21=5; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 21, 0, input); - - throw nvae; + // InternalScope.g:2105:1: ( ruleXMemberFeatureCall EOF ) + // InternalScope.g:2106:1: ruleXMemberFeatureCall EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallRule()); } + pushFollow(FOLLOW_1); + ruleXMemberFeatureCall(); - switch (alt21) { - case 1 : - // InternalScope.g:2089:2: ( ruleBooleanLiteral ) - { - // InternalScope.g:2089:2: ( ruleBooleanLiteral ) - // InternalScope.g:2090:3: ruleBooleanLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleBooleanLiteral(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); - } - - } - + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - } - break; - case 2 : - // InternalScope.g:2095:2: ( ruleIntegerLiteral ) - { - // InternalScope.g:2095:2: ( ruleIntegerLiteral ) - // InternalScope.g:2096:3: ruleIntegerLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleIntegerLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXMemberFeatureCall" - } + // $ANTLR start "ruleXMemberFeatureCall" + // InternalScope.g:2113:1: ruleXMemberFeatureCall : ( ( rule__XMemberFeatureCall__Group__0 ) ) ; + public final void ruleXMemberFeatureCall() throws RecognitionException { - } - break; - case 3 : - // InternalScope.g:2101:2: ( ruleNullLiteral ) - { - // InternalScope.g:2101:2: ( ruleNullLiteral ) - // InternalScope.g:2102:3: ruleNullLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleNullLiteral(); + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2117:2: ( ( ( rule__XMemberFeatureCall__Group__0 ) ) ) + // InternalScope.g:2118:2: ( ( rule__XMemberFeatureCall__Group__0 ) ) + { + // InternalScope.g:2118:2: ( ( rule__XMemberFeatureCall__Group__0 ) ) + // InternalScope.g:2119:3: ( rule__XMemberFeatureCall__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); + } + // InternalScope.g:2120:3: ( rule__XMemberFeatureCall__Group__0 ) + // InternalScope.g:2120:4: rule__XMemberFeatureCall__Group__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__0(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); + } - } - break; - case 4 : - // InternalScope.g:2107:2: ( ruleRealLiteral ) - { - // InternalScope.g:2107:2: ( ruleRealLiteral ) - // InternalScope.g:2108:3: ruleRealLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleRealLiteral(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 5 : - // InternalScope.g:2113:2: ( ruleStringLiteral ) - { - // InternalScope.g:2113:2: ( ruleStringLiteral ) - // InternalScope.g:2114:3: ruleStringLiteral - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); - } - pushFollow(FOLLOW_2); - ruleStringLiteral(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); - } + } + return ; + } + // $ANTLR end "ruleXMemberFeatureCall" - } + // $ANTLR start "entryRuleXPrimaryExpression" + // InternalScope.g:2129:1: entryRuleXPrimaryExpression : ruleXPrimaryExpression EOF ; + public final void entryRuleXPrimaryExpression() throws RecognitionException { + try { + // InternalScope.g:2130:1: ( ruleXPrimaryExpression EOF ) + // InternalScope.g:2131:1: ruleXPrimaryExpression EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXPrimaryExpression(); - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Literal__Alternatives" + // $ANTLR end "entryRuleXPrimaryExpression" - // $ANTLR start "rule__BooleanLiteral__ValAlternatives_0" - // InternalScope.g:2123:1: rule__BooleanLiteral__ValAlternatives_0 : ( ( 'true' ) | ( 'false' ) ); - public final void rule__BooleanLiteral__ValAlternatives_0() throws RecognitionException { + // $ANTLR start "ruleXPrimaryExpression" + // InternalScope.g:2138:1: ruleXPrimaryExpression : ( ( rule__XPrimaryExpression__Alternatives ) ) ; + public final void ruleXPrimaryExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2127:1: ( ( 'true' ) | ( 'false' ) ) - int alt22=2; - int LA22_0 = input.LA(1); - - if ( (LA22_0==31) ) { - alt22=1; - } - else if ( (LA22_0==32) ) { - alt22=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 22, 0, input); - - throw nvae; + // InternalScope.g:2142:2: ( ( ( rule__XPrimaryExpression__Alternatives ) ) ) + // InternalScope.g:2143:2: ( ( rule__XPrimaryExpression__Alternatives ) ) + { + // InternalScope.g:2143:2: ( ( rule__XPrimaryExpression__Alternatives ) ) + // InternalScope.g:2144:3: ( rule__XPrimaryExpression__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); } - switch (alt22) { - case 1 : - // InternalScope.g:2128:2: ( 'true' ) - { - // InternalScope.g:2128:2: ( 'true' ) - // InternalScope.g:2129:3: 'true' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); - } - match(input,31,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); - } - - } + // InternalScope.g:2145:3: ( rule__XPrimaryExpression__Alternatives ) + // InternalScope.g:2145:4: rule__XPrimaryExpression__Alternatives + { + pushFollow(FOLLOW_2); + rule__XPrimaryExpression__Alternatives(); + state._fsp--; + if (state.failed) return ; - } - break; - case 2 : - // InternalScope.g:2134:2: ( 'false' ) - { - // InternalScope.g:2134:2: ( 'false' ) - // InternalScope.g:2135:3: 'false' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); - } - match(input,32,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -7910,171 +7272,164 @@ else if ( (LA22_0==32) ) { } return ; } - // $ANTLR end "rule__BooleanLiteral__ValAlternatives_0" + // $ANTLR end "ruleXPrimaryExpression" - // $ANTLR start "rule__FeatureCall__Alternatives" - // InternalScope.g:2144:1: rule__FeatureCall__Alternatives : ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ); - public final void rule__FeatureCall__Alternatives() throws RecognitionException { + // $ANTLR start "entryRuleXLiteral" + // InternalScope.g:2154:1: entryRuleXLiteral : ruleXLiteral EOF ; + public final void entryRuleXLiteral() throws RecognitionException { + try { + // InternalScope.g:2155:1: ( ruleXLiteral EOF ) + // InternalScope.g:2156:1: ruleXLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXLiteral" + + + // $ANTLR start "ruleXLiteral" + // InternalScope.g:2163:1: ruleXLiteral : ( ( rule__XLiteral__Alternatives ) ) ; + public final void ruleXLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2148:1: ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ) - int alt23=4; - switch ( input.LA(1) ) { - case RULE_ID: - { - int LA23_1 = input.LA(2); + // InternalScope.g:2167:2: ( ( ( rule__XLiteral__Alternatives ) ) ) + // InternalScope.g:2168:2: ( ( rule__XLiteral__Alternatives ) ) + { + // InternalScope.g:2168:2: ( ( rule__XLiteral__Alternatives ) ) + // InternalScope.g:2169:3: ( rule__XLiteral__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getAlternatives()); + } + // InternalScope.g:2170:3: ( rule__XLiteral__Alternatives ) + // InternalScope.g:2170:4: rule__XLiteral__Alternatives + { + pushFollow(FOLLOW_2); + rule__XLiteral__Alternatives(); - if ( (LA23_1==EOF||(LA23_1>=12 && LA23_1<=21)||LA23_1==41||(LA23_1>=46 && LA23_1<=47)||LA23_1==49||LA23_1==52||LA23_1==55||LA23_1==57||LA23_1==60||(LA23_1>=67 && LA23_1<=68)||(LA23_1>=70 && LA23_1<=72)||(LA23_1>=74 && LA23_1<=75)||LA23_1==77||(LA23_1>=82 && LA23_1<=84)) ) { - alt23=2; - } - else if ( (LA23_1==51) ) { - alt23=1; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 23, 1, input); + state._fsp--; + if (state.failed) return ; - throw nvae; - } - } - break; - case 33: - case 34: - case 35: - { - alt23=2; - } - break; - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - { - alt23=3; - } - break; - case 85: - { - alt23=4; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 23, 0, input); + } - throw nvae; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getAlternatives()); } - switch (alt23) { - case 1 : - // InternalScope.g:2149:2: ( ruleOperationCall ) - { - // InternalScope.g:2149:2: ( ruleOperationCall ) - // InternalScope.g:2150:3: ruleOperationCall - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleOperationCall(); + } - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 2 : - // InternalScope.g:2155:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) - { - // InternalScope.g:2155:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) - // InternalScope.g:2156:3: ( rule__FeatureCall__TypeAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); - } - // InternalScope.g:2157:3: ( rule__FeatureCall__TypeAssignment_1 ) - // InternalScope.g:2157:4: rule__FeatureCall__TypeAssignment_1 - { - pushFollow(FOLLOW_2); - rule__FeatureCall__TypeAssignment_1(); + restoreStackSize(stackSize); - state._fsp--; - if (state.failed) return ; + } + return ; + } + // $ANTLR end "ruleXLiteral" - } - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); - } + // $ANTLR start "entryRuleXCollectionLiteral" + // InternalScope.g:2179:1: entryRuleXCollectionLiteral : ruleXCollectionLiteral EOF ; + public final void entryRuleXCollectionLiteral() throws RecognitionException { + try { + // InternalScope.g:2180:1: ( ruleXCollectionLiteral EOF ) + // InternalScope.g:2181:1: ruleXCollectionLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXCollectionLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 3 : - // InternalScope.g:2161:2: ( ruleCollectionExpression ) - { - // InternalScope.g:2161:2: ( ruleCollectionExpression ) - // InternalScope.g:2162:3: ruleCollectionExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); - } - pushFollow(FOLLOW_2); - ruleCollectionExpression(); + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXCollectionLiteral" - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); - } - } + // $ANTLR start "ruleXCollectionLiteral" + // InternalScope.g:2188:1: ruleXCollectionLiteral : ( ( rule__XCollectionLiteral__Alternatives ) ) ; + public final void ruleXCollectionLiteral() throws RecognitionException { + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2192:2: ( ( ( rule__XCollectionLiteral__Alternatives ) ) ) + // InternalScope.g:2193:2: ( ( rule__XCollectionLiteral__Alternatives ) ) + { + // InternalScope.g:2193:2: ( ( rule__XCollectionLiteral__Alternatives ) ) + // InternalScope.g:2194:3: ( rule__XCollectionLiteral__Alternatives ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); + } + // InternalScope.g:2195:3: ( rule__XCollectionLiteral__Alternatives ) + // InternalScope.g:2195:4: rule__XCollectionLiteral__Alternatives + { + pushFollow(FOLLOW_2); + rule__XCollectionLiteral__Alternatives(); - } - break; - case 4 : - // InternalScope.g:2167:2: ( ruleTypeSelectExpression ) - { - // InternalScope.g:2167:2: ( ruleTypeSelectExpression ) - // InternalScope.g:2168:3: ruleTypeSelectExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); - } - pushFollow(FOLLOW_2); - ruleTypeSelectExpression(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -8087,222 +7442,164 @@ else if ( (LA23_1==51) ) { } return ; } - // $ANTLR end "rule__FeatureCall__Alternatives" - + // $ANTLR end "ruleXCollectionLiteral" - // $ANTLR start "rule__CollectionExpression__NameAlternatives_0_0" - // InternalScope.g:2177:1: rule__CollectionExpression__NameAlternatives_0_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); - public final void rule__CollectionExpression__NameAlternatives_0_0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSetLiteral" + // InternalScope.g:2204:1: entryRuleXSetLiteral : ruleXSetLiteral EOF ; + public final void entryRuleXSetLiteral() throws RecognitionException { try { - // InternalScope.g:2181:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) - int alt24=8; - switch ( input.LA(1) ) { - case 23: - { - alt24=1; - } - break; - case 24: - { - alt24=2; - } - break; - case 25: - { - alt24=3; - } - break; - case 26: - { - alt24=4; - } - break; - case 27: - { - alt24=5; - } - break; - case 28: - { - alt24=6; - } - break; - case 29: - { - alt24=7; - } - break; - case 30: - { - alt24=8; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 24, 0, input); + // InternalScope.g:2205:1: ( ruleXSetLiteral EOF ) + // InternalScope.g:2206:1: ruleXSetLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXSetLiteral(); - throw nvae; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralRule()); } + match(input,EOF,FOLLOW_2); if (state.failed) return ; - switch (alt24) { - case 1 : - // InternalScope.g:2182:2: ( 'collect' ) - { - // InternalScope.g:2182:2: ( 'collect' ) - // InternalScope.g:2183:3: 'collect' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); - } - match(input,23,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); - } + } - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXSetLiteral" - } - break; - case 2 : - // InternalScope.g:2188:2: ( 'select' ) - { - // InternalScope.g:2188:2: ( 'select' ) - // InternalScope.g:2189:3: 'select' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); - } - match(input,24,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); - } + // $ANTLR start "ruleXSetLiteral" + // InternalScope.g:2213:1: ruleXSetLiteral : ( ( rule__XSetLiteral__Group__0 ) ) ; + public final void ruleXSetLiteral() throws RecognitionException { - } + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2217:2: ( ( ( rule__XSetLiteral__Group__0 ) ) ) + // InternalScope.g:2218:2: ( ( rule__XSetLiteral__Group__0 ) ) + { + // InternalScope.g:2218:2: ( ( rule__XSetLiteral__Group__0 ) ) + // InternalScope.g:2219:3: ( rule__XSetLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup()); + } + // InternalScope.g:2220:3: ( rule__XSetLiteral__Group__0 ) + // InternalScope.g:2220:4: rule__XSetLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__0(); + state._fsp--; + if (state.failed) return ; - } - break; - case 3 : - // InternalScope.g:2194:2: ( 'selectFirst' ) - { - // InternalScope.g:2194:2: ( 'selectFirst' ) - // InternalScope.g:2195:3: 'selectFirst' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); - } - match(input,25,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup()); + } + } - } - break; - case 4 : - // InternalScope.g:2200:2: ( 'reject' ) - { - // InternalScope.g:2200:2: ( 'reject' ) - // InternalScope.g:2201:3: 'reject' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); - } - match(input,26,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); - } - } + } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { - } - break; - case 5 : - // InternalScope.g:2206:2: ( 'exists' ) - { - // InternalScope.g:2206:2: ( 'exists' ) - // InternalScope.g:2207:3: 'exists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); - } - match(input,27,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); - } + restoreStackSize(stackSize); - } + } + return ; + } + // $ANTLR end "ruleXSetLiteral" - } - break; - case 6 : - // InternalScope.g:2212:2: ( 'notExists' ) - { - // InternalScope.g:2212:2: ( 'notExists' ) - // InternalScope.g:2213:3: 'notExists' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); - } - match(input,28,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); - } + // $ANTLR start "entryRuleXListLiteral" + // InternalScope.g:2229:1: entryRuleXListLiteral : ruleXListLiteral EOF ; + public final void entryRuleXListLiteral() throws RecognitionException { + try { + // InternalScope.g:2230:1: ( ruleXListLiteral EOF ) + // InternalScope.g:2231:1: ruleXListLiteral EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXListLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; + } - } - break; - case 7 : - // InternalScope.g:2218:2: ( 'sortBy' ) - { - // InternalScope.g:2218:2: ( 'sortBy' ) - // InternalScope.g:2219:3: 'sortBy' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); - } - match(input,29,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXListLiteral" - } + // $ANTLR start "ruleXListLiteral" + // InternalScope.g:2238:1: ruleXListLiteral : ( ( rule__XListLiteral__Group__0 ) ) ; + public final void ruleXListLiteral() throws RecognitionException { - } - break; - case 8 : - // InternalScope.g:2224:2: ( 'forAll' ) - { - // InternalScope.g:2224:2: ( 'forAll' ) - // InternalScope.g:2225:3: 'forAll' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); - } - match(input,30,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); - } + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2242:2: ( ( ( rule__XListLiteral__Group__0 ) ) ) + // InternalScope.g:2243:2: ( ( rule__XListLiteral__Group__0 ) ) + { + // InternalScope.g:2243:2: ( ( rule__XListLiteral__Group__0 ) ) + // InternalScope.g:2244:3: ( rule__XListLiteral__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup()); + } + // InternalScope.g:2245:3: ( rule__XListLiteral__Group__0 ) + // InternalScope.g:2245:4: rule__XListLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__0(); - } + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup()); + } + + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -8315,82 +7612,79 @@ public final void rule__CollectionExpression__NameAlternatives_0_0() throws Reco } return ; } - // $ANTLR end "rule__CollectionExpression__NameAlternatives_0_0" - + // $ANTLR end "ruleXListLiteral" - // $ANTLR start "rule__Type__Alternatives" - // InternalScope.g:2234:1: rule__Type__Alternatives : ( ( ruleCollectionType ) | ( ruleSimpleType ) ); - public final void rule__Type__Alternatives() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXClosure" + // InternalScope.g:2254:1: entryRuleXClosure : ruleXClosure EOF ; + public final void entryRuleXClosure() throws RecognitionException { try { - // InternalScope.g:2238:1: ( ( ruleCollectionType ) | ( ruleSimpleType ) ) - int alt25=2; - int LA25_0 = input.LA(1); - - if ( ((LA25_0>=33 && LA25_0<=35)) ) { - alt25=1; + // InternalScope.g:2255:1: ( ruleXClosure EOF ) + // InternalScope.g:2256:1: ruleXClosure EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureRule()); } - else if ( (LA25_0==RULE_ID) ) { - alt25=2; + pushFollow(FOLLOW_1); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureRule()); } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 25, 0, input); + match(input,EOF,FOLLOW_2); if (state.failed) return ; - throw nvae; } - switch (alt25) { - case 1 : - // InternalScope.g:2239:2: ( ruleCollectionType ) - { - // InternalScope.g:2239:2: ( ruleCollectionType ) - // InternalScope.g:2240:3: ruleCollectionType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); - } - pushFollow(FOLLOW_2); - ruleCollectionType(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); - } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + } + return ; + } + // $ANTLR end "entryRuleXClosure" - } + // $ANTLR start "ruleXClosure" + // InternalScope.g:2263:1: ruleXClosure : ( ( rule__XClosure__Group__0 ) ) ; + public final void ruleXClosure() throws RecognitionException { - } - break; - case 2 : - // InternalScope.g:2245:2: ( ruleSimpleType ) - { - // InternalScope.g:2245:2: ( ruleSimpleType ) - // InternalScope.g:2246:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); + int stackSize = keepStackSize(); + + try { + // InternalScope.g:2267:2: ( ( ( rule__XClosure__Group__0 ) ) ) + // InternalScope.g:2268:2: ( ( rule__XClosure__Group__0 ) ) + { + // InternalScope.g:2268:2: ( ( rule__XClosure__Group__0 ) ) + // InternalScope.g:2269:3: ( rule__XClosure__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup()); + } + // InternalScope.g:2270:3: ( rule__XClosure__Group__0 ) + // InternalScope.g:2270:4: rule__XClosure__Group__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group__0(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); - } + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -8403,194 +7697,79 @@ else if ( (LA25_0==RULE_ID) ) { } return ; } - // $ANTLR end "rule__Type__Alternatives" + // $ANTLR end "ruleXClosure" - // $ANTLR start "rule__CollectionType__ClAlternatives_0_0" - // InternalScope.g:2255:1: rule__CollectionType__ClAlternatives_0_0 : ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ); - public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpressionInClosure" + // InternalScope.g:2279:1: entryRuleXExpressionInClosure : ruleXExpressionInClosure EOF ; + public final void entryRuleXExpressionInClosure() throws RecognitionException { try { - // InternalScope.g:2259:1: ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ) - int alt26=3; - switch ( input.LA(1) ) { - case 33: - { - alt26=1; - } - break; - case 34: - { - alt26=2; - } - break; - case 35: - { - alt26=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 26, 0, input); - - throw nvae; + // InternalScope.g:2280:1: ( ruleXExpressionInClosure EOF ) + // InternalScope.g:2281:1: ruleXExpressionInClosure EOF + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureRule()); } + pushFollow(FOLLOW_1); + ruleXExpressionInClosure(); - switch (alt26) { - case 1 : - // InternalScope.g:2260:2: ( 'Collection' ) - { - // InternalScope.g:2260:2: ( 'Collection' ) - // InternalScope.g:2261:3: 'Collection' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); - } - match(input,33,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); - } - - } - - - } - break; - case 2 : - // InternalScope.g:2266:2: ( 'List' ) - { - // InternalScope.g:2266:2: ( 'List' ) - // InternalScope.g:2267:3: 'List' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); - } - match(input,34,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); - } - - } - - - } - break; - case 3 : - // InternalScope.g:2272:2: ( 'Set' ) - { - // InternalScope.g:2272:2: ( 'Set' ) - // InternalScope.g:2273:3: 'Set' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); - } - match(input,35,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); - } - - } - - - } - break; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } + } catch (RecognitionException re) { reportError(re); recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__CollectionType__ClAlternatives_0_0" + // $ANTLR end "entryRuleXExpressionInClosure" - // $ANTLR start "rule__Casing__Alternatives" - // InternalScope.g:2282:1: rule__Casing__Alternatives : ( ( ( 'sensitive' ) ) | ( ( 'insensitive' ) ) ); - public final void rule__Casing__Alternatives() throws RecognitionException { + // $ANTLR start "ruleXExpressionInClosure" + // InternalScope.g:2288:1: ruleXExpressionInClosure : ( ( rule__XExpressionInClosure__Group__0 ) ) ; + public final void ruleXExpressionInClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2286:1: ( ( ( 'sensitive' ) ) | ( ( 'insensitive' ) ) ) - int alt27=2; - int LA27_0 = input.LA(1); - - if ( (LA27_0==36) ) { - alt27=1; - } - else if ( (LA27_0==37) ) { - alt27=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 27, 0, input); - - throw nvae; + // InternalScope.g:2292:2: ( ( ( rule__XExpressionInClosure__Group__0 ) ) ) + // InternalScope.g:2293:2: ( ( rule__XExpressionInClosure__Group__0 ) ) + { + // InternalScope.g:2293:2: ( ( rule__XExpressionInClosure__Group__0 ) ) + // InternalScope.g:2294:3: ( rule__XExpressionInClosure__Group__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getGroup()); } - switch (alt27) { - case 1 : - // InternalScope.g:2287:2: ( ( 'sensitive' ) ) - { - // InternalScope.g:2287:2: ( ( 'sensitive' ) ) - // InternalScope.g:2288:3: ( 'sensitive' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); - } - // InternalScope.g:2289:3: ( 'sensitive' ) - // InternalScope.g:2289:4: 'sensitive' - { - match(input,36,FOLLOW_2); if (state.failed) return ; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); - } - - } - - - } - break; - case 2 : - // InternalScope.g:2293:2: ( ( 'insensitive' ) ) - { - // InternalScope.g:2293:2: ( ( 'insensitive' ) ) - // InternalScope.g:2294:3: ( 'insensitive' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); - } - // InternalScope.g:2295:3: ( 'insensitive' ) - // InternalScope.g:2295:4: 'insensitive' - { - match(input,37,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:2295:3: ( rule__XExpressionInClosure__Group__0 ) + // InternalScope.g:2295:4: rule__XExpressionInClosure__Group__0 + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__0(); - } + state._fsp--; + if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); - } + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getGroup()); + } + } - } - break; } + } catch (RecognitionException re) { reportError(re); @@ -8603,29 +7782,28 @@ else if ( (LA27_0==37) ) { } return ; } - // $ANTLR end "rule__Casing__Alternatives" + // $ANTLR end "ruleXExpressionInClosure" - // $ANTLR start "rule__ScopeModel__Group__0" - // InternalScope.g:2303:1: rule__ScopeModel__Group__0 : rule__ScopeModel__Group__0__Impl rule__ScopeModel__Group__1 ; - public final void rule__ScopeModel__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXShortClosure" + // InternalScope.g:2304:1: entryRuleXShortClosure : ruleXShortClosure EOF ; + public final void entryRuleXShortClosure() throws RecognitionException { try { - // InternalScope.g:2307:1: ( rule__ScopeModel__Group__0__Impl rule__ScopeModel__Group__1 ) - // InternalScope.g:2308:2: rule__ScopeModel__Group__0__Impl rule__ScopeModel__Group__1 + // InternalScope.g:2305:1: ( ruleXShortClosure EOF ) + // InternalScope.g:2306:1: ruleXShortClosure EOF { - pushFollow(FOLLOW_3); - rule__ScopeModel__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_1); + ruleXShortClosure(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8635,34 +7813,41 @@ public final void rule__ScopeModel__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__0" + // $ANTLR end "entryRuleXShortClosure" - // $ANTLR start "rule__ScopeModel__Group__0__Impl" - // InternalScope.g:2315:1: rule__ScopeModel__Group__0__Impl : ( 'scoping' ) ; - public final void rule__ScopeModel__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXShortClosure" + // InternalScope.g:2313:1: ruleXShortClosure : ( ( rule__XShortClosure__Group__0 ) ) ; + public final void ruleXShortClosure() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2319:1: ( ( 'scoping' ) ) - // InternalScope.g:2320:1: ( 'scoping' ) + // InternalScope.g:2317:2: ( ( ( rule__XShortClosure__Group__0 ) ) ) + // InternalScope.g:2318:2: ( ( rule__XShortClosure__Group__0 ) ) { - // InternalScope.g:2320:1: ( 'scoping' ) - // InternalScope.g:2321:2: 'scoping' + // InternalScope.g:2318:2: ( ( rule__XShortClosure__Group__0 ) ) + // InternalScope.g:2319:3: ( rule__XShortClosure__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); + before(grammarAccess.getXShortClosureAccess().getGroup()); + } + // InternalScope.g:2320:3: ( rule__XShortClosure__Group__0 ) + // InternalScope.g:2320:4: rule__XShortClosure__Group__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); + after(grammarAccess.getXShortClosureAccess().getGroup()); } } @@ -8682,29 +7867,28 @@ public final void rule__ScopeModel__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__0__Impl" - + // $ANTLR end "ruleXShortClosure" - // $ANTLR start "rule__ScopeModel__Group__1" - // InternalScope.g:2330:1: rule__ScopeModel__Group__1 : rule__ScopeModel__Group__1__Impl rule__ScopeModel__Group__2 ; - public final void rule__ScopeModel__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXParenthesizedExpression" + // InternalScope.g:2329:1: entryRuleXParenthesizedExpression : ruleXParenthesizedExpression EOF ; + public final void entryRuleXParenthesizedExpression() throws RecognitionException { try { - // InternalScope.g:2334:1: ( rule__ScopeModel__Group__1__Impl rule__ScopeModel__Group__2 ) - // InternalScope.g:2335:2: rule__ScopeModel__Group__1__Impl rule__ScopeModel__Group__2 + // InternalScope.g:2330:1: ( ruleXParenthesizedExpression EOF ) + // InternalScope.g:2331:1: ruleXParenthesizedExpression EOF { - pushFollow(FOLLOW_4); - rule__ScopeModel__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXParenthesizedExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8714,36 +7898,33 @@ public final void rule__ScopeModel__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__1" + // $ANTLR end "entryRuleXParenthesizedExpression" - // $ANTLR start "rule__ScopeModel__Group__1__Impl" - // InternalScope.g:2342:1: rule__ScopeModel__Group__1__Impl : ( ( rule__ScopeModel__NameAssignment_1 ) ) ; - public final void rule__ScopeModel__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXParenthesizedExpression" + // InternalScope.g:2338:1: ruleXParenthesizedExpression : ( ( rule__XParenthesizedExpression__Group__0 ) ) ; + public final void ruleXParenthesizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2346:1: ( ( ( rule__ScopeModel__NameAssignment_1 ) ) ) - // InternalScope.g:2347:1: ( ( rule__ScopeModel__NameAssignment_1 ) ) + // InternalScope.g:2342:2: ( ( ( rule__XParenthesizedExpression__Group__0 ) ) ) + // InternalScope.g:2343:2: ( ( rule__XParenthesizedExpression__Group__0 ) ) { - // InternalScope.g:2347:1: ( ( rule__ScopeModel__NameAssignment_1 ) ) - // InternalScope.g:2348:2: ( rule__ScopeModel__NameAssignment_1 ) + // InternalScope.g:2343:2: ( ( rule__XParenthesizedExpression__Group__0 ) ) + // InternalScope.g:2344:3: ( rule__XParenthesizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getNameAssignment_1()); + before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } - // InternalScope.g:2349:2: ( rule__ScopeModel__NameAssignment_1 ) - // InternalScope.g:2349:3: rule__ScopeModel__NameAssignment_1 + // InternalScope.g:2345:3: ( rule__XParenthesizedExpression__Group__0 ) + // InternalScope.g:2345:4: rule__XParenthesizedExpression__Group__0 { pushFollow(FOLLOW_2); - rule__ScopeModel__NameAssignment_1(); + rule__XParenthesizedExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -8751,7 +7932,7 @@ public final void rule__ScopeModel__Group__1__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getNameAssignment_1()); + after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); } } @@ -8771,29 +7952,28 @@ public final void rule__ScopeModel__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__1__Impl" - + // $ANTLR end "ruleXParenthesizedExpression" - // $ANTLR start "rule__ScopeModel__Group__2" - // InternalScope.g:2357:1: rule__ScopeModel__Group__2 : rule__ScopeModel__Group__2__Impl rule__ScopeModel__Group__3 ; - public final void rule__ScopeModel__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXIfExpression" + // InternalScope.g:2354:1: entryRuleXIfExpression : ruleXIfExpression EOF ; + public final void entryRuleXIfExpression() throws RecognitionException { try { - // InternalScope.g:2361:1: ( rule__ScopeModel__Group__2__Impl rule__ScopeModel__Group__3 ) - // InternalScope.g:2362:2: rule__ScopeModel__Group__2__Impl rule__ScopeModel__Group__3 + // InternalScope.g:2355:1: ( ruleXIfExpression EOF ) + // InternalScope.g:2356:1: ruleXIfExpression EOF { - pushFollow(FOLLOW_4); - rule__ScopeModel__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXIfExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8803,55 +7983,41 @@ public final void rule__ScopeModel__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__2" + // $ANTLR end "entryRuleXIfExpression" - // $ANTLR start "rule__ScopeModel__Group__2__Impl" - // InternalScope.g:2369:1: rule__ScopeModel__Group__2__Impl : ( ( rule__ScopeModel__Group_2__0 )? ) ; - public final void rule__ScopeModel__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXIfExpression" + // InternalScope.g:2363:1: ruleXIfExpression : ( ( rule__XIfExpression__Group__0 ) ) ; + public final void ruleXIfExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2373:1: ( ( ( rule__ScopeModel__Group_2__0 )? ) ) - // InternalScope.g:2374:1: ( ( rule__ScopeModel__Group_2__0 )? ) + // InternalScope.g:2367:2: ( ( ( rule__XIfExpression__Group__0 ) ) ) + // InternalScope.g:2368:2: ( ( rule__XIfExpression__Group__0 ) ) { - // InternalScope.g:2374:1: ( ( rule__ScopeModel__Group_2__0 )? ) - // InternalScope.g:2375:2: ( rule__ScopeModel__Group_2__0 )? + // InternalScope.g:2368:2: ( ( rule__XIfExpression__Group__0 ) ) + // InternalScope.g:2369:3: ( rule__XIfExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getGroup_2()); + before(grammarAccess.getXIfExpressionAccess().getGroup()); } - // InternalScope.g:2376:2: ( rule__ScopeModel__Group_2__0 )? - int alt28=2; - int LA28_0 = input.LA(1); - - if ( (LA28_0==39) ) { - alt28=1; - } - switch (alt28) { - case 1 : - // InternalScope.g:2376:3: rule__ScopeModel__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__ScopeModel__Group_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2370:3: ( rule__XIfExpression__Group__0 ) + // InternalScope.g:2370:4: rule__XIfExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getGroup_2()); + after(grammarAccess.getXIfExpressionAccess().getGroup()); } } @@ -8871,29 +8037,28 @@ public final void rule__ScopeModel__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__2__Impl" - + // $ANTLR end "ruleXIfExpression" - // $ANTLR start "rule__ScopeModel__Group__3" - // InternalScope.g:2384:1: rule__ScopeModel__Group__3 : rule__ScopeModel__Group__3__Impl rule__ScopeModel__Group__4 ; - public final void rule__ScopeModel__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSwitchExpression" + // InternalScope.g:2379:1: entryRuleXSwitchExpression : ruleXSwitchExpression EOF ; + public final void entryRuleXSwitchExpression() throws RecognitionException { try { - // InternalScope.g:2388:1: ( rule__ScopeModel__Group__3__Impl rule__ScopeModel__Group__4 ) - // InternalScope.g:2389:2: rule__ScopeModel__Group__3__Impl rule__ScopeModel__Group__4 + // InternalScope.g:2380:1: ( ruleXSwitchExpression EOF ) + // InternalScope.g:2381:1: ruleXSwitchExpression EOF { - pushFollow(FOLLOW_4); - rule__ScopeModel__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXSwitchExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -8903,62 +8068,41 @@ public final void rule__ScopeModel__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__3" + // $ANTLR end "entryRuleXSwitchExpression" - // $ANTLR start "rule__ScopeModel__Group__3__Impl" - // InternalScope.g:2396:1: rule__ScopeModel__Group__3__Impl : ( ( rule__ScopeModel__ImportsAssignment_3 )* ) ; - public final void rule__ScopeModel__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXSwitchExpression" + // InternalScope.g:2388:1: ruleXSwitchExpression : ( ( rule__XSwitchExpression__Group__0 ) ) ; + public final void ruleXSwitchExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2400:1: ( ( ( rule__ScopeModel__ImportsAssignment_3 )* ) ) - // InternalScope.g:2401:1: ( ( rule__ScopeModel__ImportsAssignment_3 )* ) + // InternalScope.g:2392:2: ( ( ( rule__XSwitchExpression__Group__0 ) ) ) + // InternalScope.g:2393:2: ( ( rule__XSwitchExpression__Group__0 ) ) { - // InternalScope.g:2401:1: ( ( rule__ScopeModel__ImportsAssignment_3 )* ) - // InternalScope.g:2402:2: ( rule__ScopeModel__ImportsAssignment_3 )* + // InternalScope.g:2393:2: ( ( rule__XSwitchExpression__Group__0 ) ) + // InternalScope.g:2394:3: ( rule__XSwitchExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); + before(grammarAccess.getXSwitchExpressionAccess().getGroup()); } - // InternalScope.g:2403:2: ( rule__ScopeModel__ImportsAssignment_3 )* - loop29: - do { - int alt29=2; - int LA29_0 = input.LA(1); - - if ( (LA29_0==40) ) { - alt29=1; - } - - - switch (alt29) { - case 1 : - // InternalScope.g:2403:3: rule__ScopeModel__ImportsAssignment_3 - { - pushFollow(FOLLOW_5); - rule__ScopeModel__ImportsAssignment_3(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2395:3: ( rule__XSwitchExpression__Group__0 ) + // InternalScope.g:2395:4: rule__XSwitchExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop29; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); + after(grammarAccess.getXSwitchExpressionAccess().getGroup()); } } @@ -8978,29 +8122,28 @@ public final void rule__ScopeModel__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__3__Impl" - + // $ANTLR end "ruleXSwitchExpression" - // $ANTLR start "rule__ScopeModel__Group__4" - // InternalScope.g:2411:1: rule__ScopeModel__Group__4 : rule__ScopeModel__Group__4__Impl rule__ScopeModel__Group__5 ; - public final void rule__ScopeModel__Group__4() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCasePart" + // InternalScope.g:2404:1: entryRuleXCasePart : ruleXCasePart EOF ; + public final void entryRuleXCasePart() throws RecognitionException { try { - // InternalScope.g:2415:1: ( rule__ScopeModel__Group__4__Impl rule__ScopeModel__Group__5 ) - // InternalScope.g:2416:2: rule__ScopeModel__Group__4__Impl rule__ScopeModel__Group__5 + // InternalScope.g:2405:1: ( ruleXCasePart EOF ) + // InternalScope.g:2406:1: ruleXCasePart EOF { - pushFollow(FOLLOW_4); - rule__ScopeModel__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_1); + ruleXCasePart(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9010,62 +8153,41 @@ public final void rule__ScopeModel__Group__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__4" + // $ANTLR end "entryRuleXCasePart" - // $ANTLR start "rule__ScopeModel__Group__4__Impl" - // InternalScope.g:2423:1: rule__ScopeModel__Group__4__Impl : ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) ; - public final void rule__ScopeModel__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXCasePart" + // InternalScope.g:2413:1: ruleXCasePart : ( ( rule__XCasePart__Group__0 ) ) ; + public final void ruleXCasePart() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2427:1: ( ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) ) - // InternalScope.g:2428:1: ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) + // InternalScope.g:2417:2: ( ( ( rule__XCasePart__Group__0 ) ) ) + // InternalScope.g:2418:2: ( ( rule__XCasePart__Group__0 ) ) { - // InternalScope.g:2428:1: ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) - // InternalScope.g:2429:2: ( rule__ScopeModel__ExtensionsAssignment_4 )* + // InternalScope.g:2418:2: ( ( rule__XCasePart__Group__0 ) ) + // InternalScope.g:2419:3: ( rule__XCasePart__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); + before(grammarAccess.getXCasePartAccess().getGroup()); } - // InternalScope.g:2430:2: ( rule__ScopeModel__ExtensionsAssignment_4 )* - loop30: - do { - int alt30=2; - int LA30_0 = input.LA(1); - - if ( (LA30_0==42) ) { - alt30=1; - } - - - switch (alt30) { - case 1 : - // InternalScope.g:2430:3: rule__ScopeModel__ExtensionsAssignment_4 - { - pushFollow(FOLLOW_6); - rule__ScopeModel__ExtensionsAssignment_4(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2420:3: ( rule__XCasePart__Group__0 ) + // InternalScope.g:2420:4: rule__XCasePart__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop30; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); + after(grammarAccess.getXCasePartAccess().getGroup()); } } @@ -9085,29 +8207,28 @@ public final void rule__ScopeModel__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__4__Impl" + // $ANTLR end "ruleXCasePart" - // $ANTLR start "rule__ScopeModel__Group__5" - // InternalScope.g:2438:1: rule__ScopeModel__Group__5 : rule__ScopeModel__Group__5__Impl rule__ScopeModel__Group__6 ; - public final void rule__ScopeModel__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXForLoopExpression" + // InternalScope.g:2429:1: entryRuleXForLoopExpression : ruleXForLoopExpression EOF ; + public final void entryRuleXForLoopExpression() throws RecognitionException { try { - // InternalScope.g:2442:1: ( rule__ScopeModel__Group__5__Impl rule__ScopeModel__Group__6 ) - // InternalScope.g:2443:2: rule__ScopeModel__Group__5__Impl rule__ScopeModel__Group__6 + // InternalScope.g:2430:1: ( ruleXForLoopExpression EOF ) + // InternalScope.g:2431:1: ruleXForLoopExpression EOF { - pushFollow(FOLLOW_4); - rule__ScopeModel__Group__5__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__6(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXForLoopExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9117,62 +8238,41 @@ public final void rule__ScopeModel__Group__5() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__5" + // $ANTLR end "entryRuleXForLoopExpression" - // $ANTLR start "rule__ScopeModel__Group__5__Impl" - // InternalScope.g:2450:1: rule__ScopeModel__Group__5__Impl : ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) ; - public final void rule__ScopeModel__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleXForLoopExpression" + // InternalScope.g:2438:1: ruleXForLoopExpression : ( ( rule__XForLoopExpression__Group__0 ) ) ; + public final void ruleXForLoopExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2454:1: ( ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) ) - // InternalScope.g:2455:1: ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) + // InternalScope.g:2442:2: ( ( ( rule__XForLoopExpression__Group__0 ) ) ) + // InternalScope.g:2443:2: ( ( rule__XForLoopExpression__Group__0 ) ) { - // InternalScope.g:2455:1: ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) - // InternalScope.g:2456:2: ( rule__ScopeModel__InjectionsAssignment_5 )* + // InternalScope.g:2443:2: ( ( rule__XForLoopExpression__Group__0 ) ) + // InternalScope.g:2444:3: ( rule__XForLoopExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); + before(grammarAccess.getXForLoopExpressionAccess().getGroup()); } - // InternalScope.g:2457:2: ( rule__ScopeModel__InjectionsAssignment_5 )* - loop31: - do { - int alt31=2; - int LA31_0 = input.LA(1); - - if ( (LA31_0==43) ) { - alt31=1; - } - - - switch (alt31) { - case 1 : - // InternalScope.g:2457:3: rule__ScopeModel__InjectionsAssignment_5 - { - pushFollow(FOLLOW_7); - rule__ScopeModel__InjectionsAssignment_5(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2445:3: ( rule__XForLoopExpression__Group__0 ) + // InternalScope.g:2445:4: rule__XForLoopExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop31; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); + after(grammarAccess.getXForLoopExpressionAccess().getGroup()); } } @@ -9192,29 +8292,28 @@ public final void rule__ScopeModel__Group__5__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__5__Impl" - + // $ANTLR end "ruleXForLoopExpression" - // $ANTLR start "rule__ScopeModel__Group__6" - // InternalScope.g:2465:1: rule__ScopeModel__Group__6 : rule__ScopeModel__Group__6__Impl rule__ScopeModel__Group__7 ; - public final void rule__ScopeModel__Group__6() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBasicForLoopExpression" + // InternalScope.g:2454:1: entryRuleXBasicForLoopExpression : ruleXBasicForLoopExpression EOF ; + public final void entryRuleXBasicForLoopExpression() throws RecognitionException { try { - // InternalScope.g:2469:1: ( rule__ScopeModel__Group__6__Impl rule__ScopeModel__Group__7 ) - // InternalScope.g:2470:2: rule__ScopeModel__Group__6__Impl rule__ScopeModel__Group__7 + // InternalScope.g:2455:1: ( ruleXBasicForLoopExpression EOF ) + // InternalScope.g:2456:1: ruleXBasicForLoopExpression EOF { - pushFollow(FOLLOW_4); - rule__ScopeModel__Group__6__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__7(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXBasicForLoopExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9224,55 +8323,41 @@ public final void rule__ScopeModel__Group__6() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__6" + // $ANTLR end "entryRuleXBasicForLoopExpression" - // $ANTLR start "rule__ScopeModel__Group__6__Impl" - // InternalScope.g:2477:1: rule__ScopeModel__Group__6__Impl : ( ( rule__ScopeModel__NamingAssignment_6 )? ) ; - public final void rule__ScopeModel__Group__6__Impl() throws RecognitionException { + // $ANTLR start "ruleXBasicForLoopExpression" + // InternalScope.g:2463:1: ruleXBasicForLoopExpression : ( ( rule__XBasicForLoopExpression__Group__0 ) ) ; + public final void ruleXBasicForLoopExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2481:1: ( ( ( rule__ScopeModel__NamingAssignment_6 )? ) ) - // InternalScope.g:2482:1: ( ( rule__ScopeModel__NamingAssignment_6 )? ) + // InternalScope.g:2467:2: ( ( ( rule__XBasicForLoopExpression__Group__0 ) ) ) + // InternalScope.g:2468:2: ( ( rule__XBasicForLoopExpression__Group__0 ) ) { - // InternalScope.g:2482:1: ( ( rule__ScopeModel__NamingAssignment_6 )? ) - // InternalScope.g:2483:2: ( rule__ScopeModel__NamingAssignment_6 )? + // InternalScope.g:2468:2: ( ( rule__XBasicForLoopExpression__Group__0 ) ) + // InternalScope.g:2469:3: ( rule__XBasicForLoopExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); - } - // InternalScope.g:2484:2: ( rule__ScopeModel__NamingAssignment_6 )? - int alt32=2; - int LA32_0 = input.LA(1); - - if ( (LA32_0==44||LA32_0==47) ) { - alt32=1; + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } - switch (alt32) { - case 1 : - // InternalScope.g:2484:3: rule__ScopeModel__NamingAssignment_6 - { - pushFollow(FOLLOW_2); - rule__ScopeModel__NamingAssignment_6(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2470:3: ( rule__XBasicForLoopExpression__Group__0 ) + // InternalScope.g:2470:4: rule__XBasicForLoopExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); } } @@ -9292,24 +8377,28 @@ public final void rule__ScopeModel__Group__6__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__6__Impl" - + // $ANTLR end "ruleXBasicForLoopExpression" - // $ANTLR start "rule__ScopeModel__Group__7" - // InternalScope.g:2492:1: rule__ScopeModel__Group__7 : rule__ScopeModel__Group__7__Impl ; - public final void rule__ScopeModel__Group__7() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXWhileExpression" + // InternalScope.g:2479:1: entryRuleXWhileExpression : ruleXWhileExpression EOF ; + public final void entryRuleXWhileExpression() throws RecognitionException { try { - // InternalScope.g:2496:1: ( rule__ScopeModel__Group__7__Impl ) - // InternalScope.g:2497:2: rule__ScopeModel__Group__7__Impl + // InternalScope.g:2480:1: ( ruleXWhileExpression EOF ) + // InternalScope.g:2481:1: ruleXWhileExpression EOF { - pushFollow(FOLLOW_2); - rule__ScopeModel__Group__7__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXWhileExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9319,62 +8408,41 @@ public final void rule__ScopeModel__Group__7() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group__7" + // $ANTLR end "entryRuleXWhileExpression" - // $ANTLR start "rule__ScopeModel__Group__7__Impl" - // InternalScope.g:2503:1: rule__ScopeModel__Group__7__Impl : ( ( rule__ScopeModel__ScopesAssignment_7 )* ) ; - public final void rule__ScopeModel__Group__7__Impl() throws RecognitionException { + // $ANTLR start "ruleXWhileExpression" + // InternalScope.g:2488:1: ruleXWhileExpression : ( ( rule__XWhileExpression__Group__0 ) ) ; + public final void ruleXWhileExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2507:1: ( ( ( rule__ScopeModel__ScopesAssignment_7 )* ) ) - // InternalScope.g:2508:1: ( ( rule__ScopeModel__ScopesAssignment_7 )* ) + // InternalScope.g:2492:2: ( ( ( rule__XWhileExpression__Group__0 ) ) ) + // InternalScope.g:2493:2: ( ( rule__XWhileExpression__Group__0 ) ) { - // InternalScope.g:2508:1: ( ( rule__ScopeModel__ScopesAssignment_7 )* ) - // InternalScope.g:2509:2: ( rule__ScopeModel__ScopesAssignment_7 )* + // InternalScope.g:2493:2: ( ( rule__XWhileExpression__Group__0 ) ) + // InternalScope.g:2494:3: ( rule__XWhileExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); + before(grammarAccess.getXWhileExpressionAccess().getGroup()); } - // InternalScope.g:2510:2: ( rule__ScopeModel__ScopesAssignment_7 )* - loop33: - do { - int alt33=2; - int LA33_0 = input.LA(1); - - if ( (LA33_0==50) ) { - alt33=1; - } - - - switch (alt33) { - case 1 : - // InternalScope.g:2510:3: rule__ScopeModel__ScopesAssignment_7 - { - pushFollow(FOLLOW_8); - rule__ScopeModel__ScopesAssignment_7(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2495:3: ( rule__XWhileExpression__Group__0 ) + // InternalScope.g:2495:4: rule__XWhileExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop33; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); + after(grammarAccess.getXWhileExpressionAccess().getGroup()); } } @@ -9394,29 +8462,28 @@ public final void rule__ScopeModel__Group__7__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeModel__Group__7__Impl" - + // $ANTLR end "ruleXWhileExpression" - // $ANTLR start "rule__ScopeModel__Group_2__0" - // InternalScope.g:2519:1: rule__ScopeModel__Group_2__0 : rule__ScopeModel__Group_2__0__Impl rule__ScopeModel__Group_2__1 ; - public final void rule__ScopeModel__Group_2__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXDoWhileExpression" + // InternalScope.g:2504:1: entryRuleXDoWhileExpression : ruleXDoWhileExpression EOF ; + public final void entryRuleXDoWhileExpression() throws RecognitionException { try { - // InternalScope.g:2523:1: ( rule__ScopeModel__Group_2__0__Impl rule__ScopeModel__Group_2__1 ) - // InternalScope.g:2524:2: rule__ScopeModel__Group_2__0__Impl rule__ScopeModel__Group_2__1 + // InternalScope.g:2505:1: ( ruleXDoWhileExpression EOF ) + // InternalScope.g:2506:1: ruleXDoWhileExpression EOF { - pushFollow(FOLLOW_3); - rule__ScopeModel__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeModel__Group_2__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXDoWhileExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9426,34 +8493,41 @@ public final void rule__ScopeModel__Group_2__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group_2__0" + // $ANTLR end "entryRuleXDoWhileExpression" - // $ANTLR start "rule__ScopeModel__Group_2__0__Impl" - // InternalScope.g:2531:1: rule__ScopeModel__Group_2__0__Impl : ( 'with' ) ; - public final void rule__ScopeModel__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXDoWhileExpression" + // InternalScope.g:2513:1: ruleXDoWhileExpression : ( ( rule__XDoWhileExpression__Group__0 ) ) ; + public final void ruleXDoWhileExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2535:1: ( ( 'with' ) ) - // InternalScope.g:2536:1: ( 'with' ) + // InternalScope.g:2517:2: ( ( ( rule__XDoWhileExpression__Group__0 ) ) ) + // InternalScope.g:2518:2: ( ( rule__XDoWhileExpression__Group__0 ) ) { - // InternalScope.g:2536:1: ( 'with' ) - // InternalScope.g:2537:2: 'with' + // InternalScope.g:2518:2: ( ( rule__XDoWhileExpression__Group__0 ) ) + // InternalScope.g:2519:3: ( rule__XDoWhileExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); + before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } - match(input,39,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); + // InternalScope.g:2520:3: ( rule__XDoWhileExpression__Group__0 ) + // InternalScope.g:2520:4: rule__XDoWhileExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); } } @@ -9473,24 +8547,28 @@ public final void rule__ScopeModel__Group_2__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ScopeModel__Group_2__0__Impl" + // $ANTLR end "ruleXDoWhileExpression" - // $ANTLR start "rule__ScopeModel__Group_2__1" - // InternalScope.g:2546:1: rule__ScopeModel__Group_2__1 : rule__ScopeModel__Group_2__1__Impl ; - public final void rule__ScopeModel__Group_2__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBlockExpression" + // InternalScope.g:2529:1: entryRuleXBlockExpression : ruleXBlockExpression EOF ; + public final void entryRuleXBlockExpression() throws RecognitionException { try { - // InternalScope.g:2550:1: ( rule__ScopeModel__Group_2__1__Impl ) - // InternalScope.g:2551:2: rule__ScopeModel__Group_2__1__Impl + // InternalScope.g:2530:1: ( ruleXBlockExpression EOF ) + // InternalScope.g:2531:1: ruleXBlockExpression EOF { - pushFollow(FOLLOW_2); - rule__ScopeModel__Group_2__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXBlockExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9500,36 +8578,33 @@ public final void rule__ScopeModel__Group_2__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeModel__Group_2__1" + // $ANTLR end "entryRuleXBlockExpression" - // $ANTLR start "rule__ScopeModel__Group_2__1__Impl" - // InternalScope.g:2557:1: rule__ScopeModel__Group_2__1__Impl : ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) ; - public final void rule__ScopeModel__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXBlockExpression" + // InternalScope.g:2538:1: ruleXBlockExpression : ( ( rule__XBlockExpression__Group__0 ) ) ; + public final void ruleXBlockExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2561:1: ( ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) ) - // InternalScope.g:2562:1: ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) + // InternalScope.g:2542:2: ( ( ( rule__XBlockExpression__Group__0 ) ) ) + // InternalScope.g:2543:2: ( ( rule__XBlockExpression__Group__0 ) ) { - // InternalScope.g:2562:1: ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) - // InternalScope.g:2563:2: ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) + // InternalScope.g:2543:2: ( ( rule__XBlockExpression__Group__0 ) ) + // InternalScope.g:2544:3: ( rule__XBlockExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); + before(grammarAccess.getXBlockExpressionAccess().getGroup()); } - // InternalScope.g:2564:2: ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) - // InternalScope.g:2564:3: rule__ScopeModel__IncludedScopesAssignment_2_1 + // InternalScope.g:2545:3: ( rule__XBlockExpression__Group__0 ) + // InternalScope.g:2545:4: rule__XBlockExpression__Group__0 { pushFollow(FOLLOW_2); - rule__ScopeModel__IncludedScopesAssignment_2_1(); + rule__XBlockExpression__Group__0(); state._fsp--; if (state.failed) return ; @@ -9537,7 +8612,7 @@ public final void rule__ScopeModel__Group_2__1__Impl() throws RecognitionExcepti } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); + after(grammarAccess.getXBlockExpressionAccess().getGroup()); } } @@ -9557,29 +8632,28 @@ public final void rule__ScopeModel__Group_2__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ScopeModel__Group_2__1__Impl" - + // $ANTLR end "ruleXBlockExpression" - // $ANTLR start "rule__Import__Group__0" - // InternalScope.g:2573:1: rule__Import__Group__0 : rule__Import__Group__0__Impl rule__Import__Group__1 ; - public final void rule__Import__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXExpressionOrVarDeclaration" + // InternalScope.g:2554:1: entryRuleXExpressionOrVarDeclaration : ruleXExpressionOrVarDeclaration EOF ; + public final void entryRuleXExpressionOrVarDeclaration() throws RecognitionException { try { - // InternalScope.g:2577:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 ) - // InternalScope.g:2578:2: rule__Import__Group__0__Impl rule__Import__Group__1 + // InternalScope.g:2555:1: ( ruleXExpressionOrVarDeclaration EOF ) + // InternalScope.g:2556:1: ruleXExpressionOrVarDeclaration EOF { - pushFollow(FOLLOW_9); - rule__Import__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Import__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXExpressionOrVarDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9589,34 +8663,41 @@ public final void rule__Import__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group__0" + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" - // $ANTLR start "rule__Import__Group__0__Impl" - // InternalScope.g:2585:1: rule__Import__Group__0__Impl : ( 'import' ) ; - public final void rule__Import__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // InternalScope.g:2563:1: ruleXExpressionOrVarDeclaration : ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ; + public final void ruleXExpressionOrVarDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2589:1: ( ( 'import' ) ) - // InternalScope.g:2590:1: ( 'import' ) + // InternalScope.g:2567:2: ( ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ) + // InternalScope.g:2568:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) { - // InternalScope.g:2590:1: ( 'import' ) - // InternalScope.g:2591:2: 'import' + // InternalScope.g:2568:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) + // InternalScope.g:2569:3: ( rule__XExpressionOrVarDeclaration__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getImportKeyword_0()); + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); + } + // InternalScope.g:2570:3: ( rule__XExpressionOrVarDeclaration__Alternatives ) + // InternalScope.g:2570:4: rule__XExpressionOrVarDeclaration__Alternatives + { + pushFollow(FOLLOW_2); + rule__XExpressionOrVarDeclaration__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getImportKeyword_0()); + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); } } @@ -9636,29 +8717,28 @@ public final void rule__Import__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group__0__Impl" - + // $ANTLR end "ruleXExpressionOrVarDeclaration" - // $ANTLR start "rule__Import__Group__1" - // InternalScope.g:2600:1: rule__Import__Group__1 : rule__Import__Group__1__Impl rule__Import__Group__2 ; - public final void rule__Import__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXVariableDeclaration" + // InternalScope.g:2579:1: entryRuleXVariableDeclaration : ruleXVariableDeclaration EOF ; + public final void entryRuleXVariableDeclaration() throws RecognitionException { try { - // InternalScope.g:2604:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 ) - // InternalScope.g:2605:2: rule__Import__Group__1__Impl rule__Import__Group__2 + // InternalScope.g:2580:1: ( ruleXVariableDeclaration EOF ) + // InternalScope.g:2581:1: ruleXVariableDeclaration EOF { - pushFollow(FOLLOW_10); - rule__Import__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Import__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXVariableDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9668,36 +8748,33 @@ public final void rule__Import__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group__1" + // $ANTLR end "entryRuleXVariableDeclaration" - // $ANTLR start "rule__Import__Group__1__Impl" - // InternalScope.g:2612:1: rule__Import__Group__1__Impl : ( ( rule__Import__PackageAssignment_1 ) ) ; - public final void rule__Import__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXVariableDeclaration" + // InternalScope.g:2588:1: ruleXVariableDeclaration : ( ( rule__XVariableDeclaration__Group__0 ) ) ; + public final void ruleXVariableDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2616:1: ( ( ( rule__Import__PackageAssignment_1 ) ) ) - // InternalScope.g:2617:1: ( ( rule__Import__PackageAssignment_1 ) ) + // InternalScope.g:2592:2: ( ( ( rule__XVariableDeclaration__Group__0 ) ) ) + // InternalScope.g:2593:2: ( ( rule__XVariableDeclaration__Group__0 ) ) { - // InternalScope.g:2617:1: ( ( rule__Import__PackageAssignment_1 ) ) - // InternalScope.g:2618:2: ( rule__Import__PackageAssignment_1 ) + // InternalScope.g:2593:2: ( ( rule__XVariableDeclaration__Group__0 ) ) + // InternalScope.g:2594:3: ( rule__XVariableDeclaration__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getPackageAssignment_1()); + before(grammarAccess.getXVariableDeclarationAccess().getGroup()); } - // InternalScope.g:2619:2: ( rule__Import__PackageAssignment_1 ) - // InternalScope.g:2619:3: rule__Import__PackageAssignment_1 + // InternalScope.g:2595:3: ( rule__XVariableDeclaration__Group__0 ) + // InternalScope.g:2595:4: rule__XVariableDeclaration__Group__0 { pushFollow(FOLLOW_2); - rule__Import__PackageAssignment_1(); + rule__XVariableDeclaration__Group__0(); state._fsp--; if (state.failed) return ; @@ -9705,7 +8782,7 @@ public final void rule__Import__Group__1__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getPackageAssignment_1()); + after(grammarAccess.getXVariableDeclarationAccess().getGroup()); } } @@ -9725,24 +8802,28 @@ public final void rule__Import__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group__1__Impl" - + // $ANTLR end "ruleXVariableDeclaration" - // $ANTLR start "rule__Import__Group__2" - // InternalScope.g:2627:1: rule__Import__Group__2 : rule__Import__Group__2__Impl ; - public final void rule__Import__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmFormalParameter" + // InternalScope.g:2604:1: entryRuleJvmFormalParameter : ruleJvmFormalParameter EOF ; + public final void entryRuleJvmFormalParameter() throws RecognitionException { try { - // InternalScope.g:2631:1: ( rule__Import__Group__2__Impl ) - // InternalScope.g:2632:2: rule__Import__Group__2__Impl + // InternalScope.g:2605:1: ( ruleJvmFormalParameter EOF ) + // InternalScope.g:2606:1: ruleJvmFormalParameter EOF { - pushFollow(FOLLOW_2); - rule__Import__Group__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + ruleJvmFormalParameter(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9752,55 +8833,41 @@ public final void rule__Import__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group__2" + // $ANTLR end "entryRuleJvmFormalParameter" - // $ANTLR start "rule__Import__Group__2__Impl" - // InternalScope.g:2638:1: rule__Import__Group__2__Impl : ( ( rule__Import__Group_2__0 )? ) ; - public final void rule__Import__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmFormalParameter" + // InternalScope.g:2613:1: ruleJvmFormalParameter : ( ( rule__JvmFormalParameter__Group__0 ) ) ; + public final void ruleJvmFormalParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2642:1: ( ( ( rule__Import__Group_2__0 )? ) ) - // InternalScope.g:2643:1: ( ( rule__Import__Group_2__0 )? ) + // InternalScope.g:2617:2: ( ( ( rule__JvmFormalParameter__Group__0 ) ) ) + // InternalScope.g:2618:2: ( ( rule__JvmFormalParameter__Group__0 ) ) { - // InternalScope.g:2643:1: ( ( rule__Import__Group_2__0 )? ) - // InternalScope.g:2644:2: ( rule__Import__Group_2__0 )? + // InternalScope.g:2618:2: ( ( rule__JvmFormalParameter__Group__0 ) ) + // InternalScope.g:2619:3: ( rule__JvmFormalParameter__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getGroup_2()); - } - // InternalScope.g:2645:2: ( rule__Import__Group_2__0 )? - int alt34=2; - int LA34_0 = input.LA(1); - - if ( (LA34_0==41) ) { - alt34=1; + before(grammarAccess.getJvmFormalParameterAccess().getGroup()); } - switch (alt34) { - case 1 : - // InternalScope.g:2645:3: rule__Import__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__Import__Group_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2620:3: ( rule__JvmFormalParameter__Group__0 ) + // InternalScope.g:2620:4: rule__JvmFormalParameter__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getGroup_2()); + after(grammarAccess.getJvmFormalParameterAccess().getGroup()); } } @@ -9820,29 +8887,28 @@ public final void rule__Import__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group__2__Impl" - + // $ANTLR end "ruleJvmFormalParameter" - // $ANTLR start "rule__Import__Group_2__0" - // InternalScope.g:2654:1: rule__Import__Group_2__0 : rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ; - public final void rule__Import__Group_2__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleFullJvmFormalParameter" + // InternalScope.g:2629:1: entryRuleFullJvmFormalParameter : ruleFullJvmFormalParameter EOF ; + public final void entryRuleFullJvmFormalParameter() throws RecognitionException { try { - // InternalScope.g:2658:1: ( rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ) - // InternalScope.g:2659:2: rule__Import__Group_2__0__Impl rule__Import__Group_2__1 + // InternalScope.g:2630:1: ( ruleFullJvmFormalParameter EOF ) + // InternalScope.g:2631:1: ruleFullJvmFormalParameter EOF { - pushFollow(FOLLOW_3); - rule__Import__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Import__Group_2__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + ruleFullJvmFormalParameter(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9852,34 +8918,41 @@ public final void rule__Import__Group_2__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group_2__0" + // $ANTLR end "entryRuleFullJvmFormalParameter" - // $ANTLR start "rule__Import__Group_2__0__Impl" - // InternalScope.g:2666:1: rule__Import__Group_2__0__Impl : ( 'as' ) ; - public final void rule__Import__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "ruleFullJvmFormalParameter" + // InternalScope.g:2638:1: ruleFullJvmFormalParameter : ( ( rule__FullJvmFormalParameter__Group__0 ) ) ; + public final void ruleFullJvmFormalParameter() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2670:1: ( ( 'as' ) ) - // InternalScope.g:2671:1: ( 'as' ) + // InternalScope.g:2642:2: ( ( ( rule__FullJvmFormalParameter__Group__0 ) ) ) + // InternalScope.g:2643:2: ( ( rule__FullJvmFormalParameter__Group__0 ) ) { - // InternalScope.g:2671:1: ( 'as' ) - // InternalScope.g:2672:2: 'as' + // InternalScope.g:2643:2: ( ( rule__FullJvmFormalParameter__Group__0 ) ) + // InternalScope.g:2644:3: ( rule__FullJvmFormalParameter__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getAsKeyword_2_0()); + before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } - match(input,41,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:2645:3: ( rule__FullJvmFormalParameter__Group__0 ) + // InternalScope.g:2645:4: rule__FullJvmFormalParameter__Group__0 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getAsKeyword_2_0()); + after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); } } @@ -9899,24 +8972,28 @@ public final void rule__Import__Group_2__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group_2__0__Impl" + // $ANTLR end "ruleFullJvmFormalParameter" - // $ANTLR start "rule__Import__Group_2__1" - // InternalScope.g:2681:1: rule__Import__Group_2__1 : rule__Import__Group_2__1__Impl ; - public final void rule__Import__Group_2__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXFeatureCall" + // InternalScope.g:2654:1: entryRuleXFeatureCall : ruleXFeatureCall EOF ; + public final void entryRuleXFeatureCall() throws RecognitionException { try { - // InternalScope.g:2685:1: ( rule__Import__Group_2__1__Impl ) - // InternalScope.g:2686:2: rule__Import__Group_2__1__Impl + // InternalScope.g:2655:1: ( ruleXFeatureCall EOF ) + // InternalScope.g:2656:1: ruleXFeatureCall EOF { - pushFollow(FOLLOW_2); - rule__Import__Group_2__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_1); + ruleXFeatureCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -9926,36 +9003,33 @@ public final void rule__Import__Group_2__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Import__Group_2__1" + // $ANTLR end "entryRuleXFeatureCall" - // $ANTLR start "rule__Import__Group_2__1__Impl" - // InternalScope.g:2692:1: rule__Import__Group_2__1__Impl : ( ( rule__Import__NameAssignment_2_1 ) ) ; - public final void rule__Import__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXFeatureCall" + // InternalScope.g:2663:1: ruleXFeatureCall : ( ( rule__XFeatureCall__Group__0 ) ) ; + public final void ruleXFeatureCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2696:1: ( ( ( rule__Import__NameAssignment_2_1 ) ) ) - // InternalScope.g:2697:1: ( ( rule__Import__NameAssignment_2_1 ) ) + // InternalScope.g:2667:2: ( ( ( rule__XFeatureCall__Group__0 ) ) ) + // InternalScope.g:2668:2: ( ( rule__XFeatureCall__Group__0 ) ) { - // InternalScope.g:2697:1: ( ( rule__Import__NameAssignment_2_1 ) ) - // InternalScope.g:2698:2: ( rule__Import__NameAssignment_2_1 ) + // InternalScope.g:2668:2: ( ( rule__XFeatureCall__Group__0 ) ) + // InternalScope.g:2669:3: ( rule__XFeatureCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getNameAssignment_2_1()); + before(grammarAccess.getXFeatureCallAccess().getGroup()); } - // InternalScope.g:2699:2: ( rule__Import__NameAssignment_2_1 ) - // InternalScope.g:2699:3: rule__Import__NameAssignment_2_1 + // InternalScope.g:2670:3: ( rule__XFeatureCall__Group__0 ) + // InternalScope.g:2670:4: rule__XFeatureCall__Group__0 { pushFollow(FOLLOW_2); - rule__Import__NameAssignment_2_1(); + rule__XFeatureCall__Group__0(); state._fsp--; if (state.failed) return ; @@ -9963,7 +9037,7 @@ public final void rule__Import__Group_2__1__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getNameAssignment_2_1()); + after(grammarAccess.getXFeatureCallAccess().getGroup()); } } @@ -9983,29 +9057,28 @@ public final void rule__Import__Group_2__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Import__Group_2__1__Impl" - + // $ANTLR end "ruleXFeatureCall" - // $ANTLR start "rule__Extension__Group__0" - // InternalScope.g:2708:1: rule__Extension__Group__0 : rule__Extension__Group__0__Impl rule__Extension__Group__1 ; - public final void rule__Extension__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleFeatureCallID" + // InternalScope.g:2679:1: entryRuleFeatureCallID : ruleFeatureCallID EOF ; + public final void entryRuleFeatureCallID() throws RecognitionException { try { - // InternalScope.g:2712:1: ( rule__Extension__Group__0__Impl rule__Extension__Group__1 ) - // InternalScope.g:2713:2: rule__Extension__Group__0__Impl rule__Extension__Group__1 + // InternalScope.g:2680:1: ( ruleFeatureCallID EOF ) + // InternalScope.g:2681:1: ruleFeatureCallID EOF { - pushFollow(FOLLOW_3); - rule__Extension__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Extension__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_1); + ruleFeatureCallID(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10015,34 +9088,41 @@ public final void rule__Extension__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Extension__Group__0" + // $ANTLR end "entryRuleFeatureCallID" - // $ANTLR start "rule__Extension__Group__0__Impl" - // InternalScope.g:2720:1: rule__Extension__Group__0__Impl : ( 'extension' ) ; - public final void rule__Extension__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleFeatureCallID" + // InternalScope.g:2688:1: ruleFeatureCallID : ( ( rule__FeatureCallID__Alternatives ) ) ; + public final void ruleFeatureCallID() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2724:1: ( ( 'extension' ) ) - // InternalScope.g:2725:1: ( 'extension' ) + // InternalScope.g:2692:2: ( ( ( rule__FeatureCallID__Alternatives ) ) ) + // InternalScope.g:2693:2: ( ( rule__FeatureCallID__Alternatives ) ) { - // InternalScope.g:2725:1: ( 'extension' ) - // InternalScope.g:2726:2: 'extension' + // InternalScope.g:2693:2: ( ( rule__FeatureCallID__Alternatives ) ) + // InternalScope.g:2694:3: ( rule__FeatureCallID__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); + before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); + } + // InternalScope.g:2695:3: ( rule__FeatureCallID__Alternatives ) + // InternalScope.g:2695:4: rule__FeatureCallID__Alternatives + { + pushFollow(FOLLOW_2); + rule__FeatureCallID__Alternatives(); + + state._fsp--; + if (state.failed) return ; + } - match(input,42,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); + after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); } } @@ -10062,24 +9142,28 @@ public final void rule__Extension__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Extension__Group__0__Impl" + // $ANTLR end "ruleFeatureCallID" - // $ANTLR start "rule__Extension__Group__1" - // InternalScope.g:2735:1: rule__Extension__Group__1 : rule__Extension__Group__1__Impl ; - public final void rule__Extension__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleIdOrSuper" + // InternalScope.g:2704:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ; + public final void entryRuleIdOrSuper() throws RecognitionException { try { - // InternalScope.g:2739:1: ( rule__Extension__Group__1__Impl ) - // InternalScope.g:2740:2: rule__Extension__Group__1__Impl + // InternalScope.g:2705:1: ( ruleIdOrSuper EOF ) + // InternalScope.g:2706:1: ruleIdOrSuper EOF { - pushFollow(FOLLOW_2); - rule__Extension__Group__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_1); + ruleIdOrSuper(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10089,36 +9173,33 @@ public final void rule__Extension__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Extension__Group__1" + // $ANTLR end "entryRuleIdOrSuper" - // $ANTLR start "rule__Extension__Group__1__Impl" - // InternalScope.g:2746:1: rule__Extension__Group__1__Impl : ( ( rule__Extension__ExtensionAssignment_1 ) ) ; - public final void rule__Extension__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleIdOrSuper" + // InternalScope.g:2713:1: ruleIdOrSuper : ( ( rule__IdOrSuper__Alternatives ) ) ; + public final void ruleIdOrSuper() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2750:1: ( ( ( rule__Extension__ExtensionAssignment_1 ) ) ) - // InternalScope.g:2751:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) + // InternalScope.g:2717:2: ( ( ( rule__IdOrSuper__Alternatives ) ) ) + // InternalScope.g:2718:2: ( ( rule__IdOrSuper__Alternatives ) ) { - // InternalScope.g:2751:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) - // InternalScope.g:2752:2: ( rule__Extension__ExtensionAssignment_1 ) + // InternalScope.g:2718:2: ( ( rule__IdOrSuper__Alternatives ) ) + // InternalScope.g:2719:3: ( rule__IdOrSuper__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); + before(grammarAccess.getIdOrSuperAccess().getAlternatives()); } - // InternalScope.g:2753:2: ( rule__Extension__ExtensionAssignment_1 ) - // InternalScope.g:2753:3: rule__Extension__ExtensionAssignment_1 + // InternalScope.g:2720:3: ( rule__IdOrSuper__Alternatives ) + // InternalScope.g:2720:4: rule__IdOrSuper__Alternatives { pushFollow(FOLLOW_2); - rule__Extension__ExtensionAssignment_1(); + rule__IdOrSuper__Alternatives(); state._fsp--; if (state.failed) return ; @@ -10126,7 +9207,7 @@ public final void rule__Extension__Group__1__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); + after(grammarAccess.getIdOrSuperAccess().getAlternatives()); } } @@ -10146,29 +9227,28 @@ public final void rule__Extension__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Extension__Group__1__Impl" - + // $ANTLR end "ruleIdOrSuper" - // $ANTLR start "rule__Injection__Group__0" - // InternalScope.g:2762:1: rule__Injection__Group__0 : rule__Injection__Group__0__Impl rule__Injection__Group__1 ; - public final void rule__Injection__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXConstructorCall" + // InternalScope.g:2729:1: entryRuleXConstructorCall : ruleXConstructorCall EOF ; + public final void entryRuleXConstructorCall() throws RecognitionException { try { - // InternalScope.g:2766:1: ( rule__Injection__Group__0__Impl rule__Injection__Group__1 ) - // InternalScope.g:2767:2: rule__Injection__Group__0__Impl rule__Injection__Group__1 + // InternalScope.g:2730:1: ( ruleXConstructorCall EOF ) + // InternalScope.g:2731:1: ruleXConstructorCall EOF { - pushFollow(FOLLOW_3); - rule__Injection__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Injection__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_1); + ruleXConstructorCall(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10178,34 +9258,41 @@ public final void rule__Injection__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Injection__Group__0" + // $ANTLR end "entryRuleXConstructorCall" - // $ANTLR start "rule__Injection__Group__0__Impl" - // InternalScope.g:2774:1: rule__Injection__Group__0__Impl : ( 'inject' ) ; - public final void rule__Injection__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXConstructorCall" + // InternalScope.g:2738:1: ruleXConstructorCall : ( ( rule__XConstructorCall__Group__0 ) ) ; + public final void ruleXConstructorCall() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2778:1: ( ( 'inject' ) ) - // InternalScope.g:2779:1: ( 'inject' ) + // InternalScope.g:2742:2: ( ( ( rule__XConstructorCall__Group__0 ) ) ) + // InternalScope.g:2743:2: ( ( rule__XConstructorCall__Group__0 ) ) { - // InternalScope.g:2779:1: ( 'inject' ) - // InternalScope.g:2780:2: 'inject' + // InternalScope.g:2743:2: ( ( rule__XConstructorCall__Group__0 ) ) + // InternalScope.g:2744:3: ( rule__XConstructorCall__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInjectionAccess().getInjectKeyword_0()); + before(grammarAccess.getXConstructorCallAccess().getGroup()); + } + // InternalScope.g:2745:3: ( rule__XConstructorCall__Group__0 ) + // InternalScope.g:2745:4: rule__XConstructorCall__Group__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,43,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInjectionAccess().getInjectKeyword_0()); + after(grammarAccess.getXConstructorCallAccess().getGroup()); } } @@ -10225,29 +9312,28 @@ public final void rule__Injection__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Injection__Group__0__Impl" + // $ANTLR end "ruleXConstructorCall" - // $ANTLR start "rule__Injection__Group__1" - // InternalScope.g:2789:1: rule__Injection__Group__1 : rule__Injection__Group__1__Impl rule__Injection__Group__2 ; - public final void rule__Injection__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXBooleanLiteral" + // InternalScope.g:2754:1: entryRuleXBooleanLiteral : ruleXBooleanLiteral EOF ; + public final void entryRuleXBooleanLiteral() throws RecognitionException { try { - // InternalScope.g:2793:1: ( rule__Injection__Group__1__Impl rule__Injection__Group__2 ) - // InternalScope.g:2794:2: rule__Injection__Group__1__Impl rule__Injection__Group__2 + // InternalScope.g:2755:1: ( ruleXBooleanLiteral EOF ) + // InternalScope.g:2756:1: ruleXBooleanLiteral EOF { - pushFollow(FOLLOW_10); - rule__Injection__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Injection__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXBooleanLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10257,36 +9343,33 @@ public final void rule__Injection__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Injection__Group__1" + // $ANTLR end "entryRuleXBooleanLiteral" - // $ANTLR start "rule__Injection__Group__1__Impl" - // InternalScope.g:2801:1: rule__Injection__Group__1__Impl : ( ( rule__Injection__TypeAssignment_1 ) ) ; - public final void rule__Injection__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXBooleanLiteral" + // InternalScope.g:2763:1: ruleXBooleanLiteral : ( ( rule__XBooleanLiteral__Group__0 ) ) ; + public final void ruleXBooleanLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2805:1: ( ( ( rule__Injection__TypeAssignment_1 ) ) ) - // InternalScope.g:2806:1: ( ( rule__Injection__TypeAssignment_1 ) ) + // InternalScope.g:2767:2: ( ( ( rule__XBooleanLiteral__Group__0 ) ) ) + // InternalScope.g:2768:2: ( ( rule__XBooleanLiteral__Group__0 ) ) { - // InternalScope.g:2806:1: ( ( rule__Injection__TypeAssignment_1 ) ) - // InternalScope.g:2807:2: ( rule__Injection__TypeAssignment_1 ) + // InternalScope.g:2768:2: ( ( rule__XBooleanLiteral__Group__0 ) ) + // InternalScope.g:2769:3: ( rule__XBooleanLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInjectionAccess().getTypeAssignment_1()); + before(grammarAccess.getXBooleanLiteralAccess().getGroup()); } - // InternalScope.g:2808:2: ( rule__Injection__TypeAssignment_1 ) - // InternalScope.g:2808:3: rule__Injection__TypeAssignment_1 + // InternalScope.g:2770:3: ( rule__XBooleanLiteral__Group__0 ) + // InternalScope.g:2770:4: rule__XBooleanLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__Injection__TypeAssignment_1(); + rule__XBooleanLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -10294,7 +9377,7 @@ public final void rule__Injection__Group__1__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getInjectionAccess().getTypeAssignment_1()); + after(grammarAccess.getXBooleanLiteralAccess().getGroup()); } } @@ -10314,29 +9397,28 @@ public final void rule__Injection__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Injection__Group__1__Impl" + // $ANTLR end "ruleXBooleanLiteral" - // $ANTLR start "rule__Injection__Group__2" - // InternalScope.g:2816:1: rule__Injection__Group__2 : rule__Injection__Group__2__Impl rule__Injection__Group__3 ; - public final void rule__Injection__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXNullLiteral" + // InternalScope.g:2779:1: entryRuleXNullLiteral : ruleXNullLiteral EOF ; + public final void entryRuleXNullLiteral() throws RecognitionException { try { - // InternalScope.g:2820:1: ( rule__Injection__Group__2__Impl rule__Injection__Group__3 ) - // InternalScope.g:2821:2: rule__Injection__Group__2__Impl rule__Injection__Group__3 + // InternalScope.g:2780:1: ( ruleXNullLiteral EOF ) + // InternalScope.g:2781:1: ruleXNullLiteral EOF { - pushFollow(FOLLOW_3); - rule__Injection__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__Injection__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXNullLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10346,34 +9428,41 @@ public final void rule__Injection__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Injection__Group__2" + // $ANTLR end "entryRuleXNullLiteral" - // $ANTLR start "rule__Injection__Group__2__Impl" - // InternalScope.g:2828:1: rule__Injection__Group__2__Impl : ( 'as' ) ; - public final void rule__Injection__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXNullLiteral" + // InternalScope.g:2788:1: ruleXNullLiteral : ( ( rule__XNullLiteral__Group__0 ) ) ; + public final void ruleXNullLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2832:1: ( ( 'as' ) ) - // InternalScope.g:2833:1: ( 'as' ) + // InternalScope.g:2792:2: ( ( ( rule__XNullLiteral__Group__0 ) ) ) + // InternalScope.g:2793:2: ( ( rule__XNullLiteral__Group__0 ) ) { - // InternalScope.g:2833:1: ( 'as' ) - // InternalScope.g:2834:2: 'as' + // InternalScope.g:2793:2: ( ( rule__XNullLiteral__Group__0 ) ) + // InternalScope.g:2794:3: ( rule__XNullLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInjectionAccess().getAsKeyword_2()); + before(grammarAccess.getXNullLiteralAccess().getGroup()); + } + // InternalScope.g:2795:3: ( rule__XNullLiteral__Group__0 ) + // InternalScope.g:2795:4: rule__XNullLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,41,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getInjectionAccess().getAsKeyword_2()); + after(grammarAccess.getXNullLiteralAccess().getGroup()); } } @@ -10393,24 +9482,28 @@ public final void rule__Injection__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Injection__Group__2__Impl" - + // $ANTLR end "ruleXNullLiteral" - // $ANTLR start "rule__Injection__Group__3" - // InternalScope.g:2843:1: rule__Injection__Group__3 : rule__Injection__Group__3__Impl ; - public final void rule__Injection__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXNumberLiteral" + // InternalScope.g:2804:1: entryRuleXNumberLiteral : ruleXNumberLiteral EOF ; + public final void entryRuleXNumberLiteral() throws RecognitionException { try { - // InternalScope.g:2847:1: ( rule__Injection__Group__3__Impl ) - // InternalScope.g:2848:2: rule__Injection__Group__3__Impl + // InternalScope.g:2805:1: ( ruleXNumberLiteral EOF ) + // InternalScope.g:2806:1: ruleXNumberLiteral EOF { - pushFollow(FOLLOW_2); - rule__Injection__Group__3__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXNumberLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10420,36 +9513,33 @@ public final void rule__Injection__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__Injection__Group__3" + // $ANTLR end "entryRuleXNumberLiteral" - // $ANTLR start "rule__Injection__Group__3__Impl" - // InternalScope.g:2854:1: rule__Injection__Group__3__Impl : ( ( rule__Injection__NameAssignment_3 ) ) ; - public final void rule__Injection__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXNumberLiteral" + // InternalScope.g:2813:1: ruleXNumberLiteral : ( ( rule__XNumberLiteral__Group__0 ) ) ; + public final void ruleXNumberLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2858:1: ( ( ( rule__Injection__NameAssignment_3 ) ) ) - // InternalScope.g:2859:1: ( ( rule__Injection__NameAssignment_3 ) ) + // InternalScope.g:2817:2: ( ( ( rule__XNumberLiteral__Group__0 ) ) ) + // InternalScope.g:2818:2: ( ( rule__XNumberLiteral__Group__0 ) ) { - // InternalScope.g:2859:1: ( ( rule__Injection__NameAssignment_3 ) ) - // InternalScope.g:2860:2: ( rule__Injection__NameAssignment_3 ) + // InternalScope.g:2818:2: ( ( rule__XNumberLiteral__Group__0 ) ) + // InternalScope.g:2819:3: ( rule__XNumberLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInjectionAccess().getNameAssignment_3()); + before(grammarAccess.getXNumberLiteralAccess().getGroup()); } - // InternalScope.g:2861:2: ( rule__Injection__NameAssignment_3 ) - // InternalScope.g:2861:3: rule__Injection__NameAssignment_3 + // InternalScope.g:2820:3: ( rule__XNumberLiteral__Group__0 ) + // InternalScope.g:2820:4: rule__XNumberLiteral__Group__0 { pushFollow(FOLLOW_2); - rule__Injection__NameAssignment_3(); + rule__XNumberLiteral__Group__0(); state._fsp--; if (state.failed) return ; @@ -10457,7 +9547,7 @@ public final void rule__Injection__Group__3__Impl() throws RecognitionException } if ( state.backtracking==0 ) { - after(grammarAccess.getInjectionAccess().getNameAssignment_3()); + after(grammarAccess.getXNumberLiteralAccess().getGroup()); } } @@ -10477,29 +9567,28 @@ public final void rule__Injection__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Injection__Group__3__Impl" + // $ANTLR end "ruleXNumberLiteral" - // $ANTLR start "rule__NamingSection__Group__0" - // InternalScope.g:2870:1: rule__NamingSection__Group__0 : rule__NamingSection__Group__0__Impl rule__NamingSection__Group__1 ; - public final void rule__NamingSection__Group__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXStringLiteral" + // InternalScope.g:2829:1: entryRuleXStringLiteral : ruleXStringLiteral EOF ; + public final void entryRuleXStringLiteral() throws RecognitionException { try { - // InternalScope.g:2874:1: ( rule__NamingSection__Group__0__Impl rule__NamingSection__Group__1 ) - // InternalScope.g:2875:2: rule__NamingSection__Group__0__Impl rule__NamingSection__Group__1 + // InternalScope.g:2830:1: ( ruleXStringLiteral EOF ) + // InternalScope.g:2831:1: ruleXStringLiteral EOF { - pushFollow(FOLLOW_11); - rule__NamingSection__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingSection__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXStringLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10509,38 +9598,41 @@ public final void rule__NamingSection__Group__0() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group__0" + // $ANTLR end "entryRuleXStringLiteral" - // $ANTLR start "rule__NamingSection__Group__0__Impl" - // InternalScope.g:2882:1: rule__NamingSection__Group__0__Impl : ( () ) ; - public final void rule__NamingSection__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXStringLiteral" + // InternalScope.g:2838:1: ruleXStringLiteral : ( ( rule__XStringLiteral__Group__0 ) ) ; + public final void ruleXStringLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2886:1: ( ( () ) ) - // InternalScope.g:2887:1: ( () ) + // InternalScope.g:2842:2: ( ( ( rule__XStringLiteral__Group__0 ) ) ) + // InternalScope.g:2843:2: ( ( rule__XStringLiteral__Group__0 ) ) { - // InternalScope.g:2887:1: ( () ) - // InternalScope.g:2888:2: () + // InternalScope.g:2843:2: ( ( rule__XStringLiteral__Group__0 ) ) + // InternalScope.g:2844:3: ( rule__XStringLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); + before(grammarAccess.getXStringLiteralAccess().getGroup()); } - // InternalScope.g:2889:2: () - // InternalScope.g:2889:3: + // InternalScope.g:2845:3: ( rule__XStringLiteral__Group__0 ) + // InternalScope.g:2845:4: rule__XStringLiteral__Group__0 { + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__0(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); + after(grammarAccess.getXStringLiteralAccess().getGroup()); } } @@ -10549,6 +9641,10 @@ public final void rule__NamingSection__Group__0__Impl() throws RecognitionExcept } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -10556,29 +9652,28 @@ public final void rule__NamingSection__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__NamingSection__Group__0__Impl" + // $ANTLR end "ruleXStringLiteral" - // $ANTLR start "rule__NamingSection__Group__1" - // InternalScope.g:2897:1: rule__NamingSection__Group__1 : rule__NamingSection__Group__1__Impl rule__NamingSection__Group__2 ; - public final void rule__NamingSection__Group__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXTypeLiteral" + // InternalScope.g:2854:1: entryRuleXTypeLiteral : ruleXTypeLiteral EOF ; + public final void entryRuleXTypeLiteral() throws RecognitionException { try { - // InternalScope.g:2901:1: ( rule__NamingSection__Group__1__Impl rule__NamingSection__Group__2 ) - // InternalScope.g:2902:2: rule__NamingSection__Group__1__Impl rule__NamingSection__Group__2 + // InternalScope.g:2855:1: ( ruleXTypeLiteral EOF ) + // InternalScope.g:2856:1: ruleXTypeLiteral EOF { - pushFollow(FOLLOW_11); - rule__NamingSection__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingSection__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_1); + ruleXTypeLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10588,55 +9683,41 @@ public final void rule__NamingSection__Group__1() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group__1" + // $ANTLR end "entryRuleXTypeLiteral" - // $ANTLR start "rule__NamingSection__Group__1__Impl" - // InternalScope.g:2909:1: rule__NamingSection__Group__1__Impl : ( ( rule__NamingSection__Group_1__0 )? ) ; - public final void rule__NamingSection__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleXTypeLiteral" + // InternalScope.g:2863:1: ruleXTypeLiteral : ( ( rule__XTypeLiteral__Group__0 ) ) ; + public final void ruleXTypeLiteral() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2913:1: ( ( ( rule__NamingSection__Group_1__0 )? ) ) - // InternalScope.g:2914:1: ( ( rule__NamingSection__Group_1__0 )? ) + // InternalScope.g:2867:2: ( ( ( rule__XTypeLiteral__Group__0 ) ) ) + // InternalScope.g:2868:2: ( ( rule__XTypeLiteral__Group__0 ) ) { - // InternalScope.g:2914:1: ( ( rule__NamingSection__Group_1__0 )? ) - // InternalScope.g:2915:2: ( rule__NamingSection__Group_1__0 )? + // InternalScope.g:2868:2: ( ( rule__XTypeLiteral__Group__0 ) ) + // InternalScope.g:2869:3: ( rule__XTypeLiteral__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getGroup_1()); - } - // InternalScope.g:2916:2: ( rule__NamingSection__Group_1__0 )? - int alt35=2; - int LA35_0 = input.LA(1); - - if ( (LA35_0==47) ) { - alt35=1; + before(grammarAccess.getXTypeLiteralAccess().getGroup()); } - switch (alt35) { - case 1 : - // InternalScope.g:2916:3: rule__NamingSection__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__NamingSection__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2870:3: ( rule__XTypeLiteral__Group__0 ) + // InternalScope.g:2870:4: rule__XTypeLiteral__Group__0 + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getGroup_1()); + after(grammarAccess.getXTypeLiteralAccess().getGroup()); } } @@ -10656,29 +9737,28 @@ public final void rule__NamingSection__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__NamingSection__Group__1__Impl" + // $ANTLR end "ruleXTypeLiteral" - // $ANTLR start "rule__NamingSection__Group__2" - // InternalScope.g:2924:1: rule__NamingSection__Group__2 : rule__NamingSection__Group__2__Impl rule__NamingSection__Group__3 ; - public final void rule__NamingSection__Group__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXThrowExpression" + // InternalScope.g:2879:1: entryRuleXThrowExpression : ruleXThrowExpression EOF ; + public final void entryRuleXThrowExpression() throws RecognitionException { try { - // InternalScope.g:2928:1: ( rule__NamingSection__Group__2__Impl rule__NamingSection__Group__3 ) - // InternalScope.g:2929:2: rule__NamingSection__Group__2__Impl rule__NamingSection__Group__3 + // InternalScope.g:2880:1: ( ruleXThrowExpression EOF ) + // InternalScope.g:2881:1: ruleXThrowExpression EOF { - pushFollow(FOLLOW_12); - rule__NamingSection__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingSection__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXThrowExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10688,34 +9768,41 @@ public final void rule__NamingSection__Group__2() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group__2" + // $ANTLR end "entryRuleXThrowExpression" - // $ANTLR start "rule__NamingSection__Group__2__Impl" - // InternalScope.g:2936:1: rule__NamingSection__Group__2__Impl : ( 'naming' ) ; - public final void rule__NamingSection__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleXThrowExpression" + // InternalScope.g:2888:1: ruleXThrowExpression : ( ( rule__XThrowExpression__Group__0 ) ) ; + public final void ruleXThrowExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2940:1: ( ( 'naming' ) ) - // InternalScope.g:2941:1: ( 'naming' ) + // InternalScope.g:2892:2: ( ( ( rule__XThrowExpression__Group__0 ) ) ) + // InternalScope.g:2893:2: ( ( rule__XThrowExpression__Group__0 ) ) { - // InternalScope.g:2941:1: ( 'naming' ) - // InternalScope.g:2942:2: 'naming' + // InternalScope.g:2893:2: ( ( rule__XThrowExpression__Group__0 ) ) + // InternalScope.g:2894:3: ( rule__XThrowExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); + before(grammarAccess.getXThrowExpressionAccess().getGroup()); + } + // InternalScope.g:2895:3: ( rule__XThrowExpression__Group__0 ) + // InternalScope.g:2895:4: rule__XThrowExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,44,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); + after(grammarAccess.getXThrowExpressionAccess().getGroup()); } } @@ -10735,29 +9822,28 @@ public final void rule__NamingSection__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__NamingSection__Group__2__Impl" - + // $ANTLR end "ruleXThrowExpression" - // $ANTLR start "rule__NamingSection__Group__3" - // InternalScope.g:2951:1: rule__NamingSection__Group__3 : rule__NamingSection__Group__3__Impl rule__NamingSection__Group__4 ; - public final void rule__NamingSection__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXReturnExpression" + // InternalScope.g:2904:1: entryRuleXReturnExpression : ruleXReturnExpression EOF ; + public final void entryRuleXReturnExpression() throws RecognitionException { try { - // InternalScope.g:2955:1: ( rule__NamingSection__Group__3__Impl rule__NamingSection__Group__4 ) - // InternalScope.g:2956:2: rule__NamingSection__Group__3__Impl rule__NamingSection__Group__4 + // InternalScope.g:2905:1: ( ruleXReturnExpression EOF ) + // InternalScope.g:2906:1: ruleXReturnExpression EOF { - pushFollow(FOLLOW_13); - rule__NamingSection__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingSection__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXReturnExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10767,34 +9853,41 @@ public final void rule__NamingSection__Group__3() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group__3" + // $ANTLR end "entryRuleXReturnExpression" - // $ANTLR start "rule__NamingSection__Group__3__Impl" - // InternalScope.g:2963:1: rule__NamingSection__Group__3__Impl : ( '{' ) ; - public final void rule__NamingSection__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXReturnExpression" + // InternalScope.g:2913:1: ruleXReturnExpression : ( ( rule__XReturnExpression__Group__0 ) ) ; + public final void ruleXReturnExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2967:1: ( ( '{' ) ) - // InternalScope.g:2968:1: ( '{' ) + // InternalScope.g:2917:2: ( ( ( rule__XReturnExpression__Group__0 ) ) ) + // InternalScope.g:2918:2: ( ( rule__XReturnExpression__Group__0 ) ) { - // InternalScope.g:2968:1: ( '{' ) - // InternalScope.g:2969:2: '{' + // InternalScope.g:2918:2: ( ( rule__XReturnExpression__Group__0 ) ) + // InternalScope.g:2919:3: ( rule__XReturnExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getXReturnExpressionAccess().getGroup()); } - match(input,45,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:2920:3: ( rule__XReturnExpression__Group__0 ) + // InternalScope.g:2920:4: rule__XReturnExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); + after(grammarAccess.getXReturnExpressionAccess().getGroup()); } } @@ -10814,29 +9907,28 @@ public final void rule__NamingSection__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__NamingSection__Group__3__Impl" + // $ANTLR end "ruleXReturnExpression" - // $ANTLR start "rule__NamingSection__Group__4" - // InternalScope.g:2978:1: rule__NamingSection__Group__4 : rule__NamingSection__Group__4__Impl rule__NamingSection__Group__5 ; - public final void rule__NamingSection__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXTryCatchFinallyExpression" + // InternalScope.g:2929:1: entryRuleXTryCatchFinallyExpression : ruleXTryCatchFinallyExpression EOF ; + public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException { try { - // InternalScope.g:2982:1: ( rule__NamingSection__Group__4__Impl rule__NamingSection__Group__5 ) - // InternalScope.g:2983:2: rule__NamingSection__Group__4__Impl rule__NamingSection__Group__5 + // InternalScope.g:2930:1: ( ruleXTryCatchFinallyExpression EOF ) + // InternalScope.g:2931:1: ruleXTryCatchFinallyExpression EOF { - pushFollow(FOLLOW_13); - rule__NamingSection__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingSection__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXTryCatchFinallyExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10846,62 +9938,41 @@ public final void rule__NamingSection__Group__4() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group__4" + // $ANTLR end "entryRuleXTryCatchFinallyExpression" - // $ANTLR start "rule__NamingSection__Group__4__Impl" - // InternalScope.g:2990:1: rule__NamingSection__Group__4__Impl : ( ( rule__NamingSection__NamingsAssignment_4 )* ) ; - public final void rule__NamingSection__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleXTryCatchFinallyExpression" + // InternalScope.g:2938:1: ruleXTryCatchFinallyExpression : ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ; + public final void ruleXTryCatchFinallyExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:2994:1: ( ( ( rule__NamingSection__NamingsAssignment_4 )* ) ) - // InternalScope.g:2995:1: ( ( rule__NamingSection__NamingsAssignment_4 )* ) + // InternalScope.g:2942:2: ( ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ) + // InternalScope.g:2943:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) { - // InternalScope.g:2995:1: ( ( rule__NamingSection__NamingsAssignment_4 )* ) - // InternalScope.g:2996:2: ( rule__NamingSection__NamingsAssignment_4 )* + // InternalScope.g:2943:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) + // InternalScope.g:2944:3: ( rule__XTryCatchFinallyExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } - // InternalScope.g:2997:2: ( rule__NamingSection__NamingsAssignment_4 )* - loop36: - do { - int alt36=2; - int LA36_0 = input.LA(1); - - if ( (LA36_0==RULE_ID) ) { - alt36=1; - } - - - switch (alt36) { - case 1 : - // InternalScope.g:2997:3: rule__NamingSection__NamingsAssignment_4 - { - pushFollow(FOLLOW_14); - rule__NamingSection__NamingsAssignment_4(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:2945:3: ( rule__XTryCatchFinallyExpression__Group__0 ) + // InternalScope.g:2945:4: rule__XTryCatchFinallyExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop36; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); } } @@ -10921,24 +9992,28 @@ public final void rule__NamingSection__Group__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__NamingSection__Group__4__Impl" + // $ANTLR end "ruleXTryCatchFinallyExpression" - // $ANTLR start "rule__NamingSection__Group__5" - // InternalScope.g:3005:1: rule__NamingSection__Group__5 : rule__NamingSection__Group__5__Impl ; - public final void rule__NamingSection__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXSynchronizedExpression" + // InternalScope.g:2954:1: entryRuleXSynchronizedExpression : ruleXSynchronizedExpression EOF ; + public final void entryRuleXSynchronizedExpression() throws RecognitionException { try { - // InternalScope.g:3009:1: ( rule__NamingSection__Group__5__Impl ) - // InternalScope.g:3010:2: rule__NamingSection__Group__5__Impl + // InternalScope.g:2955:1: ( ruleXSynchronizedExpression EOF ) + // InternalScope.g:2956:1: ruleXSynchronizedExpression EOF { - pushFollow(FOLLOW_2); - rule__NamingSection__Group__5__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_1); + ruleXSynchronizedExpression(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -10948,34 +10023,41 @@ public final void rule__NamingSection__Group__5() throws RecognitionException { recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group__5" + // $ANTLR end "entryRuleXSynchronizedExpression" - // $ANTLR start "rule__NamingSection__Group__5__Impl" - // InternalScope.g:3016:1: rule__NamingSection__Group__5__Impl : ( '}' ) ; - public final void rule__NamingSection__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleXSynchronizedExpression" + // InternalScope.g:2963:1: ruleXSynchronizedExpression : ( ( rule__XSynchronizedExpression__Group__0 ) ) ; + public final void ruleXSynchronizedExpression() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3020:1: ( ( '}' ) ) - // InternalScope.g:3021:1: ( '}' ) + // InternalScope.g:2967:2: ( ( ( rule__XSynchronizedExpression__Group__0 ) ) ) + // InternalScope.g:2968:2: ( ( rule__XSynchronizedExpression__Group__0 ) ) { - // InternalScope.g:3021:1: ( '}' ) - // InternalScope.g:3022:2: '}' + // InternalScope.g:2968:2: ( ( rule__XSynchronizedExpression__Group__0 ) ) + // InternalScope.g:2969:3: ( rule__XSynchronizedExpression__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); + } + // InternalScope.g:2970:3: ( rule__XSynchronizedExpression__Group__0 ) + // InternalScope.g:2970:4: rule__XSynchronizedExpression__Group__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); } } @@ -10995,29 +10077,28 @@ public final void rule__NamingSection__Group__5__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__NamingSection__Group__5__Impl" + // $ANTLR end "ruleXSynchronizedExpression" - // $ANTLR start "rule__NamingSection__Group_1__0" - // InternalScope.g:3032:1: rule__NamingSection__Group_1__0 : rule__NamingSection__Group_1__0__Impl rule__NamingSection__Group_1__1 ; - public final void rule__NamingSection__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXCatchClause" + // InternalScope.g:2979:1: entryRuleXCatchClause : ruleXCatchClause EOF ; + public final void entryRuleXCatchClause() throws RecognitionException { try { - // InternalScope.g:3036:1: ( rule__NamingSection__Group_1__0__Impl rule__NamingSection__Group_1__1 ) - // InternalScope.g:3037:2: rule__NamingSection__Group_1__0__Impl rule__NamingSection__Group_1__1 + // InternalScope.g:2980:1: ( ruleXCatchClause EOF ) + // InternalScope.g:2981:1: ruleXCatchClause EOF { - pushFollow(FOLLOW_15); - rule__NamingSection__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingSection__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_1); + ruleXCatchClause(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11027,34 +10108,41 @@ public final void rule__NamingSection__Group_1__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group_1__0" + // $ANTLR end "entryRuleXCatchClause" - // $ANTLR start "rule__NamingSection__Group_1__0__Impl" - // InternalScope.g:3044:1: rule__NamingSection__Group_1__0__Impl : ( 'case' ) ; - public final void rule__NamingSection__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXCatchClause" + // InternalScope.g:2988:1: ruleXCatchClause : ( ( rule__XCatchClause__Group__0 ) ) ; + public final void ruleXCatchClause() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3048:1: ( ( 'case' ) ) - // InternalScope.g:3049:1: ( 'case' ) + // InternalScope.g:2992:2: ( ( ( rule__XCatchClause__Group__0 ) ) ) + // InternalScope.g:2993:2: ( ( rule__XCatchClause__Group__0 ) ) { - // InternalScope.g:3049:1: ( 'case' ) - // InternalScope.g:3050:2: 'case' + // InternalScope.g:2993:2: ( ( rule__XCatchClause__Group__0 ) ) + // InternalScope.g:2994:3: ( rule__XCatchClause__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); + before(grammarAccess.getXCatchClauseAccess().getGroup()); + } + // InternalScope.g:2995:3: ( rule__XCatchClause__Group__0 ) + // InternalScope.g:2995:4: rule__XCatchClause__Group__0 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); + after(grammarAccess.getXCatchClauseAccess().getGroup()); } } @@ -11074,24 +10162,28 @@ public final void rule__NamingSection__Group_1__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__NamingSection__Group_1__0__Impl" - + // $ANTLR end "ruleXCatchClause" - // $ANTLR start "rule__NamingSection__Group_1__1" - // InternalScope.g:3059:1: rule__NamingSection__Group_1__1 : rule__NamingSection__Group_1__1__Impl ; - public final void rule__NamingSection__Group_1__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedName" + // InternalScope.g:3004:1: entryRuleQualifiedName : ruleQualifiedName EOF ; + public final void entryRuleQualifiedName() throws RecognitionException { try { - // InternalScope.g:3063:1: ( rule__NamingSection__Group_1__1__Impl ) - // InternalScope.g:3064:2: rule__NamingSection__Group_1__1__Impl + // InternalScope.g:3005:1: ( ruleQualifiedName EOF ) + // InternalScope.g:3006:1: ruleQualifiedName EOF { - pushFollow(FOLLOW_2); - rule__NamingSection__Group_1__1__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedName(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11101,36 +10193,33 @@ public final void rule__NamingSection__Group_1__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingSection__Group_1__1" + // $ANTLR end "entryRuleQualifiedName" - // $ANTLR start "rule__NamingSection__Group_1__1__Impl" - // InternalScope.g:3070:1: rule__NamingSection__Group_1__1__Impl : ( ( rule__NamingSection__CasingAssignment_1_1 ) ) ; - public final void rule__NamingSection__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedName" + // InternalScope.g:3013:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ; + public final void ruleQualifiedName() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3074:1: ( ( ( rule__NamingSection__CasingAssignment_1_1 ) ) ) - // InternalScope.g:3075:1: ( ( rule__NamingSection__CasingAssignment_1_1 ) ) + // InternalScope.g:3017:2: ( ( ( rule__QualifiedName__Group__0 ) ) ) + // InternalScope.g:3018:2: ( ( rule__QualifiedName__Group__0 ) ) { - // InternalScope.g:3075:1: ( ( rule__NamingSection__CasingAssignment_1_1 ) ) - // InternalScope.g:3076:2: ( rule__NamingSection__CasingAssignment_1_1 ) + // InternalScope.g:3018:2: ( ( rule__QualifiedName__Group__0 ) ) + // InternalScope.g:3019:3: ( rule__QualifiedName__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); + before(grammarAccess.getQualifiedNameAccess().getGroup()); } - // InternalScope.g:3077:2: ( rule__NamingSection__CasingAssignment_1_1 ) - // InternalScope.g:3077:3: rule__NamingSection__CasingAssignment_1_1 + // InternalScope.g:3020:3: ( rule__QualifiedName__Group__0 ) + // InternalScope.g:3020:4: rule__QualifiedName__Group__0 { pushFollow(FOLLOW_2); - rule__NamingSection__CasingAssignment_1_1(); + rule__QualifiedName__Group__0(); state._fsp--; if (state.failed) return ; @@ -11138,7 +10227,7 @@ public final void rule__NamingSection__Group_1__1__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); + after(grammarAccess.getQualifiedNameAccess().getGroup()); } } @@ -11158,29 +10247,31 @@ public final void rule__NamingSection__Group_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__NamingSection__Group_1__1__Impl" + // $ANTLR end "ruleQualifiedName" - // $ANTLR start "rule__NamingDefinition__Group__0" - // InternalScope.g:3086:1: rule__NamingDefinition__Group__0 : rule__NamingDefinition__Group__0__Impl rule__NamingDefinition__Group__1 ; - public final void rule__NamingDefinition__Group__0() throws RecognitionException { + // $ANTLR start "entryRuleNumber" + // InternalScope.g:3029:1: entryRuleNumber : ruleNumber EOF ; + public final void entryRuleNumber() throws RecognitionException { + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); - int stackSize = keepStackSize(); - try { - // InternalScope.g:3090:1: ( rule__NamingDefinition__Group__0__Impl rule__NamingDefinition__Group__1 ) - // InternalScope.g:3091:2: rule__NamingDefinition__Group__0__Impl rule__NamingDefinition__Group__1 + // InternalScope.g:3033:1: ( ruleNumber EOF ) + // InternalScope.g:3034:1: ruleNumber EOF { - pushFollow(FOLLOW_16); - rule__NamingDefinition__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingDefinition__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_1); + ruleNumber(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11191,35 +10282,36 @@ public final void rule__NamingDefinition__Group__0() throws RecognitionException } finally { - restoreStackSize(stackSize); + myHiddenTokenState.restore(); } return ; } - // $ANTLR end "rule__NamingDefinition__Group__0" + // $ANTLR end "entryRuleNumber" - // $ANTLR start "rule__NamingDefinition__Group__0__Impl" - // InternalScope.g:3098:1: rule__NamingDefinition__Group__0__Impl : ( ( rule__NamingDefinition__TypeAssignment_0 ) ) ; - public final void rule__NamingDefinition__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleNumber" + // InternalScope.g:3044:1: ruleNumber : ( ( rule__Number__Alternatives ) ) ; + public final void ruleNumber() throws RecognitionException { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); int stackSize = keepStackSize(); try { - // InternalScope.g:3102:1: ( ( ( rule__NamingDefinition__TypeAssignment_0 ) ) ) - // InternalScope.g:3103:1: ( ( rule__NamingDefinition__TypeAssignment_0 ) ) + // InternalScope.g:3049:2: ( ( ( rule__Number__Alternatives ) ) ) + // InternalScope.g:3050:2: ( ( rule__Number__Alternatives ) ) { - // InternalScope.g:3103:1: ( ( rule__NamingDefinition__TypeAssignment_0 ) ) - // InternalScope.g:3104:2: ( rule__NamingDefinition__TypeAssignment_0 ) + // InternalScope.g:3050:2: ( ( rule__Number__Alternatives ) ) + // InternalScope.g:3051:3: ( rule__Number__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); + before(grammarAccess.getNumberAccess().getAlternatives()); } - // InternalScope.g:3105:2: ( rule__NamingDefinition__TypeAssignment_0 ) - // InternalScope.g:3105:3: rule__NamingDefinition__TypeAssignment_0 + // InternalScope.g:3052:3: ( rule__Number__Alternatives ) + // InternalScope.g:3052:4: rule__Number__Alternatives { pushFollow(FOLLOW_2); - rule__NamingDefinition__TypeAssignment_0(); + rule__Number__Alternatives(); state._fsp--; if (state.failed) return ; @@ -11227,7 +10319,7 @@ public final void rule__NamingDefinition__Group__0__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); + after(grammarAccess.getNumberAccess().getAlternatives()); } } @@ -11243,33 +10335,33 @@ public final void rule__NamingDefinition__Group__0__Impl() throws RecognitionExc finally { restoreStackSize(stackSize); + myHiddenTokenState.restore(); } return ; } - // $ANTLR end "rule__NamingDefinition__Group__0__Impl" - + // $ANTLR end "ruleNumber" - // $ANTLR start "rule__NamingDefinition__Group__1" - // InternalScope.g:3113:1: rule__NamingDefinition__Group__1 : rule__NamingDefinition__Group__1__Impl rule__NamingDefinition__Group__2 ; - public final void rule__NamingDefinition__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmTypeReference" + // InternalScope.g:3062:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ; + public final void entryRuleJvmTypeReference() throws RecognitionException { try { - // InternalScope.g:3117:1: ( rule__NamingDefinition__Group__1__Impl rule__NamingDefinition__Group__2 ) - // InternalScope.g:3118:2: rule__NamingDefinition__Group__1__Impl rule__NamingDefinition__Group__2 + // InternalScope.g:3063:1: ( ruleJvmTypeReference EOF ) + // InternalScope.g:3064:1: ruleJvmTypeReference EOF { - pushFollow(FOLLOW_17); - rule__NamingDefinition__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingDefinition__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11279,34 +10371,41 @@ public final void rule__NamingDefinition__Group__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingDefinition__Group__1" + // $ANTLR end "entryRuleJvmTypeReference" - // $ANTLR start "rule__NamingDefinition__Group__1__Impl" - // InternalScope.g:3125:1: rule__NamingDefinition__Group__1__Impl : ( '=' ) ; - public final void rule__NamingDefinition__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmTypeReference" + // InternalScope.g:3071:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ; + public final void ruleJvmTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3129:1: ( ( '=' ) ) - // InternalScope.g:3130:1: ( '=' ) + // InternalScope.g:3075:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) ) + // InternalScope.g:3076:2: ( ( rule__JvmTypeReference__Alternatives ) ) { - // InternalScope.g:3130:1: ( '=' ) - // InternalScope.g:3131:2: '=' + // InternalScope.g:3076:2: ( ( rule__JvmTypeReference__Alternatives ) ) + // InternalScope.g:3077:3: ( rule__JvmTypeReference__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); + before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:3078:3: ( rule__JvmTypeReference__Alternatives ) + // InternalScope.g:3078:4: rule__JvmTypeReference__Alternatives + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Alternatives(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); + after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); } } @@ -11326,29 +10425,28 @@ public final void rule__NamingDefinition__Group__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__NamingDefinition__Group__1__Impl" - + // $ANTLR end "ruleJvmTypeReference" - // $ANTLR start "rule__NamingDefinition__Group__2" - // InternalScope.g:3140:1: rule__NamingDefinition__Group__2 : rule__NamingDefinition__Group__2__Impl rule__NamingDefinition__Group__3 ; - public final void rule__NamingDefinition__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleArrayBrackets" + // InternalScope.g:3087:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ; + public final void entryRuleArrayBrackets() throws RecognitionException { try { - // InternalScope.g:3144:1: ( rule__NamingDefinition__Group__2__Impl rule__NamingDefinition__Group__3 ) - // InternalScope.g:3145:2: rule__NamingDefinition__Group__2__Impl rule__NamingDefinition__Group__3 + // InternalScope.g:3088:1: ( ruleArrayBrackets EOF ) + // InternalScope.g:3089:1: ruleArrayBrackets EOF { - pushFollow(FOLLOW_18); - rule__NamingDefinition__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamingDefinition__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + ruleArrayBrackets(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11358,36 +10456,33 @@ public final void rule__NamingDefinition__Group__2() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingDefinition__Group__2" + // $ANTLR end "entryRuleArrayBrackets" - // $ANTLR start "rule__NamingDefinition__Group__2__Impl" - // InternalScope.g:3152:1: rule__NamingDefinition__Group__2__Impl : ( ( rule__NamingDefinition__NamingAssignment_2 ) ) ; - public final void rule__NamingDefinition__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleArrayBrackets" + // InternalScope.g:3096:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ; + public final void ruleArrayBrackets() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3156:1: ( ( ( rule__NamingDefinition__NamingAssignment_2 ) ) ) - // InternalScope.g:3157:1: ( ( rule__NamingDefinition__NamingAssignment_2 ) ) + // InternalScope.g:3100:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) ) + // InternalScope.g:3101:2: ( ( rule__ArrayBrackets__Group__0 ) ) { - // InternalScope.g:3157:1: ( ( rule__NamingDefinition__NamingAssignment_2 ) ) - // InternalScope.g:3158:2: ( rule__NamingDefinition__NamingAssignment_2 ) + // InternalScope.g:3101:2: ( ( rule__ArrayBrackets__Group__0 ) ) + // InternalScope.g:3102:3: ( rule__ArrayBrackets__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); + before(grammarAccess.getArrayBracketsAccess().getGroup()); } - // InternalScope.g:3159:2: ( rule__NamingDefinition__NamingAssignment_2 ) - // InternalScope.g:3159:3: rule__NamingDefinition__NamingAssignment_2 + // InternalScope.g:3103:3: ( rule__ArrayBrackets__Group__0 ) + // InternalScope.g:3103:4: rule__ArrayBrackets__Group__0 { pushFollow(FOLLOW_2); - rule__NamingDefinition__NamingAssignment_2(); + rule__ArrayBrackets__Group__0(); state._fsp--; if (state.failed) return ; @@ -11395,7 +10490,7 @@ public final void rule__NamingDefinition__Group__2__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); + after(grammarAccess.getArrayBracketsAccess().getGroup()); } } @@ -11415,24 +10510,28 @@ public final void rule__NamingDefinition__Group__2__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__NamingDefinition__Group__2__Impl" - + // $ANTLR end "ruleArrayBrackets" - // $ANTLR start "rule__NamingDefinition__Group__3" - // InternalScope.g:3167:1: rule__NamingDefinition__Group__3 : rule__NamingDefinition__Group__3__Impl ; - public final void rule__NamingDefinition__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalScope.g:3112:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ; + public final void entryRuleXFunctionTypeRef() throws RecognitionException { try { - // InternalScope.g:3171:1: ( rule__NamingDefinition__Group__3__Impl ) - // InternalScope.g:3172:2: rule__NamingDefinition__Group__3__Impl + // InternalScope.g:3113:1: ( ruleXFunctionTypeRef EOF ) + // InternalScope.g:3114:1: ruleXFunctionTypeRef EOF { - pushFollow(FOLLOW_2); - rule__NamingDefinition__Group__3__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + ruleXFunctionTypeRef(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11442,34 +10541,41 @@ public final void rule__NamingDefinition__Group__3() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__NamingDefinition__Group__3" + // $ANTLR end "entryRuleXFunctionTypeRef" - // $ANTLR start "rule__NamingDefinition__Group__3__Impl" - // InternalScope.g:3178:1: rule__NamingDefinition__Group__3__Impl : ( ';' ) ; - public final void rule__NamingDefinition__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleXFunctionTypeRef" + // InternalScope.g:3121:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ; + public final void ruleXFunctionTypeRef() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3182:1: ( ( ';' ) ) - // InternalScope.g:3183:1: ( ';' ) + // InternalScope.g:3125:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) ) + // InternalScope.g:3126:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) { - // InternalScope.g:3183:1: ( ';' ) - // InternalScope.g:3184:2: ';' + // InternalScope.g:3126:2: ( ( rule__XFunctionTypeRef__Group__0 ) ) + // InternalScope.g:3127:3: ( rule__XFunctionTypeRef__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); + before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); + } + // InternalScope.g:3128:3: ( rule__XFunctionTypeRef__Group__0 ) + // InternalScope.g:3128:4: rule__XFunctionTypeRef__Group__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,49,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); + after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); } } @@ -11489,29 +10595,28 @@ public final void rule__NamingDefinition__Group__3__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__NamingDefinition__Group__3__Impl" - + // $ANTLR end "ruleXFunctionTypeRef" - // $ANTLR start "rule__ScopeDefinition__Group__0" - // InternalScope.g:3194:1: rule__ScopeDefinition__Group__0 : rule__ScopeDefinition__Group__0__Impl rule__ScopeDefinition__Group__1 ; - public final void rule__ScopeDefinition__Group__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalScope.g:3137:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ; + public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException { try { - // InternalScope.g:3198:1: ( rule__ScopeDefinition__Group__0__Impl rule__ScopeDefinition__Group__1 ) - // InternalScope.g:3199:2: rule__ScopeDefinition__Group__0__Impl rule__ScopeDefinition__Group__1 + // InternalScope.g:3138:1: ( ruleJvmParameterizedTypeReference EOF ) + // InternalScope.g:3139:1: ruleJvmParameterizedTypeReference EOF { - pushFollow(FOLLOW_19); - rule__ScopeDefinition__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmParameterizedTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11521,34 +10626,41 @@ public final void rule__ScopeDefinition__Group__0() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__0" + // $ANTLR end "entryRuleJvmParameterizedTypeReference" - // $ANTLR start "rule__ScopeDefinition__Group__0__Impl" - // InternalScope.g:3206:1: rule__ScopeDefinition__Group__0__Impl : ( 'scope' ) ; - public final void rule__ScopeDefinition__Group__0__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalScope.g:3146:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ; + public final void ruleJvmParameterizedTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3210:1: ( ( 'scope' ) ) - // InternalScope.g:3211:1: ( 'scope' ) + // InternalScope.g:3150:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ) + // InternalScope.g:3151:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) { - // InternalScope.g:3211:1: ( 'scope' ) - // InternalScope.g:3212:2: 'scope' + // InternalScope.g:3151:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) + // InternalScope.g:3152:3: ( rule__JvmParameterizedTypeReference__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } - match(input,50,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:3153:3: ( rule__JvmParameterizedTypeReference__Group__0 ) + // InternalScope.g:3153:4: rule__JvmParameterizedTypeReference__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); } } @@ -11568,29 +10680,28 @@ public final void rule__ScopeDefinition__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__0__Impl" - + // $ANTLR end "ruleJvmParameterizedTypeReference" - // $ANTLR start "rule__ScopeDefinition__Group__1" - // InternalScope.g:3221:1: rule__ScopeDefinition__Group__1 : rule__ScopeDefinition__Group__1__Impl rule__ScopeDefinition__Group__2 ; - public final void rule__ScopeDefinition__Group__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalScope.g:3162:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ; + public final void entryRuleJvmArgumentTypeReference() throws RecognitionException { try { - // InternalScope.g:3225:1: ( rule__ScopeDefinition__Group__1__Impl rule__ScopeDefinition__Group__2 ) - // InternalScope.g:3226:2: rule__ScopeDefinition__Group__1__Impl rule__ScopeDefinition__Group__2 + // InternalScope.g:3163:1: ( ruleJvmArgumentTypeReference EOF ) + // InternalScope.g:3164:1: ruleJvmArgumentTypeReference EOF { - pushFollow(FOLLOW_19); - rule__ScopeDefinition__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmArgumentTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11600,55 +10711,41 @@ public final void rule__ScopeDefinition__Group__1() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__1" + // $ANTLR end "entryRuleJvmArgumentTypeReference" - // $ANTLR start "rule__ScopeDefinition__Group__1__Impl" - // InternalScope.g:3233:1: rule__ScopeDefinition__Group__1__Impl : ( ( rule__ScopeDefinition__Group_1__0 )? ) ; - public final void rule__ScopeDefinition__Group__1__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalScope.g:3171:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ; + public final void ruleJvmArgumentTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3237:1: ( ( ( rule__ScopeDefinition__Group_1__0 )? ) ) - // InternalScope.g:3238:1: ( ( rule__ScopeDefinition__Group_1__0 )? ) + // InternalScope.g:3175:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ) + // InternalScope.g:3176:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) { - // InternalScope.g:3238:1: ( ( rule__ScopeDefinition__Group_1__0 )? ) - // InternalScope.g:3239:2: ( rule__ScopeDefinition__Group_1__0 )? + // InternalScope.g:3176:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) ) + // InternalScope.g:3177:3: ( rule__JvmArgumentTypeReference__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getGroup_1()); - } - // InternalScope.g:3240:2: ( rule__ScopeDefinition__Group_1__0 )? - int alt37=2; - int LA37_0 = input.LA(1); - - if ( (LA37_0==51) ) { - alt37=1; + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } - switch (alt37) { - case 1 : - // InternalScope.g:3240:3: rule__ScopeDefinition__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:3178:3: ( rule__JvmArgumentTypeReference__Alternatives ) + // InternalScope.g:3178:4: rule__JvmArgumentTypeReference__Alternatives + { + pushFollow(FOLLOW_2); + rule__JvmArgumentTypeReference__Alternatives(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getGroup_1()); + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); } } @@ -11668,29 +10765,28 @@ public final void rule__ScopeDefinition__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__1__Impl" - + // $ANTLR end "ruleJvmArgumentTypeReference" - // $ANTLR start "rule__ScopeDefinition__Group__2" - // InternalScope.g:3248:1: rule__ScopeDefinition__Group__2 : rule__ScopeDefinition__Group__2__Impl rule__ScopeDefinition__Group__3 ; - public final void rule__ScopeDefinition__Group__2() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalScope.g:3187:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ; + public final void entryRuleJvmWildcardTypeReference() throws RecognitionException { try { - // InternalScope.g:3252:1: ( rule__ScopeDefinition__Group__2__Impl rule__ScopeDefinition__Group__3 ) - // InternalScope.g:3253:2: rule__ScopeDefinition__Group__2__Impl rule__ScopeDefinition__Group__3 + // InternalScope.g:3188:1: ( ruleJvmWildcardTypeReference EOF ) + // InternalScope.g:3189:1: ruleJvmWildcardTypeReference EOF { - pushFollow(FOLLOW_12); - rule__ScopeDefinition__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group__3(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + ruleJvmWildcardTypeReference(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11700,36 +10796,33 @@ public final void rule__ScopeDefinition__Group__2() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__2" + // $ANTLR end "entryRuleJvmWildcardTypeReference" - // $ANTLR start "rule__ScopeDefinition__Group__2__Impl" - // InternalScope.g:3260:1: rule__ScopeDefinition__Group__2__Impl : ( ( rule__ScopeDefinition__Alternatives_2 ) ) ; - public final void rule__ScopeDefinition__Group__2__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalScope.g:3196:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ; + public final void ruleJvmWildcardTypeReference() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3264:1: ( ( ( rule__ScopeDefinition__Alternatives_2 ) ) ) - // InternalScope.g:3265:1: ( ( rule__ScopeDefinition__Alternatives_2 ) ) + // InternalScope.g:3200:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ) + // InternalScope.g:3201:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) { - // InternalScope.g:3265:1: ( ( rule__ScopeDefinition__Alternatives_2 ) ) - // InternalScope.g:3266:2: ( rule__ScopeDefinition__Alternatives_2 ) + // InternalScope.g:3201:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) ) + // InternalScope.g:3202:3: ( rule__JvmWildcardTypeReference__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } - // InternalScope.g:3267:2: ( rule__ScopeDefinition__Alternatives_2 ) - // InternalScope.g:3267:3: rule__ScopeDefinition__Alternatives_2 + // InternalScope.g:3203:3: ( rule__JvmWildcardTypeReference__Group__0 ) + // InternalScope.g:3203:4: rule__JvmWildcardTypeReference__Group__0 { pushFollow(FOLLOW_2); - rule__ScopeDefinition__Alternatives_2(); + rule__JvmWildcardTypeReference__Group__0(); state._fsp--; if (state.failed) return ; @@ -11737,7 +10830,7 @@ public final void rule__ScopeDefinition__Group__2__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); } } @@ -11757,29 +10850,28 @@ public final void rule__ScopeDefinition__Group__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__2__Impl" - + // $ANTLR end "ruleJvmWildcardTypeReference" - // $ANTLR start "rule__ScopeDefinition__Group__3" - // InternalScope.g:3275:1: rule__ScopeDefinition__Group__3 : rule__ScopeDefinition__Group__3__Impl rule__ScopeDefinition__Group__4 ; - public final void rule__ScopeDefinition__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmUpperBound" + // InternalScope.g:3212:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ; + public final void entryRuleJvmUpperBound() throws RecognitionException { try { - // InternalScope.g:3279:1: ( rule__ScopeDefinition__Group__3__Impl rule__ScopeDefinition__Group__4 ) - // InternalScope.g:3280:2: rule__ScopeDefinition__Group__3__Impl rule__ScopeDefinition__Group__4 + // InternalScope.g:3213:1: ( ruleJvmUpperBound EOF ) + // InternalScope.g:3214:1: ruleJvmUpperBound EOF { - pushFollow(FOLLOW_20); - rule__ScopeDefinition__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group__4(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + ruleJvmUpperBound(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11789,34 +10881,41 @@ public final void rule__ScopeDefinition__Group__3() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__3" + // $ANTLR end "entryRuleJvmUpperBound" - // $ANTLR start "rule__ScopeDefinition__Group__3__Impl" - // InternalScope.g:3287:1: rule__ScopeDefinition__Group__3__Impl : ( '{' ) ; - public final void rule__ScopeDefinition__Group__3__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmUpperBound" + // InternalScope.g:3221:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ; + public final void ruleJvmUpperBound() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3291:1: ( ( '{' ) ) - // InternalScope.g:3292:1: ( '{' ) + // InternalScope.g:3225:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) ) + // InternalScope.g:3226:2: ( ( rule__JvmUpperBound__Group__0 ) ) { - // InternalScope.g:3292:1: ( '{' ) - // InternalScope.g:3293:2: '{' + // InternalScope.g:3226:2: ( ( rule__JvmUpperBound__Group__0 ) ) + // InternalScope.g:3227:3: ( rule__JvmUpperBound__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); + before(grammarAccess.getJvmUpperBoundAccess().getGroup()); + } + // InternalScope.g:3228:3: ( rule__JvmUpperBound__Group__0 ) + // InternalScope.g:3228:4: rule__JvmUpperBound__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); + after(grammarAccess.getJvmUpperBoundAccess().getGroup()); } } @@ -11836,29 +10935,28 @@ public final void rule__ScopeDefinition__Group__3__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__3__Impl" + // $ANTLR end "ruleJvmUpperBound" - // $ANTLR start "rule__ScopeDefinition__Group__4" - // InternalScope.g:3302:1: rule__ScopeDefinition__Group__4 : rule__ScopeDefinition__Group__4__Impl rule__ScopeDefinition__Group__5 ; - public final void rule__ScopeDefinition__Group__4() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalScope.g:3237:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ; + public final void entryRuleJvmUpperBoundAnded() throws RecognitionException { try { - // InternalScope.g:3306:1: ( rule__ScopeDefinition__Group__4__Impl rule__ScopeDefinition__Group__5 ) - // InternalScope.g:3307:2: rule__ScopeDefinition__Group__4__Impl rule__ScopeDefinition__Group__5 + // InternalScope.g:3238:1: ( ruleJvmUpperBoundAnded EOF ) + // InternalScope.g:3239:1: ruleJvmUpperBoundAnded EOF { - pushFollow(FOLLOW_21); - rule__ScopeDefinition__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group__5(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + ruleJvmUpperBoundAnded(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11868,39 +10966,33 @@ public final void rule__ScopeDefinition__Group__4() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__4" + // $ANTLR end "entryRuleJvmUpperBoundAnded" - // $ANTLR start "rule__ScopeDefinition__Group__4__Impl" - // InternalScope.g:3314:1: rule__ScopeDefinition__Group__4__Impl : ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) ; - public final void rule__ScopeDefinition__Group__4__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalScope.g:3246:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ; + public final void ruleJvmUpperBoundAnded() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3318:1: ( ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) ) - // InternalScope.g:3319:1: ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) + // InternalScope.g:3250:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ) + // InternalScope.g:3251:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) { - // InternalScope.g:3319:1: ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) - // InternalScope.g:3320:2: ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) - { - // InternalScope.g:3320:2: ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) - // InternalScope.g:3321:3: ( rule__ScopeDefinition__RulesAssignment_4 ) + // InternalScope.g:3251:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) ) + // InternalScope.g:3252:3: ( rule__JvmUpperBoundAnded__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); + before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } - // InternalScope.g:3322:3: ( rule__ScopeDefinition__RulesAssignment_4 ) - // InternalScope.g:3322:4: rule__ScopeDefinition__RulesAssignment_4 + // InternalScope.g:3253:3: ( rule__JvmUpperBoundAnded__Group__0 ) + // InternalScope.g:3253:4: rule__JvmUpperBoundAnded__Group__0 { - pushFollow(FOLLOW_22); - rule__ScopeDefinition__RulesAssignment_4(); + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__0(); state._fsp--; if (state.failed) return ; @@ -11908,48 +11000,7 @@ public final void rule__ScopeDefinition__Group__4__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); - } - - } - - // InternalScope.g:3325:2: ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) - // InternalScope.g:3326:3: ( rule__ScopeDefinition__RulesAssignment_4 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); - } - // InternalScope.g:3327:3: ( rule__ScopeDefinition__RulesAssignment_4 )* - loop38: - do { - int alt38=2; - int LA38_0 = input.LA(1); - - if ( (LA38_0==54) ) { - alt38=1; - } - - - switch (alt38) { - case 1 : - // InternalScope.g:3327:4: rule__ScopeDefinition__RulesAssignment_4 - { - pushFollow(FOLLOW_22); - rule__ScopeDefinition__RulesAssignment_4(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop38; - } - } while (true); - - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); + after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); } } @@ -11957,9 +11008,6 @@ public final void rule__ScopeDefinition__Group__4__Impl() throws RecognitionExce } - - } - } catch (RecognitionException re) { reportError(re); @@ -11972,24 +11020,28 @@ public final void rule__ScopeDefinition__Group__4__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__4__Impl" + // $ANTLR end "ruleJvmUpperBoundAnded" - // $ANTLR start "rule__ScopeDefinition__Group__5" - // InternalScope.g:3336:1: rule__ScopeDefinition__Group__5 : rule__ScopeDefinition__Group__5__Impl ; - public final void rule__ScopeDefinition__Group__5() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmLowerBound" + // InternalScope.g:3262:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ; + public final void entryRuleJvmLowerBound() throws RecognitionException { try { - // InternalScope.g:3340:1: ( rule__ScopeDefinition__Group__5__Impl ) - // InternalScope.g:3341:2: rule__ScopeDefinition__Group__5__Impl + // InternalScope.g:3263:1: ( ruleJvmLowerBound EOF ) + // InternalScope.g:3264:1: ruleJvmLowerBound EOF { - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group__5__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + ruleJvmLowerBound(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -11999,34 +11051,41 @@ public final void rule__ScopeDefinition__Group__5() throws RecognitionException recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__5" + // $ANTLR end "entryRuleJvmLowerBound" - // $ANTLR start "rule__ScopeDefinition__Group__5__Impl" - // InternalScope.g:3347:1: rule__ScopeDefinition__Group__5__Impl : ( '}' ) ; - public final void rule__ScopeDefinition__Group__5__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmLowerBound" + // InternalScope.g:3271:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ; + public final void ruleJvmLowerBound() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3351:1: ( ( '}' ) ) - // InternalScope.g:3352:1: ( '}' ) + // InternalScope.g:3275:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) ) + // InternalScope.g:3276:2: ( ( rule__JvmLowerBound__Group__0 ) ) { - // InternalScope.g:3352:1: ( '}' ) - // InternalScope.g:3353:2: '}' + // InternalScope.g:3276:2: ( ( rule__JvmLowerBound__Group__0 ) ) + // InternalScope.g:3277:3: ( rule__JvmLowerBound__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); + before(grammarAccess.getJvmLowerBoundAccess().getGroup()); + } + // InternalScope.g:3278:3: ( rule__JvmLowerBound__Group__0 ) + // InternalScope.g:3278:4: rule__JvmLowerBound__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__0(); + + state._fsp--; + if (state.failed) return ; + } - match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); + after(grammarAccess.getJvmLowerBoundAccess().getGroup()); } } @@ -12046,29 +11105,28 @@ public final void rule__ScopeDefinition__Group__5__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDefinition__Group__5__Impl" + // $ANTLR end "ruleJvmLowerBound" - // $ANTLR start "rule__ScopeDefinition__Group_1__0" - // InternalScope.g:3363:1: rule__ScopeDefinition__Group_1__0 : rule__ScopeDefinition__Group_1__0__Impl rule__ScopeDefinition__Group_1__1 ; - public final void rule__ScopeDefinition__Group_1__0() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalScope.g:3287:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ; + public final void entryRuleJvmLowerBoundAnded() throws RecognitionException { try { - // InternalScope.g:3367:1: ( rule__ScopeDefinition__Group_1__0__Impl rule__ScopeDefinition__Group_1__1 ) - // InternalScope.g:3368:2: rule__ScopeDefinition__Group_1__0__Impl rule__ScopeDefinition__Group_1__1 + // InternalScope.g:3288:1: ( ruleJvmLowerBoundAnded EOF ) + // InternalScope.g:3289:1: ruleJvmLowerBoundAnded EOF { - pushFollow(FOLLOW_3); - rule__ScopeDefinition__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + ruleJvmLowerBoundAnded(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -12078,34 +11136,41 @@ public final void rule__ScopeDefinition__Group_1__0() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_1__0" + // $ANTLR end "entryRuleJvmLowerBoundAnded" - // $ANTLR start "rule__ScopeDefinition__Group_1__0__Impl" - // InternalScope.g:3375:1: rule__ScopeDefinition__Group_1__0__Impl : ( '(' ) ; - public final void rule__ScopeDefinition__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalScope.g:3296:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ; + public final void ruleJvmLowerBoundAnded() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3379:1: ( ( '(' ) ) - // InternalScope.g:3380:1: ( '(' ) + // InternalScope.g:3300:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ) + // InternalScope.g:3301:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) { - // InternalScope.g:3380:1: ( '(' ) - // InternalScope.g:3381:2: '(' + // InternalScope.g:3301:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) ) + // InternalScope.g:3302:3: ( rule__JvmLowerBoundAnded__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); + before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:3303:3: ( rule__JvmLowerBoundAnded__Group__0 ) + // InternalScope.g:3303:4: rule__JvmLowerBoundAnded__Group__0 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); + after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); } } @@ -12125,29 +11190,28 @@ public final void rule__ScopeDefinition__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_1__0__Impl" + // $ANTLR end "ruleJvmLowerBoundAnded" - // $ANTLR start "rule__ScopeDefinition__Group_1__1" - // InternalScope.g:3390:1: rule__ScopeDefinition__Group_1__1 : rule__ScopeDefinition__Group_1__1__Impl rule__ScopeDefinition__Group_1__2 ; - public final void rule__ScopeDefinition__Group_1__1() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalScope.g:3312:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ; + public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException { try { - // InternalScope.g:3394:1: ( rule__ScopeDefinition__Group_1__1__Impl rule__ScopeDefinition__Group_1__2 ) - // InternalScope.g:3395:2: rule__ScopeDefinition__Group_1__1__Impl rule__ScopeDefinition__Group_1__2 + // InternalScope.g:3313:1: ( ruleQualifiedNameWithWildcard EOF ) + // InternalScope.g:3314:1: ruleQualifiedNameWithWildcard EOF { - pushFollow(FOLLOW_23); - rule__ScopeDefinition__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedNameWithWildcard(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -12157,36 +11221,33 @@ public final void rule__ScopeDefinition__Group_1__1() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_1__1" + // $ANTLR end "entryRuleQualifiedNameWithWildcard" - // $ANTLR start "rule__ScopeDefinition__Group_1__1__Impl" - // InternalScope.g:3402:1: rule__ScopeDefinition__Group_1__1__Impl : ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) ; - public final void rule__ScopeDefinition__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalScope.g:3321:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ; + public final void ruleQualifiedNameWithWildcard() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3406:1: ( ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) ) - // InternalScope.g:3407:1: ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) + // InternalScope.g:3325:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ) + // InternalScope.g:3326:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) { - // InternalScope.g:3407:1: ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) - // InternalScope.g:3408:2: ( rule__ScopeDefinition__NameAssignment_1_1 ) + // InternalScope.g:3326:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) + // InternalScope.g:3327:3: ( rule__QualifiedNameWithWildcard__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); + before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } - // InternalScope.g:3409:2: ( rule__ScopeDefinition__NameAssignment_1_1 ) - // InternalScope.g:3409:3: rule__ScopeDefinition__NameAssignment_1_1 + // InternalScope.g:3328:3: ( rule__QualifiedNameWithWildcard__Group__0 ) + // InternalScope.g:3328:4: rule__QualifiedNameWithWildcard__Group__0 { pushFollow(FOLLOW_2); - rule__ScopeDefinition__NameAssignment_1_1(); + rule__QualifiedNameWithWildcard__Group__0(); state._fsp--; if (state.failed) return ; @@ -12194,7 +11255,7 @@ public final void rule__ScopeDefinition__Group_1__1__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); + after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); } } @@ -12214,24 +11275,28 @@ public final void rule__ScopeDefinition__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_1__1__Impl" + // $ANTLR end "ruleQualifiedNameWithWildcard" - // $ANTLR start "rule__ScopeDefinition__Group_1__2" - // InternalScope.g:3417:1: rule__ScopeDefinition__Group_1__2 : rule__ScopeDefinition__Group_1__2__Impl ; - public final void rule__ScopeDefinition__Group_1__2() throws RecognitionException { - - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleValidID" + // InternalScope.g:3337:1: entryRuleValidID : ruleValidID EOF ; + public final void entryRuleValidID() throws RecognitionException { try { - // InternalScope.g:3421:1: ( rule__ScopeDefinition__Group_1__2__Impl ) - // InternalScope.g:3422:2: rule__ScopeDefinition__Group_1__2__Impl + // InternalScope.g:3338:1: ( ruleValidID EOF ) + // InternalScope.g:3339:1: ruleValidID EOF { - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_1__2__Impl(); + if ( state.backtracking==0 ) { + before(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + ruleValidID(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getValidIDRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -12241,34 +11306,31 @@ public final void rule__ScopeDefinition__Group_1__2() throws RecognitionExceptio recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_1__2" + // $ANTLR end "entryRuleValidID" - // $ANTLR start "rule__ScopeDefinition__Group_1__2__Impl" - // InternalScope.g:3428:1: rule__ScopeDefinition__Group_1__2__Impl : ( ')' ) ; - public final void rule__ScopeDefinition__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleValidID" + // InternalScope.g:3346:1: ruleValidID : ( RULE_ID ) ; + public final void ruleValidID() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3432:1: ( ( ')' ) ) - // InternalScope.g:3433:1: ( ')' ) + // InternalScope.g:3350:2: ( ( RULE_ID ) ) + // InternalScope.g:3351:2: ( RULE_ID ) { - // InternalScope.g:3433:1: ( ')' ) - // InternalScope.g:3434:2: ')' + // InternalScope.g:3351:2: ( RULE_ID ) + // InternalScope.g:3352:3: RULE_ID { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); + before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,RULE_ID,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); + after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); } } @@ -12288,29 +11350,28 @@ public final void rule__ScopeDefinition__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_1__2__Impl" - + // $ANTLR end "ruleValidID" - // $ANTLR start "rule__ScopeDefinition__Group_2_1__0" - // InternalScope.g:3444:1: rule__ScopeDefinition__Group_2_1__0 : rule__ScopeDefinition__Group_2_1__0__Impl rule__ScopeDefinition__Group_2_1__1 ; - public final void rule__ScopeDefinition__Group_2_1__0() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleXImportDeclaration" + // InternalScope.g:3362:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ; + public final void entryRuleXImportDeclaration() throws RecognitionException { try { - // InternalScope.g:3448:1: ( rule__ScopeDefinition__Group_2_1__0__Impl rule__ScopeDefinition__Group_2_1__1 ) - // InternalScope.g:3449:2: rule__ScopeDefinition__Group_2_1__0__Impl rule__ScopeDefinition__Group_2_1__1 + // InternalScope.g:3363:1: ( ruleXImportDeclaration EOF ) + // InternalScope.g:3364:1: ruleXImportDeclaration EOF { - pushFollow(FOLLOW_24); - rule__ScopeDefinition__Group_2_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_2_1__1(); + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + ruleXImportDeclaration(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -12320,36 +11381,33 @@ public final void rule__ScopeDefinition__Group_2_1__0() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_2_1__0" + // $ANTLR end "entryRuleXImportDeclaration" - // $ANTLR start "rule__ScopeDefinition__Group_2_1__0__Impl" - // InternalScope.g:3456:1: rule__ScopeDefinition__Group_2_1__0__Impl : ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) ; - public final void rule__ScopeDefinition__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "ruleXImportDeclaration" + // InternalScope.g:3371:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ; + public final void ruleXImportDeclaration() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3460:1: ( ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) ) - // InternalScope.g:3461:1: ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) + // InternalScope.g:3375:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) ) + // InternalScope.g:3376:2: ( ( rule__XImportDeclaration__Group__0 ) ) { - // InternalScope.g:3461:1: ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) - // InternalScope.g:3462:2: ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) + // InternalScope.g:3376:2: ( ( rule__XImportDeclaration__Group__0 ) ) + // InternalScope.g:3377:3: ( rule__XImportDeclaration__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); + before(grammarAccess.getXImportDeclarationAccess().getGroup()); } - // InternalScope.g:3463:2: ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) - // InternalScope.g:3463:3: rule__ScopeDefinition__ContextTypeAssignment_2_1_0 + // InternalScope.g:3378:3: ( rule__XImportDeclaration__Group__0 ) + // InternalScope.g:3378:4: rule__XImportDeclaration__Group__0 { pushFollow(FOLLOW_2); - rule__ScopeDefinition__ContextTypeAssignment_2_1_0(); + rule__XImportDeclaration__Group__0(); state._fsp--; if (state.failed) return ; @@ -12357,7 +11415,7 @@ public final void rule__ScopeDefinition__Group_2_1__0__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); + after(grammarAccess.getXImportDeclarationAccess().getGroup()); } } @@ -12377,29 +11435,28 @@ public final void rule__ScopeDefinition__Group_2_1__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_2_1__0__Impl" - + // $ANTLR end "ruleXImportDeclaration" - // $ANTLR start "rule__ScopeDefinition__Group_2_1__1" - // InternalScope.g:3471:1: rule__ScopeDefinition__Group_2_1__1 : rule__ScopeDefinition__Group_2_1__1__Impl rule__ScopeDefinition__Group_2_1__2 ; - public final void rule__ScopeDefinition__Group_2_1__1() throws RecognitionException { - int stackSize = keepStackSize(); - + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalScope.g:3387:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ; + public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException { try { - // InternalScope.g:3475:1: ( rule__ScopeDefinition__Group_2_1__1__Impl rule__ScopeDefinition__Group_2_1__2 ) - // InternalScope.g:3476:2: rule__ScopeDefinition__Group_2_1__1__Impl rule__ScopeDefinition__Group_2_1__2 + // InternalScope.g:3388:1: ( ruleQualifiedNameInStaticImport EOF ) + // InternalScope.g:3389:1: ruleQualifiedNameInStaticImport EOF { - pushFollow(FOLLOW_3); - rule__ScopeDefinition__Group_2_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_2_1__2(); + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + ruleQualifiedNameInStaticImport(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportRule()); + } + match(input,EOF,FOLLOW_2); if (state.failed) return ; } @@ -12409,71 +11466,98 @@ public final void rule__ScopeDefinition__Group_2_1__1() throws RecognitionExcept recover(input,re); } finally { - - restoreStackSize(stackSize); - } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_2_1__1" + // $ANTLR end "entryRuleQualifiedNameInStaticImport" - // $ANTLR start "rule__ScopeDefinition__Group_2_1__1__Impl" - // InternalScope.g:3483:1: rule__ScopeDefinition__Group_2_1__1__Impl : ( '#' ) ; - public final void rule__ScopeDefinition__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalScope.g:3396:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ; + public final void ruleQualifiedNameInStaticImport() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3487:1: ( ( '#' ) ) - // InternalScope.g:3488:1: ( '#' ) + // InternalScope.g:3400:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ) + // InternalScope.g:3401:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + { + // InternalScope.g:3401:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) + // InternalScope.g:3402:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) { - // InternalScope.g:3488:1: ( '#' ) - // InternalScope.g:3489:2: '#' + // InternalScope.g:3402:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) + // InternalScope.g:3403:4: ( rule__QualifiedNameInStaticImport__Group__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } - match(input,53,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); + // InternalScope.g:3404:4: ( rule__QualifiedNameInStaticImport__Group__0 ) + // InternalScope.g:3404:5: rule__QualifiedNameInStaticImport__Group__0 + { + pushFollow(FOLLOW_3); + rule__QualifiedNameInStaticImport__Group__0(); + + state._fsp--; + if (state.failed) return ; + } + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + } + // InternalScope.g:3407:3: ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) + // InternalScope.g:3408:4: ( rule__QualifiedNameInStaticImport__Group__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); } + // InternalScope.g:3409:4: ( rule__QualifiedNameInStaticImport__Group__0 )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( (LA1_0==RULE_ID) ) { + int LA1_2 = input.LA(2); - restoreStackSize(stackSize); + if ( (LA1_2==58) ) { + alt1=1; + } - } - return ; - } - // $ANTLR end "rule__ScopeDefinition__Group_2_1__1__Impl" + } - // $ANTLR start "rule__ScopeDefinition__Group_2_1__2" - // InternalScope.g:3498:1: rule__ScopeDefinition__Group_2_1__2 : rule__ScopeDefinition__Group_2_1__2__Impl ; - public final void rule__ScopeDefinition__Group_2_1__2() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3502:1: ( rule__ScopeDefinition__Group_2_1__2__Impl ) - // InternalScope.g:3503:2: rule__ScopeDefinition__Group_2_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeDefinition__Group_2_1__2__Impl(); + switch (alt1) { + case 1 : + // InternalScope.g:3409:5: rule__QualifiedNameInStaticImport__Group__0 + { + pushFollow(FOLLOW_3); + rule__QualifiedNameInStaticImport__Group__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop1; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); + } + + } + + + } - state._fsp--; - if (state.failed) return ; } @@ -12489,30 +11573,30 @@ public final void rule__ScopeDefinition__Group_2_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_2_1__2" + // $ANTLR end "ruleQualifiedNameInStaticImport" - // $ANTLR start "rule__ScopeDefinition__Group_2_1__2__Impl" - // InternalScope.g:3509:1: rule__ScopeDefinition__Group_2_1__2__Impl : ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) ; - public final void rule__ScopeDefinition__Group_2_1__2__Impl() throws RecognitionException { + // $ANTLR start "ruleCasing" + // InternalScope.g:3419:1: ruleCasing : ( ( rule__Casing__Alternatives ) ) ; + public final void ruleCasing() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3513:1: ( ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) ) - // InternalScope.g:3514:1: ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) + // InternalScope.g:3423:1: ( ( ( rule__Casing__Alternatives ) ) ) + // InternalScope.g:3424:2: ( ( rule__Casing__Alternatives ) ) { - // InternalScope.g:3514:1: ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) - // InternalScope.g:3515:2: ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) + // InternalScope.g:3424:2: ( ( rule__Casing__Alternatives ) ) + // InternalScope.g:3425:3: ( rule__Casing__Alternatives ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); + before(grammarAccess.getCasingAccess().getAlternatives()); } - // InternalScope.g:3516:2: ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) - // InternalScope.g:3516:3: rule__ScopeDefinition__ReferenceAssignment_2_1_2 + // InternalScope.g:3426:3: ( rule__Casing__Alternatives ) + // InternalScope.g:3426:4: rule__Casing__Alternatives { pushFollow(FOLLOW_2); - rule__ScopeDefinition__ReferenceAssignment_2_1_2(); + rule__Casing__Alternatives(); state._fsp--; if (state.failed) return ; @@ -12520,7 +11604,7 @@ public final void rule__ScopeDefinition__Group_2_1__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); + after(grammarAccess.getCasingAccess().getAlternatives()); } } @@ -12540,73 +11624,80 @@ public final void rule__ScopeDefinition__Group_2_1__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ScopeDefinition__Group_2_1__2__Impl" + // $ANTLR end "ruleCasing" - // $ANTLR start "rule__ScopeRule__Group__0" - // InternalScope.g:3525:1: rule__ScopeRule__Group__0 : rule__ScopeRule__Group__0__Impl rule__ScopeRule__Group__1 ; - public final void rule__ScopeRule__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Alternatives_2" + // InternalScope.g:3434:1: rule__ScopeDefinition__Alternatives_2 : ( ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) | ( ( rule__ScopeDefinition__Group_2_1__0 ) ) ); + public final void rule__ScopeDefinition__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3529:1: ( rule__ScopeRule__Group__0__Impl rule__ScopeRule__Group__1 ) - // InternalScope.g:3530:2: rule__ScopeRule__Group__0__Impl rule__ScopeRule__Group__1 - { - pushFollow(FOLLOW_25); - rule__ScopeRule__Group__0__Impl(); + // InternalScope.g:3438:1: ( ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) | ( ( rule__ScopeDefinition__Group_2_1__0 ) ) ) + int alt2=2; + alt2 = dfa2.predict(input); + switch (alt2) { + case 1 : + // InternalScope.g:3439:2: ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) + { + // InternalScope.g:3439:2: ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) + // InternalScope.g:3440:3: ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); + } + // InternalScope.g:3441:3: ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) + // InternalScope.g:3441:4: rule__ScopeDefinition__TargetTypeAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__ScopeDefinition__TargetTypeAssignment_2_0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeRule__Group__1(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getTargetTypeAssignment_2_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group__0" + } + break; + case 2 : + // InternalScope.g:3445:2: ( ( rule__ScopeDefinition__Group_2_1__0 ) ) + { + // InternalScope.g:3445:2: ( ( rule__ScopeDefinition__Group_2_1__0 ) ) + // InternalScope.g:3446:3: ( rule__ScopeDefinition__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); + } + // InternalScope.g:3447:3: ( rule__ScopeDefinition__Group_2_1__0 ) + // InternalScope.g:3447:4: rule__ScopeDefinition__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__ScopeDefinition__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__ScopeRule__Group__0__Impl" - // InternalScope.g:3537:1: rule__ScopeRule__Group__0__Impl : ( 'context' ) ; - public final void rule__ScopeRule__Group__0__Impl() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getGroup_2_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3541:1: ( ( 'context' ) ) - // InternalScope.g:3542:1: ( 'context' ) - { - // InternalScope.g:3542:1: ( 'context' ) - // InternalScope.g:3543:2: 'context' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); - } - match(input,54,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -12619,83 +11710,94 @@ public final void rule__ScopeRule__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeRule__Group__0__Impl" + // $ANTLR end "rule__ScopeDefinition__Alternatives_2" - // $ANTLR start "rule__ScopeRule__Group__1" - // InternalScope.g:3552:1: rule__ScopeRule__Group__1 : rule__ScopeRule__Group__1__Impl rule__ScopeRule__Group__2 ; - public final void rule__ScopeRule__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Alternatives_0" + // InternalScope.g:3455:1: rule__ScopeContext__Alternatives_0 : ( ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) | ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) ); + public final void rule__ScopeContext__Alternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3556:1: ( rule__ScopeRule__Group__1__Impl rule__ScopeRule__Group__2 ) - // InternalScope.g:3557:2: rule__ScopeRule__Group__1__Impl rule__ScopeRule__Group__2 - { - pushFollow(FOLLOW_16); - rule__ScopeRule__Group__1__Impl(); + // InternalScope.g:3459:1: ( ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) | ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) ) + int alt3=2; + int LA3_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeRule__Group__2(); - - state._fsp--; - if (state.failed) return ; + if ( (LA3_0==25) ) { + alt3=1; + } + else if ( (LA3_0==RULE_ID) ) { + alt3=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + throw nvae; } + switch (alt3) { + case 1 : + // InternalScope.g:3460:2: ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) + { + // InternalScope.g:3460:2: ( ( rule__ScopeContext__GlobalAssignment_0_0 ) ) + // InternalScope.g:3461:3: ( rule__ScopeContext__GlobalAssignment_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); + } + // InternalScope.g:3462:3: ( rule__ScopeContext__GlobalAssignment_0_0 ) + // InternalScope.g:3462:4: rule__ScopeContext__GlobalAssignment_0_0 + { + pushFollow(FOLLOW_2); + rule__ScopeContext__GlobalAssignment_0_0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group__1" + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getGlobalAssignment_0_0()); + } + } - // $ANTLR start "rule__ScopeRule__Group__1__Impl" - // InternalScope.g:3564:1: rule__ScopeRule__Group__1__Impl : ( ( rule__ScopeRule__ContextAssignment_1 ) ) ; - public final void rule__ScopeRule__Group__1__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3568:1: ( ( ( rule__ScopeRule__ContextAssignment_1 ) ) ) - // InternalScope.g:3569:1: ( ( rule__ScopeRule__ContextAssignment_1 ) ) - { - // InternalScope.g:3569:1: ( ( rule__ScopeRule__ContextAssignment_1 ) ) - // InternalScope.g:3570:2: ( rule__ScopeRule__ContextAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); - } - // InternalScope.g:3571:2: ( rule__ScopeRule__ContextAssignment_1 ) - // InternalScope.g:3571:3: rule__ScopeRule__ContextAssignment_1 - { - pushFollow(FOLLOW_2); - rule__ScopeRule__ContextAssignment_1(); + } + break; + case 2 : + // InternalScope.g:3466:2: ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) + { + // InternalScope.g:3466:2: ( ( rule__ScopeContext__ContextTypeAssignment_0_1 ) ) + // InternalScope.g:3467:3: ( rule__ScopeContext__ContextTypeAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); + } + // InternalScope.g:3468:3: ( rule__ScopeContext__ContextTypeAssignment_0_1 ) + // InternalScope.g:3468:4: rule__ScopeContext__ContextTypeAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__ScopeContext__ContextTypeAssignment_0_1(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getContextTypeAssignment_0_1()); + } - } + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12708,73 +11810,142 @@ public final void rule__ScopeRule__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeRule__Group__1__Impl" + // $ANTLR end "rule__ScopeContext__Alternatives_0" - // $ANTLR start "rule__ScopeRule__Group__2" - // InternalScope.g:3579:1: rule__ScopeRule__Group__2 : rule__ScopeRule__Group__2__Impl rule__ScopeRule__Group__3 ; - public final void rule__ScopeRule__Group__2() throws RecognitionException { + // $ANTLR start "rule__ScopeExpression__Alternatives" + // InternalScope.g:3476:1: rule__ScopeExpression__Alternatives : ( ( ruleScopeDelegation ) | ( ruleFactoryExpression ) | ( ruleNamedScopeExpression ) ); + public final void rule__ScopeExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3583:1: ( rule__ScopeRule__Group__2__Impl rule__ScopeRule__Group__3 ) - // InternalScope.g:3584:2: rule__ScopeRule__Group__2__Impl rule__ScopeRule__Group__3 - { - pushFollow(FOLLOW_26); - rule__ScopeRule__Group__2__Impl(); + // InternalScope.g:3480:1: ( ( ruleScopeDelegation ) | ( ruleFactoryExpression ) | ( ruleNamedScopeExpression ) ) + int alt4=3; + switch ( input.LA(1) ) { + case 85: + { + alt4=1; + } + break; + case 84: + { + alt4=2; + } + break; + case RULE_ID: + case RULE_INT: + case RULE_STRING: + case RULE_REAL: + case 24: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + case 40: + case 72: + case 77: + case 87: + case 94: + case 97: + case 100: + case 102: + case 103: + case 108: + case 120: + { + alt4=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 4, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeRule__Group__3(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt4) { + case 1 : + // InternalScope.g:3481:2: ( ruleScopeDelegation ) + { + // InternalScope.g:3481:2: ( ruleScopeDelegation ) + // InternalScope.g:3482:3: ruleScopeDelegation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleScopeDelegation(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeExpressionAccess().getScopeDelegationParserRuleCall_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group__2" + } + break; + case 2 : + // InternalScope.g:3487:2: ( ruleFactoryExpression ) + { + // InternalScope.g:3487:2: ( ruleFactoryExpression ) + // InternalScope.g:3488:3: ruleFactoryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleFactoryExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeExpressionAccess().getFactoryExpressionParserRuleCall_1()); + } - // $ANTLR start "rule__ScopeRule__Group__2__Impl" - // InternalScope.g:3591:1: rule__ScopeRule__Group__2__Impl : ( '=' ) ; - public final void rule__ScopeRule__Group__2__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3595:1: ( ( '=' ) ) - // InternalScope.g:3596:1: ( '=' ) - { - // InternalScope.g:3596:1: ( '=' ) - // InternalScope.g:3597:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); - } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); - } - } + } + break; + case 3 : + // InternalScope.g:3493:2: ( ruleNamedScopeExpression ) + { + // InternalScope.g:3493:2: ( ruleNamedScopeExpression ) + // InternalScope.g:3494:3: ruleNamedScopeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleNamedScopeExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeExpressionAccess().getNamedScopeExpressionParserRuleCall_2()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12787,83 +11958,94 @@ public final void rule__ScopeRule__Group__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeRule__Group__2__Impl" + // $ANTLR end "rule__ScopeExpression__Alternatives" - // $ANTLR start "rule__ScopeRule__Group__3" - // InternalScope.g:3606:1: rule__ScopeRule__Group__3 : rule__ScopeRule__Group__3__Impl rule__ScopeRule__Group__4 ; - public final void rule__ScopeRule__Group__3() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Alternatives_2" + // InternalScope.g:3503:1: rule__ScopeDelegation__Alternatives_2 : ( ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) | ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) ); + public final void rule__ScopeDelegation__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3610:1: ( rule__ScopeRule__Group__3__Impl rule__ScopeRule__Group__4 ) - // InternalScope.g:3611:2: rule__ScopeRule__Group__3__Impl rule__ScopeRule__Group__4 - { - pushFollow(FOLLOW_27); - rule__ScopeRule__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeRule__Group__4(); + // InternalScope.g:3507:1: ( ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) | ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) ) + int alt5=2; + int LA5_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA5_0==RULE_ID||LA5_0==RULE_INT||(LA5_0>=RULE_STRING && LA5_0<=RULE_REAL)||LA5_0==24||(LA5_0>=27 && LA5_0<=40)||LA5_0==72||LA5_0==77||LA5_0==94||LA5_0==97||LA5_0==100||(LA5_0>=102 && LA5_0<=103)||LA5_0==108||LA5_0==120) ) { + alt5=1; + } + else if ( (LA5_0==87) ) { + alt5=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + throw nvae; } + switch (alt5) { + case 1 : + // InternalScope.g:3508:2: ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) + { + // InternalScope.g:3508:2: ( ( rule__ScopeDelegation__DelegateAssignment_2_0 ) ) + // InternalScope.g:3509:3: ( rule__ScopeDelegation__DelegateAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); + } + // InternalScope.g:3510:3: ( rule__ScopeDelegation__DelegateAssignment_2_0 ) + // InternalScope.g:3510:4: rule__ScopeDelegation__DelegateAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__ScopeDelegation__DelegateAssignment_2_0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group__3" + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDelegationAccess().getDelegateAssignment_2_0()); + } + } - // $ANTLR start "rule__ScopeRule__Group__3__Impl" - // InternalScope.g:3618:1: rule__ScopeRule__Group__3__Impl : ( ( rule__ScopeRule__ExprsAssignment_3 ) ) ; - public final void rule__ScopeRule__Group__3__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3622:1: ( ( ( rule__ScopeRule__ExprsAssignment_3 ) ) ) - // InternalScope.g:3623:1: ( ( rule__ScopeRule__ExprsAssignment_3 ) ) - { - // InternalScope.g:3623:1: ( ( rule__ScopeRule__ExprsAssignment_3 ) ) - // InternalScope.g:3624:2: ( rule__ScopeRule__ExprsAssignment_3 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); - } - // InternalScope.g:3625:2: ( rule__ScopeRule__ExprsAssignment_3 ) - // InternalScope.g:3625:3: rule__ScopeRule__ExprsAssignment_3 - { - pushFollow(FOLLOW_2); - rule__ScopeRule__ExprsAssignment_3(); + } + break; + case 2 : + // InternalScope.g:3514:2: ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) + { + // InternalScope.g:3514:2: ( ( rule__ScopeDelegation__ExternalAssignment_2_1 ) ) + // InternalScope.g:3515:3: ( rule__ScopeDelegation__ExternalAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); + } + // InternalScope.g:3516:3: ( rule__ScopeDelegation__ExternalAssignment_2_1 ) + // InternalScope.g:3516:4: rule__ScopeDelegation__ExternalAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__ScopeDelegation__ExternalAssignment_2_1(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDelegationAccess().getExternalAssignment_2_1()); + } - } + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12876,32 +12058,82 @@ public final void rule__ScopeRule__Group__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeRule__Group__3__Impl" + // $ANTLR end "rule__ScopeDelegation__Alternatives_2" - // $ANTLR start "rule__ScopeRule__Group__4" - // InternalScope.g:3633:1: rule__ScopeRule__Group__4 : rule__ScopeRule__Group__4__Impl rule__ScopeRule__Group__5 ; - public final void rule__ScopeRule__Group__4() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Alternatives_0" + // InternalScope.g:3524:1: rule__NamedScopeExpression__Alternatives_0 : ( ( ruleGlobalScopeExpression ) | ( ruleSimpleScopeExpression ) ); + public final void rule__NamedScopeExpression__Alternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3637:1: ( rule__ScopeRule__Group__4__Impl rule__ScopeRule__Group__5 ) - // InternalScope.g:3638:2: rule__ScopeRule__Group__4__Impl rule__ScopeRule__Group__5 - { - pushFollow(FOLLOW_27); - rule__ScopeRule__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeRule__Group__5(); + // InternalScope.g:3528:1: ( ( ruleGlobalScopeExpression ) | ( ruleSimpleScopeExpression ) ) + int alt6=2; + int LA6_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA6_0==87) ) { + alt6=1; + } + else if ( (LA6_0==RULE_ID||LA6_0==RULE_INT||(LA6_0>=RULE_STRING && LA6_0<=RULE_REAL)||LA6_0==24||(LA6_0>=27 && LA6_0<=40)||LA6_0==72||LA6_0==77||LA6_0==94||LA6_0==97||LA6_0==100||(LA6_0>=102 && LA6_0<=103)||LA6_0==108||LA6_0==120) ) { + alt6=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 6, 0, input); + throw nvae; } + switch (alt6) { + case 1 : + // InternalScope.g:3529:2: ( ruleGlobalScopeExpression ) + { + // InternalScope.g:3529:2: ( ruleGlobalScopeExpression ) + // InternalScope.g:3530:3: ruleGlobalScopeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleGlobalScopeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamedScopeExpressionAccess().getGlobalScopeExpressionParserRuleCall_0_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:3535:2: ( ruleSimpleScopeExpression ) + { + // InternalScope.g:3535:2: ( ruleSimpleScopeExpression ) + // InternalScope.g:3536:3: ruleSimpleScopeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); + } + pushFollow(FOLLOW_2); + ruleSimpleScopeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamedScopeExpressionAccess().getSimpleScopeExpressionParserRuleCall_0_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -12914,63 +12146,105 @@ public final void rule__ScopeRule__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeRule__Group__4" + // $ANTLR end "rule__NamedScopeExpression__Alternatives_0" - // $ANTLR start "rule__ScopeRule__Group__4__Impl" - // InternalScope.g:3645:1: rule__ScopeRule__Group__4__Impl : ( ( rule__ScopeRule__Group_4__0 )* ) ; - public final void rule__ScopeRule__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Alternatives_3" + // InternalScope.g:3545:1: rule__GlobalScopeExpression__Alternatives_3 : ( ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) | ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) ); + public final void rule__GlobalScopeExpression__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3649:1: ( ( ( rule__ScopeRule__Group_4__0 )* ) ) - // InternalScope.g:3650:1: ( ( rule__ScopeRule__Group_4__0 )* ) - { - // InternalScope.g:3650:1: ( ( rule__ScopeRule__Group_4__0 )* ) - // InternalScope.g:3651:2: ( rule__ScopeRule__Group_4__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getGroup_4()); - } - // InternalScope.g:3652:2: ( rule__ScopeRule__Group_4__0 )* - loop39: - do { - int alt39=2; - int LA39_0 = input.LA(1); + // InternalScope.g:3549:1: ( ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) | ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) ) + int alt7=2; + int LA7_0 = input.LA(1); - if ( (LA39_0==55) ) { - alt39=1; + if ( (LA7_0==86) ) { + int LA7_1 = input.LA(2); + + if ( (LA7_1==89||LA7_1==117) ) { + alt7=2; + } + else if ( (LA7_1==88) ) { + alt7=1; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 1, input); + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 7, 0, input); - switch (alt39) { - case 1 : - // InternalScope.g:3652:3: rule__ScopeRule__Group_4__0 - { - pushFollow(FOLLOW_28); - rule__ScopeRule__Group_4__0(); + throw nvae; + } + switch (alt7) { + case 1 : + // InternalScope.g:3550:2: ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) + { + // InternalScope.g:3550:2: ( ( rule__GlobalScopeExpression__Group_3_0__0 ) ) + // InternalScope.g:3551:3: ( rule__GlobalScopeExpression__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); + } + // InternalScope.g:3552:3: ( rule__GlobalScopeExpression__Group_3_0__0 ) + // InternalScope.g:3552:4: rule__GlobalScopeExpression__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__Group_3_0__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } - default : - break loop39; - } - } while (true); + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_0()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getGroup_4()); - } + } - } + } + break; + case 2 : + // InternalScope.g:3556:2: ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) + { + // InternalScope.g:3556:2: ( ( rule__GlobalScopeExpression__Group_3_1__0 ) ) + // InternalScope.g:3557:3: ( rule__GlobalScopeExpression__Group_3_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); + } + // InternalScope.g:3558:3: ( rule__GlobalScopeExpression__Group_3_1__0 ) + // InternalScope.g:3558:4: rule__GlobalScopeExpression__Group_3_1__0 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__Group_3_1__0(); - } + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_3_1()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -12983,106 +12257,132 @@ public final void rule__ScopeRule__Group__4__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeRule__Group__4__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Alternatives_3" - // $ANTLR start "rule__ScopeRule__Group__5" - // InternalScope.g:3660:1: rule__ScopeRule__Group__5 : rule__ScopeRule__Group__5__Impl ; - public final void rule__ScopeRule__Group__5() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Alternatives_5_3" + // InternalScope.g:3566:1: rule__GlobalScopeExpression__Alternatives_5_3 : ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) | ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) | ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) ); + public final void rule__GlobalScopeExpression__Alternatives_5_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3664:1: ( rule__ScopeRule__Group__5__Impl ) - // InternalScope.g:3665:2: rule__ScopeRule__Group__5__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeRule__Group__5__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:3570:1: ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) | ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) | ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) ) + int alt8=3; + switch ( input.LA(1) ) { + case 25: + { + alt8=1; + } + break; + case RULE_ID: + { + alt8=2; + } + break; + case 77: + { + alt8=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 8, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt8) { + case 1 : + // InternalScope.g:3571:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) + { + // InternalScope.g:3571:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) ) + // InternalScope.g:3572:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); + } + // InternalScope.g:3573:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_0 ) + // InternalScope.g:3573:4: rule__GlobalScopeExpression__DomainsAssignment_5_3_0 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__DomainsAssignment_5_3_0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group__5" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_0()); + } - // $ANTLR start "rule__ScopeRule__Group__5__Impl" - // InternalScope.g:3671:1: rule__ScopeRule__Group__5__Impl : ( ';' ) ; - public final void rule__ScopeRule__Group__5__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3675:1: ( ( ';' ) ) - // InternalScope.g:3676:1: ( ';' ) - { - // InternalScope.g:3676:1: ( ';' ) - // InternalScope.g:3677:2: ';' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); - } - match(input,49,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); - } - } + } + break; + case 2 : + // InternalScope.g:3577:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) + { + // InternalScope.g:3577:2: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) ) + // InternalScope.g:3578:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); + } + // InternalScope.g:3579:3: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_1 ) + // InternalScope.g:3579:4: rule__GlobalScopeExpression__DomainsAssignment_5_3_1 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__DomainsAssignment_5_3_1(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group__5__Impl" + } + break; + case 3 : + // InternalScope.g:3583:2: ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) + { + // InternalScope.g:3583:2: ( ( rule__GlobalScopeExpression__Group_5_3_2__0 ) ) + // InternalScope.g:3584:3: ( rule__GlobalScopeExpression__Group_5_3_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); + } + // InternalScope.g:3585:3: ( rule__GlobalScopeExpression__Group_5_3_2__0 ) + // InternalScope.g:3585:4: rule__GlobalScopeExpression__Group_5_3_2__0 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__Group_5_3_2__0(); + + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__ScopeRule__Group_4__0" - // InternalScope.g:3687:1: rule__ScopeRule__Group_4__0 : rule__ScopeRule__Group_4__0__Impl rule__ScopeRule__Group_4__1 ; - public final void rule__ScopeRule__Group_4__0() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3691:1: ( rule__ScopeRule__Group_4__0__Impl rule__ScopeRule__Group_4__1 ) - // InternalScope.g:3692:2: rule__ScopeRule__Group_4__0__Impl rule__ScopeRule__Group_4__1 - { - pushFollow(FOLLOW_26); - rule__ScopeRule__Group_4__0__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeRule__Group_4__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13095,35 +12395,82 @@ public final void rule__ScopeRule__Group_4__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeRule__Group_4__0" + // $ANTLR end "rule__GlobalScopeExpression__Alternatives_5_3" - // $ANTLR start "rule__ScopeRule__Group_4__0__Impl" - // InternalScope.g:3699:1: rule__ScopeRule__Group_4__0__Impl : ( '>>' ) ; - public final void rule__ScopeRule__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__DataExpression__Alternatives" + // InternalScope.g:3593:1: rule__DataExpression__Alternatives : ( ( ruleMatchDataExpression ) | ( ruleLambdaDataExpression ) ); + public final void rule__DataExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3703:1: ( ( '>>' ) ) - // InternalScope.g:3704:1: ( '>>' ) - { - // InternalScope.g:3704:1: ( '>>' ) - // InternalScope.g:3705:2: '>>' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); + // InternalScope.g:3597:1: ( ( ruleMatchDataExpression ) | ( ruleLambdaDataExpression ) ) + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0==RULE_ID) ) { + alt9=1; } - match(input,55,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); + else if ( (LA9_0==82) ) { + alt9=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 9, 0, input); + throw nvae; } + switch (alt9) { + case 1 : + // InternalScope.g:3598:2: ( ruleMatchDataExpression ) + { + // InternalScope.g:3598:2: ( ruleMatchDataExpression ) + // InternalScope.g:3599:3: ruleMatchDataExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleMatchDataExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getDataExpressionAccess().getMatchDataExpressionParserRuleCall_0()); + } + } - } + } + break; + case 2 : + // InternalScope.g:3604:2: ( ruleLambdaDataExpression ) + { + // InternalScope.g:3604:2: ( ruleLambdaDataExpression ) + // InternalScope.g:3605:3: ruleLambdaDataExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleLambdaDataExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getDataExpressionAccess().getLambdaDataExpressionParserRuleCall_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -13136,27 +12483,80 @@ public final void rule__ScopeRule__Group_4__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ScopeRule__Group_4__0__Impl" + // $ANTLR end "rule__DataExpression__Alternatives" - // $ANTLR start "rule__ScopeRule__Group_4__1" - // InternalScope.g:3714:1: rule__ScopeRule__Group_4__1 : rule__ScopeRule__Group_4__1__Impl ; - public final void rule__ScopeRule__Group_4__1() throws RecognitionException { + // $ANTLR start "rule__Naming__Alternatives" + // InternalScope.g:3614:1: rule__Naming__Alternatives : ( ( ( rule__Naming__Group_0__0 ) ) | ( ( rule__Naming__NamesAssignment_1 ) ) ); + public final void rule__Naming__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3718:1: ( rule__ScopeRule__Group_4__1__Impl ) - // InternalScope.g:3719:2: rule__ScopeRule__Group_4__1__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeRule__Group_4__1__Impl(); + // InternalScope.g:3618:1: ( ( ( rule__Naming__Group_0__0 ) ) | ( ( rule__Naming__NamesAssignment_1 ) ) ) + int alt10=2; + alt10 = dfa10.predict(input); + switch (alt10) { + case 1 : + // InternalScope.g:3619:2: ( ( rule__Naming__Group_0__0 ) ) + { + // InternalScope.g:3619:2: ( ( rule__Naming__Group_0__0 ) ) + // InternalScope.g:3620:3: ( rule__Naming__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingAccess().getGroup_0()); + } + // InternalScope.g:3621:3: ( rule__Naming__Group_0__0 ) + // InternalScope.g:3621:4: rule__Naming__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__Naming__Group_0__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingAccess().getGroup_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:3625:2: ( ( rule__Naming__NamesAssignment_1 ) ) + { + // InternalScope.g:3625:2: ( ( rule__Naming__NamesAssignment_1 ) ) + // InternalScope.g:3626:3: ( rule__Naming__NamesAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingAccess().getNamesAssignment_1()); + } + // InternalScope.g:3627:3: ( rule__Naming__NamesAssignment_1 ) + // InternalScope.g:3627:4: rule__Naming__NamesAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Naming__NamesAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingAccess().getNamesAssignment_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13169,83 +12569,94 @@ public final void rule__ScopeRule__Group_4__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeRule__Group_4__1" + // $ANTLR end "rule__Naming__Alternatives" - // $ANTLR start "rule__ScopeRule__Group_4__1__Impl" - // InternalScope.g:3725:1: rule__ScopeRule__Group_4__1__Impl : ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) ; - public final void rule__ScopeRule__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingExpression__Alternatives" + // InternalScope.g:3635:1: rule__NamingExpression__Alternatives : ( ( ( rule__NamingExpression__ExportAssignment_0 ) ) | ( ( rule__NamingExpression__Group_1__0 ) ) ); + public final void rule__NamingExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3729:1: ( ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) ) - // InternalScope.g:3730:1: ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) - { - // InternalScope.g:3730:1: ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) - // InternalScope.g:3731:2: ( rule__ScopeRule__ExprsAssignment_4_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); + // InternalScope.g:3639:1: ( ( ( rule__NamingExpression__ExportAssignment_0 ) ) | ( ( rule__NamingExpression__Group_1__0 ) ) ) + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0==118) ) { + alt11=1; } - // InternalScope.g:3732:2: ( rule__ScopeRule__ExprsAssignment_4_1 ) - // InternalScope.g:3732:3: rule__ScopeRule__ExprsAssignment_4_1 - { - pushFollow(FOLLOW_2); - rule__ScopeRule__ExprsAssignment_4_1(); - - state._fsp--; - if (state.failed) return ; - + else if ( (LA11_0==RULE_ID||LA11_0==RULE_INT||(LA11_0>=RULE_STRING && LA11_0<=RULE_REAL)||LA11_0==24||(LA11_0>=27 && LA11_0<=40)||LA11_0==72||LA11_0==77||LA11_0==84||LA11_0==94||LA11_0==97||LA11_0==100||(LA11_0>=102 && LA11_0<=103)||LA11_0==108||LA11_0==120) ) { + alt11=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 11, 0, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); + throw nvae; } + switch (alt11) { + case 1 : + // InternalScope.g:3640:2: ( ( rule__NamingExpression__ExportAssignment_0 ) ) + { + // InternalScope.g:3640:2: ( ( rule__NamingExpression__ExportAssignment_0 ) ) + // InternalScope.g:3641:3: ( rule__NamingExpression__ExportAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); + } + // InternalScope.g:3642:3: ( rule__NamingExpression__ExportAssignment_0 ) + // InternalScope.g:3642:4: rule__NamingExpression__ExportAssignment_0 + { + pushFollow(FOLLOW_2); + rule__NamingExpression__ExportAssignment_0(); - } + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getExportAssignment_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ScopeRule__Group_4__1__Impl" + } + break; + case 2 : + // InternalScope.g:3646:2: ( ( rule__NamingExpression__Group_1__0 ) ) + { + // InternalScope.g:3646:2: ( ( rule__NamingExpression__Group_1__0 ) ) + // InternalScope.g:3647:3: ( rule__NamingExpression__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getGroup_1()); + } + // InternalScope.g:3648:3: ( rule__NamingExpression__Group_1__0 ) + // InternalScope.g:3648:4: rule__NamingExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__NamingExpression__Group_1__0(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__ScopeContext__Group__0" - // InternalScope.g:3741:1: rule__ScopeContext__Group__0 : rule__ScopeContext__Group__0__Impl rule__ScopeContext__Group__1 ; - public final void rule__ScopeContext__Group__0() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3745:1: ( rule__ScopeContext__Group__0__Impl rule__ScopeContext__Group__1 ) - // InternalScope.g:3746:2: rule__ScopeContext__Group__0__Impl rule__ScopeContext__Group__1 - { - pushFollow(FOLLOW_29); - rule__ScopeContext__Group__0__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getGroup_1()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeContext__Group__1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13258,78 +12669,97 @@ public final void rule__ScopeContext__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeContext__Group__0" + // $ANTLR end "rule__NamingExpression__Alternatives" - // $ANTLR start "rule__ScopeContext__Group__0__Impl" - // InternalScope.g:3753:1: rule__ScopeContext__Group__0__Impl : ( ( rule__ScopeContext__Alternatives_0 ) ) ; - public final void rule__ScopeContext__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Expression__Alternatives" + // InternalScope.g:3656:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ); + public final void rule__Expression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3757:1: ( ( ( rule__ScopeContext__Alternatives_0 ) ) ) - // InternalScope.g:3758:1: ( ( rule__ScopeContext__Alternatives_0 ) ) - { - // InternalScope.g:3758:1: ( ( rule__ScopeContext__Alternatives_0 ) ) - // InternalScope.g:3759:2: ( rule__ScopeContext__Alternatives_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getAlternatives_0()); - } - // InternalScope.g:3760:2: ( rule__ScopeContext__Alternatives_0 ) - // InternalScope.g:3760:3: rule__ScopeContext__Alternatives_0 - { - pushFollow(FOLLOW_2); - rule__ScopeContext__Alternatives_0(); + // InternalScope.g:3660:1: ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) ) + int alt12=3; + alt12 = dfa12.predict(input); + switch (alt12) { + case 1 : + // InternalScope.g:3661:2: ( ruleLetExpression ) + { + // InternalScope.g:3661:2: ( ruleLetExpression ) + // InternalScope.g:3662:3: ruleLetExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleLetExpression(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getLetExpressionParserRuleCall_0()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getAlternatives_0()); - } - } + } + break; + case 2 : + // InternalScope.g:3667:2: ( ( ruleCastedExpression ) ) + { + // InternalScope.g:3667:2: ( ( ruleCastedExpression ) ) + // InternalScope.g:3668:3: ( ruleCastedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } + // InternalScope.g:3669:3: ( ruleCastedExpression ) + // InternalScope.g:3669:4: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ScopeContext__Group__0__Impl" + } + break; + case 3 : + // InternalScope.g:3673:2: ( ruleChainExpression ) + { + // InternalScope.g:3673:2: ( ruleChainExpression ) + // InternalScope.g:3674:3: ruleChainExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleChainExpression(); - // $ANTLR start "rule__ScopeContext__Group__1" - // InternalScope.g:3768:1: rule__ScopeContext__Group__1 : rule__ScopeContext__Group__1__Impl ; - public final void rule__ScopeContext__Group__1() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExpressionAccess().getChainExpressionParserRuleCall_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3772:1: ( rule__ScopeContext__Group__1__Impl ) - // InternalScope.g:3773:2: rule__ScopeContext__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeContext__Group__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13342,56 +12772,138 @@ public final void rule__ScopeContext__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeContext__Group__1" + // $ANTLR end "rule__Expression__Alternatives" - // $ANTLR start "rule__ScopeContext__Group__1__Impl" - // InternalScope.g:3779:1: rule__ScopeContext__Group__1__Impl : ( ( rule__ScopeContext__Group_1__0 )? ) ; - public final void rule__ScopeContext__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainedExpression__Alternatives" + // InternalScope.g:3683:1: rule__ChainedExpression__Alternatives : ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ); + public final void rule__ChainedExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3783:1: ( ( ( rule__ScopeContext__Group_1__0 )? ) ) - // InternalScope.g:3784:1: ( ( rule__ScopeContext__Group_1__0 )? ) - { - // InternalScope.g:3784:1: ( ( rule__ScopeContext__Group_1__0 )? ) - // InternalScope.g:3785:2: ( rule__ScopeContext__Group_1__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getGroup_1()); - } - // InternalScope.g:3786:2: ( rule__ScopeContext__Group_1__0 )? - int alt40=2; - int LA40_0 = input.LA(1); + // InternalScope.g:3687:1: ( ( ruleIfExpressionKw ) | ( ruleIfExpressionTri ) | ( ruleSwitchExpression ) ) + int alt13=3; + switch ( input.LA(1) ) { + case 97: + { + alt13=1; + } + break; + case RULE_ID: + case RULE_INT: + case RULE_STRING: + case RULE_REAL: + case 24: + case 27: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 36: + case 37: + case 38: + case 39: + case 40: + case 72: + case 77: + case 102: + case 103: + case 108: + case 120: + { + alt13=2; + } + break; + case 100: + { + alt13=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 13, 0, input); - if ( (LA40_0==56) ) { - alt40=1; + throw nvae; } - switch (alt40) { + + switch (alt13) { case 1 : - // InternalScope.g:3786:3: rule__ScopeContext__Group_1__0 + // InternalScope.g:3688:2: ( ruleIfExpressionKw ) { + // InternalScope.g:3688:2: ( ruleIfExpressionKw ) + // InternalScope.g:3689:3: ruleIfExpressionKw + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); + } pushFollow(FOLLOW_2); - rule__ScopeContext__Group_1__0(); + ruleIfExpressionKw(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getIfExpressionKwParserRuleCall_0()); + } + + } + } break; + case 2 : + // InternalScope.g:3694:2: ( ruleIfExpressionTri ) + { + // InternalScope.g:3694:2: ( ruleIfExpressionTri ) + // InternalScope.g:3695:3: ruleIfExpressionTri + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleIfExpressionTri(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getIfExpressionTriParserRuleCall_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getGroup_1()); - } + } - } + } + break; + case 3 : + // InternalScope.g:3700:2: ( ruleSwitchExpression ) + { + // InternalScope.g:3700:2: ( ruleSwitchExpression ) + // InternalScope.g:3701:3: ruleSwitchExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleSwitchExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainedExpressionAccess().getSwitchExpressionParserRuleCall_2()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -13404,73 +12916,174 @@ public final void rule__ScopeContext__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ScopeContext__Group__1__Impl" + // $ANTLR end "rule__ChainedExpression__Alternatives" - // $ANTLR start "rule__ScopeContext__Group_1__0" - // InternalScope.g:3795:1: rule__ScopeContext__Group_1__0 : rule__ScopeContext__Group_1__0__Impl rule__ScopeContext__Group_1__1 ; - public final void rule__ScopeContext__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__OperatorAlternatives_1_1_0" + // InternalScope.g:3710:1: rule__RelationalExpression__OperatorAlternatives_1_1_0 : ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ); + public final void rule__RelationalExpression__OperatorAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3799:1: ( rule__ScopeContext__Group_1__0__Impl rule__ScopeContext__Group_1__1 ) - // InternalScope.g:3800:2: rule__ScopeContext__Group_1__0__Impl rule__ScopeContext__Group_1__1 - { - pushFollow(FOLLOW_17); - rule__ScopeContext__Group_1__0__Impl(); + // InternalScope.g:3714:1: ( ( '==' ) | ( '!=' ) | ( '>=' ) | ( '<=' ) | ( '>' ) | ( '<' ) ) + int alt14=6; + switch ( input.LA(1) ) { + case 17: + { + alt14=1; + } + break; + case 18: + { + alt14=2; + } + break; + case 19: + { + alt14=3; + } + break; + case 20: + { + alt14=4; + } + break; + case 21: + { + alt14=5; + } + break; + case 22: + { + alt14=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 14, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeContext__Group_1__1(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt14) { + case 1 : + // InternalScope.g:3715:2: ( '==' ) + { + // InternalScope.g:3715:2: ( '==' ) + // InternalScope.g:3716:3: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); + } + match(input,17,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:3721:2: ( '!=' ) + { + // InternalScope.g:3721:2: ( '!=' ) + // InternalScope.g:3722:3: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + } + match(input,18,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); + } - } - return ; - } - // $ANTLR end "rule__ScopeContext__Group_1__0" + } - // $ANTLR start "rule__ScopeContext__Group_1__0__Impl" - // InternalScope.g:3807:1: rule__ScopeContext__Group_1__0__Impl : ( '[' ) ; - public final void rule__ScopeContext__Group_1__0__Impl() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:3727:2: ( '>=' ) + { + // InternalScope.g:3727:2: ( '>=' ) + // InternalScope.g:3728:3: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3811:1: ( ( '[' ) ) - // InternalScope.g:3812:1: ( '[' ) - { - // InternalScope.g:3812:1: ( '[' ) - // InternalScope.g:3813:2: '[' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); - } - match(input,56,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); - } + } - } + + } + break; + case 4 : + // InternalScope.g:3733:2: ( '<=' ) + { + // InternalScope.g:3733:2: ( '<=' ) + // InternalScope.g:3734:3: '<=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + } + match(input,20,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); + } + + } - } + } + break; + case 5 : + // InternalScope.g:3739:2: ( '>' ) + { + // InternalScope.g:3739:2: ( '>' ) + // InternalScope.g:3740:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); + } + } + + + } + break; + case 6 : + // InternalScope.g:3745:2: ( '<' ) + { + // InternalScope.g:3745:2: ( '<' ) + // InternalScope.g:3746:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -13483,32 +13096,74 @@ public final void rule__ScopeContext__Group_1__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ScopeContext__Group_1__0__Impl" + // $ANTLR end "rule__RelationalExpression__OperatorAlternatives_1_1_0" - // $ANTLR start "rule__ScopeContext__Group_1__1" - // InternalScope.g:3822:1: rule__ScopeContext__Group_1__1 : rule__ScopeContext__Group_1__1__Impl rule__ScopeContext__Group_1__2 ; - public final void rule__ScopeContext__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__NameAlternatives_1_1_0" + // InternalScope.g:3755:1: rule__AdditiveExpression__NameAlternatives_1_1_0 : ( ( '+' ) | ( '-' ) ); + public final void rule__AdditiveExpression__NameAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3826:1: ( rule__ScopeContext__Group_1__1__Impl rule__ScopeContext__Group_1__2 ) - // InternalScope.g:3827:2: rule__ScopeContext__Group_1__1__Impl rule__ScopeContext__Group_1__2 - { - pushFollow(FOLLOW_30); - rule__ScopeContext__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeContext__Group_1__2(); + // InternalScope.g:3759:1: ( ( '+' ) | ( '-' ) ) + int alt15=2; + int LA15_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA15_0==23) ) { + alt15=1; + } + else if ( (LA15_0==24) ) { + alt15=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 15, 0, input); + throw nvae; } + switch (alt15) { + case 1 : + // InternalScope.g:3760:2: ( '+' ) + { + // InternalScope.g:3760:2: ( '+' ) + // InternalScope.g:3761:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); + } + + } + + } + break; + case 2 : + // InternalScope.g:3766:2: ( '-' ) + { + // InternalScope.g:3766:2: ( '-' ) + // InternalScope.g:3767:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -13521,78 +13176,74 @@ public final void rule__ScopeContext__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeContext__Group_1__1" + // $ANTLR end "rule__AdditiveExpression__NameAlternatives_1_1_0" - // $ANTLR start "rule__ScopeContext__Group_1__1__Impl" - // InternalScope.g:3834:1: rule__ScopeContext__Group_1__1__Impl : ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) ; - public final void rule__ScopeContext__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__NameAlternatives_1_1_0" + // InternalScope.g:3776:1: rule__MultiplicativeExpression__NameAlternatives_1_1_0 : ( ( '*' ) | ( '/' ) ); + public final void rule__MultiplicativeExpression__NameAlternatives_1_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3838:1: ( ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) ) - // InternalScope.g:3839:1: ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) - { - // InternalScope.g:3839:1: ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) - // InternalScope.g:3840:2: ( rule__ScopeContext__GuardAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); - } - // InternalScope.g:3841:2: ( rule__ScopeContext__GuardAssignment_1_1 ) - // InternalScope.g:3841:3: rule__ScopeContext__GuardAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__ScopeContext__GuardAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - - } + // InternalScope.g:3780:1: ( ( '*' ) | ( '/' ) ) + int alt16=2; + int LA16_0 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); + if ( (LA16_0==25) ) { + alt16=1; } - + else if ( (LA16_0==26) ) { + alt16=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 16, 0, input); - + throw nvae; } + switch (alt16) { + case 1 : + // InternalScope.g:3781:2: ( '*' ) + { + // InternalScope.g:3781:2: ( '*' ) + // InternalScope.g:3782:3: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ScopeContext__Group_1__1__Impl" + } + break; + case 2 : + // InternalScope.g:3787:2: ( '/' ) + { + // InternalScope.g:3787:2: ( '/' ) + // InternalScope.g:3788:3: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); + } + match(input,26,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); + } - // $ANTLR start "rule__ScopeContext__Group_1__2" - // InternalScope.g:3849:1: rule__ScopeContext__Group_1__2 : rule__ScopeContext__Group_1__2__Impl ; - public final void rule__ScopeContext__Group_1__2() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3853:1: ( rule__ScopeContext__Group_1__2__Impl ) - // InternalScope.g:3854:2: rule__ScopeContext__Group_1__2__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeContext__Group_1__2__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13605,73 +13256,82 @@ public final void rule__ScopeContext__Group_1__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ScopeContext__Group_1__2" + // $ANTLR end "rule__MultiplicativeExpression__NameAlternatives_1_1_0" - // $ANTLR start "rule__ScopeContext__Group_1__2__Impl" - // InternalScope.g:3860:1: rule__ScopeContext__Group_1__2__Impl : ( ']' ) ; - public final void rule__ScopeContext__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__UnaryOrInfixExpression__Alternatives" + // InternalScope.g:3797:1: rule__UnaryOrInfixExpression__Alternatives : ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ); + public final void rule__UnaryOrInfixExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3864:1: ( ( ']' ) ) - // InternalScope.g:3865:1: ( ']' ) - { - // InternalScope.g:3865:1: ( ']' ) - // InternalScope.g:3866:2: ']' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); - } - match(input,57,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); - } + // InternalScope.g:3801:1: ( ( ruleUnaryExpression ) | ( ruleInfixExpression ) ) + int alt17=2; + int LA17_0 = input.LA(1); + if ( (LA17_0==24||LA17_0==27) ) { + alt17=1; } + else if ( (LA17_0==RULE_ID||LA17_0==RULE_INT||(LA17_0>=RULE_STRING && LA17_0<=RULE_REAL)||(LA17_0>=28 && LA17_0<=40)||LA17_0==72||LA17_0==77||(LA17_0>=102 && LA17_0<=103)||LA17_0==108||LA17_0==120) ) { + alt17=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); - + throw nvae; } + switch (alt17) { + case 1 : + // InternalScope.g:3802:2: ( ruleUnaryExpression ) + { + // InternalScope.g:3802:2: ( ruleUnaryExpression ) + // InternalScope.g:3803:3: ruleUnaryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleUnaryExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryOrInfixExpressionAccess().getUnaryExpressionParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__ScopeContext__Group_1__2__Impl" + } + break; + case 2 : + // InternalScope.g:3808:2: ( ruleInfixExpression ) + { + // InternalScope.g:3808:2: ( ruleInfixExpression ) + // InternalScope.g:3809:3: ruleInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleInfixExpression(); - // $ANTLR start "rule__FactoryExpression__Group__0" - // InternalScope.g:3876:1: rule__FactoryExpression__Group__0 : rule__FactoryExpression__Group__0__Impl rule__FactoryExpression__Group__1 ; - public final void rule__FactoryExpression__Group__0() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryOrInfixExpressionAccess().getInfixExpressionParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3880:1: ( rule__FactoryExpression__Group__0__Impl rule__FactoryExpression__Group__1 ) - // InternalScope.g:3881:2: rule__FactoryExpression__Group__0__Impl rule__FactoryExpression__Group__1 - { - pushFollow(FOLLOW_17); - rule__FactoryExpression__Group__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__FactoryExpression__Group__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13684,68 +13344,74 @@ public final void rule__FactoryExpression__Group__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__FactoryExpression__Group__0" + // $ANTLR end "rule__UnaryOrInfixExpression__Alternatives" - // $ANTLR start "rule__FactoryExpression__Group__0__Impl" - // InternalScope.g:3888:1: rule__FactoryExpression__Group__0__Impl : ( 'factory' ) ; - public final void rule__FactoryExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__NameAlternatives_0_0" + // InternalScope.g:3818:1: rule__UnaryExpression__NameAlternatives_0_0 : ( ( '!' ) | ( '-' ) ); + public final void rule__UnaryExpression__NameAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3892:1: ( ( 'factory' ) ) - // InternalScope.g:3893:1: ( 'factory' ) - { - // InternalScope.g:3893:1: ( 'factory' ) - // InternalScope.g:3894:2: 'factory' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); - } - match(input,58,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); - } + // InternalScope.g:3822:1: ( ( '!' ) | ( '-' ) ) + int alt18=2; + int LA18_0 = input.LA(1); + if ( (LA18_0==27) ) { + alt18=1; } - - + else if ( (LA18_0==24) ) { + alt18=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 18, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + throw nvae; + } + switch (alt18) { + case 1 : + // InternalScope.g:3823:2: ( '!' ) + { + // InternalScope.g:3823:2: ( '!' ) + // InternalScope.g:3824:3: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); + } + match(input,27,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__FactoryExpression__Group__0__Impl" + } + break; + case 2 : + // InternalScope.g:3829:2: ( '-' ) + { + // InternalScope.g:3829:2: ( '-' ) + // InternalScope.g:3830:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); + } - // $ANTLR start "rule__FactoryExpression__Group__1" - // InternalScope.g:3903:1: rule__FactoryExpression__Group__1 : rule__FactoryExpression__Group__1__Impl ; - public final void rule__FactoryExpression__Group__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3907:1: ( rule__FactoryExpression__Group__1__Impl ) - // InternalScope.g:3908:2: rule__FactoryExpression__Group__1__Impl - { - pushFollow(FOLLOW_2); - rule__FactoryExpression__Group__1__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13758,162 +13424,200 @@ public final void rule__FactoryExpression__Group__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__FactoryExpression__Group__1" + // $ANTLR end "rule__UnaryExpression__NameAlternatives_0_0" - // $ANTLR start "rule__FactoryExpression__Group__1__Impl" - // InternalScope.g:3914:1: rule__FactoryExpression__Group__1__Impl : ( ( rule__FactoryExpression__ExprAssignment_1 ) ) ; - public final void rule__FactoryExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Alternatives_1" + // InternalScope.g:3839:1: rule__InfixExpression__Alternatives_1 : ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ); + public final void rule__InfixExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3918:1: ( ( ( rule__FactoryExpression__ExprAssignment_1 ) ) ) - // InternalScope.g:3919:1: ( ( rule__FactoryExpression__ExprAssignment_1 ) ) - { - // InternalScope.g:3919:1: ( ( rule__FactoryExpression__ExprAssignment_1 ) ) - // InternalScope.g:3920:2: ( rule__FactoryExpression__ExprAssignment_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); - } - // InternalScope.g:3921:2: ( rule__FactoryExpression__ExprAssignment_1 ) - // InternalScope.g:3921:3: rule__FactoryExpression__ExprAssignment_1 - { - pushFollow(FOLLOW_2); - rule__FactoryExpression__ExprAssignment_1(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:3843:1: ( ( ( rule__InfixExpression__Group_1_0__0 ) ) | ( ( rule__InfixExpression__Group_1_1__0 ) ) | ( ( rule__InfixExpression__Group_1_2__0 ) ) | ( ( rule__InfixExpression__Group_1_3__0 ) ) ) + int alt19=4; + int LA19_0 = input.LA(1); - } + if ( (LA19_0==58) ) { + switch ( input.LA(2) ) { + case 38: + case 39: + case 40: + { + alt19=2; + } + break; + case RULE_ID: + { + int LA19_3 = input.LA(3); - if ( state.backtracking==0 ) { - after(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); - } + if ( (LA19_3==EOF||(LA19_3>=15 && LA19_3<=26)||LA19_3==48||LA19_3==58||LA19_3==69||(LA19_3>=73 && LA19_3<=75)||LA19_3==78||LA19_3==81||LA19_3==83||LA19_3==86||LA19_3==93||(LA19_3>=95 && LA19_3<=96)||(LA19_3>=98 && LA19_3<=99)||LA19_3==101||LA19_3==119) ) { + alt19=2; + } + else if ( (LA19_3==77) ) { + alt19=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 19, 3, input); - } + throw nvae; + } + } + break; + case 120: + { + alt19=3; + } + break; + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + { + alt19=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 19, 1, input); + throw nvae; + } } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 19, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + throw nvae; + } + switch (alt19) { + case 1 : + // InternalScope.g:3844:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) + { + // InternalScope.g:3844:2: ( ( rule__InfixExpression__Group_1_0__0 ) ) + // InternalScope.g:3845:3: ( rule__InfixExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:3846:3: ( rule__InfixExpression__Group_1_0__0 ) + // InternalScope.g:3846:4: rule__InfixExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__0(); - } - return ; - } - // $ANTLR end "rule__FactoryExpression__Group__1__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__ScopeDelegation__Group__0" - // InternalScope.g:3930:1: rule__ScopeDelegation__Group__0 : rule__ScopeDelegation__Group__0__Impl rule__ScopeDelegation__Group__1 ; - public final void rule__ScopeDelegation__Group__0() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3934:1: ( rule__ScopeDelegation__Group__0__Impl rule__ScopeDelegation__Group__1 ) - // InternalScope.g:3935:2: rule__ScopeDelegation__Group__0__Impl rule__ScopeDelegation__Group__1 - { - pushFollow(FOLLOW_31); - rule__ScopeDelegation__Group__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group__1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 2 : + // InternalScope.g:3850:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) + { + // InternalScope.g:3850:2: ( ( rule__InfixExpression__Group_1_1__0 ) ) + // InternalScope.g:3851:3: ( rule__InfixExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); + } + // InternalScope.g:3852:3: ( rule__InfixExpression__Group_1_1__0 ) + // InternalScope.g:3852:4: rule__InfixExpression__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__0(); - } + state._fsp--; + if (state.failed) return ; - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_1()); + } - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group__0" + } - // $ANTLR start "rule__ScopeDelegation__Group__0__Impl" - // InternalScope.g:3942:1: rule__ScopeDelegation__Group__0__Impl : ( 'scopeof' ) ; - public final void rule__ScopeDelegation__Group__0__Impl() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:3856:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) + { + // InternalScope.g:3856:2: ( ( rule__InfixExpression__Group_1_2__0 ) ) + // InternalScope.g:3857:3: ( rule__InfixExpression__Group_1_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); + } + // InternalScope.g:3858:3: ( rule__InfixExpression__Group_1_2__0 ) + // InternalScope.g:3858:4: rule__InfixExpression__Group_1_2__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__0(); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3946:1: ( ( 'scopeof' ) ) - // InternalScope.g:3947:1: ( 'scopeof' ) - { - // InternalScope.g:3947:1: ( 'scopeof' ) - // InternalScope.g:3948:2: 'scopeof' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); - } - match(input,59,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_2()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 4 : + // InternalScope.g:3862:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) + { + // InternalScope.g:3862:2: ( ( rule__InfixExpression__Group_1_3__0 ) ) + // InternalScope.g:3863:3: ( rule__InfixExpression__Group_1_3__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); + } + // InternalScope.g:3864:3: ( rule__InfixExpression__Group_1_3__0 ) + // InternalScope.g:3864:4: rule__InfixExpression__Group_1_3__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__0(); - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group__0__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__ScopeDelegation__Group__1" - // InternalScope.g:3957:1: rule__ScopeDelegation__Group__1 : rule__ScopeDelegation__Group__1__Impl rule__ScopeDelegation__Group__2 ; - public final void rule__ScopeDelegation__Group__1() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getGroup_1_3()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3961:1: ( rule__ScopeDelegation__Group__1__Impl rule__ScopeDelegation__Group__2 ) - // InternalScope.g:3962:2: rule__ScopeDelegation__Group__1__Impl rule__ScopeDelegation__Group__2 - { - pushFollow(FOLLOW_32); - rule__ScopeDelegation__Group__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group__2(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -13926,124 +13630,222 @@ public final void rule__ScopeDelegation__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeDelegation__Group__1" + // $ANTLR end "rule__InfixExpression__Alternatives_1" - // $ANTLR start "rule__ScopeDelegation__Group__1__Impl" - // InternalScope.g:3969:1: rule__ScopeDelegation__Group__1__Impl : ( '(' ) ; - public final void rule__ScopeDelegation__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__NameAlternatives_1_3_2_0" + // InternalScope.g:3872:1: rule__InfixExpression__NameAlternatives_1_3_2_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); + public final void rule__InfixExpression__NameAlternatives_1_3_2_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:3973:1: ( ( '(' ) ) - // InternalScope.g:3974:1: ( '(' ) - { - // InternalScope.g:3974:1: ( '(' ) - // InternalScope.g:3975:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); - } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); - } + // InternalScope.g:3876:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) + int alt20=8; + switch ( input.LA(1) ) { + case 28: + { + alt20=1; + } + break; + case 29: + { + alt20=2; + } + break; + case 30: + { + alt20=3; + } + break; + case 31: + { + alt20=4; + } + break; + case 32: + { + alt20=5; + } + break; + case 33: + { + alt20=6; + } + break; + case 34: + { + alt20=7; + } + break; + case 35: + { + alt20=8; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 20, 0, input); + throw nvae; } + switch (alt20) { + case 1 : + // InternalScope.g:3877:2: ( 'collect' ) + { + // InternalScope.g:3877:2: ( 'collect' ) + // InternalScope.g:3878:3: 'collect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); + } + match(input,28,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:3883:2: ( 'select' ) + { + // InternalScope.g:3883:2: ( 'select' ) + // InternalScope.g:3884:3: 'select' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); + } + match(input,29,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); + } - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group__1__Impl" + } - // $ANTLR start "rule__ScopeDelegation__Group__2" - // InternalScope.g:3984:1: rule__ScopeDelegation__Group__2 : rule__ScopeDelegation__Group__2__Impl rule__ScopeDelegation__Group__3 ; - public final void rule__ScopeDelegation__Group__2() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:3889:2: ( 'selectFirst' ) + { + // InternalScope.g:3889:2: ( 'selectFirst' ) + // InternalScope.g:3890:3: 'selectFirst' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); + } + match(input,30,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:3988:1: ( rule__ScopeDelegation__Group__2__Impl rule__ScopeDelegation__Group__3 ) - // InternalScope.g:3989:2: rule__ScopeDelegation__Group__2__Impl rule__ScopeDelegation__Group__3 - { - pushFollow(FOLLOW_33); - rule__ScopeDelegation__Group__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group__3(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalScope.g:3895:2: ( 'reject' ) + { + // InternalScope.g:3895:2: ( 'reject' ) + // InternalScope.g:3896:3: 'reject' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); + } + match(input,31,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 5 : + // InternalScope.g:3901:2: ( 'exists' ) + { + // InternalScope.g:3901:2: ( 'exists' ) + // InternalScope.g:3902:3: 'exists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); + } + match(input,32,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); + } - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group__2" + } - // $ANTLR start "rule__ScopeDelegation__Group__2__Impl" - // InternalScope.g:3996:1: rule__ScopeDelegation__Group__2__Impl : ( ( rule__ScopeDelegation__Alternatives_2 ) ) ; - public final void rule__ScopeDelegation__Group__2__Impl() throws RecognitionException { + } + break; + case 6 : + // InternalScope.g:3907:2: ( 'notExists' ) + { + // InternalScope.g:3907:2: ( 'notExists' ) + // InternalScope.g:3908:3: 'notExists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); + } + match(input,33,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4000:1: ( ( ( rule__ScopeDelegation__Alternatives_2 ) ) ) - // InternalScope.g:4001:1: ( ( rule__ScopeDelegation__Alternatives_2 ) ) - { - // InternalScope.g:4001:1: ( ( rule__ScopeDelegation__Alternatives_2 ) ) - // InternalScope.g:4002:2: ( rule__ScopeDelegation__Alternatives_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); - } - // InternalScope.g:4003:2: ( rule__ScopeDelegation__Alternatives_2 ) - // InternalScope.g:4003:3: rule__ScopeDelegation__Alternatives_2 - { - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Alternatives_2(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 7 : + // InternalScope.g:3913:2: ( 'sortBy' ) + { + // InternalScope.g:3913:2: ( 'sortBy' ) + // InternalScope.g:3914:3: 'sortBy' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); + } + match(input,34,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); - } + } - } + + } + break; + case 8 : + // InternalScope.g:3919:2: ( 'forAll' ) + { + // InternalScope.g:3919:2: ( 'forAll' ) + // InternalScope.g:3920:3: 'forAll' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); + } + match(input,35,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); + } + + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14056,127 +13858,215 @@ public final void rule__ScopeDelegation__Group__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDelegation__Group__2__Impl" + // $ANTLR end "rule__InfixExpression__NameAlternatives_1_3_2_0" - // $ANTLR start "rule__ScopeDelegation__Group__3" - // InternalScope.g:4011:1: rule__ScopeDelegation__Group__3 : rule__ScopeDelegation__Group__3__Impl rule__ScopeDelegation__Group__4 ; - public final void rule__ScopeDelegation__Group__3() throws RecognitionException { + // $ANTLR start "rule__PrimaryExpression__Alternatives" + // InternalScope.g:3929:1: rule__PrimaryExpression__Alternatives : ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ); + public final void rule__PrimaryExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4015:1: ( rule__ScopeDelegation__Group__3__Impl rule__ScopeDelegation__Group__4 ) - // InternalScope.g:4016:2: rule__ScopeDelegation__Group__3__Impl rule__ScopeDelegation__Group__4 - { - pushFollow(FOLLOW_33); - rule__ScopeDelegation__Group__3__Impl(); + // InternalScope.g:3933:1: ( ( ruleLiteral ) | ( ruleFeatureCall ) | ( ruleListLiteral ) | ( ruleConstructorCallExpression ) | ( ruleGlobalVarExpression ) | ( ruleParanthesizedExpression ) ) + int alt21=6; + switch ( input.LA(1) ) { + case RULE_INT: + case RULE_STRING: + case RULE_REAL: + case 36: + case 37: + case 108: + { + alt21=1; + } + break; + case RULE_ID: + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + case 38: + case 39: + case 40: + case 120: + { + alt21=2; + } + break; + case 72: + { + alt21=3; + } + break; + case 103: + { + alt21=4; + } + break; + case 102: + { + alt21=5; + } + break; + case 77: + { + alt21=6; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 21, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group__4(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt21) { + case 1 : + // InternalScope.g:3934:2: ( ruleLiteral ) + { + // InternalScope.g:3934:2: ( ruleLiteral ) + // InternalScope.g:3935:3: ruleLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleLiteral(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getLiteralParserRuleCall_0()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group__3" + } + break; + case 2 : + // InternalScope.g:3940:2: ( ruleFeatureCall ) + { + // InternalScope.g:3940:2: ( ruleFeatureCall ) + // InternalScope.g:3941:3: ruleFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCall(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getFeatureCallParserRuleCall_1()); + } - // $ANTLR start "rule__ScopeDelegation__Group__3__Impl" - // InternalScope.g:4023:1: rule__ScopeDelegation__Group__3__Impl : ( ( rule__ScopeDelegation__Group_3__0 )? ) ; - public final void rule__ScopeDelegation__Group__3__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4027:1: ( ( ( rule__ScopeDelegation__Group_3__0 )? ) ) - // InternalScope.g:4028:1: ( ( rule__ScopeDelegation__Group_3__0 )? ) - { - // InternalScope.g:4028:1: ( ( rule__ScopeDelegation__Group_3__0 )? ) - // InternalScope.g:4029:2: ( rule__ScopeDelegation__Group_3__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getGroup_3()); - } - // InternalScope.g:4030:2: ( rule__ScopeDelegation__Group_3__0 )? - int alt41=2; - int LA41_0 = input.LA(1); - if ( (LA41_0==60) ) { - alt41=1; - } - switch (alt41) { - case 1 : - // InternalScope.g:4030:3: rule__ScopeDelegation__Group_3__0 + } + break; + case 3 : + // InternalScope.g:3946:2: ( ruleListLiteral ) { + // InternalScope.g:3946:2: ( ruleListLiteral ) + // InternalScope.g:3947:3: ruleListLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); + } pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group_3__0(); + ruleListLiteral(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getListLiteralParserRuleCall_2()); + } + + } + } break; + case 4 : + // InternalScope.g:3952:2: ( ruleConstructorCallExpression ) + { + // InternalScope.g:3952:2: ( ruleConstructorCallExpression ) + // InternalScope.g:3953:3: ruleConstructorCallExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleConstructorCallExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getConstructorCallExpressionParserRuleCall_3()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getGroup_3()); - } + } - } + } + break; + case 5 : + // InternalScope.g:3958:2: ( ruleGlobalVarExpression ) + { + // InternalScope.g:3958:2: ( ruleGlobalVarExpression ) + // InternalScope.g:3959:3: ruleGlobalVarExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleGlobalVarExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getGlobalVarExpressionParserRuleCall_4()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group__3__Impl" + } + break; + case 6 : + // InternalScope.g:3964:2: ( ruleParanthesizedExpression ) + { + // InternalScope.g:3964:2: ( ruleParanthesizedExpression ) + // InternalScope.g:3965:3: ruleParanthesizedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleParanthesizedExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getPrimaryExpressionAccess().getParanthesizedExpressionParserRuleCall_5()); + } - // $ANTLR start "rule__ScopeDelegation__Group__4" - // InternalScope.g:4038:1: rule__ScopeDelegation__Group__4 : rule__ScopeDelegation__Group__4__Impl ; - public final void rule__ScopeDelegation__Group__4() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4042:1: ( rule__ScopeDelegation__Group__4__Impl ) - // InternalScope.g:4043:2: rule__ScopeDelegation__Group__4__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group__4__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14189,35 +14079,171 @@ public final void rule__ScopeDelegation__Group__4() throws RecognitionException } return ; } - // $ANTLR end "rule__ScopeDelegation__Group__4" + // $ANTLR end "rule__PrimaryExpression__Alternatives" - // $ANTLR start "rule__ScopeDelegation__Group__4__Impl" - // InternalScope.g:4049:1: rule__ScopeDelegation__Group__4__Impl : ( ')' ) ; - public final void rule__ScopeDelegation__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Literal__Alternatives" + // InternalScope.g:3974:1: rule__Literal__Alternatives : ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ); + public final void rule__Literal__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4053:1: ( ( ')' ) ) - // InternalScope.g:4054:1: ( ')' ) - { - // InternalScope.g:4054:1: ( ')' ) - // InternalScope.g:4055:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); - } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); - } + // InternalScope.g:3978:1: ( ( ruleBooleanLiteral ) | ( ruleIntegerLiteral ) | ( ruleNullLiteral ) | ( ruleRealLiteral ) | ( ruleStringLiteral ) ) + int alt22=5; + switch ( input.LA(1) ) { + case 36: + case 37: + { + alt22=1; + } + break; + case RULE_INT: + { + alt22=2; + } + break; + case 108: + { + alt22=3; + } + break; + case RULE_REAL: + { + alt22=4; + } + break; + case RULE_STRING: + { + alt22=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 22, 0, input); + throw nvae; } + switch (alt22) { + case 1 : + // InternalScope.g:3979:2: ( ruleBooleanLiteral ) + { + // InternalScope.g:3979:2: ( ruleBooleanLiteral ) + // InternalScope.g:3980:3: ruleBooleanLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleBooleanLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:3985:2: ( ruleIntegerLiteral ) + { + // InternalScope.g:3985:2: ( ruleIntegerLiteral ) + // InternalScope.g:3986:3: ruleIntegerLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleIntegerLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getIntegerLiteralParserRuleCall_1()); + } + + } + + + } + break; + case 3 : + // InternalScope.g:3991:2: ( ruleNullLiteral ) + { + // InternalScope.g:3991:2: ( ruleNullLiteral ) + // InternalScope.g:3992:3: ruleNullLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleNullLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getNullLiteralParserRuleCall_2()); + } + + } + + + } + break; + case 4 : + // InternalScope.g:3997:2: ( ruleRealLiteral ) + { + // InternalScope.g:3997:2: ( ruleRealLiteral ) + // InternalScope.g:3998:3: ruleRealLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleRealLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getRealLiteralParserRuleCall_3()); + } + + } + + + } + break; + case 5 : + // InternalScope.g:4003:2: ( ruleStringLiteral ) + { + // InternalScope.g:4003:2: ( ruleStringLiteral ) + // InternalScope.g:4004:3: ruleStringLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleStringLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_4()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14230,32 +14256,74 @@ public final void rule__ScopeDelegation__Group__4__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeDelegation__Group__4__Impl" + // $ANTLR end "rule__Literal__Alternatives" - // $ANTLR start "rule__ScopeDelegation__Group_3__0" - // InternalScope.g:4065:1: rule__ScopeDelegation__Group_3__0 : rule__ScopeDelegation__Group_3__0__Impl rule__ScopeDelegation__Group_3__1 ; - public final void rule__ScopeDelegation__Group_3__0() throws RecognitionException { + // $ANTLR start "rule__BooleanLiteral__ValAlternatives_0" + // InternalScope.g:4013:1: rule__BooleanLiteral__ValAlternatives_0 : ( ( 'true' ) | ( 'false' ) ); + public final void rule__BooleanLiteral__ValAlternatives_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4069:1: ( rule__ScopeDelegation__Group_3__0__Impl rule__ScopeDelegation__Group_3__1 ) - // InternalScope.g:4070:2: rule__ScopeDelegation__Group_3__0__Impl rule__ScopeDelegation__Group_3__1 - { - pushFollow(FOLLOW_3); - rule__ScopeDelegation__Group_3__0__Impl(); + // InternalScope.g:4017:1: ( ( 'true' ) | ( 'false' ) ) + int alt23=2; + int LA23_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group_3__1(); - - state._fsp--; - if (state.failed) return ; + if ( (LA23_0==36) ) { + alt23=1; + } + else if ( (LA23_0==37) ) { + alt23=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 23, 0, input); + throw nvae; } + switch (alt23) { + case 1 : + // InternalScope.g:4018:2: ( 'true' ) + { + // InternalScope.g:4018:2: ( 'true' ) + // InternalScope.g:4019:3: 'true' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); + } + match(input,36,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4024:2: ( 'false' ) + { + // InternalScope.g:4024:2: ( 'false' ) + // InternalScope.g:4025:3: 'false' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); + } + match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14268,119 +14336,171 @@ public final void rule__ScopeDelegation__Group_3__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ScopeDelegation__Group_3__0" + // $ANTLR end "rule__BooleanLiteral__ValAlternatives_0" - // $ANTLR start "rule__ScopeDelegation__Group_3__0__Impl" - // InternalScope.g:4077:1: rule__ScopeDelegation__Group_3__0__Impl : ( ',' ) ; - public final void rule__ScopeDelegation__Group_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__FeatureCall__Alternatives" + // InternalScope.g:4034:1: rule__FeatureCall__Alternatives : ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ); + public final void rule__FeatureCall__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4081:1: ( ( ',' ) ) - // InternalScope.g:4082:1: ( ',' ) - { - // InternalScope.g:4082:1: ( ',' ) - // InternalScope.g:4083:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); - } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); - } + // InternalScope.g:4038:1: ( ( ruleOperationCall ) | ( ( rule__FeatureCall__TypeAssignment_1 ) ) | ( ruleCollectionExpression ) | ( ruleTypeSelectExpression ) ) + int alt24=4; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA24_1 = input.LA(2); - } + if ( (LA24_1==77) ) { + alt24=1; + } + else if ( (LA24_1==EOF||(LA24_1>=15 && LA24_1<=26)||LA24_1==48||LA24_1==58||LA24_1==69||(LA24_1>=73 && LA24_1<=75)||LA24_1==78||LA24_1==81||LA24_1==83||LA24_1==86||LA24_1==93||(LA24_1>=95 && LA24_1<=96)||(LA24_1>=98 && LA24_1<=99)||LA24_1==101||LA24_1==119) ) { + alt24=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 24, 1, input); + throw nvae; + } + } + break; + case 38: + case 39: + case 40: + { + alt24=2; + } + break; + case 28: + case 29: + case 30: + case 31: + case 32: + case 33: + case 34: + case 35: + { + alt24=3; + } + break; + case 120: + { + alt24=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 24, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt24) { + case 1 : + // InternalScope.g:4039:2: ( ruleOperationCall ) + { + // InternalScope.g:4039:2: ( ruleOperationCall ) + // InternalScope.g:4040:3: ruleOperationCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleOperationCall(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getOperationCallParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group_3__0__Impl" + } - // $ANTLR start "rule__ScopeDelegation__Group_3__1" - // InternalScope.g:4092:1: rule__ScopeDelegation__Group_3__1 : rule__ScopeDelegation__Group_3__1__Impl ; - public final void rule__ScopeDelegation__Group_3__1() throws RecognitionException { + } + break; + case 2 : + // InternalScope.g:4045:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) + { + // InternalScope.g:4045:2: ( ( rule__FeatureCall__TypeAssignment_1 ) ) + // InternalScope.g:4046:3: ( rule__FeatureCall__TypeAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); + } + // InternalScope.g:4047:3: ( rule__FeatureCall__TypeAssignment_1 ) + // InternalScope.g:4047:4: rule__FeatureCall__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__FeatureCall__TypeAssignment_1(); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4096:1: ( rule__ScopeDelegation__Group_3__1__Impl ) - // InternalScope.g:4097:2: rule__ScopeDelegation__Group_3__1__Impl - { - pushFollow(FOLLOW_2); - rule__ScopeDelegation__Group_3__1__Impl(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeAssignment_1()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__ScopeDelegation__Group_3__1" + } + break; + case 3 : + // InternalScope.g:4051:2: ( ruleCollectionExpression ) + { + // InternalScope.g:4051:2: ( ruleCollectionExpression ) + // InternalScope.g:4052:3: ruleCollectionExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleCollectionExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getCollectionExpressionParserRuleCall_2()); + } - // $ANTLR start "rule__ScopeDelegation__Group_3__1__Impl" - // InternalScope.g:4103:1: rule__ScopeDelegation__Group_3__1__Impl : ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) ; - public final void rule__ScopeDelegation__Group_3__1__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4107:1: ( ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) ) - // InternalScope.g:4108:1: ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) - { - // InternalScope.g:4108:1: ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) - // InternalScope.g:4109:2: ( rule__ScopeDelegation__ScopeAssignment_3_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); - } - // InternalScope.g:4110:2: ( rule__ScopeDelegation__ScopeAssignment_3_1 ) - // InternalScope.g:4110:3: rule__ScopeDelegation__ScopeAssignment_3_1 - { - pushFollow(FOLLOW_2); - rule__ScopeDelegation__ScopeAssignment_3_1(); - state._fsp--; - if (state.failed) return ; + } + break; + case 4 : + // InternalScope.g:4057:2: ( ruleTypeSelectExpression ) + { + // InternalScope.g:4057:2: ( ruleTypeSelectExpression ) + // InternalScope.g:4058:3: ruleTypeSelectExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleTypeSelectExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeSelectExpressionParserRuleCall_3()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14393,121 +14513,222 @@ public final void rule__ScopeDelegation__Group_3__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ScopeDelegation__Group_3__1__Impl" + // $ANTLR end "rule__FeatureCall__Alternatives" - // $ANTLR start "rule__NamedScopeExpression__Group__0" - // InternalScope.g:4119:1: rule__NamedScopeExpression__Group__0 : rule__NamedScopeExpression__Group__0__Impl rule__NamedScopeExpression__Group__1 ; - public final void rule__NamedScopeExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__CollectionExpression__NameAlternatives_0_0" + // InternalScope.g:4067:1: rule__CollectionExpression__NameAlternatives_0_0 : ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ); + public final void rule__CollectionExpression__NameAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4123:1: ( rule__NamedScopeExpression__Group__0__Impl rule__NamedScopeExpression__Group__1 ) - // InternalScope.g:4124:2: rule__NamedScopeExpression__Group__0__Impl rule__NamedScopeExpression__Group__1 - { - pushFollow(FOLLOW_34); - rule__NamedScopeExpression__Group__0__Impl(); + // InternalScope.g:4071:1: ( ( 'collect' ) | ( 'select' ) | ( 'selectFirst' ) | ( 'reject' ) | ( 'exists' ) | ( 'notExists' ) | ( 'sortBy' ) | ( 'forAll' ) ) + int alt25=8; + switch ( input.LA(1) ) { + case 28: + { + alt25=1; + } + break; + case 29: + { + alt25=2; + } + break; + case 30: + { + alt25=3; + } + break; + case 31: + { + alt25=4; + } + break; + case 32: + { + alt25=5; + } + break; + case 33: + { + alt25=6; + } + break; + case 34: + { + alt25=7; + } + break; + case 35: + { + alt25=8; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 25, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group__1(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt25) { + case 1 : + // InternalScope.g:4072:2: ( 'collect' ) + { + // InternalScope.g:4072:2: ( 'collect' ) + // InternalScope.g:4073:3: 'collect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); + } + match(input,28,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:4078:2: ( 'select' ) + { + // InternalScope.g:4078:2: ( 'select' ) + // InternalScope.g:4079:3: 'select' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); + } + match(input,29,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); + } - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group__0" + } - // $ANTLR start "rule__NamedScopeExpression__Group__0__Impl" - // InternalScope.g:4131:1: rule__NamedScopeExpression__Group__0__Impl : ( ( rule__NamedScopeExpression__Alternatives_0 ) ) ; - public final void rule__NamedScopeExpression__Group__0__Impl() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:4084:2: ( 'selectFirst' ) + { + // InternalScope.g:4084:2: ( 'selectFirst' ) + // InternalScope.g:4085:3: 'selectFirst' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); + } + match(input,30,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4135:1: ( ( ( rule__NamedScopeExpression__Alternatives_0 ) ) ) - // InternalScope.g:4136:1: ( ( rule__NamedScopeExpression__Alternatives_0 ) ) - { - // InternalScope.g:4136:1: ( ( rule__NamedScopeExpression__Alternatives_0 ) ) - // InternalScope.g:4137:2: ( rule__NamedScopeExpression__Alternatives_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); - } - // InternalScope.g:4138:2: ( rule__NamedScopeExpression__Alternatives_0 ) - // InternalScope.g:4138:3: rule__NamedScopeExpression__Alternatives_0 - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Alternatives_0(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 4 : + // InternalScope.g:4090:2: ( 'reject' ) + { + // InternalScope.g:4090:2: ( 'reject' ) + // InternalScope.g:4091:3: 'reject' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); + } + match(input,31,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); - } + } - } + } + break; + case 5 : + // InternalScope.g:4096:2: ( 'exists' ) + { + // InternalScope.g:4096:2: ( 'exists' ) + // InternalScope.g:4097:3: 'exists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); + } + match(input,32,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 6 : + // InternalScope.g:4102:2: ( 'notExists' ) + { + // InternalScope.g:4102:2: ( 'notExists' ) + // InternalScope.g:4103:3: 'notExists' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); + } + match(input,33,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); + } - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group__0__Impl" + } - // $ANTLR start "rule__NamedScopeExpression__Group__1" - // InternalScope.g:4146:1: rule__NamedScopeExpression__Group__1 : rule__NamedScopeExpression__Group__1__Impl rule__NamedScopeExpression__Group__2 ; - public final void rule__NamedScopeExpression__Group__1() throws RecognitionException { + } + break; + case 7 : + // InternalScope.g:4108:2: ( 'sortBy' ) + { + // InternalScope.g:4108:2: ( 'sortBy' ) + // InternalScope.g:4109:3: 'sortBy' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); + } + match(input,34,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4150:1: ( rule__NamedScopeExpression__Group__1__Impl rule__NamedScopeExpression__Group__2 ) - // InternalScope.g:4151:2: rule__NamedScopeExpression__Group__1__Impl rule__NamedScopeExpression__Group__2 - { - pushFollow(FOLLOW_34); - rule__NamedScopeExpression__Group__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group__2(); - state._fsp--; - if (state.failed) return ; + } + break; + case 8 : + // InternalScope.g:4114:2: ( 'forAll' ) + { + // InternalScope.g:4114:2: ( 'forAll' ) + // InternalScope.g:4115:3: 'forAll' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); + } + match(input,35,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14520,56 +14741,82 @@ public final void rule__NamedScopeExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group__1" + // $ANTLR end "rule__CollectionExpression__NameAlternatives_0_0" - // $ANTLR start "rule__NamedScopeExpression__Group__1__Impl" - // InternalScope.g:4158:1: rule__NamedScopeExpression__Group__1__Impl : ( ( rule__NamedScopeExpression__Group_1__0 )? ) ; - public final void rule__NamedScopeExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Type__Alternatives" + // InternalScope.g:4124:1: rule__Type__Alternatives : ( ( ruleCollectionType ) | ( ruleSimpleType ) ); + public final void rule__Type__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4162:1: ( ( ( rule__NamedScopeExpression__Group_1__0 )? ) ) - // InternalScope.g:4163:1: ( ( rule__NamedScopeExpression__Group_1__0 )? ) - { - // InternalScope.g:4163:1: ( ( rule__NamedScopeExpression__Group_1__0 )? ) - // InternalScope.g:4164:2: ( rule__NamedScopeExpression__Group_1__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); + // InternalScope.g:4128:1: ( ( ruleCollectionType ) | ( ruleSimpleType ) ) + int alt26=2; + int LA26_0 = input.LA(1); + + if ( ((LA26_0>=38 && LA26_0<=40)) ) { + alt26=1; } - // InternalScope.g:4165:2: ( rule__NamedScopeExpression__Group_1__0 )? - int alt42=2; - int LA42_0 = input.LA(1); + else if ( (LA26_0==RULE_ID) ) { + alt26=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 26, 0, input); - if ( (LA42_0==47) ) { - alt42=1; + throw nvae; } - switch (alt42) { + switch (alt26) { case 1 : - // InternalScope.g:4165:3: rule__NamedScopeExpression__Group_1__0 + // InternalScope.g:4129:2: ( ruleCollectionType ) + { + // InternalScope.g:4129:2: ( ruleCollectionType ) + // InternalScope.g:4130:3: ruleCollectionType { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); + } pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group_1__0(); + ruleCollectionType(); state._fsp--; if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeAccess().getCollectionTypeParserRuleCall_0()); + } + + } + } break; + case 2 : + // InternalScope.g:4135:2: ( ruleSimpleType ) + { + // InternalScope.g:4135:2: ( ruleSimpleType ) + // InternalScope.g:4136:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeAccess().getSimpleTypeParserRuleCall_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14582,27 +14829,102 @@ public final void rule__NamedScopeExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group__1__Impl" + // $ANTLR end "rule__Type__Alternatives" - // $ANTLR start "rule__NamedScopeExpression__Group__2" - // InternalScope.g:4173:1: rule__NamedScopeExpression__Group__2 : rule__NamedScopeExpression__Group__2__Impl ; - public final void rule__NamedScopeExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__CollectionType__ClAlternatives_0_0" + // InternalScope.g:4145:1: rule__CollectionType__ClAlternatives_0_0 : ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ); + public final void rule__CollectionType__ClAlternatives_0_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4177:1: ( rule__NamedScopeExpression__Group__2__Impl ) - // InternalScope.g:4178:2: rule__NamedScopeExpression__Group__2__Impl - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:4149:1: ( ( 'Collection' ) | ( 'List' ) | ( 'Set' ) ) + int alt27=3; + switch ( input.LA(1) ) { + case 38: + { + alt27=1; + } + break; + case 39: + { + alt27=2; + } + break; + case 40: + { + alt27=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 27, 0, input); + throw nvae; } + switch (alt27) { + case 1 : + // InternalScope.g:4150:2: ( 'Collection' ) + { + // InternalScope.g:4150:2: ( 'Collection' ) + // InternalScope.g:4151:3: 'Collection' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); + } + match(input,38,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4156:2: ( 'List' ) + { + // InternalScope.g:4156:2: ( 'List' ) + // InternalScope.g:4157:3: 'List' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); + } + match(input,39,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); + } + + } + + + } + break; + case 3 : + // InternalScope.g:4162:2: ( 'Set' ) + { + // InternalScope.g:4162:2: ( 'Set' ) + // InternalScope.g:4163:3: 'Set' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); + } + match(input,40,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -14615,94 +14937,214 @@ public final void rule__NamedScopeExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group__2" + // $ANTLR end "rule__CollectionType__ClAlternatives_0_0" - // $ANTLR start "rule__NamedScopeExpression__Group__2__Impl" - // InternalScope.g:4184:1: rule__NamedScopeExpression__Group__2__Impl : ( ( rule__NamedScopeExpression__Group_2__0 )? ) ; - public final void rule__NamedScopeExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XAssignment__Alternatives" + // InternalScope.g:4172:1: rule__XAssignment__Alternatives : ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ); + public final void rule__XAssignment__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4188:1: ( ( ( rule__NamedScopeExpression__Group_2__0 )? ) ) - // InternalScope.g:4189:1: ( ( rule__NamedScopeExpression__Group_2__0 )? ) - { - // InternalScope.g:4189:1: ( ( rule__NamedScopeExpression__Group_2__0 )? ) - // InternalScope.g:4190:2: ( rule__NamedScopeExpression__Group_2__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); - } - // InternalScope.g:4191:2: ( rule__NamedScopeExpression__Group_2__0 )? - int alt43=2; - int LA43_0 = input.LA(1); + // InternalScope.g:4176:1: ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) ) + int alt28=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA28_1 = input.LA(2); - if ( (LA43_0==41) ) { - alt43=1; + if ( (LA28_1==14) ) { + alt28=1; + } + else if ( (LA28_1==EOF||(LA28_1>=RULE_ID && LA28_1<=RULE_STRING)||(LA28_1>=15 && LA28_1<=19)||(LA28_1>=21 && LA28_1<=27)||(LA28_1>=36 && LA28_1<=37)||(LA28_1>=41 && LA28_1<=64)||LA28_1==69||(LA28_1>=72 && LA28_1<=75)||(LA28_1>=77 && LA28_1<=79)||(LA28_1>=82 && LA28_1<=83)||LA28_1==86||LA28_1==93||LA28_1==95||LA28_1==97||(LA28_1>=99 && LA28_1<=101)||(LA28_1>=103 && LA28_1<=115)||(LA28_1>=121 && LA28_1<=122)) ) { + alt28=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 1, input); + + throw nvae; + } + } + break; + case 60: + { + int LA28_2 = input.LA(2); + + if ( (LA28_2==14) ) { + alt28=1; + } + else if ( (LA28_2==EOF||(LA28_2>=RULE_ID && LA28_2<=RULE_STRING)||(LA28_2>=15 && LA28_2<=19)||(LA28_2>=21 && LA28_2<=27)||(LA28_2>=36 && LA28_2<=37)||(LA28_2>=41 && LA28_2<=64)||LA28_2==69||(LA28_2>=72 && LA28_2<=75)||(LA28_2>=77 && LA28_2<=79)||(LA28_2>=82 && LA28_2<=83)||LA28_2==86||LA28_2==93||LA28_2==95||LA28_2==97||(LA28_2>=99 && LA28_2<=101)||(LA28_2>=103 && LA28_2<=115)||(LA28_2>=121 && LA28_2<=122)) ) { + alt28=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 2, input); + + throw nvae; + } + } + break; + case 61: + { + int LA28_3 = input.LA(2); + + if ( (LA28_3==EOF||(LA28_3>=RULE_ID && LA28_3<=RULE_STRING)||(LA28_3>=15 && LA28_3<=19)||(LA28_3>=21 && LA28_3<=27)||(LA28_3>=36 && LA28_3<=37)||(LA28_3>=41 && LA28_3<=64)||LA28_3==69||(LA28_3>=72 && LA28_3<=75)||(LA28_3>=77 && LA28_3<=79)||(LA28_3>=82 && LA28_3<=83)||LA28_3==86||LA28_3==93||LA28_3==95||LA28_3==97||(LA28_3>=99 && LA28_3<=101)||(LA28_3>=103 && LA28_3<=115)||(LA28_3>=121 && LA28_3<=122)) ) { + alt28=2; + } + else if ( (LA28_3==14) ) { + alt28=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 3, input); + + throw nvae; + } + } + break; + case 62: + { + int LA28_4 = input.LA(2); + + if ( (LA28_4==14) ) { + alt28=1; + } + else if ( (LA28_4==EOF||(LA28_4>=RULE_ID && LA28_4<=RULE_STRING)||(LA28_4>=15 && LA28_4<=19)||(LA28_4>=21 && LA28_4<=27)||(LA28_4>=36 && LA28_4<=37)||(LA28_4>=41 && LA28_4<=64)||LA28_4==69||(LA28_4>=72 && LA28_4<=75)||(LA28_4>=77 && LA28_4<=79)||(LA28_4>=82 && LA28_4<=83)||LA28_4==86||LA28_4==93||LA28_4==95||LA28_4==97||(LA28_4>=99 && LA28_4<=101)||(LA28_4>=103 && LA28_4<=115)||(LA28_4>=121 && LA28_4<=122)) ) { + alt28=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 4, input); + + throw nvae; + } + } + break; + case 63: + { + int LA28_5 = input.LA(2); + + if ( (LA28_5==EOF||(LA28_5>=RULE_ID && LA28_5<=RULE_STRING)||(LA28_5>=15 && LA28_5<=19)||(LA28_5>=21 && LA28_5<=27)||(LA28_5>=36 && LA28_5<=37)||(LA28_5>=41 && LA28_5<=64)||LA28_5==69||(LA28_5>=72 && LA28_5<=75)||(LA28_5>=77 && LA28_5<=79)||(LA28_5>=82 && LA28_5<=83)||LA28_5==86||LA28_5==93||LA28_5==95||LA28_5==97||(LA28_5>=99 && LA28_5<=101)||(LA28_5>=103 && LA28_5<=115)||(LA28_5>=121 && LA28_5<=122)) ) { + alt28=2; + } + else if ( (LA28_5==14) ) { + alt28=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 5, input); + + throw nvae; + } + } + break; + case RULE_HEX: + case RULE_INT: + case RULE_DECIMAL: + case RULE_STRING: + case 22: + case 23: + case 24: + case 27: + case 36: + case 37: + case 64: + case 72: + case 77: + case 79: + case 82: + case 97: + case 100: + case 103: + case 105: + case 106: + case 107: + case 108: + case 109: + case 110: + case 111: + case 112: + case 114: + { + alt28=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 28, 0, input); + + throw nvae; } - switch (alt43) { + + switch (alt28) { case 1 : - // InternalScope.g:4191:3: rule__NamedScopeExpression__Group_2__0 + // InternalScope.g:4177:2: ( ( rule__XAssignment__Group_0__0 ) ) + { + // InternalScope.g:4177:2: ( ( rule__XAssignment__Group_0__0 ) ) + // InternalScope.g:4178:3: ( rule__XAssignment__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_0()); + } + // InternalScope.g:4179:3: ( rule__XAssignment__Group_0__0 ) + // InternalScope.g:4179:4: rule__XAssignment__Group_0__0 { pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group_2__0(); + rule__XAssignment__Group_0__0(); state._fsp--; if (state.failed) return ; } - break; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); - } - - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:4183:2: ( ( rule__XAssignment__Group_1__0 ) ) + { + // InternalScope.g:4183:2: ( ( rule__XAssignment__Group_1__0 ) ) + // InternalScope.g:4184:3: ( rule__XAssignment__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1()); + } + // InternalScope.g:4185:3: ( rule__XAssignment__Group_1__0 ) + // InternalScope.g:4185:4: rule__XAssignment__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__0(); - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group__2__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__NamedScopeExpression__Group_1__0" - // InternalScope.g:4200:1: rule__NamedScopeExpression__Group_1__0 : rule__NamedScopeExpression__Group_1__0__Impl rule__NamedScopeExpression__Group_1__1 ; - public final void rule__NamedScopeExpression__Group_1__0() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4204:1: ( rule__NamedScopeExpression__Group_1__0__Impl rule__NamedScopeExpression__Group_1__1 ) - // InternalScope.g:4205:2: rule__NamedScopeExpression__Group_1__0__Impl rule__NamedScopeExpression__Group_1__1 - { - pushFollow(FOLLOW_15); - rule__NamedScopeExpression__Group_1__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group_1__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -14715,129 +15157,218 @@ public final void rule__NamedScopeExpression__Group_1__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group_1__0" + // $ANTLR end "rule__XAssignment__Alternatives" - // $ANTLR start "rule__NamedScopeExpression__Group_1__0__Impl" - // InternalScope.g:4212:1: rule__NamedScopeExpression__Group_1__0__Impl : ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) ; - public final void rule__NamedScopeExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpMultiAssign__Alternatives" + // InternalScope.g:4193:1: rule__OpMultiAssign__Alternatives : ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ); + public final void rule__OpMultiAssign__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4216:1: ( ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) ) - // InternalScope.g:4217:1: ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) - { - // InternalScope.g:4217:1: ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) - // InternalScope.g:4218:2: ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); + // InternalScope.g:4197:1: ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) ) + int alt29=7; + switch ( input.LA(1) ) { + case 41: + { + alt29=1; + } + break; + case 42: + { + alt29=2; + } + break; + case 43: + { + alt29=3; + } + break; + case 44: + { + alt29=4; + } + break; + case 45: + { + alt29=5; + } + break; + case 22: + { + alt29=6; + } + break; + case 21: + { + alt29=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 29, 0, input); + + throw nvae; } - // InternalScope.g:4219:2: ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) - // InternalScope.g:4219:3: rule__NamedScopeExpression__CaseDefAssignment_1_0 - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__CaseDefAssignment_1_0(); - state._fsp--; - if (state.failed) return ; + switch (alt29) { + case 1 : + // InternalScope.g:4198:2: ( '+=' ) + { + // InternalScope.g:4198:2: ( '+=' ) + // InternalScope.g:4199:3: '+=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + match(input,41,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); - } - } + } + break; + case 2 : + // InternalScope.g:4204:2: ( '-=' ) + { + // InternalScope.g:4204:2: ( '-=' ) + // InternalScope.g:4205:3: '-=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + match(input,42,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 3 : + // InternalScope.g:4210:2: ( '*=' ) + { + // InternalScope.g:4210:2: ( '*=' ) + // InternalScope.g:4211:3: '*=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + match(input,43,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group_1__0__Impl" + } + break; + case 4 : + // InternalScope.g:4216:2: ( '/=' ) + { + // InternalScope.g:4216:2: ( '/=' ) + // InternalScope.g:4217:3: '/=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + match(input,44,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } - // $ANTLR start "rule__NamedScopeExpression__Group_1__1" - // InternalScope.g:4227:1: rule__NamedScopeExpression__Group_1__1 : rule__NamedScopeExpression__Group_1__1__Impl ; - public final void rule__NamedScopeExpression__Group_1__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4231:1: ( rule__NamedScopeExpression__Group_1__1__Impl ) - // InternalScope.g:4232:2: rule__NamedScopeExpression__Group_1__1__Impl - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group_1__1__Impl(); - state._fsp--; - if (state.failed) return ; + } + break; + case 5 : + // InternalScope.g:4222:2: ( '%=' ) + { + // InternalScope.g:4222:2: ( '%=' ) + // InternalScope.g:4223:3: '%=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 6 : + // InternalScope.g:4228:2: ( ( rule__OpMultiAssign__Group_5__0 ) ) + { + // InternalScope.g:4228:2: ( ( rule__OpMultiAssign__Group_5__0 ) ) + // InternalScope.g:4229:3: ( rule__OpMultiAssign__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } + // InternalScope.g:4230:3: ( rule__OpMultiAssign__Group_5__0 ) + // InternalScope.g:4230:4: rule__OpMultiAssign__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__0(); - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group_1__1" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__NamedScopeExpression__Group_1__1__Impl" - // InternalScope.g:4238:1: rule__NamedScopeExpression__Group_1__1__Impl : ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) ; - public final void rule__NamedScopeExpression__Group_1__1__Impl() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4242:1: ( ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) ) - // InternalScope.g:4243:1: ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) - { - // InternalScope.g:4243:1: ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) - // InternalScope.g:4244:2: ( rule__NamedScopeExpression__CasingAssignment_1_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); - } - // InternalScope.g:4245:2: ( rule__NamedScopeExpression__CasingAssignment_1_1 ) - // InternalScope.g:4245:3: rule__NamedScopeExpression__CasingAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__CasingAssignment_1_1(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 7 : + // InternalScope.g:4234:2: ( ( rule__OpMultiAssign__Group_6__0 ) ) + { + // InternalScope.g:4234:2: ( ( rule__OpMultiAssign__Group_6__0 ) ) + // InternalScope.g:4235:3: ( rule__OpMultiAssign__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } + // InternalScope.g:4236:3: ( rule__OpMultiAssign__Group_6__0 ) + // InternalScope.g:4236:4: rule__OpMultiAssign__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__0(); - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); + } - } + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14850,73 +15381,126 @@ public final void rule__NamedScopeExpression__Group_1__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group_1__1__Impl" + // $ANTLR end "rule__OpMultiAssign__Alternatives" - // $ANTLR start "rule__NamedScopeExpression__Group_2__0" - // InternalScope.g:4254:1: rule__NamedScopeExpression__Group_2__0 : rule__NamedScopeExpression__Group_2__0__Impl rule__NamedScopeExpression__Group_2__1 ; - public final void rule__NamedScopeExpression__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__OpEquality__Alternatives" + // InternalScope.g:4244:1: rule__OpEquality__Alternatives : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ); + public final void rule__OpEquality__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4258:1: ( rule__NamedScopeExpression__Group_2__0__Impl rule__NamedScopeExpression__Group_2__1 ) - // InternalScope.g:4259:2: rule__NamedScopeExpression__Group_2__0__Impl rule__NamedScopeExpression__Group_2__1 - { - pushFollow(FOLLOW_17); - rule__NamedScopeExpression__Group_2__0__Impl(); + // InternalScope.g:4248:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) ) + int alt30=4; + switch ( input.LA(1) ) { + case 17: + { + alt30=1; + } + break; + case 18: + { + alt30=2; + } + break; + case 46: + { + alt30=3; + } + break; + case 47: + { + alt30=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 30, 0, input); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group_2__1(); + throw nvae; + } - state._fsp--; - if (state.failed) return ; + switch (alt30) { + case 1 : + // InternalScope.g:4249:2: ( '==' ) + { + // InternalScope.g:4249:2: ( '==' ) + // InternalScope.g:4250:3: '==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + match(input,17,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:4255:2: ( '!=' ) + { + // InternalScope.g:4255:2: ( '!=' ) + // InternalScope.g:4256:3: '!=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + match(input,18,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group_2__0" + } - // $ANTLR start "rule__NamedScopeExpression__Group_2__0__Impl" - // InternalScope.g:4266:1: rule__NamedScopeExpression__Group_2__0__Impl : ( 'as' ) ; - public final void rule__NamedScopeExpression__Group_2__0__Impl() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:4261:2: ( '===' ) + { + // InternalScope.g:4261:2: ( '===' ) + // InternalScope.g:4262:3: '===' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4270:1: ( ( 'as' ) ) - // InternalScope.g:4271:1: ( 'as' ) - { - // InternalScope.g:4271:1: ( 'as' ) - // InternalScope.g:4272:2: 'as' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); - } - match(input,41,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); - } + } - } + + } + break; + case 4 : + // InternalScope.g:4267:2: ( '!==' ) + { + // InternalScope.g:4267:2: ( '!==' ) + // InternalScope.g:4268:3: '!==' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -14929,78 +15513,94 @@ public final void rule__NamedScopeExpression__Group_2__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group_2__0__Impl" + // $ANTLR end "rule__OpEquality__Alternatives" - // $ANTLR start "rule__NamedScopeExpression__Group_2__1" - // InternalScope.g:4281:1: rule__NamedScopeExpression__Group_2__1 : rule__NamedScopeExpression__Group_2__1__Impl ; - public final void rule__NamedScopeExpression__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__XRelationalExpression__Alternatives_1" + // InternalScope.g:4277:1: rule__XRelationalExpression__Alternatives_1 : ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ); + public final void rule__XRelationalExpression__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4285:1: ( rule__NamedScopeExpression__Group_2__1__Impl ) - // InternalScope.g:4286:2: rule__NamedScopeExpression__Group_2__1__Impl - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__Group_2__1__Impl(); + // InternalScope.g:4281:1: ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) ) + int alt31=2; + int LA31_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA31_0==104) ) { + alt31=1; + } + else if ( (LA31_0==19||(LA31_0>=21 && LA31_0<=22)) ) { + alt31=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 31, 0, input); + throw nvae; } + switch (alt31) { + case 1 : + // InternalScope.g:4282:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + { + // InternalScope.g:4282:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) ) + // InternalScope.g:4283:3: ( rule__XRelationalExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:4284:3: ( rule__XRelationalExpression__Group_1_0__0 ) + // InternalScope.g:4284:4: rule__XRelationalExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__NamedScopeExpression__Group_2__1" + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); + } + } - // $ANTLR start "rule__NamedScopeExpression__Group_2__1__Impl" - // InternalScope.g:4292:1: rule__NamedScopeExpression__Group_2__1__Impl : ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) ; - public final void rule__NamedScopeExpression__Group_2__1__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4296:1: ( ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) ) - // InternalScope.g:4297:1: ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) - { - // InternalScope.g:4297:1: ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) - // InternalScope.g:4298:2: ( rule__NamedScopeExpression__NamingAssignment_2_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); - } - // InternalScope.g:4299:2: ( rule__NamedScopeExpression__NamingAssignment_2_1 ) - // InternalScope.g:4299:3: rule__NamedScopeExpression__NamingAssignment_2_1 - { - pushFollow(FOLLOW_2); - rule__NamedScopeExpression__NamingAssignment_2_1(); + } + break; + case 2 : + // InternalScope.g:4288:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + { + // InternalScope.g:4288:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) ) + // InternalScope.g:4289:3: ( rule__XRelationalExpression__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } + // InternalScope.g:4290:3: ( rule__XRelationalExpression__Group_1_1__0 ) + // InternalScope.g:4290:4: rule__XRelationalExpression__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); + } - } + } - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -15013,111 +15613,145 @@ public final void rule__NamedScopeExpression__Group_2__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__NamedScopeExpression__Group_2__1__Impl" + // $ANTLR end "rule__XRelationalExpression__Alternatives_1" - // $ANTLR start "rule__GlobalScopeExpression__Group__0" - // InternalScope.g:4308:1: rule__GlobalScopeExpression__Group__0 : rule__GlobalScopeExpression__Group__0__Impl rule__GlobalScopeExpression__Group__1 ; - public final void rule__GlobalScopeExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__OpCompare__Alternatives" + // InternalScope.g:4298:1: rule__OpCompare__Alternatives : ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ); + public final void rule__OpCompare__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4312:1: ( rule__GlobalScopeExpression__Group__0__Impl rule__GlobalScopeExpression__Group__1 ) - // InternalScope.g:4313:2: rule__GlobalScopeExpression__Group__0__Impl rule__GlobalScopeExpression__Group__1 - { - pushFollow(FOLLOW_31); - rule__GlobalScopeExpression__Group__0__Impl(); + // InternalScope.g:4302:1: ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) ) + int alt32=4; + switch ( input.LA(1) ) { + case 19: + { + alt32=1; + } + break; + case 22: + { + int LA32_2 = input.LA(2); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__1(); + if ( (LA32_2==EOF||(LA32_2>=RULE_ID && LA32_2<=RULE_STRING)||(LA32_2>=22 && LA32_2<=24)||LA32_2==27||(LA32_2>=36 && LA32_2<=37)||(LA32_2>=60 && LA32_2<=64)||LA32_2==72||LA32_2==77||LA32_2==79||LA32_2==82||LA32_2==97||LA32_2==100||LA32_2==103||(LA32_2>=105 && LA32_2<=112)||LA32_2==114) ) { + alt32=4; + } + else if ( (LA32_2==14) ) { + alt32=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 32, 2, input); - state._fsp--; - if (state.failed) return ; + throw nvae; + } + } + break; + case 21: + { + alt32=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 32, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - - restoreStackSize(stackSize); + switch (alt32) { + case 1 : + // InternalScope.g:4303:2: ( '>=' ) + { + // InternalScope.g:4303:2: ( '>=' ) + // InternalScope.g:4304:3: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__0" + } - // $ANTLR start "rule__GlobalScopeExpression__Group__0__Impl" - // InternalScope.g:4320:1: rule__GlobalScopeExpression__Group__0__Impl : ( 'find' ) ; - public final void rule__GlobalScopeExpression__Group__0__Impl() throws RecognitionException { + } + break; + case 2 : + // InternalScope.g:4309:2: ( ( rule__OpCompare__Group_1__0 ) ) + { + // InternalScope.g:4309:2: ( ( rule__OpCompare__Group_1__0 ) ) + // InternalScope.g:4310:3: ( rule__OpCompare__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGroup_1()); + } + // InternalScope.g:4311:3: ( rule__OpCompare__Group_1__0 ) + // InternalScope.g:4311:4: rule__OpCompare__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__0(); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4324:1: ( ( 'find' ) ) - // InternalScope.g:4325:1: ( 'find' ) - { - // InternalScope.g:4325:1: ( 'find' ) - // InternalScope.g:4326:2: 'find' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); - } - match(input,61,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGroup_1()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 3 : + // InternalScope.g:4315:2: ( '>' ) + { + // InternalScope.g:4315:2: ( '>' ) + // InternalScope.g:4316:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__0__Impl" + } - // $ANTLR start "rule__GlobalScopeExpression__Group__1" - // InternalScope.g:4335:1: rule__GlobalScopeExpression__Group__1 : rule__GlobalScopeExpression__Group__1__Impl rule__GlobalScopeExpression__Group__2 ; - public final void rule__GlobalScopeExpression__Group__1() throws RecognitionException { + } + break; + case 4 : + // InternalScope.g:4321:2: ( '<' ) + { + // InternalScope.g:4321:2: ( '<' ) + // InternalScope.g:4322:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4339:1: ( rule__GlobalScopeExpression__Group__1__Impl rule__GlobalScopeExpression__Group__2 ) - // InternalScope.g:4340:2: rule__GlobalScopeExpression__Group__1__Impl rule__GlobalScopeExpression__Group__2 - { - pushFollow(FOLLOW_3); - rule__GlobalScopeExpression__Group__1__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__2(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15130,162 +15764,223 @@ public final void rule__GlobalScopeExpression__Group__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__1" + // $ANTLR end "rule__OpCompare__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group__1__Impl" - // InternalScope.g:4347:1: rule__GlobalScopeExpression__Group__1__Impl : ( '(' ) ; - public final void rule__GlobalScopeExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives" + // InternalScope.g:4331:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ); + public final void rule__OpOther__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4351:1: ( ( '(' ) ) - // InternalScope.g:4352:1: ( '(' ) - { - // InternalScope.g:4352:1: ( '(' ) - // InternalScope.g:4353:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); - } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); - } + // InternalScope.g:4335:1: ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) ) + int alt33=9; + alt33 = dfa33.predict(input); + switch (alt33) { + case 1 : + // InternalScope.g:4336:2: ( '->' ) + { + // InternalScope.g:4336:2: ( '->' ) + // InternalScope.g:4337:3: '->' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + match(input,48,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } - } + } - } + } + break; + case 2 : + // InternalScope.g:4342:2: ( '..<' ) + { + // InternalScope.g:4342:2: ( '..<' ) + // InternalScope.g:4343:3: '..<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + match(input,49,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__1__Impl" + } + break; + case 3 : + // InternalScope.g:4348:2: ( ( rule__OpOther__Group_2__0 ) ) + { + // InternalScope.g:4348:2: ( ( rule__OpOther__Group_2__0 ) ) + // InternalScope.g:4349:3: ( rule__OpOther__Group_2__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_2()); + } + // InternalScope.g:4350:3: ( rule__OpOther__Group_2__0 ) + // InternalScope.g:4350:4: rule__OpOther__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__0(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__GlobalScopeExpression__Group__2" - // InternalScope.g:4362:1: rule__GlobalScopeExpression__Group__2 : rule__GlobalScopeExpression__Group__2__Impl rule__GlobalScopeExpression__Group__3 ; - public final void rule__GlobalScopeExpression__Group__2() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4366:1: ( rule__GlobalScopeExpression__Group__2__Impl rule__GlobalScopeExpression__Group__3 ) - // InternalScope.g:4367:2: rule__GlobalScopeExpression__Group__2__Impl rule__GlobalScopeExpression__Group__3 - { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group__2__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_2()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__3(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 4 : + // InternalScope.g:4354:2: ( '..' ) + { + // InternalScope.g:4354:2: ( '..' ) + // InternalScope.g:4355:3: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + match(input,50,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__2" + } + break; + case 5 : + // InternalScope.g:4360:2: ( '=>' ) + { + // InternalScope.g:4360:2: ( '=>' ) + // InternalScope.g:4361:3: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + } - // $ANTLR start "rule__GlobalScopeExpression__Group__2__Impl" - // InternalScope.g:4374:1: rule__GlobalScopeExpression__Group__2__Impl : ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) ; - public final void rule__GlobalScopeExpression__Group__2__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4378:1: ( ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) ) - // InternalScope.g:4379:1: ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) - { - // InternalScope.g:4379:1: ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) - // InternalScope.g:4380:2: ( rule__GlobalScopeExpression__TypeAssignment_2 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); - } - // InternalScope.g:4381:2: ( rule__GlobalScopeExpression__TypeAssignment_2 ) - // InternalScope.g:4381:3: rule__GlobalScopeExpression__TypeAssignment_2 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__TypeAssignment_2(); + } + break; + case 6 : + // InternalScope.g:4366:2: ( ( rule__OpOther__Group_5__0 ) ) + { + // InternalScope.g:4366:2: ( ( rule__OpOther__Group_5__0 ) ) + // InternalScope.g:4367:3: ( rule__OpOther__Group_5__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5()); + } + // InternalScope.g:4368:3: ( rule__OpOther__Group_5__0 ) + // InternalScope.g:4368:4: rule__OpOther__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5()); + } - } + } - } + } + break; + case 7 : + // InternalScope.g:4372:2: ( ( rule__OpOther__Group_6__0 ) ) + { + // InternalScope.g:4372:2: ( ( rule__OpOther__Group_6__0 ) ) + // InternalScope.g:4373:3: ( rule__OpOther__Group_6__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6()); + } + // InternalScope.g:4374:3: ( rule__OpOther__Group_6__0 ) + // InternalScope.g:4374:4: rule__OpOther__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__0(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__2__Impl" + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6()); + } + } - // $ANTLR start "rule__GlobalScopeExpression__Group__3" - // InternalScope.g:4389:1: rule__GlobalScopeExpression__Group__3 : rule__GlobalScopeExpression__Group__3__Impl rule__GlobalScopeExpression__Group__4 ; - public final void rule__GlobalScopeExpression__Group__3() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4393:1: ( rule__GlobalScopeExpression__Group__3__Impl rule__GlobalScopeExpression__Group__4 ) - // InternalScope.g:4394:2: rule__GlobalScopeExpression__Group__3__Impl rule__GlobalScopeExpression__Group__4 - { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group__3__Impl(); + } + break; + case 8 : + // InternalScope.g:4378:2: ( '<>' ) + { + // InternalScope.g:4378:2: ( '<>' ) + // InternalScope.g:4379:3: '<>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__4(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 9 : + // InternalScope.g:4384:2: ( '?:' ) + { + // InternalScope.g:4384:2: ( '?:' ) + // InternalScope.g:4385:3: '?:' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + match(input,53,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15298,98 +15993,95 @@ public final void rule__GlobalScopeExpression__Group__3() throws RecognitionExce } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__3" + // $ANTLR end "rule__OpOther__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group__3__Impl" - // InternalScope.g:4401:1: rule__GlobalScopeExpression__Group__3__Impl : ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) ; - public final void rule__GlobalScopeExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives_5_1" + // InternalScope.g:4394:1: rule__OpOther__Alternatives_5_1 : ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ); + public final void rule__OpOther__Alternatives_5_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4405:1: ( ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) ) - // InternalScope.g:4406:1: ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) - { - // InternalScope.g:4406:1: ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) - // InternalScope.g:4407:2: ( rule__GlobalScopeExpression__Alternatives_3 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); - } - // InternalScope.g:4408:2: ( rule__GlobalScopeExpression__Alternatives_3 )? - int alt44=2; - int LA44_0 = input.LA(1); + // InternalScope.g:4398:1: ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) ) + int alt34=2; + int LA34_0 = input.LA(1); - if ( (LA44_0==60) ) { - int LA44_1 = input.LA(2); + if ( (LA34_0==21) ) { + int LA34_1 = input.LA(2); + + if ( (LA34_1==EOF||(LA34_1>=RULE_ID && LA34_1<=RULE_STRING)||(LA34_1>=22 && LA34_1<=24)||LA34_1==27||(LA34_1>=36 && LA34_1<=37)||(LA34_1>=60 && LA34_1<=64)||LA34_1==72||LA34_1==77||LA34_1==79||LA34_1==82||LA34_1==97||LA34_1==100||LA34_1==103||(LA34_1>=105 && LA34_1<=112)||LA34_1==114) ) { + alt34=2; + } + else if ( (LA34_1==21) ) { + alt34=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 34, 1, input); - if ( ((LA44_1>=62 && LA44_1<=63)||LA44_1==80) ) { - alt44=1; + throw nvae; } } - switch (alt44) { + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 34, 0, input); + + throw nvae; + } + switch (alt34) { case 1 : - // InternalScope.g:4408:3: rule__GlobalScopeExpression__Alternatives_3 + // InternalScope.g:4399:2: ( ( rule__OpOther__Group_5_1_0__0 ) ) + { + // InternalScope.g:4399:2: ( ( rule__OpOther__Group_5_1_0__0 ) ) + // InternalScope.g:4400:3: ( rule__OpOther__Group_5_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } + // InternalScope.g:4401:3: ( rule__OpOther__Group_5_1_0__0 ) + // InternalScope.g:4401:4: rule__OpOther__Group_5_1_0__0 { pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Alternatives_3(); + rule__OpOther__Group_5_1_0__0(); state._fsp--; if (state.failed) return ; } - break; - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); - } - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__3__Impl" + } - // $ANTLR start "rule__GlobalScopeExpression__Group__4" - // InternalScope.g:4416:1: rule__GlobalScopeExpression__Group__4 : rule__GlobalScopeExpression__Group__4__Impl rule__GlobalScopeExpression__Group__5 ; - public final void rule__GlobalScopeExpression__Group__4() throws RecognitionException { + } + break; + case 2 : + // InternalScope.g:4405:2: ( '>' ) + { + // InternalScope.g:4405:2: ( '>' ) + // InternalScope.g:4406:3: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4420:1: ( rule__GlobalScopeExpression__Group__4__Impl rule__GlobalScopeExpression__Group__5 ) - // InternalScope.g:4421:2: rule__GlobalScopeExpression__Group__4__Impl rule__GlobalScopeExpression__Group__5 - { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group__4__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__5(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15402,60 +16094,117 @@ public final void rule__GlobalScopeExpression__Group__4() throws RecognitionExce } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__4" + // $ANTLR end "rule__OpOther__Alternatives_5_1" - // $ANTLR start "rule__GlobalScopeExpression__Group__4__Impl" - // InternalScope.g:4428:1: rule__GlobalScopeExpression__Group__4__Impl : ( ( rule__GlobalScopeExpression__Group_4__0 )? ) ; - public final void rule__GlobalScopeExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__OpOther__Alternatives_6_1" + // InternalScope.g:4415:1: rule__OpOther__Alternatives_6_1 : ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ); + public final void rule__OpOther__Alternatives_6_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4432:1: ( ( ( rule__GlobalScopeExpression__Group_4__0 )? ) ) - // InternalScope.g:4433:1: ( ( rule__GlobalScopeExpression__Group_4__0 )? ) - { - // InternalScope.g:4433:1: ( ( rule__GlobalScopeExpression__Group_4__0 )? ) - // InternalScope.g:4434:2: ( rule__GlobalScopeExpression__Group_4__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); - } - // InternalScope.g:4435:2: ( rule__GlobalScopeExpression__Group_4__0 )? - int alt45=2; - int LA45_0 = input.LA(1); + // InternalScope.g:4419:1: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) ) + int alt35=3; + int LA35_0 = input.LA(1); - if ( (LA45_0==60) ) { - int LA45_1 = input.LA(2); + if ( (LA35_0==22) ) { + int LA35_1 = input.LA(2); - if ( (LA45_1==64) ) { - alt45=1; + if ( (synpred83_InternalScope()) ) { + alt35=1; } - } - switch (alt45) { + else if ( (synpred84_InternalScope()) ) { + alt35=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 35, 1, input); + + throw nvae; + } + } + else if ( (LA35_0==51) ) { + alt35=3; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 35, 0, input); + + throw nvae; + } + switch (alt35) { case 1 : - // InternalScope.g:4435:3: rule__GlobalScopeExpression__Group_4__0 + // InternalScope.g:4420:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // InternalScope.g:4420:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // InternalScope.g:4421:3: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // InternalScope.g:4422:3: ( rule__OpOther__Group_6_1_0__0 ) + // InternalScope.g:4422:4: rule__OpOther__Group_6_1_0__0 { pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__0(); + rule__OpOther__Group_6_1_0__0(); state._fsp--; if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + + } + + } break; + case 2 : + // InternalScope.g:4426:2: ( '<' ) + { + // InternalScope.g:4426:2: ( '<' ) + // InternalScope.g:4427:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); - } - } + } + break; + case 3 : + // InternalScope.g:4432:2: ( '=>' ) + { + // InternalScope.g:4432:2: ( '=>' ) + // InternalScope.g:4433:3: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15468,32 +16217,74 @@ public final void rule__GlobalScopeExpression__Group__4__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__4__Impl" + // $ANTLR end "rule__OpOther__Alternatives_6_1" - // $ANTLR start "rule__GlobalScopeExpression__Group__5" - // InternalScope.g:4443:1: rule__GlobalScopeExpression__Group__5 : rule__GlobalScopeExpression__Group__5__Impl rule__GlobalScopeExpression__Group__6 ; - public final void rule__GlobalScopeExpression__Group__5() throws RecognitionException { + // $ANTLR start "rule__OpAdd__Alternatives" + // InternalScope.g:4442:1: rule__OpAdd__Alternatives : ( ( '+' ) | ( '-' ) ); + public final void rule__OpAdd__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4447:1: ( rule__GlobalScopeExpression__Group__5__Impl rule__GlobalScopeExpression__Group__6 ) - // InternalScope.g:4448:2: rule__GlobalScopeExpression__Group__5__Impl rule__GlobalScopeExpression__Group__6 - { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group__5__Impl(); + // InternalScope.g:4446:1: ( ( '+' ) | ( '-' ) ) + int alt36=2; + int LA36_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__6(); - - state._fsp--; - if (state.failed) return ; + if ( (LA36_0==23) ) { + alt36=1; + } + else if ( (LA36_0==24) ) { + alt36=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 36, 0, input); + throw nvae; } + switch (alt36) { + case 1 : + // InternalScope.g:4447:2: ( '+' ) + { + // InternalScope.g:4447:2: ( '+' ) + // InternalScope.g:4448:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4453:2: ( '-' ) + { + // InternalScope.g:4453:2: ( '-' ) + // InternalScope.g:4454:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -15506,56 +16297,126 @@ public final void rule__GlobalScopeExpression__Group__5() throws RecognitionExce } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__5" + // $ANTLR end "rule__OpAdd__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group__5__Impl" - // InternalScope.g:4455:1: rule__GlobalScopeExpression__Group__5__Impl : ( ( rule__GlobalScopeExpression__Group_5__0 )? ) ; - public final void rule__GlobalScopeExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__OpMulti__Alternatives" + // InternalScope.g:4463:1: rule__OpMulti__Alternatives : ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ); + public final void rule__OpMulti__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4459:1: ( ( ( rule__GlobalScopeExpression__Group_5__0 )? ) ) - // InternalScope.g:4460:1: ( ( rule__GlobalScopeExpression__Group_5__0 )? ) - { - // InternalScope.g:4460:1: ( ( rule__GlobalScopeExpression__Group_5__0 )? ) - // InternalScope.g:4461:2: ( rule__GlobalScopeExpression__Group_5__0 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); - } - // InternalScope.g:4462:2: ( rule__GlobalScopeExpression__Group_5__0 )? - int alt46=2; - int LA46_0 = input.LA(1); + // InternalScope.g:4467:1: ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) ) + int alt37=4; + switch ( input.LA(1) ) { + case 25: + { + alt37=1; + } + break; + case 54: + { + alt37=2; + } + break; + case 26: + { + alt37=3; + } + break; + case 55: + { + alt37=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 37, 0, input); - if ( (LA46_0==60) ) { - alt46=1; + throw nvae; } - switch (alt46) { + + switch (alt37) { case 1 : - // InternalScope.g:4462:3: rule__GlobalScopeExpression__Group_5__0 + // InternalScope.g:4468:2: ( '*' ) { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5__0(); + // InternalScope.g:4468:2: ( '*' ) + // InternalScope.g:4469:3: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + + } - state._fsp--; - if (state.failed) return ; } break; + case 2 : + // InternalScope.g:4474:2: ( '**' ) + { + // InternalScope.g:4474:2: ( '**' ) + // InternalScope.g:4475:3: '**' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + match(input,54,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); - } - } + } + break; + case 3 : + // InternalScope.g:4480:2: ( '/' ) + { + // InternalScope.g:4480:2: ( '/' ) + // InternalScope.g:4481:3: '/' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + match(input,26,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + + } - } + } + break; + case 4 : + // InternalScope.g:4486:2: ( '%' ) + { + // InternalScope.g:4486:2: ( '%' ) + // InternalScope.g:4487:3: '%' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + match(input,55,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15568,27 +16429,88 @@ public final void rule__GlobalScopeExpression__Group__5__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__5__Impl" + // $ANTLR end "rule__OpMulti__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group__6" - // InternalScope.g:4470:1: rule__GlobalScopeExpression__Group__6 : rule__GlobalScopeExpression__Group__6__Impl ; - public final void rule__GlobalScopeExpression__Group__6() throws RecognitionException { + // $ANTLR start "rule__XUnaryOperation__Alternatives" + // InternalScope.g:4496:1: rule__XUnaryOperation__Alternatives : ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ); + public final void rule__XUnaryOperation__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4474:1: ( rule__GlobalScopeExpression__Group__6__Impl ) - // InternalScope.g:4475:2: rule__GlobalScopeExpression__Group__6__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group__6__Impl(); + // InternalScope.g:4500:1: ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) ) + int alt38=2; + int LA38_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( ((LA38_0>=23 && LA38_0<=24)||LA38_0==27) ) { + alt38=1; + } + else if ( ((LA38_0>=RULE_ID && LA38_0<=RULE_STRING)||LA38_0==22||(LA38_0>=36 && LA38_0<=37)||(LA38_0>=60 && LA38_0<=64)||LA38_0==72||LA38_0==77||LA38_0==79||LA38_0==82||LA38_0==97||LA38_0==100||LA38_0==103||(LA38_0>=105 && LA38_0<=112)||LA38_0==114) ) { + alt38=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 38, 0, input); + throw nvae; } + switch (alt38) { + case 1 : + // InternalScope.g:4501:2: ( ( rule__XUnaryOperation__Group_0__0 ) ) + { + // InternalScope.g:4501:2: ( ( rule__XUnaryOperation__Group_0__0 ) ) + // InternalScope.g:4502:3: ( rule__XUnaryOperation__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } + // InternalScope.g:4503:3: ( rule__XUnaryOperation__Group_0__0 ) + // InternalScope.g:4503:4: rule__XUnaryOperation__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); + } + + } + + } + break; + case 2 : + // InternalScope.g:4507:2: ( ruleXCastedExpression ) + { + // InternalScope.g:4507:2: ( ruleXCastedExpression ) + // InternalScope.g:4508:3: ruleXCastedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15601,73 +16523,102 @@ public final void rule__GlobalScopeExpression__Group__6() throws RecognitionExce } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group__6" + // $ANTLR end "rule__XUnaryOperation__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group__6__Impl" - // InternalScope.g:4481:1: rule__GlobalScopeExpression__Group__6__Impl : ( ')' ) ; - public final void rule__GlobalScopeExpression__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__OpUnary__Alternatives" + // InternalScope.g:4517:1: rule__OpUnary__Alternatives : ( ( '!' ) | ( '-' ) | ( '+' ) ); + public final void rule__OpUnary__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4485:1: ( ( ')' ) ) - // InternalScope.g:4486:1: ( ')' ) - { - // InternalScope.g:4486:1: ( ')' ) - // InternalScope.g:4487:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); - } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); - } + // InternalScope.g:4521:1: ( ( '!' ) | ( '-' ) | ( '+' ) ) + int alt39=3; + switch ( input.LA(1) ) { + case 27: + { + alt39=1; + } + break; + case 24: + { + alt39=2; + } + break; + case 23: + { + alt39=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 39, 0, input); + throw nvae; } + switch (alt39) { + case 1 : + // InternalScope.g:4522:2: ( '!' ) + { + // InternalScope.g:4522:2: ( '!' ) + // InternalScope.g:4523:3: '!' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + match(input,27,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:4528:2: ( '-' ) + { + // InternalScope.g:4528:2: ( '-' ) + // InternalScope.g:4529:3: '-' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + match(input,24,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group__6__Impl" + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__0" - // InternalScope.g:4497:1: rule__GlobalScopeExpression__Group_3_0__0 : rule__GlobalScopeExpression__Group_3_0__0__Impl rule__GlobalScopeExpression__Group_3_0__1 ; - public final void rule__GlobalScopeExpression__Group_3_0__0() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:4534:2: ( '+' ) + { + // InternalScope.g:4534:2: ( '+' ) + // InternalScope.g:4535:3: '+' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + match(input,23,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4501:1: ( rule__GlobalScopeExpression__Group_3_0__0__Impl rule__GlobalScopeExpression__Group_3_0__1 ) - // InternalScope.g:4502:2: rule__GlobalScopeExpression__Group_3_0__0__Impl rule__GlobalScopeExpression__Group_3_0__1 - { - pushFollow(FOLLOW_35); - rule__GlobalScopeExpression__Group_3_0__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_0__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15680,35 +16631,74 @@ public final void rule__GlobalScopeExpression__Group_3_0__0() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__0" + // $ANTLR end "rule__OpUnary__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__0__Impl" - // InternalScope.g:4509:1: rule__GlobalScopeExpression__Group_3_0__0__Impl : ( ',' ) ; - public final void rule__GlobalScopeExpression__Group_3_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OpPostfix__Alternatives" + // InternalScope.g:4544:1: rule__OpPostfix__Alternatives : ( ( '++' ) | ( '--' ) ); + public final void rule__OpPostfix__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4513:1: ( ( ',' ) ) - // InternalScope.g:4514:1: ( ',' ) - { - // InternalScope.g:4514:1: ( ',' ) - // InternalScope.g:4515:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); + // InternalScope.g:4548:1: ( ( '++' ) | ( '--' ) ) + int alt40=2; + int LA40_0 = input.LA(1); + + if ( (LA40_0==56) ) { + alt40=1; } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); + else if ( (LA40_0==57) ) { + alt40=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 40, 0, input); + throw nvae; } + switch (alt40) { + case 1 : + // InternalScope.g:4549:2: ( '++' ) + { + // InternalScope.g:4549:2: ( '++' ) + // InternalScope.g:4550:3: '++' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + match(input,56,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + } - } + } + break; + case 2 : + // InternalScope.g:4555:2: ( '--' ) + { + // InternalScope.g:4555:2: ( '--' ) + // InternalScope.g:4556:3: '--' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + match(input,57,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15721,32 +16711,80 @@ public final void rule__GlobalScopeExpression__Group_3_0__0__Impl() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__0__Impl" + // $ANTLR end "rule__OpPostfix__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__1" - // InternalScope.g:4524:1: rule__GlobalScopeExpression__Group_3_0__1 : rule__GlobalScopeExpression__Group_3_0__1__Impl rule__GlobalScopeExpression__Group_3_0__2 ; - public final void rule__GlobalScopeExpression__Group_3_0__1() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1" + // InternalScope.g:4565:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4528:1: ( rule__GlobalScopeExpression__Group_3_0__1__Impl rule__GlobalScopeExpression__Group_3_0__2 ) - // InternalScope.g:4529:2: rule__GlobalScopeExpression__Group_3_0__1__Impl rule__GlobalScopeExpression__Group_3_0__2 - { - pushFollow(FOLLOW_16); - rule__GlobalScopeExpression__Group_3_0__1__Impl(); + // InternalScope.g:4569:1: ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) ) + int alt41=2; + alt41 = dfa41.predict(input); + switch (alt41) { + case 1 : + // InternalScope.g:4570:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) + { + // InternalScope.g:4570:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) + // InternalScope.g:4571:3: ( rule__XMemberFeatureCall__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); + } + // InternalScope.g:4572:3: ( rule__XMemberFeatureCall__Group_1_0__0 ) + // InternalScope.g:4572:4: rule__XMemberFeatureCall__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_0__2(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4576:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) + { + // InternalScope.g:4576:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) + // InternalScope.g:4577:3: ( rule__XMemberFeatureCall__Group_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); + } + // InternalScope.g:4578:3: ( rule__XMemberFeatureCall__Group_1_1__0 ) + // InternalScope.g:4578:4: rule__XMemberFeatureCall__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -15759,73 +16797,84 @@ public final void rule__GlobalScopeExpression__Group_3_0__1() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__1" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__1__Impl" - // InternalScope.g:4536:1: rule__GlobalScopeExpression__Group_3_0__1__Impl : ( 'key' ) ; - public final void rule__GlobalScopeExpression__Group_3_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1" + // InternalScope.g:4586:1: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_0_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4540:1: ( ( 'key' ) ) - // InternalScope.g:4541:1: ( 'key' ) - { - // InternalScope.g:4541:1: ( 'key' ) - // InternalScope.g:4542:2: 'key' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); + // InternalScope.g:4590:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) ) + int alt42=2; + int LA42_0 = input.LA(1); + + if ( (LA42_0==58) ) { + alt42=1; } - match(input,62,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); + else if ( (LA42_0==93) ) { + alt42=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 42, 0, input); + throw nvae; } + switch (alt42) { + case 1 : + // InternalScope.g:4591:2: ( '.' ) + { + // InternalScope.g:4591:2: ( '.' ) + // InternalScope.g:4592:3: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + } - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:4597:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) + { + // InternalScope.g:4597:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) + // InternalScope.g:4598:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); + } + // InternalScope.g:4599:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) + // InternalScope.g:4599:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1(); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__1__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__2" - // InternalScope.g:4551:1: rule__GlobalScopeExpression__Group_3_0__2 : rule__GlobalScopeExpression__Group_3_0__2__Impl rule__GlobalScopeExpression__Group_3_0__3 ; - public final void rule__GlobalScopeExpression__Group_3_0__2() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4555:1: ( rule__GlobalScopeExpression__Group_3_0__2__Impl rule__GlobalScopeExpression__Group_3_0__3 ) - // InternalScope.g:4556:2: rule__GlobalScopeExpression__Group_3_0__2__Impl rule__GlobalScopeExpression__Group_3_0__3 - { - pushFollow(FOLLOW_17); - rule__GlobalScopeExpression__Group_3_0__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_0__3(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -15838,68 +16887,122 @@ public final void rule__GlobalScopeExpression__Group_3_0__2() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__2" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__2__Impl" - // InternalScope.g:4563:1: rule__GlobalScopeExpression__Group_3_0__2__Impl : ( '=' ) ; - public final void rule__GlobalScopeExpression__Group_3_0__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1" + // InternalScope.g:4607:1: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_1_0_0_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4567:1: ( ( '=' ) ) - // InternalScope.g:4568:1: ( '=' ) - { - // InternalScope.g:4568:1: ( '=' ) - // InternalScope.g:4569:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); - } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); - } + // InternalScope.g:4611:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) ) + int alt43=3; + switch ( input.LA(1) ) { + case 58: + { + alt43=1; + } + break; + case 121: + { + alt43=2; + } + break; + case 93: + { + alt43=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 43, 0, input); + throw nvae; } + switch (alt43) { + case 1 : + // InternalScope.g:4612:2: ( '.' ) + { + // InternalScope.g:4612:2: ( '.' ) + // InternalScope.g:4613:3: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:4618:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) + { + // InternalScope.g:4618:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) + // InternalScope.g:4619:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); + } + // InternalScope.g:4620:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) + // InternalScope.g:4620:4: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1(); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__2__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__3" - // InternalScope.g:4578:1: rule__GlobalScopeExpression__Group_3_0__3 : rule__GlobalScopeExpression__Group_3_0__3__Impl ; - public final void rule__GlobalScopeExpression__Group_3_0__3() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4582:1: ( rule__GlobalScopeExpression__Group_3_0__3__Impl ) - // InternalScope.g:4583:2: rule__GlobalScopeExpression__Group_3_0__3__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_0__3__Impl(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + case 3 : + // InternalScope.g:4624:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) + { + // InternalScope.g:4624:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) + // InternalScope.g:4625:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); + } + // InternalScope.g:4626:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) + // InternalScope.g:4626:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15912,45 +17015,80 @@ public final void rule__GlobalScopeExpression__Group_3_0__3() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__3" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__3__Impl" - // InternalScope.g:4589:1: rule__GlobalScopeExpression__Group_3_0__3__Impl : ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) ; - public final void rule__GlobalScopeExpression__Group_3_0__3__Impl() throws RecognitionException { + // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_3_1" + // InternalScope.g:4634:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) ); + public final void rule__XMemberFeatureCall__Alternatives_1_1_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4593:1: ( ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) ) - // InternalScope.g:4594:1: ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) - { - // InternalScope.g:4594:1: ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) - // InternalScope.g:4595:2: ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); - } - // InternalScope.g:4596:2: ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) - // InternalScope.g:4596:3: rule__GlobalScopeExpression__NameAssignment_3_0_3 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__NameAssignment_3_0_3(); + // InternalScope.g:4638:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) ) + int alt44=2; + alt44 = dfa44.predict(input); + switch (alt44) { + case 1 : + // InternalScope.g:4639:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + { + // InternalScope.g:4639:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + // InternalScope.g:4640:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + // InternalScope.g:4641:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + // InternalScope.g:4641:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } - } + } - } + } + break; + case 2 : + // InternalScope.g:4645:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) + { + // InternalScope.g:4645:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) + // InternalScope.g:4646:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); + } + // InternalScope.g:4647:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) + // InternalScope.g:4647:4: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -15963,252 +17101,379 @@ public final void rule__GlobalScopeExpression__Group_3_0__3__Impl() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__3__Impl" + // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_3_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__0" - // InternalScope.g:4605:1: rule__GlobalScopeExpression__Group_3_1__0 : rule__GlobalScopeExpression__Group_3_1__0__Impl rule__GlobalScopeExpression__Group_3_1__1 ; - public final void rule__GlobalScopeExpression__Group_3_1__0() throws RecognitionException { + // $ANTLR start "rule__XPrimaryExpression__Alternatives" + // InternalScope.g:4655:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) ); + public final void rule__XPrimaryExpression__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4609:1: ( rule__GlobalScopeExpression__Group_3_1__0__Impl rule__GlobalScopeExpression__Group_3_1__1 ) - // InternalScope.g:4610:2: rule__GlobalScopeExpression__Group_3_1__0__Impl rule__GlobalScopeExpression__Group_3_1__1 - { - pushFollow(FOLLOW_36); - rule__GlobalScopeExpression__Group_3_1__0__Impl(); + // InternalScope.g:4659:1: ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) ) + int alt45=15; + alt45 = dfa45.predict(input); + switch (alt45) { + case 1 : + // InternalScope.g:4660:2: ( ruleXConstructorCall ) + { + // InternalScope.g:4660:2: ( ruleXConstructorCall ) + // InternalScope.g:4661:3: ruleXConstructorCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXConstructorCall(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_1__1(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } - state._fsp--; - if (state.failed) return ; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 2 : + // InternalScope.g:4666:2: ( ruleXBlockExpression ) + { + // InternalScope.g:4666:2: ( ruleXBlockExpression ) + // InternalScope.g:4667:3: ruleXBlockExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXBlockExpression(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__0" + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__0__Impl" - // InternalScope.g:4617:1: rule__GlobalScopeExpression__Group_3_1__0__Impl : ( ',' ) ; - public final void rule__GlobalScopeExpression__Group_3_1__0__Impl() throws RecognitionException { + } + break; + case 3 : + // InternalScope.g:4672:2: ( ruleXSwitchExpression ) + { + // InternalScope.g:4672:2: ( ruleXSwitchExpression ) + // InternalScope.g:4673:3: ruleXSwitchExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleXSwitchExpression(); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4621:1: ( ( ',' ) ) - // InternalScope.g:4622:1: ( ',' ) - { - // InternalScope.g:4622:1: ( ',' ) - // InternalScope.g:4623:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); - } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } - } + } - } + } + break; + case 4 : + // InternalScope.g:4678:2: ( ( ruleXSynchronizedExpression ) ) + { + // InternalScope.g:4678:2: ( ( ruleXSynchronizedExpression ) ) + // InternalScope.g:4679:3: ( ruleXSynchronizedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + // InternalScope.g:4680:3: ( ruleXSynchronizedExpression ) + // InternalScope.g:4680:4: ruleXSynchronizedExpression + { + pushFollow(FOLLOW_2); + ruleXSynchronizedExpression(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__0__Impl" + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__1" - // InternalScope.g:4632:1: rule__GlobalScopeExpression__Group_3_1__1 : rule__GlobalScopeExpression__Group_3_1__1__Impl rule__GlobalScopeExpression__Group_3_1__2 ; - public final void rule__GlobalScopeExpression__Group_3_1__1() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4636:1: ( rule__GlobalScopeExpression__Group_3_1__1__Impl rule__GlobalScopeExpression__Group_3_1__2 ) - // InternalScope.g:4637:2: rule__GlobalScopeExpression__Group_3_1__1__Impl rule__GlobalScopeExpression__Group_3_1__2 - { - pushFollow(FOLLOW_36); - rule__GlobalScopeExpression__Group_3_1__1__Impl(); + } + break; + case 5 : + // InternalScope.g:4684:2: ( ruleXFeatureCall ) + { + // InternalScope.g:4684:2: ( ruleXFeatureCall ) + // InternalScope.g:4685:3: ruleXFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleXFeatureCall(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_1__2(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } - state._fsp--; - if (state.failed) return ; + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 6 : + // InternalScope.g:4690:2: ( ruleXLiteral ) + { + // InternalScope.g:4690:2: ( ruleXLiteral ) + // InternalScope.g:4691:3: ruleXLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleXLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__1" + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__1__Impl" - // InternalScope.g:4644:1: rule__GlobalScopeExpression__Group_3_1__1__Impl : ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) ; - public final void rule__GlobalScopeExpression__Group_3_1__1__Impl() throws RecognitionException { + } + break; + case 7 : + // InternalScope.g:4696:2: ( ruleXIfExpression ) + { + // InternalScope.g:4696:2: ( ruleXIfExpression ) + // InternalScope.g:4697:3: ruleXIfExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } + pushFollow(FOLLOW_2); + ruleXIfExpression(); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4648:1: ( ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) ) - // InternalScope.g:4649:1: ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) - { - // InternalScope.g:4649:1: ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) - // InternalScope.g:4650:2: ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); - } - // InternalScope.g:4651:2: ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? - int alt47=2; - int LA47_0 = input.LA(1); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } - if ( (LA47_0==80) ) { - alt47=1; - } - switch (alt47) { - case 1 : - // InternalScope.g:4651:3: rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 + } + + + } + break; + case 8 : + // InternalScope.g:4702:2: ( ( ruleXForLoopExpression ) ) + { + // InternalScope.g:4702:2: ( ( ruleXForLoopExpression ) ) + // InternalScope.g:4703:3: ( ruleXForLoopExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + // InternalScope.g:4704:3: ( ruleXForLoopExpression ) + // InternalScope.g:4704:4: ruleXForLoopExpression { pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1(); + ruleXForLoopExpression(); state._fsp--; if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + + } + + } break; + case 9 : + // InternalScope.g:4708:2: ( ruleXBasicForLoopExpression ) + { + // InternalScope.g:4708:2: ( ruleXBasicForLoopExpression ) + // InternalScope.g:4709:3: ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + pushFollow(FOLLOW_2); + ruleXBasicForLoopExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); - } + } - } + } + break; + case 10 : + // InternalScope.g:4714:2: ( ruleXWhileExpression ) + { + // InternalScope.g:4714:2: ( ruleXWhileExpression ) + // InternalScope.g:4715:3: ruleXWhileExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } + pushFollow(FOLLOW_2); + ruleXWhileExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__1__Impl" + } + break; + case 11 : + // InternalScope.g:4720:2: ( ruleXDoWhileExpression ) + { + // InternalScope.g:4720:2: ( ruleXDoWhileExpression ) + // InternalScope.g:4721:3: ruleXDoWhileExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } + pushFollow(FOLLOW_2); + ruleXDoWhileExpression(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__2" - // InternalScope.g:4659:1: rule__GlobalScopeExpression__Group_3_1__2 : rule__GlobalScopeExpression__Group_3_1__2__Impl rule__GlobalScopeExpression__Group_3_1__3 ; - public final void rule__GlobalScopeExpression__Group_3_1__2() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4663:1: ( rule__GlobalScopeExpression__Group_3_1__2__Impl rule__GlobalScopeExpression__Group_3_1__3 ) - // InternalScope.g:4664:2: rule__GlobalScopeExpression__Group_3_1__2__Impl rule__GlobalScopeExpression__Group_3_1__3 - { - pushFollow(FOLLOW_16); - rule__GlobalScopeExpression__Group_3_1__2__Impl(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_1__3(); + } + break; + case 12 : + // InternalScope.g:4726:2: ( ruleXThrowExpression ) + { + // InternalScope.g:4726:2: ( ruleXThrowExpression ) + // InternalScope.g:4727:3: ruleXThrowExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } + pushFollow(FOLLOW_2); + ruleXThrowExpression(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 13 : + // InternalScope.g:4732:2: ( ruleXReturnExpression ) + { + // InternalScope.g:4732:2: ( ruleXReturnExpression ) + // InternalScope.g:4733:3: ruleXReturnExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + pushFollow(FOLLOW_2); + ruleXReturnExpression(); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__2" + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__2__Impl" - // InternalScope.g:4671:1: rule__GlobalScopeExpression__Group_3_1__2__Impl : ( 'prefix' ) ; - public final void rule__GlobalScopeExpression__Group_3_1__2__Impl() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4675:1: ( ( 'prefix' ) ) - // InternalScope.g:4676:1: ( 'prefix' ) - { - // InternalScope.g:4676:1: ( 'prefix' ) - // InternalScope.g:4677:2: 'prefix' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); - } - match(input,63,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); - } + } + break; + case 14 : + // InternalScope.g:4738:2: ( ruleXTryCatchFinallyExpression ) + { + // InternalScope.g:4738:2: ( ruleXTryCatchFinallyExpression ) + // InternalScope.g:4739:3: ruleXTryCatchFinallyExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + pushFollow(FOLLOW_2); + ruleXTryCatchFinallyExpression(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + } - } + } + break; + case 15 : + // InternalScope.g:4744:2: ( ruleXParenthesizedExpression ) + { + // InternalScope.g:4744:2: ( ruleXParenthesizedExpression ) + // InternalScope.g:4745:3: ruleXParenthesizedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + pushFollow(FOLLOW_2); + ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16221,106 +17486,235 @@ public final void rule__GlobalScopeExpression__Group_3_1__2__Impl() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__2__Impl" + // $ANTLR end "rule__XPrimaryExpression__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__3" - // InternalScope.g:4686:1: rule__GlobalScopeExpression__Group_3_1__3 : rule__GlobalScopeExpression__Group_3_1__3__Impl rule__GlobalScopeExpression__Group_3_1__4 ; - public final void rule__GlobalScopeExpression__Group_3_1__3() throws RecognitionException { + // $ANTLR start "rule__XLiteral__Alternatives" + // InternalScope.g:4754:1: rule__XLiteral__Alternatives : ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) ); + public final void rule__XLiteral__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4690:1: ( rule__GlobalScopeExpression__Group_3_1__3__Impl rule__GlobalScopeExpression__Group_3_1__4 ) - // InternalScope.g:4691:2: rule__GlobalScopeExpression__Group_3_1__3__Impl rule__GlobalScopeExpression__Group_3_1__4 - { - pushFollow(FOLLOW_17); - rule__GlobalScopeExpression__Group_3_1__3__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_1__4(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:4758:1: ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) ) + int alt46=7; + switch ( input.LA(1) ) { + case 79: + { + alt46=1; + } + break; + case 82: + { + alt46=2; + } + break; + case 36: + case 37: + { + alt46=3; + } + break; + case RULE_HEX: + case RULE_INT: + case RULE_DECIMAL: + { + alt46=4; + } + break; + case 108: + { + alt46=5; + } + break; + case RULE_STRING: + { + alt46=6; + } + break; + case 109: + { + alt46=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 46, 0, input); + throw nvae; } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + switch (alt46) { + case 1 : + // InternalScope.g:4759:2: ( ruleXCollectionLiteral ) + { + // InternalScope.g:4759:2: ( ruleXCollectionLiteral ) + // InternalScope.g:4760:3: ruleXCollectionLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXCollectionLiteral(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__3" + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__3__Impl" - // InternalScope.g:4698:1: rule__GlobalScopeExpression__Group_3_1__3__Impl : ( '=' ) ; - public final void rule__GlobalScopeExpression__Group_3_1__3__Impl() throws RecognitionException { + } + break; + case 2 : + // InternalScope.g:4765:2: ( ( ruleXClosure ) ) + { + // InternalScope.g:4765:2: ( ( ruleXClosure ) ) + // InternalScope.g:4766:3: ( ruleXClosure ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } + // InternalScope.g:4767:3: ( ruleXClosure ) + // InternalScope.g:4767:4: ruleXClosure + { + pushFollow(FOLLOW_2); + ruleXClosure(); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4702:1: ( ( '=' ) ) - // InternalScope.g:4703:1: ( '=' ) - { - // InternalScope.g:4703:1: ( '=' ) - // InternalScope.g:4704:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); - } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); - } + state._fsp--; + if (state.failed) return ; - } + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 3 : + // InternalScope.g:4771:2: ( ruleXBooleanLiteral ) + { + // InternalScope.g:4771:2: ( ruleXBooleanLiteral ) + // InternalScope.g:4772:3: ruleXBooleanLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + pushFollow(FOLLOW_2); + ruleXBooleanLiteral(); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__3__Impl" + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + } - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__4" - // InternalScope.g:4713:1: rule__GlobalScopeExpression__Group_3_1__4 : rule__GlobalScopeExpression__Group_3_1__4__Impl ; - public final void rule__GlobalScopeExpression__Group_3_1__4() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4717:1: ( rule__GlobalScopeExpression__Group_3_1__4__Impl ) - // InternalScope.g:4718:2: rule__GlobalScopeExpression__Group_3_1__4__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_3_1__4__Impl(); + } + break; + case 4 : + // InternalScope.g:4777:2: ( ruleXNumberLiteral ) + { + // InternalScope.g:4777:2: ( ruleXNumberLiteral ) + // InternalScope.g:4778:3: ruleXNumberLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + pushFollow(FOLLOW_2); + ruleXNumberLiteral(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + + } + + + } + break; + case 5 : + // InternalScope.g:4783:2: ( ruleXNullLiteral ) + { + // InternalScope.g:4783:2: ( ruleXNullLiteral ) + // InternalScope.g:4784:3: ruleXNullLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + pushFollow(FOLLOW_2); + ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + + } + + + } + break; + case 6 : + // InternalScope.g:4789:2: ( ruleXStringLiteral ) + { + // InternalScope.g:4789:2: ( ruleXStringLiteral ) + // InternalScope.g:4790:3: ruleXStringLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + pushFollow(FOLLOW_2); + ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + + } + + + } + break; + case 7 : + // InternalScope.g:4795:2: ( ruleXTypeLiteral ) + { + // InternalScope.g:4795:2: ( ruleXTypeLiteral ) + // InternalScope.g:4796:3: ruleXTypeLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + pushFollow(FOLLOW_2); + ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16333,45 +17727,93 @@ public final void rule__GlobalScopeExpression__Group_3_1__4() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__4" + // $ANTLR end "rule__XLiteral__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__4__Impl" - // InternalScope.g:4724:1: rule__GlobalScopeExpression__Group_3_1__4__Impl : ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) ; - public final void rule__GlobalScopeExpression__Group_3_1__4__Impl() throws RecognitionException { + // $ANTLR start "rule__XCollectionLiteral__Alternatives" + // InternalScope.g:4805:1: rule__XCollectionLiteral__Alternatives : ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) ); + public final void rule__XCollectionLiteral__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4728:1: ( ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) ) - // InternalScope.g:4729:1: ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) - { - // InternalScope.g:4729:1: ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) - // InternalScope.g:4730:2: ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); - } - // InternalScope.g:4731:2: ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) - // InternalScope.g:4731:3: rule__GlobalScopeExpression__PrefixAssignment_3_1_4 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__PrefixAssignment_3_1_4(); + // InternalScope.g:4809:1: ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) ) + int alt47=2; + int LA47_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA47_0==79) ) { + int LA47_1 = input.LA(2); - } + if ( (LA47_1==72) ) { + alt47=1; + } + else if ( (LA47_1==82) ) { + alt47=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 47, 1, input); - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); + throw nvae; + } } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 47, 0, input); + throw nvae; } + switch (alt47) { + case 1 : + // InternalScope.g:4810:2: ( ruleXSetLiteral ) + { + // InternalScope.g:4810:2: ( ruleXSetLiteral ) + // InternalScope.g:4811:3: ruleXSetLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + + } - } + } + break; + case 2 : + // InternalScope.g:4816:2: ( ruleXListLiteral ) + { + // InternalScope.g:4816:2: ( ruleXListLiteral ) + // InternalScope.g:4817:3: ruleXListLiteral + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXListLiteral(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16384,32 +17826,80 @@ public final void rule__GlobalScopeExpression__Group_3_1__4__Impl() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__4__Impl" + // $ANTLR end "rule__XCollectionLiteral__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__0" - // InternalScope.g:4740:1: rule__GlobalScopeExpression__Group_4__0 : rule__GlobalScopeExpression__Group_4__0__Impl rule__GlobalScopeExpression__Group_4__1 ; - public final void rule__GlobalScopeExpression__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__XSwitchExpression__Alternatives_2" + // InternalScope.g:4826:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) ); + public final void rule__XSwitchExpression__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4744:1: ( rule__GlobalScopeExpression__Group_4__0__Impl rule__GlobalScopeExpression__Group_4__1 ) - // InternalScope.g:4745:2: rule__GlobalScopeExpression__Group_4__0__Impl rule__GlobalScopeExpression__Group_4__1 - { - pushFollow(FOLLOW_37); - rule__GlobalScopeExpression__Group_4__0__Impl(); + // InternalScope.g:4830:1: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) ) + int alt48=2; + alt48 = dfa48.predict(input); + switch (alt48) { + case 1 : + // InternalScope.g:4831:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + { + // InternalScope.g:4831:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + // InternalScope.g:4832:3: ( rule__XSwitchExpression__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + // InternalScope.g:4833:3: ( rule__XSwitchExpression__Group_2_0__0 ) + // InternalScope.g:4833:4: rule__XSwitchExpression__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__1(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4837:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) ) + { + // InternalScope.g:4837:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) ) + // InternalScope.g:4838:3: ( rule__XSwitchExpression__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); + } + // InternalScope.g:4839:3: ( rule__XSwitchExpression__Group_2_1__0 ) + // InternalScope.g:4839:4: rule__XSwitchExpression__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16422,73 +17912,94 @@ public final void rule__GlobalScopeExpression__Group_4__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__0" + // $ANTLR end "rule__XSwitchExpression__Alternatives_2" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__0__Impl" - // InternalScope.g:4752:1: rule__GlobalScopeExpression__Group_4__0__Impl : ( ',' ) ; - public final void rule__GlobalScopeExpression__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XCasePart__Alternatives_3" + // InternalScope.g:4847:1: rule__XCasePart__Alternatives_3 : ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) ); + public final void rule__XCasePart__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4756:1: ( ( ',' ) ) - // InternalScope.g:4757:1: ( ',' ) - { - // InternalScope.g:4757:1: ( ',' ) - // InternalScope.g:4758:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); + // InternalScope.g:4851:1: ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) ) + int alt49=2; + int LA49_0 = input.LA(1); + + if ( (LA49_0==95) ) { + alt49=1; } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); + else if ( (LA49_0==86) ) { + alt49=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 49, 0, input); + throw nvae; } + switch (alt49) { + case 1 : + // InternalScope.g:4852:2: ( ( rule__XCasePart__Group_3_0__0 ) ) + { + // InternalScope.g:4852:2: ( ( rule__XCasePart__Group_3_0__0 ) ) + // InternalScope.g:4853:3: ( rule__XCasePart__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup_3_0()); + } + // InternalScope.g:4854:3: ( rule__XCasePart__Group_3_0__0 ) + // InternalScope.g:4854:4: rule__XCasePart__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__0(); + state._fsp--; + if (state.failed) return ; - } + } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getGroup_3_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__0__Impl" + } + break; + case 2 : + // InternalScope.g:4858:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) + { + // InternalScope.g:4858:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) + // InternalScope.g:4859:3: ( rule__XCasePart__FallThroughAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); + } + // InternalScope.g:4860:3: ( rule__XCasePart__FallThroughAssignment_3_1 ) + // InternalScope.g:4860:4: rule__XCasePart__FallThroughAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__FallThroughAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__GlobalScopeExpression__Group_4__1" - // InternalScope.g:4767:1: rule__GlobalScopeExpression__Group_4__1 : rule__GlobalScopeExpression__Group_4__1__Impl rule__GlobalScopeExpression__Group_4__2 ; - public final void rule__GlobalScopeExpression__Group_4__1() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4771:1: ( rule__GlobalScopeExpression__Group_4__1__Impl rule__GlobalScopeExpression__Group_4__2 ) - // InternalScope.g:4772:2: rule__GlobalScopeExpression__Group_4__1__Impl rule__GlobalScopeExpression__Group_4__2 - { - pushFollow(FOLLOW_16); - rule__GlobalScopeExpression__Group_4__1__Impl(); + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__2(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16501,73 +18012,82 @@ public final void rule__GlobalScopeExpression__Group_4__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__1" + // $ANTLR end "rule__XCasePart__Alternatives_3" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__1__Impl" - // InternalScope.g:4779:1: rule__GlobalScopeExpression__Group_4__1__Impl : ( 'data' ) ; - public final void rule__GlobalScopeExpression__Group_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__XExpressionOrVarDeclaration__Alternatives" + // InternalScope.g:4868:1: rule__XExpressionOrVarDeclaration__Alternatives : ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) ); + public final void rule__XExpressionOrVarDeclaration__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4783:1: ( ( 'data' ) ) - // InternalScope.g:4784:1: ( 'data' ) - { - // InternalScope.g:4784:1: ( 'data' ) - // InternalScope.g:4785:2: 'data' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); - } - match(input,64,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); - } + // InternalScope.g:4872:1: ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) ) + int alt50=2; + int LA50_0 = input.LA(1); + if ( (LA50_0==59||LA50_0==122) ) { + alt50=1; } + else if ( ((LA50_0>=RULE_ID && LA50_0<=RULE_STRING)||(LA50_0>=22 && LA50_0<=24)||LA50_0==27||(LA50_0>=36 && LA50_0<=37)||(LA50_0>=60 && LA50_0<=64)||LA50_0==72||LA50_0==77||LA50_0==79||LA50_0==82||LA50_0==97||LA50_0==100||LA50_0==103||(LA50_0>=105 && LA50_0<=112)||LA50_0==114) ) { + alt50=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 50, 0, input); - + throw nvae; } + switch (alt50) { + case 1 : + // InternalScope.g:4873:2: ( ruleXVariableDeclaration ) + { + // InternalScope.g:4873:2: ( ruleXVariableDeclaration ) + // InternalScope.g:4874:3: ruleXVariableDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXVariableDeclaration(); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__1__Impl" + } + break; + case 2 : + // InternalScope.g:4879:2: ( ruleXExpression ) + { + // InternalScope.g:4879:2: ( ruleXExpression ) + // InternalScope.g:4880:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); - // $ANTLR start "rule__GlobalScopeExpression__Group_4__2" - // InternalScope.g:4794:1: rule__GlobalScopeExpression__Group_4__2 : rule__GlobalScopeExpression__Group_4__2__Impl rule__GlobalScopeExpression__Group_4__3 ; - public final void rule__GlobalScopeExpression__Group_4__2() throws RecognitionException { + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4798:1: ( rule__GlobalScopeExpression__Group_4__2__Impl rule__GlobalScopeExpression__Group_4__3 ) - // InternalScope.g:4799:2: rule__GlobalScopeExpression__Group_4__2__Impl rule__GlobalScopeExpression__Group_4__3 - { - pushFollow(FOLLOW_31); - rule__GlobalScopeExpression__Group_4__2__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__3(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -16580,35 +18100,84 @@ public final void rule__GlobalScopeExpression__Group_4__2() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__2" + // $ANTLR end "rule__XExpressionOrVarDeclaration__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__2__Impl" - // InternalScope.g:4806:1: rule__GlobalScopeExpression__Group_4__2__Impl : ( '=' ) ; - public final void rule__GlobalScopeExpression__Group_4__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XVariableDeclaration__Alternatives_1" + // InternalScope.g:4889:1: rule__XVariableDeclaration__Alternatives_1 : ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) ); + public final void rule__XVariableDeclaration__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4810:1: ( ( '=' ) ) - // InternalScope.g:4811:1: ( '=' ) - { - // InternalScope.g:4811:1: ( '=' ) - // InternalScope.g:4812:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); + // InternalScope.g:4893:1: ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) ) + int alt51=2; + int LA51_0 = input.LA(1); + + if ( (LA51_0==122) ) { + alt51=1; } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); + else if ( (LA51_0==59) ) { + alt51=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 51, 0, input); + throw nvae; } + switch (alt51) { + case 1 : + // InternalScope.g:4894:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) + { + // InternalScope.g:4894:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) + // InternalScope.g:4895:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); + } + // InternalScope.g:4896:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) + // InternalScope.g:4896:4: rule__XVariableDeclaration__WriteableAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__WriteableAssignment_1_0(); + + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4900:2: ( 'val' ) + { + // InternalScope.g:4900:2: ( 'val' ) + // InternalScope.g:4901:3: 'val' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + match(input,59,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16621,73 +18190,108 @@ public final void rule__GlobalScopeExpression__Group_4__2__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__2__Impl" + // $ANTLR end "rule__XVariableDeclaration__Alternatives_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__3" - // InternalScope.g:4821:1: rule__GlobalScopeExpression__Group_4__3 : rule__GlobalScopeExpression__Group_4__3__Impl rule__GlobalScopeExpression__Group_4__4 ; - public final void rule__GlobalScopeExpression__Group_4__3() throws RecognitionException { + // $ANTLR start "rule__XVariableDeclaration__Alternatives_2" + // InternalScope.g:4910:1: rule__XVariableDeclaration__Alternatives_2 : ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) ); + public final void rule__XVariableDeclaration__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4825:1: ( rule__GlobalScopeExpression__Group_4__3__Impl rule__GlobalScopeExpression__Group_4__4 ) - // InternalScope.g:4826:2: rule__GlobalScopeExpression__Group_4__3__Impl rule__GlobalScopeExpression__Group_4__4 - { - pushFollow(FOLLOW_38); - rule__GlobalScopeExpression__Group_4__3__Impl(); + // InternalScope.g:4914:1: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) ) + int alt52=2; + int LA52_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__4(); + if ( (LA52_0==RULE_ID) ) { + int LA52_1 = input.LA(2); - state._fsp--; - if (state.failed) return ; + if ( (synpred123_InternalScope()) ) { + alt52=1; + } + else if ( (true) ) { + alt52=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 52, 1, input); + throw nvae; + } } + else if ( (LA52_0==51||LA52_0==77) ) { + alt52=1; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 52, 0, input); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + throw nvae; + } + switch (alt52) { + case 1 : + // InternalScope.g:4915:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + { + // InternalScope.g:4915:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + // InternalScope.g:4916:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + // InternalScope.g:4917:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + // InternalScope.g:4917:4: rule__XVariableDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0(); - restoreStackSize(stackSize); + state._fsp--; + if (state.failed) return ; - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__3" + } + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } - // $ANTLR start "rule__GlobalScopeExpression__Group_4__3__Impl" - // InternalScope.g:4833:1: rule__GlobalScopeExpression__Group_4__3__Impl : ( '(' ) ; - public final void rule__GlobalScopeExpression__Group_4__3__Impl() throws RecognitionException { + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4837:1: ( ( '(' ) ) - // InternalScope.g:4838:1: ( '(' ) - { - // InternalScope.g:4838:1: ( '(' ) - // InternalScope.g:4839:2: '(' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); - } - match(input,51,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); - } - } + } + break; + case 2 : + // InternalScope.g:4921:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) + { + // InternalScope.g:4921:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) + // InternalScope.g:4922:3: ( rule__XVariableDeclaration__NameAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); + } + // InternalScope.g:4923:3: ( rule__XVariableDeclaration__NameAssignment_2_1 ) + // InternalScope.g:4923:4: rule__XVariableDeclaration__NameAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__NameAssignment_2_1(); + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16700,32 +18304,80 @@ public final void rule__GlobalScopeExpression__Group_4__3__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__3__Impl" + // $ANTLR end "rule__XVariableDeclaration__Alternatives_2" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__4" - // InternalScope.g:4848:1: rule__GlobalScopeExpression__Group_4__4 : rule__GlobalScopeExpression__Group_4__4__Impl rule__GlobalScopeExpression__Group_4__5 ; - public final void rule__GlobalScopeExpression__Group_4__4() throws RecognitionException { + // $ANTLR start "rule__XFeatureCall__Alternatives_3_1" + // InternalScope.g:4931:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) ); + public final void rule__XFeatureCall__Alternatives_3_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4852:1: ( rule__GlobalScopeExpression__Group_4__4__Impl rule__GlobalScopeExpression__Group_4__5 ) - // InternalScope.g:4853:2: rule__GlobalScopeExpression__Group_4__4__Impl rule__GlobalScopeExpression__Group_4__5 - { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group_4__4__Impl(); + // InternalScope.g:4935:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) ) + int alt53=2; + alt53 = dfa53.predict(input); + switch (alt53) { + case 1 : + // InternalScope.g:4936:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + { + // InternalScope.g:4936:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + // InternalScope.g:4937:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + // InternalScope.g:4938:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + // InternalScope.g:4938:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__5(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:4942:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) + { + // InternalScope.g:4942:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) + // InternalScope.g:4943:3: ( rule__XFeatureCall__Group_3_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); + } + // InternalScope.g:4944:3: ( rule__XFeatureCall__Group_3_1_1__0 ) + // InternalScope.g:4944:4: rule__XFeatureCall__Group_3_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); + } + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -16738,83 +18390,154 @@ public final void rule__GlobalScopeExpression__Group_4__4() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__4" + // $ANTLR end "rule__XFeatureCall__Alternatives_3_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__4__Impl" - // InternalScope.g:4860:1: rule__GlobalScopeExpression__Group_4__4__Impl : ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) ; - public final void rule__GlobalScopeExpression__Group_4__4__Impl() throws RecognitionException { + // $ANTLR start "rule__FeatureCallID__Alternatives" + // InternalScope.g:4952:1: rule__FeatureCallID__Alternatives : ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) ); + public final void rule__FeatureCallID__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4864:1: ( ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) ) - // InternalScope.g:4865:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) - { - // InternalScope.g:4865:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) - // InternalScope.g:4866:2: ( rule__GlobalScopeExpression__DataAssignment_4_4 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); + // InternalScope.g:4956:1: ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) ) + int alt54=5; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt54=1; + } + break; + case 60: + { + alt54=2; + } + break; + case 61: + { + alt54=3; + } + break; + case 62: + { + alt54=4; + } + break; + case 63: + { + alt54=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 54, 0, input); + + throw nvae; } - // InternalScope.g:4867:2: ( rule__GlobalScopeExpression__DataAssignment_4_4 ) - // InternalScope.g:4867:3: rule__GlobalScopeExpression__DataAssignment_4_4 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__DataAssignment_4_4(); - state._fsp--; - if (state.failed) return ; + switch (alt54) { + case 1 : + // InternalScope.g:4957:2: ( ruleValidID ) + { + // InternalScope.g:4957:2: ( ruleValidID ) + // InternalScope.g:4958:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); - } + } - } + } + break; + case 2 : + // InternalScope.g:4963:2: ( 'extends' ) + { + // InternalScope.g:4963:2: ( 'extends' ) + // InternalScope.g:4964:3: 'extends' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + match(input,60,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + + } - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + } + break; + case 3 : + // InternalScope.g:4969:2: ( 'static' ) + { + // InternalScope.g:4969:2: ( 'static' ) + // InternalScope.g:4970:3: 'static' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + match(input,61,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } - restoreStackSize(stackSize); + } - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__4__Impl" + } + break; + case 4 : + // InternalScope.g:4975:2: ( 'import' ) + { + // InternalScope.g:4975:2: ( 'import' ) + // InternalScope.g:4976:3: 'import' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + match(input,62,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + + } - // $ANTLR start "rule__GlobalScopeExpression__Group_4__5" - // InternalScope.g:4875:1: rule__GlobalScopeExpression__Group_4__5 : rule__GlobalScopeExpression__Group_4__5__Impl rule__GlobalScopeExpression__Group_4__6 ; - public final void rule__GlobalScopeExpression__Group_4__5() throws RecognitionException { - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4879:1: ( rule__GlobalScopeExpression__Group_4__5__Impl rule__GlobalScopeExpression__Group_4__6 ) - // InternalScope.g:4880:2: rule__GlobalScopeExpression__Group_4__5__Impl rule__GlobalScopeExpression__Group_4__6 - { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group_4__5__Impl(); + } + break; + case 5 : + // InternalScope.g:4981:2: ( 'extension' ) + { + // InternalScope.g:4981:2: ( 'extension' ) + // InternalScope.g:4982:3: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__6(); + } - state._fsp--; - if (state.failed) return ; - } + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16827,63 +18550,78 @@ public final void rule__GlobalScopeExpression__Group_4__5() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__5" + // $ANTLR end "rule__FeatureCallID__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__5__Impl" - // InternalScope.g:4887:1: rule__GlobalScopeExpression__Group_4__5__Impl : ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) ; - public final void rule__GlobalScopeExpression__Group_4__5__Impl() throws RecognitionException { + // $ANTLR start "rule__IdOrSuper__Alternatives" + // InternalScope.g:4991:1: rule__IdOrSuper__Alternatives : ( ( ruleFeatureCallID ) | ( 'super' ) ); + public final void rule__IdOrSuper__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4891:1: ( ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) ) - // InternalScope.g:4892:1: ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) - { - // InternalScope.g:4892:1: ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) - // InternalScope.g:4893:2: ( rule__GlobalScopeExpression__Group_4_5__0 )* - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); - } - // InternalScope.g:4894:2: ( rule__GlobalScopeExpression__Group_4_5__0 )* - loop48: - do { - int alt48=2; - int LA48_0 = input.LA(1); + // InternalScope.g:4995:1: ( ( ruleFeatureCallID ) | ( 'super' ) ) + int alt55=2; + int LA55_0 = input.LA(1); - if ( (LA48_0==60) ) { - alt48=1; - } + if ( (LA55_0==RULE_ID||(LA55_0>=60 && LA55_0<=63)) ) { + alt55=1; + } + else if ( (LA55_0==64) ) { + alt55=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 55, 0, input); + throw nvae; + } + switch (alt55) { + case 1 : + // InternalScope.g:4996:2: ( ruleFeatureCallID ) + { + // InternalScope.g:4996:2: ( ruleFeatureCallID ) + // InternalScope.g:4997:3: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); - switch (alt48) { - case 1 : - // InternalScope.g:4894:3: rule__GlobalScopeExpression__Group_4_5__0 - { - pushFollow(FOLLOW_39); - rule__GlobalScopeExpression__Group_4_5__0(); + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } - state._fsp--; - if (state.failed) return ; + } - } - break; - default : - break loop48; - } - } while (true); + } + break; + case 2 : + // InternalScope.g:5002:2: ( 'super' ) + { + // InternalScope.g:5002:2: ( 'super' ) + // InternalScope.g:5003:3: 'super' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + match(input,64,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); - } + } - } + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -16896,27 +18634,80 @@ public final void rule__GlobalScopeExpression__Group_4__5__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__5__Impl" + // $ANTLR end "rule__IdOrSuper__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__6" - // InternalScope.g:4902:1: rule__GlobalScopeExpression__Group_4__6 : rule__GlobalScopeExpression__Group_4__6__Impl ; - public final void rule__GlobalScopeExpression__Group_4__6() throws RecognitionException { + // $ANTLR start "rule__XConstructorCall__Alternatives_4_1" + // InternalScope.g:5012:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) ); + public final void rule__XConstructorCall__Alternatives_4_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4906:1: ( rule__GlobalScopeExpression__Group_4__6__Impl ) - // InternalScope.g:4907:2: rule__GlobalScopeExpression__Group_4__6__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4__6__Impl(); + // InternalScope.g:5016:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) ) + int alt56=2; + alt56 = dfa56.predict(input); + switch (alt56) { + case 1 : + // InternalScope.g:5017:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + { + // InternalScope.g:5017:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + // InternalScope.g:5018:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + // InternalScope.g:5019:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + // InternalScope.g:5019:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5023:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) + { + // InternalScope.g:5023:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) + // InternalScope.g:5024:3: ( rule__XConstructorCall__Group_4_1_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); + } + // InternalScope.g:5025:3: ( rule__XConstructorCall__Group_4_1_1__0 ) + // InternalScope.g:5025:4: rule__XConstructorCall__Group_4_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -16929,73 +18720,84 @@ public final void rule__GlobalScopeExpression__Group_4__6() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__6" + // $ANTLR end "rule__XConstructorCall__Alternatives_4_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_4__6__Impl" - // InternalScope.g:4913:1: rule__GlobalScopeExpression__Group_4__6__Impl : ( ')' ) ; - public final void rule__GlobalScopeExpression__Group_4__6__Impl() throws RecognitionException { + // $ANTLR start "rule__XBooleanLiteral__Alternatives_1" + // InternalScope.g:5033:1: rule__XBooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) ); + public final void rule__XBooleanLiteral__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4917:1: ( ( ')' ) ) - // InternalScope.g:4918:1: ( ')' ) - { - // InternalScope.g:4918:1: ( ')' ) - // InternalScope.g:4919:2: ')' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); + // InternalScope.g:5037:1: ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) ) + int alt57=2; + int LA57_0 = input.LA(1); + + if ( (LA57_0==37) ) { + alt57=1; } - match(input,52,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); + else if ( (LA57_0==36) ) { + alt57=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 57, 0, input); + throw nvae; } + switch (alt57) { + case 1 : + // InternalScope.g:5038:2: ( 'false' ) + { + // InternalScope.g:5038:2: ( 'false' ) + // InternalScope.g:5039:3: 'false' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + match(input,37,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + } - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - restoreStackSize(stackSize); + } + break; + case 2 : + // InternalScope.g:5044:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) + { + // InternalScope.g:5044:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) + // InternalScope.g:5045:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); + } + // InternalScope.g:5046:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) + // InternalScope.g:5046:4: rule__XBooleanLiteral__IsTrueAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__IsTrueAssignment_1_1(); - } - return ; - } - // $ANTLR end "rule__GlobalScopeExpression__Group_4__6__Impl" + state._fsp--; + if (state.failed) return ; + } - // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__0" - // InternalScope.g:4929:1: rule__GlobalScopeExpression__Group_4_5__0 : rule__GlobalScopeExpression__Group_4_5__0__Impl rule__GlobalScopeExpression__Group_4_5__1 ; - public final void rule__GlobalScopeExpression__Group_4_5__0() throws RecognitionException { + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); + } - int stackSize = keepStackSize(); - - try { - // InternalScope.g:4933:1: ( rule__GlobalScopeExpression__Group_4_5__0__Impl rule__GlobalScopeExpression__Group_4_5__1 ) - // InternalScope.g:4934:2: rule__GlobalScopeExpression__Group_4_5__0__Impl rule__GlobalScopeExpression__Group_4_5__1 - { - pushFollow(FOLLOW_38); - rule__GlobalScopeExpression__Group_4_5__0__Impl(); + } - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4_5__1(); - state._fsp--; - if (state.failed) return ; + } + break; } - } catch (RecognitionException re) { reportError(re); @@ -17008,35 +18810,94 @@ public final void rule__GlobalScopeExpression__Group_4_5__0() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__0" + // $ANTLR end "rule__XBooleanLiteral__Alternatives_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__0__Impl" - // InternalScope.g:4941:1: rule__GlobalScopeExpression__Group_4_5__0__Impl : ( ',' ) ; - public final void rule__GlobalScopeExpression__Group_4_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__XTryCatchFinallyExpression__Alternatives_3" + // InternalScope.g:5054:1: rule__XTryCatchFinallyExpression__Alternatives_3 : ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) ); + public final void rule__XTryCatchFinallyExpression__Alternatives_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4945:1: ( ( ',' ) ) - // InternalScope.g:4946:1: ( ',' ) - { - // InternalScope.g:4946:1: ( ',' ) - // InternalScope.g:4947:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); + // InternalScope.g:5058:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) ) + int alt58=2; + int LA58_0 = input.LA(1); + + if ( (LA58_0==115) ) { + alt58=1; } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); + else if ( (LA58_0==113) ) { + alt58=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 58, 0, input); + throw nvae; } + switch (alt58) { + case 1 : + // InternalScope.g:5059:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) + { + // InternalScope.g:5059:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) + // InternalScope.g:5060:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); + } + // InternalScope.g:5061:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) + // InternalScope.g:5061:4: rule__XTryCatchFinallyExpression__Group_3_0__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__0(); + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5065:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) + { + // InternalScope.g:5065:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) + // InternalScope.g:5066:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); + } + // InternalScope.g:5067:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) + // InternalScope.g:5067:4: rule__XTryCatchFinallyExpression__Group_3_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -17049,27 +18910,84 @@ public final void rule__GlobalScopeExpression__Group_4_5__0__Impl() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__0__Impl" + // $ANTLR end "rule__XTryCatchFinallyExpression__Alternatives_3" - // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__1" - // InternalScope.g:4956:1: rule__GlobalScopeExpression__Group_4_5__1 : rule__GlobalScopeExpression__Group_4_5__1__Impl ; - public final void rule__GlobalScopeExpression__Group_4_5__1() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives" + // InternalScope.g:5075:1: rule__Number__Alternatives : ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) ); + public final void rule__Number__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4960:1: ( rule__GlobalScopeExpression__Group_4_5__1__Impl ) - // InternalScope.g:4961:2: rule__GlobalScopeExpression__Group_4_5__1__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_4_5__1__Impl(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:5079:1: ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) ) + int alt59=2; + int LA59_0 = input.LA(1); + if ( (LA59_0==RULE_HEX) ) { + alt59=1; } + else if ( ((LA59_0>=RULE_INT && LA59_0<=RULE_DECIMAL)) ) { + alt59=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 59, 0, input); + throw nvae; + } + switch (alt59) { + case 1 : + // InternalScope.g:5080:2: ( RULE_HEX ) + { + // InternalScope.g:5080:2: ( RULE_HEX ) + // InternalScope.g:5081:3: RULE_HEX + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + match(input,RULE_HEX,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5086:2: ( ( rule__Number__Group_1__0 ) ) + { + // InternalScope.g:5086:2: ( ( rule__Number__Group_1__0 ) ) + // InternalScope.g:5087:3: ( rule__Number__Group_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getGroup_1()); + } + // InternalScope.g:5088:3: ( rule__Number__Group_1__0 ) + // InternalScope.g:5088:4: rule__Number__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__Number__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getGroup_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -17082,45 +19000,74 @@ public final void rule__GlobalScopeExpression__Group_4_5__1() throws Recognition } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__1" + // $ANTLR end "rule__Number__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__1__Impl" - // InternalScope.g:4967:1: rule__GlobalScopeExpression__Group_4_5__1__Impl : ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) ; - public final void rule__GlobalScopeExpression__Group_4_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives_1_0" + // InternalScope.g:5096:1: rule__Number__Alternatives_1_0 : ( ( RULE_INT ) | ( RULE_DECIMAL ) ); + public final void rule__Number__Alternatives_1_0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4971:1: ( ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) ) - // InternalScope.g:4972:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) - { - // InternalScope.g:4972:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) - // InternalScope.g:4973:2: ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); - } - // InternalScope.g:4974:2: ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) - // InternalScope.g:4974:3: rule__GlobalScopeExpression__DataAssignment_4_5_1 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__DataAssignment_4_5_1(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:5100:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) ) + int alt60=2; + int LA60_0 = input.LA(1); + if ( (LA60_0==RULE_INT) ) { + alt60=1; } - - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); + else if ( (LA60_0==RULE_DECIMAL) ) { + alt60=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 60, 0, input); + throw nvae; } + switch (alt60) { + case 1 : + // InternalScope.g:5101:2: ( RULE_INT ) + { + // InternalScope.g:5101:2: ( RULE_INT ) + // InternalScope.g:5102:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + } - } + } + break; + case 2 : + // InternalScope.g:5107:2: ( RULE_DECIMAL ) + { + // InternalScope.g:5107:2: ( RULE_DECIMAL ) + // InternalScope.g:5108:3: RULE_DECIMAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -17133,32 +19080,74 @@ public final void rule__GlobalScopeExpression__Group_4_5__1__Impl() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__1__Impl" + // $ANTLR end "rule__Number__Alternatives_1_0" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__0" - // InternalScope.g:4983:1: rule__GlobalScopeExpression__Group_5__0 : rule__GlobalScopeExpression__Group_5__0__Impl rule__GlobalScopeExpression__Group_5__1 ; - public final void rule__GlobalScopeExpression__Group_5__0() throws RecognitionException { + // $ANTLR start "rule__Number__Alternatives_1_1_1" + // InternalScope.g:5117:1: rule__Number__Alternatives_1_1_1 : ( ( RULE_INT ) | ( RULE_DECIMAL ) ); + public final void rule__Number__Alternatives_1_1_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4987:1: ( rule__GlobalScopeExpression__Group_5__0__Impl rule__GlobalScopeExpression__Group_5__1 ) - // InternalScope.g:4988:2: rule__GlobalScopeExpression__Group_5__0__Impl rule__GlobalScopeExpression__Group_5__1 - { - pushFollow(FOLLOW_40); - rule__GlobalScopeExpression__Group_5__0__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5__1(); + // InternalScope.g:5121:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) ) + int alt61=2; + int LA61_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA61_0==RULE_INT) ) { + alt61=1; + } + else if ( (LA61_0==RULE_DECIMAL) ) { + alt61=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 61, 0, input); + throw nvae; } + switch (alt61) { + case 1 : + // InternalScope.g:5122:2: ( RULE_INT ) + { + // InternalScope.g:5122:2: ( RULE_INT ) + // InternalScope.g:5123:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5128:2: ( RULE_DECIMAL ) + { + // InternalScope.g:5128:2: ( RULE_DECIMAL ) + // InternalScope.g:5129:3: RULE_DECIMAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -17171,35 +19160,88 @@ public final void rule__GlobalScopeExpression__Group_5__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__0" + // $ANTLR end "rule__Number__Alternatives_1_1_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__0__Impl" - // InternalScope.g:4995:1: rule__GlobalScopeExpression__Group_5__0__Impl : ( ',' ) ; - public final void rule__GlobalScopeExpression__Group_5__0__Impl() throws RecognitionException { + // $ANTLR start "rule__JvmTypeReference__Alternatives" + // InternalScope.g:5138:1: rule__JvmTypeReference__Alternatives : ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ); + public final void rule__JvmTypeReference__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:4999:1: ( ( ',' ) ) - // InternalScope.g:5000:1: ( ',' ) - { - // InternalScope.g:5000:1: ( ',' ) - // InternalScope.g:5001:2: ',' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); + // InternalScope.g:5142:1: ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) ) + int alt62=2; + int LA62_0 = input.LA(1); + + if ( (LA62_0==RULE_ID) ) { + alt62=1; } - match(input,60,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); + else if ( (LA62_0==51||LA62_0==77) ) { + alt62=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 62, 0, input); + throw nvae; } + switch (alt62) { + case 1 : + // InternalScope.g:5143:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) + { + // InternalScope.g:5143:2: ( ( rule__JvmTypeReference__Group_0__0 ) ) + // InternalScope.g:5144:3: ( rule__JvmTypeReference__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); + } + // InternalScope.g:5145:3: ( rule__JvmTypeReference__Group_0__0 ) + // InternalScope.g:5145:4: rule__JvmTypeReference__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0__0(); + state._fsp--; + if (state.failed) return ; - } + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); + } + } + + + } + break; + case 2 : + // InternalScope.g:5149:2: ( ruleXFunctionTypeRef ) + { + // InternalScope.g:5149:2: ( ruleXFunctionTypeRef ) + // InternalScope.g:5150:3: ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + + } + + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -17212,32 +19254,82 @@ public final void rule__GlobalScopeExpression__Group_5__0__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__0__Impl" + // $ANTLR end "rule__JvmTypeReference__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__1" - // InternalScope.g:5010:1: rule__GlobalScopeExpression__Group_5__1 : rule__GlobalScopeExpression__Group_5__1__Impl rule__GlobalScopeExpression__Group_5__2 ; - public final void rule__GlobalScopeExpression__Group_5__1() throws RecognitionException { + // $ANTLR start "rule__JvmArgumentTypeReference__Alternatives" + // InternalScope.g:5159:1: rule__JvmArgumentTypeReference__Alternatives : ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ); + public final void rule__JvmArgumentTypeReference__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5014:1: ( rule__GlobalScopeExpression__Group_5__1__Impl rule__GlobalScopeExpression__Group_5__2 ) - // InternalScope.g:5015:2: rule__GlobalScopeExpression__Group_5__1__Impl rule__GlobalScopeExpression__Group_5__2 - { - pushFollow(FOLLOW_16); - rule__GlobalScopeExpression__Group_5__1__Impl(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5__2(); + // InternalScope.g:5163:1: ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) ) + int alt63=2; + int LA63_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA63_0==RULE_ID||LA63_0==51||LA63_0==77) ) { + alt63=1; + } + else if ( (LA63_0==96) ) { + alt63=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 63, 0, input); + throw nvae; } + switch (alt63) { + case 1 : + // InternalScope.g:5164:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:5164:2: ( ruleJvmTypeReference ) + // InternalScope.g:5165:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5170:2: ( ruleJvmWildcardTypeReference ) + { + // InternalScope.g:5170:2: ( ruleJvmWildcardTypeReference ) + // InternalScope.g:5171:3: ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -17250,35 +19342,94 @@ public final void rule__GlobalScopeExpression__Group_5__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__1" + // $ANTLR end "rule__JvmArgumentTypeReference__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__1__Impl" - // InternalScope.g:5022:1: rule__GlobalScopeExpression__Group_5__1__Impl : ( 'domains' ) ; - public final void rule__GlobalScopeExpression__Group_5__1__Impl() throws RecognitionException { + // $ANTLR start "rule__JvmWildcardTypeReference__Alternatives_2" + // InternalScope.g:5180:1: rule__JvmWildcardTypeReference__Alternatives_2 : ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ); + public final void rule__JvmWildcardTypeReference__Alternatives_2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5026:1: ( ( 'domains' ) ) - // InternalScope.g:5027:1: ( 'domains' ) - { - // InternalScope.g:5027:1: ( 'domains' ) - // InternalScope.g:5028:2: 'domains' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); + // InternalScope.g:5184:1: ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) ) + int alt64=2; + int LA64_0 = input.LA(1); + + if ( (LA64_0==60) ) { + alt64=1; } - match(input,65,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); + else if ( (LA64_0==64) ) { + alt64=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 64, 0, input); + throw nvae; } + switch (alt64) { + case 1 : + // InternalScope.g:5185:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) + { + // InternalScope.g:5185:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) + // InternalScope.g:5186:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); + } + // InternalScope.g:5187:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 ) + // InternalScope.g:5187:4: rule__JvmWildcardTypeReference__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5191:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) + { + // InternalScope.g:5191:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) + // InternalScope.g:5192:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); + } + // InternalScope.g:5193:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 ) + // InternalScope.g:5193:4: rule__JvmWildcardTypeReference__Group_2_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); + } + + } + + + } + break; + } } catch (RecognitionException re) { reportError(re); @@ -17291,32 +19442,109 @@ public final void rule__GlobalScopeExpression__Group_5__1__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__1__Impl" + // $ANTLR end "rule__JvmWildcardTypeReference__Alternatives_2" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__2" - // InternalScope.g:5037:1: rule__GlobalScopeExpression__Group_5__2 : rule__GlobalScopeExpression__Group_5__2__Impl rule__GlobalScopeExpression__Group_5__3 ; - public final void rule__GlobalScopeExpression__Group_5__2() throws RecognitionException { + // $ANTLR start "rule__XImportDeclaration__Alternatives_1" + // InternalScope.g:5201:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ); + public final void rule__XImportDeclaration__Alternatives_1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5041:1: ( rule__GlobalScopeExpression__Group_5__2__Impl rule__GlobalScopeExpression__Group_5__3 ) - // InternalScope.g:5042:2: rule__GlobalScopeExpression__Group_5__2__Impl rule__GlobalScopeExpression__Group_5__3 - { - pushFollow(FOLLOW_41); - rule__GlobalScopeExpression__Group_5__2__Impl(); + // InternalScope.g:5205:1: ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) ) + int alt65=3; + alt65 = dfa65.predict(input); + switch (alt65) { + case 1 : + // InternalScope.g:5206:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) + { + // InternalScope.g:5206:2: ( ( rule__XImportDeclaration__Group_1_0__0 ) ) + // InternalScope.g:5207:3: ( rule__XImportDeclaration__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); + } + // InternalScope.g:5208:3: ( rule__XImportDeclaration__Group_1_0__0 ) + // InternalScope.g:5208:4: rule__XImportDeclaration__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__0(); - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5__3(); + state._fsp--; + if (state.failed) return ; - state._fsp--; - if (state.failed) return ; + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5212:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) + { + // InternalScope.g:5212:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) + // InternalScope.g:5213:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); + } + // InternalScope.g:5214:3: ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) + // InternalScope.g:5214:4: rule__XImportDeclaration__ImportedTypeAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedTypeAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); + } + + } + + + } + break; + case 3 : + // InternalScope.g:5218:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) + { + // InternalScope.g:5218:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) + // InternalScope.g:5219:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); + } + // InternalScope.g:5220:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) + // InternalScope.g:5220:4: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedNamespaceAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); + } + + } - } + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -17329,35 +19557,94 @@ public final void rule__GlobalScopeExpression__Group_5__2() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__2" + // $ANTLR end "rule__XImportDeclaration__Alternatives_1" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__2__Impl" - // InternalScope.g:5049:1: rule__GlobalScopeExpression__Group_5__2__Impl : ( '=' ) ; - public final void rule__GlobalScopeExpression__Group_5__2__Impl() throws RecognitionException { + // $ANTLR start "rule__XImportDeclaration__Alternatives_1_0_3" + // InternalScope.g:5228:1: rule__XImportDeclaration__Alternatives_1_0_3 : ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ); + public final void rule__XImportDeclaration__Alternatives_1_0_3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5053:1: ( ( '=' ) ) - // InternalScope.g:5054:1: ( '=' ) - { - // InternalScope.g:5054:1: ( '=' ) - // InternalScope.g:5055:2: '=' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); + // InternalScope.g:5232:1: ( ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) ) + int alt66=2; + int LA66_0 = input.LA(1); + + if ( (LA66_0==25) ) { + alt66=1; } - match(input,48,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); + else if ( (LA66_0==RULE_ID) ) { + alt66=2; } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 66, 0, input); + throw nvae; } + switch (alt66) { + case 1 : + // InternalScope.g:5233:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) + { + // InternalScope.g:5233:2: ( ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) ) + // InternalScope.g:5234:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); + } + // InternalScope.g:5235:3: ( rule__XImportDeclaration__WildcardAssignment_1_0_3_0 ) + // InternalScope.g:5235:4: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__WildcardAssignment_1_0_3_0(); + + state._fsp--; + if (state.failed) return ; + } - } + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5239:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) + { + // InternalScope.g:5239:2: ( ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) ) + // InternalScope.g:5240:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); + } + // InternalScope.g:5241:3: ( rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 ) + // InternalScope.g:5241:4: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__MemberNameAssignment_1_0_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -17370,27 +19657,86 @@ public final void rule__GlobalScopeExpression__Group_5__2__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__2__Impl" + // $ANTLR end "rule__XImportDeclaration__Alternatives_1_0_3" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__3" - // InternalScope.g:5064:1: rule__GlobalScopeExpression__Group_5__3 : rule__GlobalScopeExpression__Group_5__3__Impl ; - public final void rule__GlobalScopeExpression__Group_5__3() throws RecognitionException { + // $ANTLR start "rule__Casing__Alternatives" + // InternalScope.g:5249:1: rule__Casing__Alternatives : ( ( ( 'sensitive' ) ) | ( ( 'insensitive' ) ) ); + public final void rule__Casing__Alternatives() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5068:1: ( rule__GlobalScopeExpression__Group_5__3__Impl ) - // InternalScope.g:5069:2: rule__GlobalScopeExpression__Group_5__3__Impl - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5__3__Impl(); + // InternalScope.g:5253:1: ( ( ( 'sensitive' ) ) | ( ( 'insensitive' ) ) ) + int alt67=2; + int LA67_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA67_0==65) ) { + alt67=1; + } + else if ( (LA67_0==66) ) { + alt67=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 67, 0, input); + throw nvae; } + switch (alt67) { + case 1 : + // InternalScope.g:5254:2: ( ( 'sensitive' ) ) + { + // InternalScope.g:5254:2: ( ( 'sensitive' ) ) + // InternalScope.g:5255:3: ( 'sensitive' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); + } + // InternalScope.g:5256:3: ( 'sensitive' ) + // InternalScope.g:5256:4: 'sensitive' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); + } + + } + + + } + break; + case 2 : + // InternalScope.g:5260:2: ( ( 'insensitive' ) ) + { + // InternalScope.g:5260:2: ( ( 'insensitive' ) ) + // InternalScope.g:5261:3: ( 'insensitive' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); + } + // InternalScope.g:5262:3: ( 'insensitive' ) + // InternalScope.g:5262:4: 'insensitive' + { + match(input,66,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); + } + + } + + } + break; + + } } catch (RecognitionException re) { reportError(re); @@ -17403,42 +19749,29 @@ public final void rule__GlobalScopeExpression__Group_5__3() throws RecognitionEx } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__3" + // $ANTLR end "rule__Casing__Alternatives" - // $ANTLR start "rule__GlobalScopeExpression__Group_5__3__Impl" - // InternalScope.g:5075:1: rule__GlobalScopeExpression__Group_5__3__Impl : ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) ; - public final void rule__GlobalScopeExpression__Group_5__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__0" + // InternalScope.g:5270:1: rule__ScopeModel__Group__0 : rule__ScopeModel__Group__0__Impl rule__ScopeModel__Group__1 ; + public final void rule__ScopeModel__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5079:1: ( ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) ) - // InternalScope.g:5080:1: ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) - { - // InternalScope.g:5080:1: ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) - // InternalScope.g:5081:2: ( rule__GlobalScopeExpression__Alternatives_5_3 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); - } - // InternalScope.g:5082:2: ( rule__GlobalScopeExpression__Alternatives_5_3 ) - // InternalScope.g:5082:3: rule__GlobalScopeExpression__Alternatives_5_3 + // InternalScope.g:5274:1: ( rule__ScopeModel__Group__0__Impl rule__ScopeModel__Group__1 ) + // InternalScope.g:5275:2: rule__ScopeModel__Group__0__Impl rule__ScopeModel__Group__1 { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Alternatives_5_3(); + pushFollow(FOLLOW_4); + rule__ScopeModel__Group__0__Impl(); state._fsp--; if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ScopeModel__Group__1(); - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); - } - - } - + state._fsp--; + if (state.failed) return ; } @@ -17454,26 +19787,67 @@ public final void rule__GlobalScopeExpression__Group_5__3__Impl() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5__3__Impl" + // $ANTLR end "rule__ScopeModel__Group__0" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__0" - // InternalScope.g:5091:1: rule__GlobalScopeExpression__Group_5_3_2__0 : rule__GlobalScopeExpression__Group_5_3_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2__1 ; - public final void rule__GlobalScopeExpression__Group_5_3_2__0() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__0__Impl" + // InternalScope.g:5282:1: rule__ScopeModel__Group__0__Impl : ( 'scoping' ) ; + public final void rule__ScopeModel__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5095:1: ( rule__GlobalScopeExpression__Group_5_3_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2__1 ) - // InternalScope.g:5096:2: rule__GlobalScopeExpression__Group_5_3_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2__1 + // InternalScope.g:5286:1: ( ( 'scoping' ) ) + // InternalScope.g:5287:1: ( 'scoping' ) { - pushFollow(FOLLOW_3); - rule__GlobalScopeExpression__Group_5_3_2__0__Impl(); + // InternalScope.g:5287:1: ( 'scoping' ) + // InternalScope.g:5288:2: 'scoping' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); + } + match(input,67,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getScopingKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__Group__0__Impl" + + + // $ANTLR start "rule__ScopeModel__Group__1" + // InternalScope.g:5297:1: rule__ScopeModel__Group__1 : rule__ScopeModel__Group__1__Impl rule__ScopeModel__Group__2 ; + public final void rule__ScopeModel__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:5301:1: ( rule__ScopeModel__Group__1__Impl rule__ScopeModel__Group__2 ) + // InternalScope.g:5302:2: rule__ScopeModel__Group__1__Impl rule__ScopeModel__Group__2 + { + pushFollow(FOLLOW_5); + rule__ScopeModel__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2__1(); + rule__ScopeModel__Group__2(); state._fsp--; if (state.failed) return ; @@ -17492,28 +19866,38 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__0() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__0" + // $ANTLR end "rule__ScopeModel__Group__1" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__0__Impl" - // InternalScope.g:5103:1: rule__GlobalScopeExpression__Group_5_3_2__0__Impl : ( '(' ) ; - public final void rule__GlobalScopeExpression__Group_5_3_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__1__Impl" + // InternalScope.g:5309:1: rule__ScopeModel__Group__1__Impl : ( ( rule__ScopeModel__NameAssignment_1 ) ) ; + public final void rule__ScopeModel__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5107:1: ( ( '(' ) ) - // InternalScope.g:5108:1: ( '(' ) + // InternalScope.g:5313:1: ( ( ( rule__ScopeModel__NameAssignment_1 ) ) ) + // InternalScope.g:5314:1: ( ( rule__ScopeModel__NameAssignment_1 ) ) { - // InternalScope.g:5108:1: ( '(' ) - // InternalScope.g:5109:2: '(' + // InternalScope.g:5314:1: ( ( rule__ScopeModel__NameAssignment_1 ) ) + // InternalScope.g:5315:2: ( rule__ScopeModel__NameAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); + before(grammarAccess.getScopeModelAccess().getNameAssignment_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:5316:2: ( rule__ScopeModel__NameAssignment_1 ) + // InternalScope.g:5316:3: rule__ScopeModel__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ScopeModel__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); + after(grammarAccess.getScopeModelAccess().getNameAssignment_1()); } } @@ -17533,26 +19917,26 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__0__Impl() throws Rec } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__0__Impl" + // $ANTLR end "rule__ScopeModel__Group__1__Impl" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__1" - // InternalScope.g:5118:1: rule__GlobalScopeExpression__Group_5_3_2__1 : rule__GlobalScopeExpression__Group_5_3_2__1__Impl rule__GlobalScopeExpression__Group_5_3_2__2 ; - public final void rule__GlobalScopeExpression__Group_5_3_2__1() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__2" + // InternalScope.g:5324:1: rule__ScopeModel__Group__2 : rule__ScopeModel__Group__2__Impl rule__ScopeModel__Group__3 ; + public final void rule__ScopeModel__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5122:1: ( rule__GlobalScopeExpression__Group_5_3_2__1__Impl rule__GlobalScopeExpression__Group_5_3_2__2 ) - // InternalScope.g:5123:2: rule__GlobalScopeExpression__Group_5_3_2__1__Impl rule__GlobalScopeExpression__Group_5_3_2__2 + // InternalScope.g:5328:1: ( rule__ScopeModel__Group__2__Impl rule__ScopeModel__Group__3 ) + // InternalScope.g:5329:2: rule__ScopeModel__Group__2__Impl rule__ScopeModel__Group__3 { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group_5_3_2__1__Impl(); + pushFollow(FOLLOW_5); + rule__ScopeModel__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2__2(); + rule__ScopeModel__Group__3(); state._fsp--; if (state.failed) return ; @@ -17571,38 +19955,49 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__1() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__1" + // $ANTLR end "rule__ScopeModel__Group__2" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__1__Impl" - // InternalScope.g:5130:1: rule__GlobalScopeExpression__Group_5_3_2__1__Impl : ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) ; - public final void rule__GlobalScopeExpression__Group_5_3_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__2__Impl" + // InternalScope.g:5336:1: rule__ScopeModel__Group__2__Impl : ( ( rule__ScopeModel__Group_2__0 )? ) ; + public final void rule__ScopeModel__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5134:1: ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) ) - // InternalScope.g:5135:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) + // InternalScope.g:5340:1: ( ( ( rule__ScopeModel__Group_2__0 )? ) ) + // InternalScope.g:5341:1: ( ( rule__ScopeModel__Group_2__0 )? ) { - // InternalScope.g:5135:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) - // InternalScope.g:5136:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) + // InternalScope.g:5341:1: ( ( rule__ScopeModel__Group_2__0 )? ) + // InternalScope.g:5342:2: ( rule__ScopeModel__Group_2__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); + before(grammarAccess.getScopeModelAccess().getGroup_2()); } - // InternalScope.g:5137:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) - // InternalScope.g:5137:3: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1(); + // InternalScope.g:5343:2: ( rule__ScopeModel__Group_2__0 )? + int alt68=2; + int LA68_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA68_0==68) ) { + alt68=1; + } + switch (alt68) { + case 1 : + // InternalScope.g:5343:3: rule__ScopeModel__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ScopeModel__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); + after(grammarAccess.getScopeModelAccess().getGroup_2()); } } @@ -17622,26 +20017,26 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__1__Impl() throws Rec } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__1__Impl" + // $ANTLR end "rule__ScopeModel__Group__2__Impl" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__2" - // InternalScope.g:5145:1: rule__GlobalScopeExpression__Group_5_3_2__2 : rule__GlobalScopeExpression__Group_5_3_2__2__Impl rule__GlobalScopeExpression__Group_5_3_2__3 ; - public final void rule__GlobalScopeExpression__Group_5_3_2__2() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__3" + // InternalScope.g:5351:1: rule__ScopeModel__Group__3 : rule__ScopeModel__Group__3__Impl rule__ScopeModel__Group__4 ; + public final void rule__ScopeModel__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5149:1: ( rule__GlobalScopeExpression__Group_5_3_2__2__Impl rule__GlobalScopeExpression__Group_5_3_2__3 ) - // InternalScope.g:5150:2: rule__GlobalScopeExpression__Group_5_3_2__2__Impl rule__GlobalScopeExpression__Group_5_3_2__3 + // InternalScope.g:5355:1: ( rule__ScopeModel__Group__3__Impl rule__ScopeModel__Group__4 ) + // InternalScope.g:5356:2: rule__ScopeModel__Group__3__Impl rule__ScopeModel__Group__4 { - pushFollow(FOLLOW_33); - rule__GlobalScopeExpression__Group_5_3_2__2__Impl(); + pushFollow(FOLLOW_5); + rule__ScopeModel__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2__3(); + rule__ScopeModel__Group__4(); state._fsp--; if (state.failed) return ; @@ -17660,42 +20055,42 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__2() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__2" + // $ANTLR end "rule__ScopeModel__Group__3" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__2__Impl" - // InternalScope.g:5157:1: rule__GlobalScopeExpression__Group_5_3_2__2__Impl : ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) ; - public final void rule__GlobalScopeExpression__Group_5_3_2__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__3__Impl" + // InternalScope.g:5363:1: rule__ScopeModel__Group__3__Impl : ( ( rule__ScopeModel__ImportsAssignment_3 )* ) ; + public final void rule__ScopeModel__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5161:1: ( ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) ) - // InternalScope.g:5162:1: ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) + // InternalScope.g:5367:1: ( ( ( rule__ScopeModel__ImportsAssignment_3 )* ) ) + // InternalScope.g:5368:1: ( ( rule__ScopeModel__ImportsAssignment_3 )* ) { - // InternalScope.g:5162:1: ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) - // InternalScope.g:5163:2: ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* + // InternalScope.g:5368:1: ( ( rule__ScopeModel__ImportsAssignment_3 )* ) + // InternalScope.g:5369:2: ( rule__ScopeModel__ImportsAssignment_3 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); + before(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); } - // InternalScope.g:5164:2: ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* - loop49: + // InternalScope.g:5370:2: ( rule__ScopeModel__ImportsAssignment_3 )* + loop69: do { - int alt49=2; - int LA49_0 = input.LA(1); + int alt69=2; + int LA69_0 = input.LA(1); - if ( (LA49_0==60) ) { - alt49=1; + if ( (LA69_0==62) ) { + alt69=1; } - switch (alt49) { + switch (alt69) { case 1 : - // InternalScope.g:5164:3: rule__GlobalScopeExpression__Group_5_3_2_2__0 + // InternalScope.g:5370:3: rule__ScopeModel__ImportsAssignment_3 { - pushFollow(FOLLOW_39); - rule__GlobalScopeExpression__Group_5_3_2_2__0(); + pushFollow(FOLLOW_6); + rule__ScopeModel__ImportsAssignment_3(); state._fsp--; if (state.failed) return ; @@ -17704,12 +20099,12 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__2__Impl() throws Rec break; default : - break loop49; + break loop69; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); + after(grammarAccess.getScopeModelAccess().getImportsAssignment_3()); } } @@ -17729,21 +20124,26 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__2__Impl() throws Rec } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__2__Impl" + // $ANTLR end "rule__ScopeModel__Group__3__Impl" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__3" - // InternalScope.g:5172:1: rule__GlobalScopeExpression__Group_5_3_2__3 : rule__GlobalScopeExpression__Group_5_3_2__3__Impl ; - public final void rule__GlobalScopeExpression__Group_5_3_2__3() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__4" + // InternalScope.g:5378:1: rule__ScopeModel__Group__4 : rule__ScopeModel__Group__4__Impl rule__ScopeModel__Group__5 ; + public final void rule__ScopeModel__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5176:1: ( rule__GlobalScopeExpression__Group_5_3_2__3__Impl ) - // InternalScope.g:5177:2: rule__GlobalScopeExpression__Group_5_3_2__3__Impl + // InternalScope.g:5382:1: ( rule__ScopeModel__Group__4__Impl rule__ScopeModel__Group__5 ) + // InternalScope.g:5383:2: rule__ScopeModel__Group__4__Impl rule__ScopeModel__Group__5 { + pushFollow(FOLLOW_5); + rule__ScopeModel__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2__3__Impl(); + rule__ScopeModel__Group__5(); state._fsp--; if (state.failed) return ; @@ -17762,28 +20162,56 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__3() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__3" + // $ANTLR end "rule__ScopeModel__Group__4" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__3__Impl" - // InternalScope.g:5183:1: rule__GlobalScopeExpression__Group_5_3_2__3__Impl : ( ')' ) ; - public final void rule__GlobalScopeExpression__Group_5_3_2__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__4__Impl" + // InternalScope.g:5390:1: rule__ScopeModel__Group__4__Impl : ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) ; + public final void rule__ScopeModel__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5187:1: ( ( ')' ) ) - // InternalScope.g:5188:1: ( ')' ) + // InternalScope.g:5394:1: ( ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) ) + // InternalScope.g:5395:1: ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) { - // InternalScope.g:5188:1: ( ')' ) - // InternalScope.g:5189:2: ')' + // InternalScope.g:5395:1: ( ( rule__ScopeModel__ExtensionsAssignment_4 )* ) + // InternalScope.g:5396:2: ( rule__ScopeModel__ExtensionsAssignment_4 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); + before(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:5397:2: ( rule__ScopeModel__ExtensionsAssignment_4 )* + loop70: + do { + int alt70=2; + int LA70_0 = input.LA(1); + + if ( (LA70_0==63) ) { + alt70=1; + } + + + switch (alt70) { + case 1 : + // InternalScope.g:5397:3: rule__ScopeModel__ExtensionsAssignment_4 + { + pushFollow(FOLLOW_7); + rule__ScopeModel__ExtensionsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop70; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); + after(grammarAccess.getScopeModelAccess().getExtensionsAssignment_4()); } } @@ -17803,26 +20231,26 @@ public final void rule__GlobalScopeExpression__Group_5_3_2__3__Impl() throws Rec } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__3__Impl" + // $ANTLR end "rule__ScopeModel__Group__4__Impl" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__0" - // InternalScope.g:5199:1: rule__GlobalScopeExpression__Group_5_3_2_2__0 : rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2_2__1 ; - public final void rule__GlobalScopeExpression__Group_5_3_2_2__0() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__5" + // InternalScope.g:5405:1: rule__ScopeModel__Group__5 : rule__ScopeModel__Group__5__Impl rule__ScopeModel__Group__6 ; + public final void rule__ScopeModel__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5203:1: ( rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2_2__1 ) - // InternalScope.g:5204:2: rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2_2__1 + // InternalScope.g:5409:1: ( rule__ScopeModel__Group__5__Impl rule__ScopeModel__Group__6 ) + // InternalScope.g:5410:2: rule__ScopeModel__Group__5__Impl rule__ScopeModel__Group__6 { - pushFollow(FOLLOW_3); - rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl(); + pushFollow(FOLLOW_5); + rule__ScopeModel__Group__5__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2_2__1(); + rule__ScopeModel__Group__6(); state._fsp--; if (state.failed) return ; @@ -17841,28 +20269,56 @@ public final void rule__GlobalScopeExpression__Group_5_3_2_2__0() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__0" + // $ANTLR end "rule__ScopeModel__Group__5" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl" - // InternalScope.g:5211:1: rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl : ( ',' ) ; - public final void rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__5__Impl" + // InternalScope.g:5417:1: rule__ScopeModel__Group__5__Impl : ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) ; + public final void rule__ScopeModel__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5215:1: ( ( ',' ) ) - // InternalScope.g:5216:1: ( ',' ) + // InternalScope.g:5421:1: ( ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) ) + // InternalScope.g:5422:1: ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) { - // InternalScope.g:5216:1: ( ',' ) - // InternalScope.g:5217:2: ',' + // InternalScope.g:5422:1: ( ( rule__ScopeModel__InjectionsAssignment_5 )* ) + // InternalScope.g:5423:2: ( rule__ScopeModel__InjectionsAssignment_5 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); + before(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); } - match(input,60,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:5424:2: ( rule__ScopeModel__InjectionsAssignment_5 )* + loop71: + do { + int alt71=2; + int LA71_0 = input.LA(1); + + if ( (LA71_0==70) ) { + alt71=1; + } + + + switch (alt71) { + case 1 : + // InternalScope.g:5424:3: rule__ScopeModel__InjectionsAssignment_5 + { + pushFollow(FOLLOW_8); + rule__ScopeModel__InjectionsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop71; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); + after(grammarAccess.getScopeModelAccess().getInjectionsAssignment_5()); } } @@ -17882,21 +20338,26 @@ public final void rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl() throws R } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl" + // $ANTLR end "rule__ScopeModel__Group__5__Impl" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__1" - // InternalScope.g:5226:1: rule__GlobalScopeExpression__Group_5_3_2_2__1 : rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl ; - public final void rule__GlobalScopeExpression__Group_5_3_2_2__1() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__6" + // InternalScope.g:5432:1: rule__ScopeModel__Group__6 : rule__ScopeModel__Group__6__Impl rule__ScopeModel__Group__7 ; + public final void rule__ScopeModel__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5230:1: ( rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl ) - // InternalScope.g:5231:2: rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl + // InternalScope.g:5436:1: ( rule__ScopeModel__Group__6__Impl rule__ScopeModel__Group__7 ) + // InternalScope.g:5437:2: rule__ScopeModel__Group__6__Impl rule__ScopeModel__Group__7 { + pushFollow(FOLLOW_5); + rule__ScopeModel__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl(); + rule__ScopeModel__Group__7(); state._fsp--; if (state.failed) return ; @@ -17915,38 +20376,49 @@ public final void rule__GlobalScopeExpression__Group_5_3_2_2__1() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__1" + // $ANTLR end "rule__ScopeModel__Group__6" - // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl" - // InternalScope.g:5237:1: rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl : ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) ; - public final void rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__6__Impl" + // InternalScope.g:5444:1: rule__ScopeModel__Group__6__Impl : ( ( rule__ScopeModel__NamingAssignment_6 )? ) ; + public final void rule__ScopeModel__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5241:1: ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) ) - // InternalScope.g:5242:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) + // InternalScope.g:5448:1: ( ( ( rule__ScopeModel__NamingAssignment_6 )? ) ) + // InternalScope.g:5449:1: ( ( rule__ScopeModel__NamingAssignment_6 )? ) { - // InternalScope.g:5242:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) - // InternalScope.g:5243:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) + // InternalScope.g:5449:1: ( ( rule__ScopeModel__NamingAssignment_6 )? ) + // InternalScope.g:5450:2: ( rule__ScopeModel__NamingAssignment_6 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); + before(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); } - // InternalScope.g:5244:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) - // InternalScope.g:5244:3: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 - { - pushFollow(FOLLOW_2); - rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1(); + // InternalScope.g:5451:2: ( rule__ScopeModel__NamingAssignment_6 )? + int alt72=2; + int LA72_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA72_0==71||LA72_0==74) ) { + alt72=1; + } + switch (alt72) { + case 1 : + // InternalScope.g:5451:3: rule__ScopeModel__NamingAssignment_6 + { + pushFollow(FOLLOW_2); + rule__ScopeModel__NamingAssignment_6(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); + after(grammarAccess.getScopeModelAccess().getNamingAssignment_6()); } } @@ -17966,26 +20438,21 @@ public final void rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl() throws R } return ; } - // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl" + // $ANTLR end "rule__ScopeModel__Group__6__Impl" - // $ANTLR start "rule__MatchDataExpression__Group__0" - // InternalScope.g:5253:1: rule__MatchDataExpression__Group__0 : rule__MatchDataExpression__Group__0__Impl rule__MatchDataExpression__Group__1 ; - public final void rule__MatchDataExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__7" + // InternalScope.g:5459:1: rule__ScopeModel__Group__7 : rule__ScopeModel__Group__7__Impl ; + public final void rule__ScopeModel__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5257:1: ( rule__MatchDataExpression__Group__0__Impl rule__MatchDataExpression__Group__1 ) - // InternalScope.g:5258:2: rule__MatchDataExpression__Group__0__Impl rule__MatchDataExpression__Group__1 + // InternalScope.g:5463:1: ( rule__ScopeModel__Group__7__Impl ) + // InternalScope.g:5464:2: rule__ScopeModel__Group__7__Impl { - pushFollow(FOLLOW_16); - rule__MatchDataExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MatchDataExpression__Group__1(); + rule__ScopeModel__Group__7__Impl(); state._fsp--; if (state.failed) return ; @@ -18004,38 +20471,56 @@ public final void rule__MatchDataExpression__Group__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__MatchDataExpression__Group__0" + // $ANTLR end "rule__ScopeModel__Group__7" - // $ANTLR start "rule__MatchDataExpression__Group__0__Impl" - // InternalScope.g:5265:1: rule__MatchDataExpression__Group__0__Impl : ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) ; - public final void rule__MatchDataExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group__7__Impl" + // InternalScope.g:5470:1: rule__ScopeModel__Group__7__Impl : ( ( rule__ScopeModel__ScopesAssignment_7 )* ) ; + public final void rule__ScopeModel__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5269:1: ( ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) ) - // InternalScope.g:5270:1: ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) + // InternalScope.g:5474:1: ( ( ( rule__ScopeModel__ScopesAssignment_7 )* ) ) + // InternalScope.g:5475:1: ( ( rule__ScopeModel__ScopesAssignment_7 )* ) { - // InternalScope.g:5270:1: ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) - // InternalScope.g:5271:2: ( rule__MatchDataExpression__KeyAssignment_0 ) + // InternalScope.g:5475:1: ( ( rule__ScopeModel__ScopesAssignment_7 )* ) + // InternalScope.g:5476:2: ( rule__ScopeModel__ScopesAssignment_7 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); + before(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); } - // InternalScope.g:5272:2: ( rule__MatchDataExpression__KeyAssignment_0 ) - // InternalScope.g:5272:3: rule__MatchDataExpression__KeyAssignment_0 - { - pushFollow(FOLLOW_2); - rule__MatchDataExpression__KeyAssignment_0(); + // InternalScope.g:5477:2: ( rule__ScopeModel__ScopesAssignment_7 )* + loop73: + do { + int alt73=2; + int LA73_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA73_0==76) ) { + alt73=1; + } - } + + switch (alt73) { + case 1 : + // InternalScope.g:5477:3: rule__ScopeModel__ScopesAssignment_7 + { + pushFollow(FOLLOW_9); + rule__ScopeModel__ScopesAssignment_7(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop73; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); + after(grammarAccess.getScopeModelAccess().getScopesAssignment_7()); } } @@ -18055,26 +20540,26 @@ public final void rule__MatchDataExpression__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__MatchDataExpression__Group__0__Impl" + // $ANTLR end "rule__ScopeModel__Group__7__Impl" - // $ANTLR start "rule__MatchDataExpression__Group__1" - // InternalScope.g:5280:1: rule__MatchDataExpression__Group__1 : rule__MatchDataExpression__Group__1__Impl rule__MatchDataExpression__Group__2 ; - public final void rule__MatchDataExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group_2__0" + // InternalScope.g:5486:1: rule__ScopeModel__Group_2__0 : rule__ScopeModel__Group_2__0__Impl rule__ScopeModel__Group_2__1 ; + public final void rule__ScopeModel__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5284:1: ( rule__MatchDataExpression__Group__1__Impl rule__MatchDataExpression__Group__2 ) - // InternalScope.g:5285:2: rule__MatchDataExpression__Group__1__Impl rule__MatchDataExpression__Group__2 + // InternalScope.g:5490:1: ( rule__ScopeModel__Group_2__0__Impl rule__ScopeModel__Group_2__1 ) + // InternalScope.g:5491:2: rule__ScopeModel__Group_2__0__Impl rule__ScopeModel__Group_2__1 { - pushFollow(FOLLOW_17); - rule__MatchDataExpression__Group__1__Impl(); + pushFollow(FOLLOW_4); + rule__ScopeModel__Group_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MatchDataExpression__Group__2(); + rule__ScopeModel__Group_2__1(); state._fsp--; if (state.failed) return ; @@ -18093,28 +20578,28 @@ public final void rule__MatchDataExpression__Group__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__MatchDataExpression__Group__1" + // $ANTLR end "rule__ScopeModel__Group_2__0" - // $ANTLR start "rule__MatchDataExpression__Group__1__Impl" - // InternalScope.g:5292:1: rule__MatchDataExpression__Group__1__Impl : ( '=' ) ; - public final void rule__MatchDataExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group_2__0__Impl" + // InternalScope.g:5498:1: rule__ScopeModel__Group_2__0__Impl : ( 'with' ) ; + public final void rule__ScopeModel__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5296:1: ( ( '=' ) ) - // InternalScope.g:5297:1: ( '=' ) + // InternalScope.g:5502:1: ( ( 'with' ) ) + // InternalScope.g:5503:1: ( 'with' ) { - // InternalScope.g:5297:1: ( '=' ) - // InternalScope.g:5298:2: '=' + // InternalScope.g:5503:1: ( 'with' ) + // InternalScope.g:5504:2: 'with' { if ( state.backtracking==0 ) { - before(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); + before(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + match(input,68,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); + after(grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); } } @@ -18134,21 +20619,21 @@ public final void rule__MatchDataExpression__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__MatchDataExpression__Group__1__Impl" + // $ANTLR end "rule__ScopeModel__Group_2__0__Impl" - // $ANTLR start "rule__MatchDataExpression__Group__2" - // InternalScope.g:5307:1: rule__MatchDataExpression__Group__2 : rule__MatchDataExpression__Group__2__Impl ; - public final void rule__MatchDataExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group_2__1" + // InternalScope.g:5513:1: rule__ScopeModel__Group_2__1 : rule__ScopeModel__Group_2__1__Impl ; + public final void rule__ScopeModel__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5311:1: ( rule__MatchDataExpression__Group__2__Impl ) - // InternalScope.g:5312:2: rule__MatchDataExpression__Group__2__Impl + // InternalScope.g:5517:1: ( rule__ScopeModel__Group_2__1__Impl ) + // InternalScope.g:5518:2: rule__ScopeModel__Group_2__1__Impl { pushFollow(FOLLOW_2); - rule__MatchDataExpression__Group__2__Impl(); + rule__ScopeModel__Group_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -18167,30 +20652,30 @@ public final void rule__MatchDataExpression__Group__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__MatchDataExpression__Group__2" + // $ANTLR end "rule__ScopeModel__Group_2__1" - // $ANTLR start "rule__MatchDataExpression__Group__2__Impl" - // InternalScope.g:5318:1: rule__MatchDataExpression__Group__2__Impl : ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) ; - public final void rule__MatchDataExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeModel__Group_2__1__Impl" + // InternalScope.g:5524:1: rule__ScopeModel__Group_2__1__Impl : ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) ; + public final void rule__ScopeModel__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5322:1: ( ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) ) - // InternalScope.g:5323:1: ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) + // InternalScope.g:5528:1: ( ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) ) + // InternalScope.g:5529:1: ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) { - // InternalScope.g:5323:1: ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) - // InternalScope.g:5324:2: ( rule__MatchDataExpression__ValueAssignment_2 ) + // InternalScope.g:5529:1: ( ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) ) + // InternalScope.g:5530:2: ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); + before(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); } - // InternalScope.g:5325:2: ( rule__MatchDataExpression__ValueAssignment_2 ) - // InternalScope.g:5325:3: rule__MatchDataExpression__ValueAssignment_2 + // InternalScope.g:5531:2: ( rule__ScopeModel__IncludedScopesAssignment_2_1 ) + // InternalScope.g:5531:3: rule__ScopeModel__IncludedScopesAssignment_2_1 { pushFollow(FOLLOW_2); - rule__MatchDataExpression__ValueAssignment_2(); + rule__ScopeModel__IncludedScopesAssignment_2_1(); state._fsp--; if (state.failed) return ; @@ -18198,7 +20683,7 @@ public final void rule__MatchDataExpression__Group__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); + after(grammarAccess.getScopeModelAccess().getIncludedScopesAssignment_2_1()); } } @@ -18218,26 +20703,26 @@ public final void rule__MatchDataExpression__Group__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__MatchDataExpression__Group__2__Impl" + // $ANTLR end "rule__ScopeModel__Group_2__1__Impl" - // $ANTLR start "rule__LambdaDataExpression__Group__0" - // InternalScope.g:5334:1: rule__LambdaDataExpression__Group__0 : rule__LambdaDataExpression__Group__0__Impl rule__LambdaDataExpression__Group__1 ; - public final void rule__LambdaDataExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__Import__Group__0" + // InternalScope.g:5540:1: rule__Import__Group__0 : rule__Import__Group__0__Impl rule__Import__Group__1 ; + public final void rule__Import__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5338:1: ( rule__LambdaDataExpression__Group__0__Impl rule__LambdaDataExpression__Group__1 ) - // InternalScope.g:5339:2: rule__LambdaDataExpression__Group__0__Impl rule__LambdaDataExpression__Group__1 + // InternalScope.g:5544:1: ( rule__Import__Group__0__Impl rule__Import__Group__1 ) + // InternalScope.g:5545:2: rule__Import__Group__0__Impl rule__Import__Group__1 { - pushFollow(FOLLOW_3); - rule__LambdaDataExpression__Group__0__Impl(); + pushFollow(FOLLOW_10); + rule__Import__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LambdaDataExpression__Group__1(); + rule__Import__Group__1(); state._fsp--; if (state.failed) return ; @@ -18256,28 +20741,28 @@ public final void rule__LambdaDataExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__0" + // $ANTLR end "rule__Import__Group__0" - // $ANTLR start "rule__LambdaDataExpression__Group__0__Impl" - // InternalScope.g:5346:1: rule__LambdaDataExpression__Group__0__Impl : ( '[' ) ; - public final void rule__LambdaDataExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group__0__Impl" + // InternalScope.g:5552:1: rule__Import__Group__0__Impl : ( 'import' ) ; + public final void rule__Import__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5350:1: ( ( '[' ) ) - // InternalScope.g:5351:1: ( '[' ) + // InternalScope.g:5556:1: ( ( 'import' ) ) + // InternalScope.g:5557:1: ( 'import' ) { - // InternalScope.g:5351:1: ( '[' ) - // InternalScope.g:5352:2: '[' + // InternalScope.g:5557:1: ( 'import' ) + // InternalScope.g:5558:2: 'import' { if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); + before(grammarAccess.getImportAccess().getImportKeyword_0()); } - match(input,56,FOLLOW_2); if (state.failed) return ; + match(input,62,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); + after(grammarAccess.getImportAccess().getImportKeyword_0()); } } @@ -18297,26 +20782,26 @@ public final void rule__LambdaDataExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__0__Impl" + // $ANTLR end "rule__Import__Group__0__Impl" - // $ANTLR start "rule__LambdaDataExpression__Group__1" - // InternalScope.g:5361:1: rule__LambdaDataExpression__Group__1 : rule__LambdaDataExpression__Group__1__Impl rule__LambdaDataExpression__Group__2 ; - public final void rule__LambdaDataExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__Import__Group__1" + // InternalScope.g:5567:1: rule__Import__Group__1 : rule__Import__Group__1__Impl rule__Import__Group__2 ; + public final void rule__Import__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5365:1: ( rule__LambdaDataExpression__Group__1__Impl rule__LambdaDataExpression__Group__2 ) - // InternalScope.g:5366:2: rule__LambdaDataExpression__Group__1__Impl rule__LambdaDataExpression__Group__2 + // InternalScope.g:5571:1: ( rule__Import__Group__1__Impl rule__Import__Group__2 ) + // InternalScope.g:5572:2: rule__Import__Group__1__Impl rule__Import__Group__2 { - pushFollow(FOLLOW_42); - rule__LambdaDataExpression__Group__1__Impl(); + pushFollow(FOLLOW_11); + rule__Import__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LambdaDataExpression__Group__2(); + rule__Import__Group__2(); state._fsp--; if (state.failed) return ; @@ -18335,30 +20820,30 @@ public final void rule__LambdaDataExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__1" + // $ANTLR end "rule__Import__Group__1" - // $ANTLR start "rule__LambdaDataExpression__Group__1__Impl" - // InternalScope.g:5373:1: rule__LambdaDataExpression__Group__1__Impl : ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) ; - public final void rule__LambdaDataExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group__1__Impl" + // InternalScope.g:5579:1: rule__Import__Group__1__Impl : ( ( rule__Import__PackageAssignment_1 ) ) ; + public final void rule__Import__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5377:1: ( ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) ) - // InternalScope.g:5378:1: ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) + // InternalScope.g:5583:1: ( ( ( rule__Import__PackageAssignment_1 ) ) ) + // InternalScope.g:5584:1: ( ( rule__Import__PackageAssignment_1 ) ) { - // InternalScope.g:5378:1: ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) - // InternalScope.g:5379:2: ( rule__LambdaDataExpression__DescAssignment_1 ) + // InternalScope.g:5584:1: ( ( rule__Import__PackageAssignment_1 ) ) + // InternalScope.g:5585:2: ( rule__Import__PackageAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); + before(grammarAccess.getImportAccess().getPackageAssignment_1()); } - // InternalScope.g:5380:2: ( rule__LambdaDataExpression__DescAssignment_1 ) - // InternalScope.g:5380:3: rule__LambdaDataExpression__DescAssignment_1 + // InternalScope.g:5586:2: ( rule__Import__PackageAssignment_1 ) + // InternalScope.g:5586:3: rule__Import__PackageAssignment_1 { pushFollow(FOLLOW_2); - rule__LambdaDataExpression__DescAssignment_1(); + rule__Import__PackageAssignment_1(); state._fsp--; if (state.failed) return ; @@ -18366,7 +20851,7 @@ public final void rule__LambdaDataExpression__Group__1__Impl() throws Recognitio } if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); + after(grammarAccess.getImportAccess().getPackageAssignment_1()); } } @@ -18386,26 +20871,21 @@ public final void rule__LambdaDataExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__1__Impl" + // $ANTLR end "rule__Import__Group__1__Impl" - // $ANTLR start "rule__LambdaDataExpression__Group__2" - // InternalScope.g:5388:1: rule__LambdaDataExpression__Group__2 : rule__LambdaDataExpression__Group__2__Impl rule__LambdaDataExpression__Group__3 ; - public final void rule__LambdaDataExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__Import__Group__2" + // InternalScope.g:5594:1: rule__Import__Group__2 : rule__Import__Group__2__Impl ; + public final void rule__Import__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5392:1: ( rule__LambdaDataExpression__Group__2__Impl rule__LambdaDataExpression__Group__3 ) - // InternalScope.g:5393:2: rule__LambdaDataExpression__Group__2__Impl rule__LambdaDataExpression__Group__3 + // InternalScope.g:5598:1: ( rule__Import__Group__2__Impl ) + // InternalScope.g:5599:2: rule__Import__Group__2__Impl { - pushFollow(FOLLOW_17); - rule__LambdaDataExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LambdaDataExpression__Group__3(); + rule__Import__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -18424,28 +20904,49 @@ public final void rule__LambdaDataExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__2" + // $ANTLR end "rule__Import__Group__2" - // $ANTLR start "rule__LambdaDataExpression__Group__2__Impl" - // InternalScope.g:5400:1: rule__LambdaDataExpression__Group__2__Impl : ( '|' ) ; - public final void rule__LambdaDataExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group__2__Impl" + // InternalScope.g:5605:1: rule__Import__Group__2__Impl : ( ( rule__Import__Group_2__0 )? ) ; + public final void rule__Import__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5404:1: ( ( '|' ) ) - // InternalScope.g:5405:1: ( '|' ) + // InternalScope.g:5609:1: ( ( ( rule__Import__Group_2__0 )? ) ) + // InternalScope.g:5610:1: ( ( rule__Import__Group_2__0 )? ) { - // InternalScope.g:5405:1: ( '|' ) - // InternalScope.g:5406:2: '|' + // InternalScope.g:5610:1: ( ( rule__Import__Group_2__0 )? ) + // InternalScope.g:5611:2: ( rule__Import__Group_2__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); + before(grammarAccess.getImportAccess().getGroup_2()); + } + // InternalScope.g:5612:2: ( rule__Import__Group_2__0 )? + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==69) ) { + alt74=1; + } + switch (alt74) { + case 1 : + // InternalScope.g:5612:3: rule__Import__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__Import__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } - match(input,66,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); + after(grammarAccess.getImportAccess().getGroup_2()); } } @@ -18465,26 +20966,26 @@ public final void rule__LambdaDataExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__2__Impl" + // $ANTLR end "rule__Import__Group__2__Impl" - // $ANTLR start "rule__LambdaDataExpression__Group__3" - // InternalScope.g:5415:1: rule__LambdaDataExpression__Group__3 : rule__LambdaDataExpression__Group__3__Impl rule__LambdaDataExpression__Group__4 ; - public final void rule__LambdaDataExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__0" + // InternalScope.g:5621:1: rule__Import__Group_2__0 : rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ; + public final void rule__Import__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5419:1: ( rule__LambdaDataExpression__Group__3__Impl rule__LambdaDataExpression__Group__4 ) - // InternalScope.g:5420:2: rule__LambdaDataExpression__Group__3__Impl rule__LambdaDataExpression__Group__4 + // InternalScope.g:5625:1: ( rule__Import__Group_2__0__Impl rule__Import__Group_2__1 ) + // InternalScope.g:5626:2: rule__Import__Group_2__0__Impl rule__Import__Group_2__1 { - pushFollow(FOLLOW_30); - rule__LambdaDataExpression__Group__3__Impl(); + pushFollow(FOLLOW_4); + rule__Import__Group_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LambdaDataExpression__Group__4(); + rule__Import__Group_2__1(); state._fsp--; if (state.failed) return ; @@ -18503,38 +21004,28 @@ public final void rule__LambdaDataExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__3" + // $ANTLR end "rule__Import__Group_2__0" - // $ANTLR start "rule__LambdaDataExpression__Group__3__Impl" - // InternalScope.g:5427:1: rule__LambdaDataExpression__Group__3__Impl : ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) ; - public final void rule__LambdaDataExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__0__Impl" + // InternalScope.g:5633:1: rule__Import__Group_2__0__Impl : ( 'as' ) ; + public final void rule__Import__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5431:1: ( ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) ) - // InternalScope.g:5432:1: ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) + // InternalScope.g:5637:1: ( ( 'as' ) ) + // InternalScope.g:5638:1: ( 'as' ) { - // InternalScope.g:5432:1: ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) - // InternalScope.g:5433:2: ( rule__LambdaDataExpression__ValueAssignment_3 ) + // InternalScope.g:5638:1: ( 'as' ) + // InternalScope.g:5639:2: 'as' { if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); - } - // InternalScope.g:5434:2: ( rule__LambdaDataExpression__ValueAssignment_3 ) - // InternalScope.g:5434:3: rule__LambdaDataExpression__ValueAssignment_3 - { - pushFollow(FOLLOW_2); - rule__LambdaDataExpression__ValueAssignment_3(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getImportAccess().getAsKeyword_2_0()); } - + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); + after(grammarAccess.getImportAccess().getAsKeyword_2_0()); } } @@ -18554,21 +21045,21 @@ public final void rule__LambdaDataExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__3__Impl" + // $ANTLR end "rule__Import__Group_2__0__Impl" - // $ANTLR start "rule__LambdaDataExpression__Group__4" - // InternalScope.g:5442:1: rule__LambdaDataExpression__Group__4 : rule__LambdaDataExpression__Group__4__Impl ; - public final void rule__LambdaDataExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__1" + // InternalScope.g:5648:1: rule__Import__Group_2__1 : rule__Import__Group_2__1__Impl ; + public final void rule__Import__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5446:1: ( rule__LambdaDataExpression__Group__4__Impl ) - // InternalScope.g:5447:2: rule__LambdaDataExpression__Group__4__Impl + // InternalScope.g:5652:1: ( rule__Import__Group_2__1__Impl ) + // InternalScope.g:5653:2: rule__Import__Group_2__1__Impl { pushFollow(FOLLOW_2); - rule__LambdaDataExpression__Group__4__Impl(); + rule__Import__Group_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -18587,28 +21078,38 @@ public final void rule__LambdaDataExpression__Group__4() throws RecognitionExcep } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__4" + // $ANTLR end "rule__Import__Group_2__1" - // $ANTLR start "rule__LambdaDataExpression__Group__4__Impl" - // InternalScope.g:5453:1: rule__LambdaDataExpression__Group__4__Impl : ( ']' ) ; - public final void rule__LambdaDataExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__Import__Group_2__1__Impl" + // InternalScope.g:5659:1: rule__Import__Group_2__1__Impl : ( ( rule__Import__NameAssignment_2_1 ) ) ; + public final void rule__Import__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5457:1: ( ( ']' ) ) - // InternalScope.g:5458:1: ( ']' ) + // InternalScope.g:5663:1: ( ( ( rule__Import__NameAssignment_2_1 ) ) ) + // InternalScope.g:5664:1: ( ( rule__Import__NameAssignment_2_1 ) ) { - // InternalScope.g:5458:1: ( ']' ) - // InternalScope.g:5459:2: ']' + // InternalScope.g:5664:1: ( ( rule__Import__NameAssignment_2_1 ) ) + // InternalScope.g:5665:2: ( rule__Import__NameAssignment_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); + before(grammarAccess.getImportAccess().getNameAssignment_2_1()); + } + // InternalScope.g:5666:2: ( rule__Import__NameAssignment_2_1 ) + // InternalScope.g:5666:3: rule__Import__NameAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__Import__NameAssignment_2_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,57,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); + after(grammarAccess.getImportAccess().getNameAssignment_2_1()); } } @@ -18628,21 +21129,26 @@ public final void rule__LambdaDataExpression__Group__4__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__LambdaDataExpression__Group__4__Impl" + // $ANTLR end "rule__Import__Group_2__1__Impl" - // $ANTLR start "rule__Naming__Group_0__0" - // InternalScope.g:5469:1: rule__Naming__Group_0__0 : rule__Naming__Group_0__0__Impl ; - public final void rule__Naming__Group_0__0() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__0" + // InternalScope.g:5675:1: rule__Extension__Group__0 : rule__Extension__Group__0__Impl rule__Extension__Group__1 ; + public final void rule__Extension__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5473:1: ( rule__Naming__Group_0__0__Impl ) - // InternalScope.g:5474:2: rule__Naming__Group_0__0__Impl + // InternalScope.g:5679:1: ( rule__Extension__Group__0__Impl rule__Extension__Group__1 ) + // InternalScope.g:5680:2: rule__Extension__Group__0__Impl rule__Extension__Group__1 { + pushFollow(FOLLOW_4); + rule__Extension__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0__0__Impl(); + rule__Extension__Group__1(); state._fsp--; if (state.failed) return ; @@ -18661,38 +21167,28 @@ public final void rule__Naming__Group_0__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0__0" + // $ANTLR end "rule__Extension__Group__0" - // $ANTLR start "rule__Naming__Group_0__0__Impl" - // InternalScope.g:5480:1: rule__Naming__Group_0__0__Impl : ( ( rule__Naming__Group_0_0__0 ) ) ; - public final void rule__Naming__Group_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__0__Impl" + // InternalScope.g:5687:1: rule__Extension__Group__0__Impl : ( 'extension' ) ; + public final void rule__Extension__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5484:1: ( ( ( rule__Naming__Group_0_0__0 ) ) ) - // InternalScope.g:5485:1: ( ( rule__Naming__Group_0_0__0 ) ) + // InternalScope.g:5691:1: ( ( 'extension' ) ) + // InternalScope.g:5692:1: ( 'extension' ) { - // InternalScope.g:5485:1: ( ( rule__Naming__Group_0_0__0 ) ) - // InternalScope.g:5486:2: ( rule__Naming__Group_0_0__0 ) + // InternalScope.g:5692:1: ( 'extension' ) + // InternalScope.g:5693:2: 'extension' { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getGroup_0_0()); - } - // InternalScope.g:5487:2: ( rule__Naming__Group_0_0__0 ) - // InternalScope.g:5487:3: rule__Naming__Group_0_0__0 - { - pushFollow(FOLLOW_2); - rule__Naming__Group_0_0__0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } - + match(input,63,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getGroup_0_0()); + after(grammarAccess.getExtensionAccess().getExtensionKeyword_0()); } } @@ -18712,26 +21208,21 @@ public final void rule__Naming__Group_0__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0__0__Impl" + // $ANTLR end "rule__Extension__Group__0__Impl" - // $ANTLR start "rule__Naming__Group_0_0__0" - // InternalScope.g:5496:1: rule__Naming__Group_0_0__0 : rule__Naming__Group_0_0__0__Impl rule__Naming__Group_0_0__1 ; - public final void rule__Naming__Group_0_0__0() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__1" + // InternalScope.g:5702:1: rule__Extension__Group__1 : rule__Extension__Group__1__Impl ; + public final void rule__Extension__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5500:1: ( rule__Naming__Group_0_0__0__Impl rule__Naming__Group_0_0__1 ) - // InternalScope.g:5501:2: rule__Naming__Group_0_0__0__Impl rule__Naming__Group_0_0__1 + // InternalScope.g:5706:1: ( rule__Extension__Group__1__Impl ) + // InternalScope.g:5707:2: rule__Extension__Group__1__Impl { - pushFollow(FOLLOW_17); - rule__Naming__Group_0_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0_0__1(); + rule__Extension__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -18750,28 +21241,38 @@ public final void rule__Naming__Group_0_0__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0_0__0" + // $ANTLR end "rule__Extension__Group__1" - // $ANTLR start "rule__Naming__Group_0_0__0__Impl" - // InternalScope.g:5508:1: rule__Naming__Group_0_0__0__Impl : ( '(' ) ; - public final void rule__Naming__Group_0_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Extension__Group__1__Impl" + // InternalScope.g:5713:1: rule__Extension__Group__1__Impl : ( ( rule__Extension__ExtensionAssignment_1 ) ) ; + public final void rule__Extension__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5512:1: ( ( '(' ) ) - // InternalScope.g:5513:1: ( '(' ) + // InternalScope.g:5717:1: ( ( ( rule__Extension__ExtensionAssignment_1 ) ) ) + // InternalScope.g:5718:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) { - // InternalScope.g:5513:1: ( '(' ) - // InternalScope.g:5514:2: '(' + // InternalScope.g:5718:1: ( ( rule__Extension__ExtensionAssignment_1 ) ) + // InternalScope.g:5719:2: ( rule__Extension__ExtensionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); + before(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:5720:2: ( rule__Extension__ExtensionAssignment_1 ) + // InternalScope.g:5720:3: rule__Extension__ExtensionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Extension__ExtensionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); + after(grammarAccess.getExtensionAccess().getExtensionAssignment_1()); } } @@ -18791,26 +21292,26 @@ public final void rule__Naming__Group_0_0__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Naming__Group_0_0__0__Impl" + // $ANTLR end "rule__Extension__Group__1__Impl" - // $ANTLR start "rule__Naming__Group_0_0__1" - // InternalScope.g:5523:1: rule__Naming__Group_0_0__1 : rule__Naming__Group_0_0__1__Impl rule__Naming__Group_0_0__2 ; - public final void rule__Naming__Group_0_0__1() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__0" + // InternalScope.g:5729:1: rule__Injection__Group__0 : rule__Injection__Group__0__Impl rule__Injection__Group__1 ; + public final void rule__Injection__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5527:1: ( rule__Naming__Group_0_0__1__Impl rule__Naming__Group_0_0__2 ) - // InternalScope.g:5528:2: rule__Naming__Group_0_0__1__Impl rule__Naming__Group_0_0__2 + // InternalScope.g:5733:1: ( rule__Injection__Group__0__Impl rule__Injection__Group__1 ) + // InternalScope.g:5734:2: rule__Injection__Group__0__Impl rule__Injection__Group__1 { - pushFollow(FOLLOW_33); - rule__Naming__Group_0_0__1__Impl(); + pushFollow(FOLLOW_4); + rule__Injection__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0_0__2(); + rule__Injection__Group__1(); state._fsp--; if (state.failed) return ; @@ -18829,38 +21330,28 @@ public final void rule__Naming__Group_0_0__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0_0__1" + // $ANTLR end "rule__Injection__Group__0" - // $ANTLR start "rule__Naming__Group_0_0__1__Impl" - // InternalScope.g:5535:1: rule__Naming__Group_0_0__1__Impl : ( ( rule__Naming__NamesAssignment_0_0_1 ) ) ; - public final void rule__Naming__Group_0_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__0__Impl" + // InternalScope.g:5741:1: rule__Injection__Group__0__Impl : ( 'inject' ) ; + public final void rule__Injection__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5539:1: ( ( ( rule__Naming__NamesAssignment_0_0_1 ) ) ) - // InternalScope.g:5540:1: ( ( rule__Naming__NamesAssignment_0_0_1 ) ) + // InternalScope.g:5745:1: ( ( 'inject' ) ) + // InternalScope.g:5746:1: ( 'inject' ) { - // InternalScope.g:5540:1: ( ( rule__Naming__NamesAssignment_0_0_1 ) ) - // InternalScope.g:5541:2: ( rule__Naming__NamesAssignment_0_0_1 ) + // InternalScope.g:5746:1: ( 'inject' ) + // InternalScope.g:5747:2: 'inject' { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); - } - // InternalScope.g:5542:2: ( rule__Naming__NamesAssignment_0_0_1 ) - // InternalScope.g:5542:3: rule__Naming__NamesAssignment_0_0_1 - { - pushFollow(FOLLOW_2); - rule__Naming__NamesAssignment_0_0_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getInjectionAccess().getInjectKeyword_0()); } - + match(input,70,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); + after(grammarAccess.getInjectionAccess().getInjectKeyword_0()); } } @@ -18880,26 +21371,26 @@ public final void rule__Naming__Group_0_0__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Naming__Group_0_0__1__Impl" + // $ANTLR end "rule__Injection__Group__0__Impl" - // $ANTLR start "rule__Naming__Group_0_0__2" - // InternalScope.g:5550:1: rule__Naming__Group_0_0__2 : rule__Naming__Group_0_0__2__Impl rule__Naming__Group_0_0__3 ; - public final void rule__Naming__Group_0_0__2() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__1" + // InternalScope.g:5756:1: rule__Injection__Group__1 : rule__Injection__Group__1__Impl rule__Injection__Group__2 ; + public final void rule__Injection__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5554:1: ( rule__Naming__Group_0_0__2__Impl rule__Naming__Group_0_0__3 ) - // InternalScope.g:5555:2: rule__Naming__Group_0_0__2__Impl rule__Naming__Group_0_0__3 + // InternalScope.g:5760:1: ( rule__Injection__Group__1__Impl rule__Injection__Group__2 ) + // InternalScope.g:5761:2: rule__Injection__Group__1__Impl rule__Injection__Group__2 { - pushFollow(FOLLOW_33); - rule__Naming__Group_0_0__2__Impl(); + pushFollow(FOLLOW_11); + rule__Injection__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0_0__3(); + rule__Injection__Group__2(); state._fsp--; if (state.failed) return ; @@ -18918,56 +21409,38 @@ public final void rule__Naming__Group_0_0__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0_0__2" + // $ANTLR end "rule__Injection__Group__1" - // $ANTLR start "rule__Naming__Group_0_0__2__Impl" - // InternalScope.g:5562:1: rule__Naming__Group_0_0__2__Impl : ( ( rule__Naming__Group_0_0_2__0 )* ) ; - public final void rule__Naming__Group_0_0__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__1__Impl" + // InternalScope.g:5768:1: rule__Injection__Group__1__Impl : ( ( rule__Injection__TypeAssignment_1 ) ) ; + public final void rule__Injection__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5566:1: ( ( ( rule__Naming__Group_0_0_2__0 )* ) ) - // InternalScope.g:5567:1: ( ( rule__Naming__Group_0_0_2__0 )* ) + // InternalScope.g:5772:1: ( ( ( rule__Injection__TypeAssignment_1 ) ) ) + // InternalScope.g:5773:1: ( ( rule__Injection__TypeAssignment_1 ) ) { - // InternalScope.g:5567:1: ( ( rule__Naming__Group_0_0_2__0 )* ) - // InternalScope.g:5568:2: ( rule__Naming__Group_0_0_2__0 )* + // InternalScope.g:5773:1: ( ( rule__Injection__TypeAssignment_1 ) ) + // InternalScope.g:5774:2: ( rule__Injection__TypeAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getGroup_0_0_2()); + before(grammarAccess.getInjectionAccess().getTypeAssignment_1()); } - // InternalScope.g:5569:2: ( rule__Naming__Group_0_0_2__0 )* - loop50: - do { - int alt50=2; - int LA50_0 = input.LA(1); - - if ( (LA50_0==60) ) { - alt50=1; - } - - - switch (alt50) { - case 1 : - // InternalScope.g:5569:3: rule__Naming__Group_0_0_2__0 - { - pushFollow(FOLLOW_39); - rule__Naming__Group_0_0_2__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:5775:2: ( rule__Injection__TypeAssignment_1 ) + // InternalScope.g:5775:3: rule__Injection__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Injection__TypeAssignment_1(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop50; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getGroup_0_0_2()); + after(grammarAccess.getInjectionAccess().getTypeAssignment_1()); } } @@ -18987,21 +21460,26 @@ public final void rule__Naming__Group_0_0__2__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Naming__Group_0_0__2__Impl" + // $ANTLR end "rule__Injection__Group__1__Impl" - // $ANTLR start "rule__Naming__Group_0_0__3" - // InternalScope.g:5577:1: rule__Naming__Group_0_0__3 : rule__Naming__Group_0_0__3__Impl ; - public final void rule__Naming__Group_0_0__3() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__2" + // InternalScope.g:5783:1: rule__Injection__Group__2 : rule__Injection__Group__2__Impl rule__Injection__Group__3 ; + public final void rule__Injection__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5581:1: ( rule__Naming__Group_0_0__3__Impl ) - // InternalScope.g:5582:2: rule__Naming__Group_0_0__3__Impl + // InternalScope.g:5787:1: ( rule__Injection__Group__2__Impl rule__Injection__Group__3 ) + // InternalScope.g:5788:2: rule__Injection__Group__2__Impl rule__Injection__Group__3 { + pushFollow(FOLLOW_4); + rule__Injection__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0_0__3__Impl(); + rule__Injection__Group__3(); state._fsp--; if (state.failed) return ; @@ -19020,28 +21498,28 @@ public final void rule__Naming__Group_0_0__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0_0__3" + // $ANTLR end "rule__Injection__Group__2" - // $ANTLR start "rule__Naming__Group_0_0__3__Impl" - // InternalScope.g:5588:1: rule__Naming__Group_0_0__3__Impl : ( ')' ) ; - public final void rule__Naming__Group_0_0__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__2__Impl" + // InternalScope.g:5795:1: rule__Injection__Group__2__Impl : ( 'as' ) ; + public final void rule__Injection__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5592:1: ( ( ')' ) ) - // InternalScope.g:5593:1: ( ')' ) + // InternalScope.g:5799:1: ( ( 'as' ) ) + // InternalScope.g:5800:1: ( 'as' ) { - // InternalScope.g:5593:1: ( ')' ) - // InternalScope.g:5594:2: ')' + // InternalScope.g:5800:1: ( 'as' ) + // InternalScope.g:5801:2: 'as' { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); + before(grammarAccess.getInjectionAccess().getAsKeyword_2()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); + after(grammarAccess.getInjectionAccess().getAsKeyword_2()); } } @@ -19061,26 +21539,21 @@ public final void rule__Naming__Group_0_0__3__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__Naming__Group_0_0__3__Impl" + // $ANTLR end "rule__Injection__Group__2__Impl" - // $ANTLR start "rule__Naming__Group_0_0_2__0" - // InternalScope.g:5604:1: rule__Naming__Group_0_0_2__0 : rule__Naming__Group_0_0_2__0__Impl rule__Naming__Group_0_0_2__1 ; - public final void rule__Naming__Group_0_0_2__0() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__3" + // InternalScope.g:5810:1: rule__Injection__Group__3 : rule__Injection__Group__3__Impl ; + public final void rule__Injection__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5608:1: ( rule__Naming__Group_0_0_2__0__Impl rule__Naming__Group_0_0_2__1 ) - // InternalScope.g:5609:2: rule__Naming__Group_0_0_2__0__Impl rule__Naming__Group_0_0_2__1 + // InternalScope.g:5814:1: ( rule__Injection__Group__3__Impl ) + // InternalScope.g:5815:2: rule__Injection__Group__3__Impl { - pushFollow(FOLLOW_17); - rule__Naming__Group_0_0_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0_0_2__1(); + rule__Injection__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -19099,28 +21572,38 @@ public final void rule__Naming__Group_0_0_2__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0_0_2__0" + // $ANTLR end "rule__Injection__Group__3" - // $ANTLR start "rule__Naming__Group_0_0_2__0__Impl" - // InternalScope.g:5616:1: rule__Naming__Group_0_0_2__0__Impl : ( ',' ) ; - public final void rule__Naming__Group_0_0_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Injection__Group__3__Impl" + // InternalScope.g:5821:1: rule__Injection__Group__3__Impl : ( ( rule__Injection__NameAssignment_3 ) ) ; + public final void rule__Injection__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5620:1: ( ( ',' ) ) - // InternalScope.g:5621:1: ( ',' ) + // InternalScope.g:5825:1: ( ( ( rule__Injection__NameAssignment_3 ) ) ) + // InternalScope.g:5826:1: ( ( rule__Injection__NameAssignment_3 ) ) { - // InternalScope.g:5621:1: ( ',' ) - // InternalScope.g:5622:2: ',' + // InternalScope.g:5826:1: ( ( rule__Injection__NameAssignment_3 ) ) + // InternalScope.g:5827:2: ( rule__Injection__NameAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); + before(grammarAccess.getInjectionAccess().getNameAssignment_3()); } - match(input,60,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:5828:2: ( rule__Injection__NameAssignment_3 ) + // InternalScope.g:5828:3: rule__Injection__NameAssignment_3 + { + pushFollow(FOLLOW_2); + rule__Injection__NameAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); + after(grammarAccess.getInjectionAccess().getNameAssignment_3()); } } @@ -19140,21 +21623,26 @@ public final void rule__Naming__Group_0_0_2__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Naming__Group_0_0_2__0__Impl" + // $ANTLR end "rule__Injection__Group__3__Impl" - // $ANTLR start "rule__Naming__Group_0_0_2__1" - // InternalScope.g:5631:1: rule__Naming__Group_0_0_2__1 : rule__Naming__Group_0_0_2__1__Impl ; - public final void rule__Naming__Group_0_0_2__1() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__0" + // InternalScope.g:5837:1: rule__NamingSection__Group__0 : rule__NamingSection__Group__0__Impl rule__NamingSection__Group__1 ; + public final void rule__NamingSection__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5635:1: ( rule__Naming__Group_0_0_2__1__Impl ) - // InternalScope.g:5636:2: rule__Naming__Group_0_0_2__1__Impl + // InternalScope.g:5841:1: ( rule__NamingSection__Group__0__Impl rule__NamingSection__Group__1 ) + // InternalScope.g:5842:2: rule__NamingSection__Group__0__Impl rule__NamingSection__Group__1 { + pushFollow(FOLLOW_12); + rule__NamingSection__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Naming__Group_0_0_2__1__Impl(); + rule__NamingSection__Group__1(); state._fsp--; if (state.failed) return ; @@ -19173,38 +21661,32 @@ public final void rule__Naming__Group_0_0_2__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Naming__Group_0_0_2__1" + // $ANTLR end "rule__NamingSection__Group__0" - // $ANTLR start "rule__Naming__Group_0_0_2__1__Impl" - // InternalScope.g:5642:1: rule__Naming__Group_0_0_2__1__Impl : ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) ; - public final void rule__Naming__Group_0_0_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__0__Impl" + // InternalScope.g:5849:1: rule__NamingSection__Group__0__Impl : ( () ) ; + public final void rule__NamingSection__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5646:1: ( ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) ) - // InternalScope.g:5647:1: ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) + // InternalScope.g:5853:1: ( ( () ) ) + // InternalScope.g:5854:1: ( () ) { - // InternalScope.g:5647:1: ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) - // InternalScope.g:5648:2: ( rule__Naming__NamesAssignment_0_0_2_1 ) + // InternalScope.g:5854:1: ( () ) + // InternalScope.g:5855:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); + before(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); } - // InternalScope.g:5649:2: ( rule__Naming__NamesAssignment_0_0_2_1 ) - // InternalScope.g:5649:3: rule__Naming__NamesAssignment_0_0_2_1 + // InternalScope.g:5856:2: () + // InternalScope.g:5856:3: { - pushFollow(FOLLOW_2); - rule__Naming__NamesAssignment_0_0_2_1(); - - state._fsp--; - if (state.failed) return ; - } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); + after(grammarAccess.getNamingSectionAccess().getNamingSectionAction_0()); } } @@ -19213,10 +21695,6 @@ public final void rule__Naming__Group_0_0_2__1__Impl() throws RecognitionExcepti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -19224,26 +21702,26 @@ public final void rule__Naming__Group_0_0_2__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__Naming__Group_0_0_2__1__Impl" + // $ANTLR end "rule__NamingSection__Group__0__Impl" - // $ANTLR start "rule__NamingExpression__Group_1__0" - // InternalScope.g:5658:1: rule__NamingExpression__Group_1__0 : rule__NamingExpression__Group_1__0__Impl rule__NamingExpression__Group_1__1 ; - public final void rule__NamingExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__1" + // InternalScope.g:5864:1: rule__NamingSection__Group__1 : rule__NamingSection__Group__1__Impl rule__NamingSection__Group__2 ; + public final void rule__NamingSection__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5662:1: ( rule__NamingExpression__Group_1__0__Impl rule__NamingExpression__Group_1__1 ) - // InternalScope.g:5663:2: rule__NamingExpression__Group_1__0__Impl rule__NamingExpression__Group_1__1 + // InternalScope.g:5868:1: ( rule__NamingSection__Group__1__Impl rule__NamingSection__Group__2 ) + // InternalScope.g:5869:2: rule__NamingSection__Group__1__Impl rule__NamingSection__Group__2 { - pushFollow(FOLLOW_17); - rule__NamingExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_12); + rule__NamingSection__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__NamingExpression__Group_1__1(); + rule__NamingSection__Group__2(); state._fsp--; if (state.failed) return ; @@ -19262,38 +21740,38 @@ public final void rule__NamingExpression__Group_1__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__NamingExpression__Group_1__0" + // $ANTLR end "rule__NamingSection__Group__1" - // $ANTLR start "rule__NamingExpression__Group_1__0__Impl" - // InternalScope.g:5670:1: rule__NamingExpression__Group_1__0__Impl : ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) ; - public final void rule__NamingExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__1__Impl" + // InternalScope.g:5876:1: rule__NamingSection__Group__1__Impl : ( ( rule__NamingSection__Group_1__0 )? ) ; + public final void rule__NamingSection__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5674:1: ( ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) ) - // InternalScope.g:5675:1: ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) + // InternalScope.g:5880:1: ( ( ( rule__NamingSection__Group_1__0 )? ) ) + // InternalScope.g:5881:1: ( ( rule__NamingSection__Group_1__0 )? ) { - // InternalScope.g:5675:1: ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) - // InternalScope.g:5676:2: ( rule__NamingExpression__FactoryAssignment_1_0 )? + // InternalScope.g:5881:1: ( ( rule__NamingSection__Group_1__0 )? ) + // InternalScope.g:5882:2: ( rule__NamingSection__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); + before(grammarAccess.getNamingSectionAccess().getGroup_1()); } - // InternalScope.g:5677:2: ( rule__NamingExpression__FactoryAssignment_1_0 )? - int alt51=2; - int LA51_0 = input.LA(1); + // InternalScope.g:5883:2: ( rule__NamingSection__Group_1__0 )? + int alt75=2; + int LA75_0 = input.LA(1); - if ( (LA51_0==58) ) { - alt51=1; + if ( (LA75_0==74) ) { + alt75=1; } - switch (alt51) { + switch (alt75) { case 1 : - // InternalScope.g:5677:3: rule__NamingExpression__FactoryAssignment_1_0 + // InternalScope.g:5883:3: rule__NamingSection__Group_1__0 { pushFollow(FOLLOW_2); - rule__NamingExpression__FactoryAssignment_1_0(); + rule__NamingSection__Group_1__0(); state._fsp--; if (state.failed) return ; @@ -19304,7 +21782,7 @@ public final void rule__NamingExpression__Group_1__0__Impl() throws RecognitionE } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); + after(grammarAccess.getNamingSectionAccess().getGroup_1()); } } @@ -19324,21 +21802,26 @@ public final void rule__NamingExpression__Group_1__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__NamingExpression__Group_1__0__Impl" + // $ANTLR end "rule__NamingSection__Group__1__Impl" - // $ANTLR start "rule__NamingExpression__Group_1__1" - // InternalScope.g:5685:1: rule__NamingExpression__Group_1__1 : rule__NamingExpression__Group_1__1__Impl ; - public final void rule__NamingExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__2" + // InternalScope.g:5891:1: rule__NamingSection__Group__2 : rule__NamingSection__Group__2__Impl rule__NamingSection__Group__3 ; + public final void rule__NamingSection__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5689:1: ( rule__NamingExpression__Group_1__1__Impl ) - // InternalScope.g:5690:2: rule__NamingExpression__Group_1__1__Impl + // InternalScope.g:5895:1: ( rule__NamingSection__Group__2__Impl rule__NamingSection__Group__3 ) + // InternalScope.g:5896:2: rule__NamingSection__Group__2__Impl rule__NamingSection__Group__3 { + pushFollow(FOLLOW_13); + rule__NamingSection__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__NamingExpression__Group_1__1__Impl(); + rule__NamingSection__Group__3(); state._fsp--; if (state.failed) return ; @@ -19357,38 +21840,28 @@ public final void rule__NamingExpression__Group_1__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__NamingExpression__Group_1__1" + // $ANTLR end "rule__NamingSection__Group__2" - // $ANTLR start "rule__NamingExpression__Group_1__1__Impl" - // InternalScope.g:5696:1: rule__NamingExpression__Group_1__1__Impl : ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) ; - public final void rule__NamingExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__2__Impl" + // InternalScope.g:5903:1: rule__NamingSection__Group__2__Impl : ( 'naming' ) ; + public final void rule__NamingSection__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5700:1: ( ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) ) - // InternalScope.g:5701:1: ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) + // InternalScope.g:5907:1: ( ( 'naming' ) ) + // InternalScope.g:5908:1: ( 'naming' ) { - // InternalScope.g:5701:1: ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) - // InternalScope.g:5702:2: ( rule__NamingExpression__ExpressionAssignment_1_1 ) + // InternalScope.g:5908:1: ( 'naming' ) + // InternalScope.g:5909:2: 'naming' { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); - } - // InternalScope.g:5703:2: ( rule__NamingExpression__ExpressionAssignment_1_1 ) - // InternalScope.g:5703:3: rule__NamingExpression__ExpressionAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__NamingExpression__ExpressionAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } - + match(input,71,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); + after(grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } } @@ -19408,26 +21881,26 @@ public final void rule__NamingExpression__Group_1__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__NamingExpression__Group_1__1__Impl" + // $ANTLR end "rule__NamingSection__Group__2__Impl" - // $ANTLR start "rule__QualifiedID__Group__0" - // InternalScope.g:5712:1: rule__QualifiedID__Group__0 : rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ; - public final void rule__QualifiedID__Group__0() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__3" + // InternalScope.g:5918:1: rule__NamingSection__Group__3 : rule__NamingSection__Group__3__Impl rule__NamingSection__Group__4 ; + public final void rule__NamingSection__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5716:1: ( rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ) - // InternalScope.g:5717:2: rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 + // InternalScope.g:5922:1: ( rule__NamingSection__Group__3__Impl rule__NamingSection__Group__4 ) + // InternalScope.g:5923:2: rule__NamingSection__Group__3__Impl rule__NamingSection__Group__4 { - pushFollow(FOLLOW_43); - rule__QualifiedID__Group__0__Impl(); + pushFollow(FOLLOW_14); + rule__NamingSection__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__QualifiedID__Group__1(); + rule__NamingSection__Group__4(); state._fsp--; if (state.failed) return ; @@ -19446,32 +21919,28 @@ public final void rule__QualifiedID__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group__0" + // $ANTLR end "rule__NamingSection__Group__3" - // $ANTLR start "rule__QualifiedID__Group__0__Impl" - // InternalScope.g:5724:1: rule__QualifiedID__Group__0__Impl : ( ruleIdentifier ) ; - public final void rule__QualifiedID__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__3__Impl" + // InternalScope.g:5930:1: rule__NamingSection__Group__3__Impl : ( '{' ) ; + public final void rule__NamingSection__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5728:1: ( ( ruleIdentifier ) ) - // InternalScope.g:5729:1: ( ruleIdentifier ) + // InternalScope.g:5934:1: ( ( '{' ) ) + // InternalScope.g:5935:1: ( '{' ) { - // InternalScope.g:5729:1: ( ruleIdentifier ) - // InternalScope.g:5730:2: ruleIdentifier + // InternalScope.g:5935:1: ( '{' ) + // InternalScope.g:5936:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); + before(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); } - pushFollow(FOLLOW_2); - ruleIdentifier(); - - state._fsp--; - if (state.failed) return ; + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); + after(grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); } } @@ -19491,21 +21960,26 @@ public final void rule__QualifiedID__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__QualifiedID__Group__0__Impl" + // $ANTLR end "rule__NamingSection__Group__3__Impl" - // $ANTLR start "rule__QualifiedID__Group__1" - // InternalScope.g:5739:1: rule__QualifiedID__Group__1 : rule__QualifiedID__Group__1__Impl ; - public final void rule__QualifiedID__Group__1() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__4" + // InternalScope.g:5945:1: rule__NamingSection__Group__4 : rule__NamingSection__Group__4__Impl rule__NamingSection__Group__5 ; + public final void rule__NamingSection__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5743:1: ( rule__QualifiedID__Group__1__Impl ) - // InternalScope.g:5744:2: rule__QualifiedID__Group__1__Impl + // InternalScope.g:5949:1: ( rule__NamingSection__Group__4__Impl rule__NamingSection__Group__5 ) + // InternalScope.g:5950:2: rule__NamingSection__Group__4__Impl rule__NamingSection__Group__5 { + pushFollow(FOLLOW_14); + rule__NamingSection__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__QualifiedID__Group__1__Impl(); + rule__NamingSection__Group__5(); state._fsp--; if (state.failed) return ; @@ -19524,42 +21998,42 @@ public final void rule__QualifiedID__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group__1" + // $ANTLR end "rule__NamingSection__Group__4" - // $ANTLR start "rule__QualifiedID__Group__1__Impl" - // InternalScope.g:5750:1: rule__QualifiedID__Group__1__Impl : ( ( rule__QualifiedID__Group_1__0 )* ) ; - public final void rule__QualifiedID__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__4__Impl" + // InternalScope.g:5957:1: rule__NamingSection__Group__4__Impl : ( ( rule__NamingSection__NamingsAssignment_4 )* ) ; + public final void rule__NamingSection__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5754:1: ( ( ( rule__QualifiedID__Group_1__0 )* ) ) - // InternalScope.g:5755:1: ( ( rule__QualifiedID__Group_1__0 )* ) + // InternalScope.g:5961:1: ( ( ( rule__NamingSection__NamingsAssignment_4 )* ) ) + // InternalScope.g:5962:1: ( ( rule__NamingSection__NamingsAssignment_4 )* ) { - // InternalScope.g:5755:1: ( ( rule__QualifiedID__Group_1__0 )* ) - // InternalScope.g:5756:2: ( rule__QualifiedID__Group_1__0 )* + // InternalScope.g:5962:1: ( ( rule__NamingSection__NamingsAssignment_4 )* ) + // InternalScope.g:5963:2: ( rule__NamingSection__NamingsAssignment_4 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getGroup_1()); + before(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); } - // InternalScope.g:5757:2: ( rule__QualifiedID__Group_1__0 )* - loop52: + // InternalScope.g:5964:2: ( rule__NamingSection__NamingsAssignment_4 )* + loop76: do { - int alt52=2; - int LA52_0 = input.LA(1); + int alt76=2; + int LA76_0 = input.LA(1); - if ( (LA52_0==67) ) { - alt52=1; + if ( (LA76_0==RULE_ID) ) { + alt76=1; } - switch (alt52) { + switch (alt76) { case 1 : - // InternalScope.g:5757:3: rule__QualifiedID__Group_1__0 + // InternalScope.g:5964:3: rule__NamingSection__NamingsAssignment_4 { - pushFollow(FOLLOW_44); - rule__QualifiedID__Group_1__0(); + pushFollow(FOLLOW_3); + rule__NamingSection__NamingsAssignment_4(); state._fsp--; if (state.failed) return ; @@ -19568,12 +22042,12 @@ public final void rule__QualifiedID__Group__1__Impl() throws RecognitionExceptio break; default : - break loop52; + break loop76; } } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getGroup_1()); + after(grammarAccess.getNamingSectionAccess().getNamingsAssignment_4()); } } @@ -19593,26 +22067,21 @@ public final void rule__QualifiedID__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__QualifiedID__Group__1__Impl" + // $ANTLR end "rule__NamingSection__Group__4__Impl" - // $ANTLR start "rule__QualifiedID__Group_1__0" - // InternalScope.g:5766:1: rule__QualifiedID__Group_1__0 : rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ; - public final void rule__QualifiedID__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__5" + // InternalScope.g:5972:1: rule__NamingSection__Group__5 : rule__NamingSection__Group__5__Impl ; + public final void rule__NamingSection__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5770:1: ( rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ) - // InternalScope.g:5771:2: rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 + // InternalScope.g:5976:1: ( rule__NamingSection__Group__5__Impl ) + // InternalScope.g:5977:2: rule__NamingSection__Group__5__Impl { - pushFollow(FOLLOW_3); - rule__QualifiedID__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__QualifiedID__Group_1__1(); + rule__NamingSection__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -19631,28 +22100,28 @@ public final void rule__QualifiedID__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group_1__0" + // $ANTLR end "rule__NamingSection__Group__5" - // $ANTLR start "rule__QualifiedID__Group_1__0__Impl" - // InternalScope.g:5778:1: rule__QualifiedID__Group_1__0__Impl : ( '::' ) ; - public final void rule__QualifiedID__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group__5__Impl" + // InternalScope.g:5983:1: rule__NamingSection__Group__5__Impl : ( '}' ) ; + public final void rule__NamingSection__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5782:1: ( ( '::' ) ) - // InternalScope.g:5783:1: ( '::' ) + // InternalScope.g:5987:1: ( ( '}' ) ) + // InternalScope.g:5988:1: ( '}' ) { - // InternalScope.g:5783:1: ( '::' ) - // InternalScope.g:5784:2: '::' + // InternalScope.g:5988:1: ( '}' ) + // InternalScope.g:5989:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); + before(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); } - match(input,67,FOLLOW_2); if (state.failed) return ; + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); + after(grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); } } @@ -19672,21 +22141,26 @@ public final void rule__QualifiedID__Group_1__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__QualifiedID__Group_1__0__Impl" + // $ANTLR end "rule__NamingSection__Group__5__Impl" - // $ANTLR start "rule__QualifiedID__Group_1__1" - // InternalScope.g:5793:1: rule__QualifiedID__Group_1__1 : rule__QualifiedID__Group_1__1__Impl ; - public final void rule__QualifiedID__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group_1__0" + // InternalScope.g:5999:1: rule__NamingSection__Group_1__0 : rule__NamingSection__Group_1__0__Impl rule__NamingSection__Group_1__1 ; + public final void rule__NamingSection__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5797:1: ( rule__QualifiedID__Group_1__1__Impl ) - // InternalScope.g:5798:2: rule__QualifiedID__Group_1__1__Impl + // InternalScope.g:6003:1: ( rule__NamingSection__Group_1__0__Impl rule__NamingSection__Group_1__1 ) + // InternalScope.g:6004:2: rule__NamingSection__Group_1__0__Impl rule__NamingSection__Group_1__1 { + pushFollow(FOLLOW_15); + rule__NamingSection__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__QualifiedID__Group_1__1__Impl(); + rule__NamingSection__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -19705,32 +22179,28 @@ public final void rule__QualifiedID__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__QualifiedID__Group_1__1" + // $ANTLR end "rule__NamingSection__Group_1__0" - // $ANTLR start "rule__QualifiedID__Group_1__1__Impl" - // InternalScope.g:5804:1: rule__QualifiedID__Group_1__1__Impl : ( ruleIdentifier ) ; - public final void rule__QualifiedID__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group_1__0__Impl" + // InternalScope.g:6011:1: rule__NamingSection__Group_1__0__Impl : ( 'case' ) ; + public final void rule__NamingSection__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5808:1: ( ( ruleIdentifier ) ) - // InternalScope.g:5809:1: ( ruleIdentifier ) + // InternalScope.g:6015:1: ( ( 'case' ) ) + // InternalScope.g:6016:1: ( 'case' ) { - // InternalScope.g:5809:1: ( ruleIdentifier ) - // InternalScope.g:5810:2: ruleIdentifier + // InternalScope.g:6016:1: ( 'case' ) + // InternalScope.g:6017:2: 'case' { if ( state.backtracking==0 ) { - before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); + before(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); } - pushFollow(FOLLOW_2); - ruleIdentifier(); - - state._fsp--; - if (state.failed) return ; + match(input,74,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); + after(grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); } } @@ -19750,26 +22220,21 @@ public final void rule__QualifiedID__Group_1__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__QualifiedID__Group_1__1__Impl" + // $ANTLR end "rule__NamingSection__Group_1__0__Impl" - // $ANTLR start "rule__DottedID__Group__0" - // InternalScope.g:5820:1: rule__DottedID__Group__0 : rule__DottedID__Group__0__Impl rule__DottedID__Group__1 ; - public final void rule__DottedID__Group__0() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group_1__1" + // InternalScope.g:6026:1: rule__NamingSection__Group_1__1 : rule__NamingSection__Group_1__1__Impl ; + public final void rule__NamingSection__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5824:1: ( rule__DottedID__Group__0__Impl rule__DottedID__Group__1 ) - // InternalScope.g:5825:2: rule__DottedID__Group__0__Impl rule__DottedID__Group__1 + // InternalScope.g:6030:1: ( rule__NamingSection__Group_1__1__Impl ) + // InternalScope.g:6031:2: rule__NamingSection__Group_1__1__Impl { - pushFollow(FOLLOW_45); - rule__DottedID__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__DottedID__Group__1(); + rule__NamingSection__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -19788,32 +22253,38 @@ public final void rule__DottedID__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__DottedID__Group__0" + // $ANTLR end "rule__NamingSection__Group_1__1" - // $ANTLR start "rule__DottedID__Group__0__Impl" - // InternalScope.g:5832:1: rule__DottedID__Group__0__Impl : ( ruleIdentifier ) ; - public final void rule__DottedID__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingSection__Group_1__1__Impl" + // InternalScope.g:6037:1: rule__NamingSection__Group_1__1__Impl : ( ( rule__NamingSection__CasingAssignment_1_1 ) ) ; + public final void rule__NamingSection__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5836:1: ( ( ruleIdentifier ) ) - // InternalScope.g:5837:1: ( ruleIdentifier ) + // InternalScope.g:6041:1: ( ( ( rule__NamingSection__CasingAssignment_1_1 ) ) ) + // InternalScope.g:6042:1: ( ( rule__NamingSection__CasingAssignment_1_1 ) ) { - // InternalScope.g:5837:1: ( ruleIdentifier ) - // InternalScope.g:5838:2: ruleIdentifier + // InternalScope.g:6042:1: ( ( rule__NamingSection__CasingAssignment_1_1 ) ) + // InternalScope.g:6043:2: ( rule__NamingSection__CasingAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); + before(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); } + // InternalScope.g:6044:2: ( rule__NamingSection__CasingAssignment_1_1 ) + // InternalScope.g:6044:3: rule__NamingSection__CasingAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__NamingSection__CasingAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); + after(grammarAccess.getNamingSectionAccess().getCasingAssignment_1_1()); } } @@ -19833,21 +22304,26 @@ public final void rule__DottedID__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__DottedID__Group__0__Impl" + // $ANTLR end "rule__NamingSection__Group_1__1__Impl" - // $ANTLR start "rule__DottedID__Group__1" - // InternalScope.g:5847:1: rule__DottedID__Group__1 : rule__DottedID__Group__1__Impl ; - public final void rule__DottedID__Group__1() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__0" + // InternalScope.g:6053:1: rule__NamingDefinition__Group__0 : rule__NamingDefinition__Group__0__Impl rule__NamingDefinition__Group__1 ; + public final void rule__NamingDefinition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5851:1: ( rule__DottedID__Group__1__Impl ) - // InternalScope.g:5852:2: rule__DottedID__Group__1__Impl + // InternalScope.g:6057:1: ( rule__NamingDefinition__Group__0__Impl rule__NamingDefinition__Group__1 ) + // InternalScope.g:6058:2: rule__NamingDefinition__Group__0__Impl rule__NamingDefinition__Group__1 { + pushFollow(FOLLOW_16); + rule__NamingDefinition__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__DottedID__Group__1__Impl(); + rule__NamingDefinition__Group__1(); state._fsp--; if (state.failed) return ; @@ -19866,56 +22342,38 @@ public final void rule__DottedID__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__DottedID__Group__1" + // $ANTLR end "rule__NamingDefinition__Group__0" - // $ANTLR start "rule__DottedID__Group__1__Impl" - // InternalScope.g:5858:1: rule__DottedID__Group__1__Impl : ( ( rule__DottedID__Group_1__0 )* ) ; - public final void rule__DottedID__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__0__Impl" + // InternalScope.g:6065:1: rule__NamingDefinition__Group__0__Impl : ( ( rule__NamingDefinition__TypeAssignment_0 ) ) ; + public final void rule__NamingDefinition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5862:1: ( ( ( rule__DottedID__Group_1__0 )* ) ) - // InternalScope.g:5863:1: ( ( rule__DottedID__Group_1__0 )* ) + // InternalScope.g:6069:1: ( ( ( rule__NamingDefinition__TypeAssignment_0 ) ) ) + // InternalScope.g:6070:1: ( ( rule__NamingDefinition__TypeAssignment_0 ) ) { - // InternalScope.g:5863:1: ( ( rule__DottedID__Group_1__0 )* ) - // InternalScope.g:5864:2: ( rule__DottedID__Group_1__0 )* + // InternalScope.g:6070:1: ( ( rule__NamingDefinition__TypeAssignment_0 ) ) + // InternalScope.g:6071:2: ( rule__NamingDefinition__TypeAssignment_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getDottedIDAccess().getGroup_1()); + before(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); } - // InternalScope.g:5865:2: ( rule__DottedID__Group_1__0 )* - loop53: - do { - int alt53=2; - int LA53_0 = input.LA(1); - - if ( (LA53_0==68) ) { - alt53=1; - } - - - switch (alt53) { - case 1 : - // InternalScope.g:5865:3: rule__DottedID__Group_1__0 - { - pushFollow(FOLLOW_46); - rule__DottedID__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:6072:2: ( rule__NamingDefinition__TypeAssignment_0 ) + // InternalScope.g:6072:3: rule__NamingDefinition__TypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__NamingDefinition__TypeAssignment_0(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop53; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getDottedIDAccess().getGroup_1()); + after(grammarAccess.getNamingDefinitionAccess().getTypeAssignment_0()); } } @@ -19935,26 +22393,26 @@ public final void rule__DottedID__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__DottedID__Group__1__Impl" + // $ANTLR end "rule__NamingDefinition__Group__0__Impl" - // $ANTLR start "rule__DottedID__Group_1__0" - // InternalScope.g:5874:1: rule__DottedID__Group_1__0 : rule__DottedID__Group_1__0__Impl rule__DottedID__Group_1__1 ; - public final void rule__DottedID__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__1" + // InternalScope.g:6080:1: rule__NamingDefinition__Group__1 : rule__NamingDefinition__Group__1__Impl rule__NamingDefinition__Group__2 ; + public final void rule__NamingDefinition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5878:1: ( rule__DottedID__Group_1__0__Impl rule__DottedID__Group_1__1 ) - // InternalScope.g:5879:2: rule__DottedID__Group_1__0__Impl rule__DottedID__Group_1__1 + // InternalScope.g:6084:1: ( rule__NamingDefinition__Group__1__Impl rule__NamingDefinition__Group__2 ) + // InternalScope.g:6085:2: rule__NamingDefinition__Group__1__Impl rule__NamingDefinition__Group__2 { - pushFollow(FOLLOW_3); - rule__DottedID__Group_1__0__Impl(); + pushFollow(FOLLOW_17); + rule__NamingDefinition__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__DottedID__Group_1__1(); + rule__NamingDefinition__Group__2(); state._fsp--; if (state.failed) return ; @@ -19973,28 +22431,28 @@ public final void rule__DottedID__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__DottedID__Group_1__0" + // $ANTLR end "rule__NamingDefinition__Group__1" - // $ANTLR start "rule__DottedID__Group_1__0__Impl" - // InternalScope.g:5886:1: rule__DottedID__Group_1__0__Impl : ( '.' ) ; - public final void rule__DottedID__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__1__Impl" + // InternalScope.g:6092:1: rule__NamingDefinition__Group__1__Impl : ( '=' ) ; + public final void rule__NamingDefinition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5890:1: ( ( '.' ) ) - // InternalScope.g:5891:1: ( '.' ) + // InternalScope.g:6096:1: ( ( '=' ) ) + // InternalScope.g:6097:1: ( '=' ) { - // InternalScope.g:5891:1: ( '.' ) - // InternalScope.g:5892:2: '.' + // InternalScope.g:6097:1: ( '=' ) + // InternalScope.g:6098:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); + before(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); + after(grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); } } @@ -20014,21 +22472,26 @@ public final void rule__DottedID__Group_1__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__DottedID__Group_1__0__Impl" + // $ANTLR end "rule__NamingDefinition__Group__1__Impl" - // $ANTLR start "rule__DottedID__Group_1__1" - // InternalScope.g:5901:1: rule__DottedID__Group_1__1 : rule__DottedID__Group_1__1__Impl ; - public final void rule__DottedID__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__2" + // InternalScope.g:6107:1: rule__NamingDefinition__Group__2 : rule__NamingDefinition__Group__2__Impl rule__NamingDefinition__Group__3 ; + public final void rule__NamingDefinition__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5905:1: ( rule__DottedID__Group_1__1__Impl ) - // InternalScope.g:5906:2: rule__DottedID__Group_1__1__Impl + // InternalScope.g:6111:1: ( rule__NamingDefinition__Group__2__Impl rule__NamingDefinition__Group__3 ) + // InternalScope.g:6112:2: rule__NamingDefinition__Group__2__Impl rule__NamingDefinition__Group__3 { + pushFollow(FOLLOW_18); + rule__NamingDefinition__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__DottedID__Group_1__1__Impl(); + rule__NamingDefinition__Group__3(); state._fsp--; if (state.failed) return ; @@ -20047,32 +22510,38 @@ public final void rule__DottedID__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__DottedID__Group_1__1" + // $ANTLR end "rule__NamingDefinition__Group__2" - // $ANTLR start "rule__DottedID__Group_1__1__Impl" - // InternalScope.g:5912:1: rule__DottedID__Group_1__1__Impl : ( ruleIdentifier ) ; - public final void rule__DottedID__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__2__Impl" + // InternalScope.g:6119:1: rule__NamingDefinition__Group__2__Impl : ( ( rule__NamingDefinition__NamingAssignment_2 ) ) ; + public final void rule__NamingDefinition__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5916:1: ( ( ruleIdentifier ) ) - // InternalScope.g:5917:1: ( ruleIdentifier ) + // InternalScope.g:6123:1: ( ( ( rule__NamingDefinition__NamingAssignment_2 ) ) ) + // InternalScope.g:6124:1: ( ( rule__NamingDefinition__NamingAssignment_2 ) ) { - // InternalScope.g:5917:1: ( ruleIdentifier ) - // InternalScope.g:5918:2: ruleIdentifier + // InternalScope.g:6124:1: ( ( rule__NamingDefinition__NamingAssignment_2 ) ) + // InternalScope.g:6125:2: ( rule__NamingDefinition__NamingAssignment_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); + before(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); } + // InternalScope.g:6126:2: ( rule__NamingDefinition__NamingAssignment_2 ) + // InternalScope.g:6126:3: rule__NamingDefinition__NamingAssignment_2 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__NamingDefinition__NamingAssignment_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); + after(grammarAccess.getNamingDefinitionAccess().getNamingAssignment_2()); } } @@ -20092,26 +22561,21 @@ public final void rule__DottedID__Group_1__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__DottedID__Group_1__1__Impl" + // $ANTLR end "rule__NamingDefinition__Group__2__Impl" - // $ANTLR start "rule__LetExpression__Group__0" - // InternalScope.g:5928:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ; - public final void rule__LetExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__3" + // InternalScope.g:6134:1: rule__NamingDefinition__Group__3 : rule__NamingDefinition__Group__3__Impl ; + public final void rule__NamingDefinition__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5932:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ) - // InternalScope.g:5933:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 + // InternalScope.g:6138:1: ( rule__NamingDefinition__Group__3__Impl ) + // InternalScope.g:6139:2: rule__NamingDefinition__Group__3__Impl { - pushFollow(FOLLOW_3); - rule__LetExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LetExpression__Group__1(); + rule__NamingDefinition__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -20130,28 +22594,28 @@ public final void rule__LetExpression__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__0" + // $ANTLR end "rule__NamingDefinition__Group__3" - // $ANTLR start "rule__LetExpression__Group__0__Impl" - // InternalScope.g:5940:1: rule__LetExpression__Group__0__Impl : ( 'let' ) ; - public final void rule__LetExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingDefinition__Group__3__Impl" + // InternalScope.g:6145:1: rule__NamingDefinition__Group__3__Impl : ( ';' ) ; + public final void rule__NamingDefinition__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5944:1: ( ( 'let' ) ) - // InternalScope.g:5945:1: ( 'let' ) + // InternalScope.g:6149:1: ( ( ';' ) ) + // InternalScope.g:6150:1: ( ';' ) { - // InternalScope.g:5945:1: ( 'let' ) - // InternalScope.g:5946:2: 'let' + // InternalScope.g:6150:1: ( ';' ) + // InternalScope.g:6151:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); + before(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); } - match(input,69,FOLLOW_2); if (state.failed) return ; + match(input,75,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); + after(grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); } } @@ -20171,26 +22635,26 @@ public final void rule__LetExpression__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__0__Impl" + // $ANTLR end "rule__NamingDefinition__Group__3__Impl" - // $ANTLR start "rule__LetExpression__Group__1" - // InternalScope.g:5955:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ; - public final void rule__LetExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__0" + // InternalScope.g:6161:1: rule__ScopeDefinition__Group__0 : rule__ScopeDefinition__Group__0__Impl rule__ScopeDefinition__Group__1 ; + public final void rule__ScopeDefinition__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5959:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ) - // InternalScope.g:5960:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 + // InternalScope.g:6165:1: ( rule__ScopeDefinition__Group__0__Impl rule__ScopeDefinition__Group__1 ) + // InternalScope.g:6166:2: rule__ScopeDefinition__Group__0__Impl rule__ScopeDefinition__Group__1 { - pushFollow(FOLLOW_16); - rule__LetExpression__Group__1__Impl(); + pushFollow(FOLLOW_19); + rule__ScopeDefinition__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LetExpression__Group__2(); + rule__ScopeDefinition__Group__1(); state._fsp--; if (state.failed) return ; @@ -20209,38 +22673,28 @@ public final void rule__LetExpression__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__1" + // $ANTLR end "rule__ScopeDefinition__Group__0" - // $ANTLR start "rule__LetExpression__Group__1__Impl" - // InternalScope.g:5967:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ; - public final void rule__LetExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__0__Impl" + // InternalScope.g:6173:1: rule__ScopeDefinition__Group__0__Impl : ( 'scope' ) ; + public final void rule__ScopeDefinition__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5971:1: ( ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ) - // InternalScope.g:5972:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) + // InternalScope.g:6177:1: ( ( 'scope' ) ) + // InternalScope.g:6178:1: ( 'scope' ) { - // InternalScope.g:5972:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) - // InternalScope.g:5973:2: ( rule__LetExpression__IdentifierAssignment_1 ) + // InternalScope.g:6178:1: ( 'scope' ) + // InternalScope.g:6179:2: 'scope' { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); - } - // InternalScope.g:5974:2: ( rule__LetExpression__IdentifierAssignment_1 ) - // InternalScope.g:5974:3: rule__LetExpression__IdentifierAssignment_1 - { - pushFollow(FOLLOW_2); - rule__LetExpression__IdentifierAssignment_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); } - + match(input,76,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); + after(grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); } } @@ -20260,26 +22714,26 @@ public final void rule__LetExpression__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__1__Impl" + // $ANTLR end "rule__ScopeDefinition__Group__0__Impl" - // $ANTLR start "rule__LetExpression__Group__2" - // InternalScope.g:5982:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ; - public final void rule__LetExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__1" + // InternalScope.g:6188:1: rule__ScopeDefinition__Group__1 : rule__ScopeDefinition__Group__1__Impl rule__ScopeDefinition__Group__2 ; + public final void rule__ScopeDefinition__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5986:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ) - // InternalScope.g:5987:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 + // InternalScope.g:6192:1: ( rule__ScopeDefinition__Group__1__Impl rule__ScopeDefinition__Group__2 ) + // InternalScope.g:6193:2: rule__ScopeDefinition__Group__1__Impl rule__ScopeDefinition__Group__2 { - pushFollow(FOLLOW_17); - rule__LetExpression__Group__2__Impl(); + pushFollow(FOLLOW_19); + rule__ScopeDefinition__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LetExpression__Group__3(); + rule__ScopeDefinition__Group__2(); state._fsp--; if (state.failed) return ; @@ -20298,28 +22752,49 @@ public final void rule__LetExpression__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__2" + // $ANTLR end "rule__ScopeDefinition__Group__1" - // $ANTLR start "rule__LetExpression__Group__2__Impl" - // InternalScope.g:5994:1: rule__LetExpression__Group__2__Impl : ( '=' ) ; - public final void rule__LetExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__1__Impl" + // InternalScope.g:6200:1: rule__ScopeDefinition__Group__1__Impl : ( ( rule__ScopeDefinition__Group_1__0 )? ) ; + public final void rule__ScopeDefinition__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:5998:1: ( ( '=' ) ) - // InternalScope.g:5999:1: ( '=' ) + // InternalScope.g:6204:1: ( ( ( rule__ScopeDefinition__Group_1__0 )? ) ) + // InternalScope.g:6205:1: ( ( rule__ScopeDefinition__Group_1__0 )? ) { - // InternalScope.g:5999:1: ( '=' ) - // InternalScope.g:6000:2: '=' + // InternalScope.g:6205:1: ( ( rule__ScopeDefinition__Group_1__0 )? ) + // InternalScope.g:6206:2: ( rule__ScopeDefinition__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); + before(grammarAccess.getScopeDefinitionAccess().getGroup_1()); } - match(input,48,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:6207:2: ( rule__ScopeDefinition__Group_1__0 )? + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==77) ) { + alt77=1; + } + switch (alt77) { + case 1 : + // InternalScope.g:6207:3: rule__ScopeDefinition__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__ScopeDefinition__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); + after(grammarAccess.getScopeDefinitionAccess().getGroup_1()); } } @@ -20339,26 +22814,26 @@ public final void rule__LetExpression__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__2__Impl" + // $ANTLR end "rule__ScopeDefinition__Group__1__Impl" - // $ANTLR start "rule__LetExpression__Group__3" - // InternalScope.g:6009:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ; - public final void rule__LetExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__2" + // InternalScope.g:6215:1: rule__ScopeDefinition__Group__2 : rule__ScopeDefinition__Group__2__Impl rule__ScopeDefinition__Group__3 ; + public final void rule__ScopeDefinition__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6013:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ) - // InternalScope.g:6014:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 + // InternalScope.g:6219:1: ( rule__ScopeDefinition__Group__2__Impl rule__ScopeDefinition__Group__3 ) + // InternalScope.g:6220:2: rule__ScopeDefinition__Group__2__Impl rule__ScopeDefinition__Group__3 { - pushFollow(FOLLOW_47); - rule__LetExpression__Group__3__Impl(); + pushFollow(FOLLOW_13); + rule__ScopeDefinition__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LetExpression__Group__4(); + rule__ScopeDefinition__Group__3(); state._fsp--; if (state.failed) return ; @@ -20377,30 +22852,30 @@ public final void rule__LetExpression__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__3" + // $ANTLR end "rule__ScopeDefinition__Group__2" - // $ANTLR start "rule__LetExpression__Group__3__Impl" - // InternalScope.g:6021:1: rule__LetExpression__Group__3__Impl : ( ( rule__LetExpression__VarExprAssignment_3 ) ) ; - public final void rule__LetExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__2__Impl" + // InternalScope.g:6227:1: rule__ScopeDefinition__Group__2__Impl : ( ( rule__ScopeDefinition__Alternatives_2 ) ) ; + public final void rule__ScopeDefinition__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6025:1: ( ( ( rule__LetExpression__VarExprAssignment_3 ) ) ) - // InternalScope.g:6026:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) + // InternalScope.g:6231:1: ( ( ( rule__ScopeDefinition__Alternatives_2 ) ) ) + // InternalScope.g:6232:1: ( ( rule__ScopeDefinition__Alternatives_2 ) ) { - // InternalScope.g:6026:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) - // InternalScope.g:6027:2: ( rule__LetExpression__VarExprAssignment_3 ) + // InternalScope.g:6232:1: ( ( rule__ScopeDefinition__Alternatives_2 ) ) + // InternalScope.g:6233:2: ( rule__ScopeDefinition__Alternatives_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); + before(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); } - // InternalScope.g:6028:2: ( rule__LetExpression__VarExprAssignment_3 ) - // InternalScope.g:6028:3: rule__LetExpression__VarExprAssignment_3 + // InternalScope.g:6234:2: ( rule__ScopeDefinition__Alternatives_2 ) + // InternalScope.g:6234:3: rule__ScopeDefinition__Alternatives_2 { pushFollow(FOLLOW_2); - rule__LetExpression__VarExprAssignment_3(); + rule__ScopeDefinition__Alternatives_2(); state._fsp--; if (state.failed) return ; @@ -20408,7 +22883,7 @@ public final void rule__LetExpression__Group__3__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); + after(grammarAccess.getScopeDefinitionAccess().getAlternatives_2()); } } @@ -20428,26 +22903,26 @@ public final void rule__LetExpression__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__3__Impl" + // $ANTLR end "rule__ScopeDefinition__Group__2__Impl" - // $ANTLR start "rule__LetExpression__Group__4" - // InternalScope.g:6036:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ; - public final void rule__LetExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__3" + // InternalScope.g:6242:1: rule__ScopeDefinition__Group__3 : rule__ScopeDefinition__Group__3__Impl rule__ScopeDefinition__Group__4 ; + public final void rule__ScopeDefinition__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6040:1: ( rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ) - // InternalScope.g:6041:2: rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 + // InternalScope.g:6246:1: ( rule__ScopeDefinition__Group__3__Impl rule__ScopeDefinition__Group__4 ) + // InternalScope.g:6247:2: rule__ScopeDefinition__Group__3__Impl rule__ScopeDefinition__Group__4 { - pushFollow(FOLLOW_17); - rule__LetExpression__Group__4__Impl(); + pushFollow(FOLLOW_20); + rule__ScopeDefinition__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LetExpression__Group__5(); + rule__ScopeDefinition__Group__4(); state._fsp--; if (state.failed) return ; @@ -20466,28 +22941,28 @@ public final void rule__LetExpression__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__4" + // $ANTLR end "rule__ScopeDefinition__Group__3" - // $ANTLR start "rule__LetExpression__Group__4__Impl" - // InternalScope.g:6048:1: rule__LetExpression__Group__4__Impl : ( ':' ) ; - public final void rule__LetExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__3__Impl" + // InternalScope.g:6254:1: rule__ScopeDefinition__Group__3__Impl : ( '{' ) ; + public final void rule__ScopeDefinition__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6052:1: ( ( ':' ) ) - // InternalScope.g:6053:1: ( ':' ) + // InternalScope.g:6258:1: ( ( '{' ) ) + // InternalScope.g:6259:1: ( '{' ) { - // InternalScope.g:6053:1: ( ':' ) - // InternalScope.g:6054:2: ':' + // InternalScope.g:6259:1: ( '{' ) + // InternalScope.g:6260:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); + before(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); } - match(input,70,FOLLOW_2); if (state.failed) return ; + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); + after(grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); } } @@ -20507,21 +22982,26 @@ public final void rule__LetExpression__Group__4__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__4__Impl" + // $ANTLR end "rule__ScopeDefinition__Group__3__Impl" - // $ANTLR start "rule__LetExpression__Group__5" - // InternalScope.g:6063:1: rule__LetExpression__Group__5 : rule__LetExpression__Group__5__Impl ; - public final void rule__LetExpression__Group__5() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__4" + // InternalScope.g:6269:1: rule__ScopeDefinition__Group__4 : rule__ScopeDefinition__Group__4__Impl rule__ScopeDefinition__Group__5 ; + public final void rule__ScopeDefinition__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6067:1: ( rule__LetExpression__Group__5__Impl ) - // InternalScope.g:6068:2: rule__LetExpression__Group__5__Impl + // InternalScope.g:6273:1: ( rule__ScopeDefinition__Group__4__Impl rule__ScopeDefinition__Group__5 ) + // InternalScope.g:6274:2: rule__ScopeDefinition__Group__4__Impl rule__ScopeDefinition__Group__5 { + pushFollow(FOLLOW_21); + rule__ScopeDefinition__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__LetExpression__Group__5__Impl(); + rule__ScopeDefinition__Group__5(); state._fsp--; if (state.failed) return ; @@ -20540,30 +23020,33 @@ public final void rule__LetExpression__Group__5() throws RecognitionException { } return ; } - // $ANTLR end "rule__LetExpression__Group__5" + // $ANTLR end "rule__ScopeDefinition__Group__4" - // $ANTLR start "rule__LetExpression__Group__5__Impl" - // InternalScope.g:6074:1: rule__LetExpression__Group__5__Impl : ( ( rule__LetExpression__TargetAssignment_5 ) ) ; - public final void rule__LetExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__4__Impl" + // InternalScope.g:6281:1: rule__ScopeDefinition__Group__4__Impl : ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) ; + public final void rule__ScopeDefinition__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6078:1: ( ( ( rule__LetExpression__TargetAssignment_5 ) ) ) - // InternalScope.g:6079:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) + // InternalScope.g:6285:1: ( ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) ) + // InternalScope.g:6286:1: ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) + { + // InternalScope.g:6286:1: ( ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) ) + // InternalScope.g:6287:2: ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) { - // InternalScope.g:6079:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) - // InternalScope.g:6080:2: ( rule__LetExpression__TargetAssignment_5 ) + // InternalScope.g:6287:2: ( ( rule__ScopeDefinition__RulesAssignment_4 ) ) + // InternalScope.g:6288:3: ( rule__ScopeDefinition__RulesAssignment_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); + before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); } - // InternalScope.g:6081:2: ( rule__LetExpression__TargetAssignment_5 ) - // InternalScope.g:6081:3: rule__LetExpression__TargetAssignment_5 + // InternalScope.g:6289:3: ( rule__ScopeDefinition__RulesAssignment_4 ) + // InternalScope.g:6289:4: rule__ScopeDefinition__RulesAssignment_4 { - pushFollow(FOLLOW_2); - rule__LetExpression__TargetAssignment_5(); + pushFollow(FOLLOW_22); + rule__ScopeDefinition__RulesAssignment_4(); state._fsp--; if (state.failed) return ; @@ -20571,9 +23054,53 @@ public final void rule__LetExpression__Group__5__Impl() throws RecognitionExcept } if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); + after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); + } + + } + + // InternalScope.g:6292:2: ( ( rule__ScopeDefinition__RulesAssignment_4 )* ) + // InternalScope.g:6293:3: ( rule__ScopeDefinition__RulesAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); + } + // InternalScope.g:6294:3: ( rule__ScopeDefinition__RulesAssignment_4 )* + loop78: + do { + int alt78=2; + int LA78_0 = input.LA(1); + + if ( (LA78_0==80) ) { + alt78=1; + } + + + switch (alt78) { + case 1 : + // InternalScope.g:6294:4: rule__ScopeDefinition__RulesAssignment_4 + { + pushFollow(FOLLOW_22); + rule__ScopeDefinition__RulesAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop78; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getRulesAssignment_4()); + } + } + } @@ -20591,26 +23118,21 @@ public final void rule__LetExpression__Group__5__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__LetExpression__Group__5__Impl" + // $ANTLR end "rule__ScopeDefinition__Group__4__Impl" - // $ANTLR start "rule__CastedExpression__Group__0" - // InternalScope.g:6090:1: rule__CastedExpression__Group__0 : rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ; - public final void rule__CastedExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__5" + // InternalScope.g:6303:1: rule__ScopeDefinition__Group__5 : rule__ScopeDefinition__Group__5__Impl ; + public final void rule__ScopeDefinition__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6094:1: ( rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ) - // InternalScope.g:6095:2: rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 + // InternalScope.g:6307:1: ( rule__ScopeDefinition__Group__5__Impl ) + // InternalScope.g:6308:2: rule__ScopeDefinition__Group__5__Impl { - pushFollow(FOLLOW_48); - rule__CastedExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CastedExpression__Group__1(); + rule__ScopeDefinition__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -20629,28 +23151,28 @@ public final void rule__CastedExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__0" + // $ANTLR end "rule__ScopeDefinition__Group__5" - // $ANTLR start "rule__CastedExpression__Group__0__Impl" - // InternalScope.g:6102:1: rule__CastedExpression__Group__0__Impl : ( '(' ) ; - public final void rule__CastedExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group__5__Impl" + // InternalScope.g:6314:1: rule__ScopeDefinition__Group__5__Impl : ( '}' ) ; + public final void rule__ScopeDefinition__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6106:1: ( ( '(' ) ) - // InternalScope.g:6107:1: ( '(' ) + // InternalScope.g:6318:1: ( ( '}' ) ) + // InternalScope.g:6319:1: ( '}' ) { - // InternalScope.g:6107:1: ( '(' ) - // InternalScope.g:6108:2: '(' + // InternalScope.g:6319:1: ( '}' ) + // InternalScope.g:6320:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); + before(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); + after(grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); } } @@ -20670,26 +23192,26 @@ public final void rule__CastedExpression__Group__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__0__Impl" + // $ANTLR end "rule__ScopeDefinition__Group__5__Impl" - // $ANTLR start "rule__CastedExpression__Group__1" - // InternalScope.g:6117:1: rule__CastedExpression__Group__1 : rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ; - public final void rule__CastedExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_1__0" + // InternalScope.g:6330:1: rule__ScopeDefinition__Group_1__0 : rule__ScopeDefinition__Group_1__0__Impl rule__ScopeDefinition__Group_1__1 ; + public final void rule__ScopeDefinition__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6121:1: ( rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ) - // InternalScope.g:6122:2: rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 + // InternalScope.g:6334:1: ( rule__ScopeDefinition__Group_1__0__Impl rule__ScopeDefinition__Group_1__1 ) + // InternalScope.g:6335:2: rule__ScopeDefinition__Group_1__0__Impl rule__ScopeDefinition__Group_1__1 { - pushFollow(FOLLOW_23); - rule__CastedExpression__Group__1__Impl(); + pushFollow(FOLLOW_4); + rule__ScopeDefinition__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CastedExpression__Group__2(); + rule__ScopeDefinition__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -20708,38 +23230,28 @@ public final void rule__CastedExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__1" + // $ANTLR end "rule__ScopeDefinition__Group_1__0" - // $ANTLR start "rule__CastedExpression__Group__1__Impl" - // InternalScope.g:6129:1: rule__CastedExpression__Group__1__Impl : ( ( rule__CastedExpression__TypeAssignment_1 ) ) ; - public final void rule__CastedExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_1__0__Impl" + // InternalScope.g:6342:1: rule__ScopeDefinition__Group_1__0__Impl : ( '(' ) ; + public final void rule__ScopeDefinition__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6133:1: ( ( ( rule__CastedExpression__TypeAssignment_1 ) ) ) - // InternalScope.g:6134:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) + // InternalScope.g:6346:1: ( ( '(' ) ) + // InternalScope.g:6347:1: ( '(' ) { - // InternalScope.g:6134:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) - // InternalScope.g:6135:2: ( rule__CastedExpression__TypeAssignment_1 ) + // InternalScope.g:6347:1: ( '(' ) + // InternalScope.g:6348:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); - } - // InternalScope.g:6136:2: ( rule__CastedExpression__TypeAssignment_1 ) - // InternalScope.g:6136:3: rule__CastedExpression__TypeAssignment_1 - { - pushFollow(FOLLOW_2); - rule__CastedExpression__TypeAssignment_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); } - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); + after(grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); } } @@ -20759,26 +23271,26 @@ public final void rule__CastedExpression__Group__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__1__Impl" + // $ANTLR end "rule__ScopeDefinition__Group_1__0__Impl" - // $ANTLR start "rule__CastedExpression__Group__2" - // InternalScope.g:6144:1: rule__CastedExpression__Group__2 : rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ; - public final void rule__CastedExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_1__1" + // InternalScope.g:6357:1: rule__ScopeDefinition__Group_1__1 : rule__ScopeDefinition__Group_1__1__Impl rule__ScopeDefinition__Group_1__2 ; + public final void rule__ScopeDefinition__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6148:1: ( rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ) - // InternalScope.g:6149:2: rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 + // InternalScope.g:6361:1: ( rule__ScopeDefinition__Group_1__1__Impl rule__ScopeDefinition__Group_1__2 ) + // InternalScope.g:6362:2: rule__ScopeDefinition__Group_1__1__Impl rule__ScopeDefinition__Group_1__2 { - pushFollow(FOLLOW_17); - rule__CastedExpression__Group__2__Impl(); + pushFollow(FOLLOW_23); + rule__ScopeDefinition__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CastedExpression__Group__3(); + rule__ScopeDefinition__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -20797,28 +23309,38 @@ public final void rule__CastedExpression__Group__2() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__2" + // $ANTLR end "rule__ScopeDefinition__Group_1__1" - // $ANTLR start "rule__CastedExpression__Group__2__Impl" - // InternalScope.g:6156:1: rule__CastedExpression__Group__2__Impl : ( ')' ) ; - public final void rule__CastedExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_1__1__Impl" + // InternalScope.g:6369:1: rule__ScopeDefinition__Group_1__1__Impl : ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) ; + public final void rule__ScopeDefinition__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6160:1: ( ( ')' ) ) - // InternalScope.g:6161:1: ( ')' ) + // InternalScope.g:6373:1: ( ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) ) + // InternalScope.g:6374:1: ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) { - // InternalScope.g:6161:1: ( ')' ) - // InternalScope.g:6162:2: ')' + // InternalScope.g:6374:1: ( ( rule__ScopeDefinition__NameAssignment_1_1 ) ) + // InternalScope.g:6375:2: ( rule__ScopeDefinition__NameAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + before(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); + } + // InternalScope.g:6376:2: ( rule__ScopeDefinition__NameAssignment_1_1 ) + // InternalScope.g:6376:3: rule__ScopeDefinition__NameAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__ScopeDefinition__NameAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); + after(grammarAccess.getScopeDefinitionAccess().getNameAssignment_1_1()); } } @@ -20838,21 +23360,21 @@ public final void rule__CastedExpression__Group__2__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__2__Impl" + // $ANTLR end "rule__ScopeDefinition__Group_1__1__Impl" - // $ANTLR start "rule__CastedExpression__Group__3" - // InternalScope.g:6171:1: rule__CastedExpression__Group__3 : rule__CastedExpression__Group__3__Impl ; - public final void rule__CastedExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_1__2" + // InternalScope.g:6384:1: rule__ScopeDefinition__Group_1__2 : rule__ScopeDefinition__Group_1__2__Impl ; + public final void rule__ScopeDefinition__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6175:1: ( rule__CastedExpression__Group__3__Impl ) - // InternalScope.g:6176:2: rule__CastedExpression__Group__3__Impl + // InternalScope.g:6388:1: ( rule__ScopeDefinition__Group_1__2__Impl ) + // InternalScope.g:6389:2: rule__ScopeDefinition__Group_1__2__Impl { pushFollow(FOLLOW_2); - rule__CastedExpression__Group__3__Impl(); + rule__ScopeDefinition__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -20871,38 +23393,28 @@ public final void rule__CastedExpression__Group__3() throws RecognitionException } return ; } - // $ANTLR end "rule__CastedExpression__Group__3" + // $ANTLR end "rule__ScopeDefinition__Group_1__2" - // $ANTLR start "rule__CastedExpression__Group__3__Impl" - // InternalScope.g:6182:1: rule__CastedExpression__Group__3__Impl : ( ( rule__CastedExpression__TargetAssignment_3 ) ) ; - public final void rule__CastedExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_1__2__Impl" + // InternalScope.g:6395:1: rule__ScopeDefinition__Group_1__2__Impl : ( ')' ) ; + public final void rule__ScopeDefinition__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6186:1: ( ( ( rule__CastedExpression__TargetAssignment_3 ) ) ) - // InternalScope.g:6187:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) + // InternalScope.g:6399:1: ( ( ')' ) ) + // InternalScope.g:6400:1: ( ')' ) { - // InternalScope.g:6187:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) - // InternalScope.g:6188:2: ( rule__CastedExpression__TargetAssignment_3 ) + // InternalScope.g:6400:1: ( ')' ) + // InternalScope.g:6401:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); - } - // InternalScope.g:6189:2: ( rule__CastedExpression__TargetAssignment_3 ) - // InternalScope.g:6189:3: rule__CastedExpression__TargetAssignment_3 - { - pushFollow(FOLLOW_2); - rule__CastedExpression__TargetAssignment_3(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); + after(grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); } } @@ -20922,26 +23434,26 @@ public final void rule__CastedExpression__Group__3__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__CastedExpression__Group__3__Impl" + // $ANTLR end "rule__ScopeDefinition__Group_1__2__Impl" - // $ANTLR start "rule__ChainExpression__Group__0" - // InternalScope.g:6198:1: rule__ChainExpression__Group__0 : rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ; - public final void rule__ChainExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_2_1__0" + // InternalScope.g:6411:1: rule__ScopeDefinition__Group_2_1__0 : rule__ScopeDefinition__Group_2_1__0__Impl rule__ScopeDefinition__Group_2_1__1 ; + public final void rule__ScopeDefinition__Group_2_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6202:1: ( rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ) - // InternalScope.g:6203:2: rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 + // InternalScope.g:6415:1: ( rule__ScopeDefinition__Group_2_1__0__Impl rule__ScopeDefinition__Group_2_1__1 ) + // InternalScope.g:6416:2: rule__ScopeDefinition__Group_2_1__0__Impl rule__ScopeDefinition__Group_2_1__1 { - pushFollow(FOLLOW_49); - rule__ChainExpression__Group__0__Impl(); + pushFollow(FOLLOW_24); + rule__ScopeDefinition__Group_2_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ChainExpression__Group__1(); + rule__ScopeDefinition__Group_2_1__1(); state._fsp--; if (state.failed) return ; @@ -20960,32 +23472,38 @@ public final void rule__ChainExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ChainExpression__Group__0" + // $ANTLR end "rule__ScopeDefinition__Group_2_1__0" - // $ANTLR start "rule__ChainExpression__Group__0__Impl" - // InternalScope.g:6210:1: rule__ChainExpression__Group__0__Impl : ( ruleChainedExpression ) ; - public final void rule__ChainExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_2_1__0__Impl" + // InternalScope.g:6423:1: rule__ScopeDefinition__Group_2_1__0__Impl : ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) ; + public final void rule__ScopeDefinition__Group_2_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6214:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:6215:1: ( ruleChainedExpression ) + // InternalScope.g:6427:1: ( ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) ) + // InternalScope.g:6428:1: ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) { - // InternalScope.g:6215:1: ( ruleChainedExpression ) - // InternalScope.g:6216:2: ruleChainedExpression + // InternalScope.g:6428:1: ( ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) ) + // InternalScope.g:6429:2: ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); + before(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); } + // InternalScope.g:6430:2: ( rule__ScopeDefinition__ContextTypeAssignment_2_1_0 ) + // InternalScope.g:6430:3: rule__ScopeDefinition__ContextTypeAssignment_2_1_0 + { pushFollow(FOLLOW_2); - ruleChainedExpression(); + rule__ScopeDefinition__ContextTypeAssignment_2_1_0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); + after(grammarAccess.getScopeDefinitionAccess().getContextTypeAssignment_2_1_0()); } } @@ -21005,21 +23523,26 @@ public final void rule__ChainExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ChainExpression__Group__0__Impl" + // $ANTLR end "rule__ScopeDefinition__Group_2_1__0__Impl" - // $ANTLR start "rule__ChainExpression__Group__1" - // InternalScope.g:6225:1: rule__ChainExpression__Group__1 : rule__ChainExpression__Group__1__Impl ; - public final void rule__ChainExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_2_1__1" + // InternalScope.g:6438:1: rule__ScopeDefinition__Group_2_1__1 : rule__ScopeDefinition__Group_2_1__1__Impl rule__ScopeDefinition__Group_2_1__2 ; + public final void rule__ScopeDefinition__Group_2_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6229:1: ( rule__ChainExpression__Group__1__Impl ) - // InternalScope.g:6230:2: rule__ChainExpression__Group__1__Impl + // InternalScope.g:6442:1: ( rule__ScopeDefinition__Group_2_1__1__Impl rule__ScopeDefinition__Group_2_1__2 ) + // InternalScope.g:6443:2: rule__ScopeDefinition__Group_2_1__1__Impl rule__ScopeDefinition__Group_2_1__2 { + pushFollow(FOLLOW_4); + rule__ScopeDefinition__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ChainExpression__Group__1__Impl(); + rule__ScopeDefinition__Group_2_1__2(); state._fsp--; if (state.failed) return ; @@ -21038,56 +23561,28 @@ public final void rule__ChainExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ChainExpression__Group__1" + // $ANTLR end "rule__ScopeDefinition__Group_2_1__1" - // $ANTLR start "rule__ChainExpression__Group__1__Impl" - // InternalScope.g:6236:1: rule__ChainExpression__Group__1__Impl : ( ( rule__ChainExpression__Group_1__0 )* ) ; - public final void rule__ChainExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_2_1__1__Impl" + // InternalScope.g:6450:1: rule__ScopeDefinition__Group_2_1__1__Impl : ( '#' ) ; + public final void rule__ScopeDefinition__Group_2_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6240:1: ( ( ( rule__ChainExpression__Group_1__0 )* ) ) - // InternalScope.g:6241:1: ( ( rule__ChainExpression__Group_1__0 )* ) + // InternalScope.g:6454:1: ( ( '#' ) ) + // InternalScope.g:6455:1: ( '#' ) { - // InternalScope.g:6241:1: ( ( rule__ChainExpression__Group_1__0 )* ) - // InternalScope.g:6242:2: ( rule__ChainExpression__Group_1__0 )* + // InternalScope.g:6455:1: ( '#' ) + // InternalScope.g:6456:2: '#' { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getGroup_1()); + before(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); } - // InternalScope.g:6243:2: ( rule__ChainExpression__Group_1__0 )* - loop54: - do { - int alt54=2; - int LA54_0 = input.LA(1); - - if ( (LA54_0==71) ) { - alt54=1; - } - - - switch (alt54) { - case 1 : - // InternalScope.g:6243:3: rule__ChainExpression__Group_1__0 - { - pushFollow(FOLLOW_50); - rule__ChainExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop54; - } - } while (true); - + match(input,79,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getGroup_1()); + after(grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); } } @@ -21107,26 +23602,21 @@ public final void rule__ChainExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ChainExpression__Group__1__Impl" + // $ANTLR end "rule__ScopeDefinition__Group_2_1__1__Impl" - // $ANTLR start "rule__ChainExpression__Group_1__0" - // InternalScope.g:6252:1: rule__ChainExpression__Group_1__0 : rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ; - public final void rule__ChainExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_2_1__2" + // InternalScope.g:6465:1: rule__ScopeDefinition__Group_2_1__2 : rule__ScopeDefinition__Group_2_1__2__Impl ; + public final void rule__ScopeDefinition__Group_2_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6256:1: ( rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ) - // InternalScope.g:6257:2: rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 + // InternalScope.g:6469:1: ( rule__ScopeDefinition__Group_2_1__2__Impl ) + // InternalScope.g:6470:2: rule__ScopeDefinition__Group_2_1__2__Impl { - pushFollow(FOLLOW_49); - rule__ChainExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__1(); + rule__ScopeDefinition__Group_2_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -21145,32 +23635,38 @@ public final void rule__ChainExpression__Group_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__0" + // $ANTLR end "rule__ScopeDefinition__Group_2_1__2" - // $ANTLR start "rule__ChainExpression__Group_1__0__Impl" - // InternalScope.g:6264:1: rule__ChainExpression__Group_1__0__Impl : ( () ) ; - public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDefinition__Group_2_1__2__Impl" + // InternalScope.g:6476:1: rule__ScopeDefinition__Group_2_1__2__Impl : ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) ; + public final void rule__ScopeDefinition__Group_2_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6268:1: ( ( () ) ) - // InternalScope.g:6269:1: ( () ) + // InternalScope.g:6480:1: ( ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) ) + // InternalScope.g:6481:1: ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) { - // InternalScope.g:6269:1: ( () ) - // InternalScope.g:6270:2: () + // InternalScope.g:6481:1: ( ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) ) + // InternalScope.g:6482:2: ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); + before(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); } - // InternalScope.g:6271:2: () - // InternalScope.g:6271:3: + // InternalScope.g:6483:2: ( rule__ScopeDefinition__ReferenceAssignment_2_1_2 ) + // InternalScope.g:6483:3: rule__ScopeDefinition__ReferenceAssignment_2_1_2 { + pushFollow(FOLLOW_2); + rule__ScopeDefinition__ReferenceAssignment_2_1_2(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); + after(grammarAccess.getScopeDefinitionAccess().getReferenceAssignment_2_1_2()); } } @@ -21179,6 +23675,10 @@ public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionEx } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -21186,26 +23686,26 @@ public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__0__Impl" + // $ANTLR end "rule__ScopeDefinition__Group_2_1__2__Impl" - // $ANTLR start "rule__ChainExpression__Group_1__1" - // InternalScope.g:6279:1: rule__ChainExpression__Group_1__1 : rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ; - public final void rule__ChainExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__0" + // InternalScope.g:6492:1: rule__ScopeRule__Group__0 : rule__ScopeRule__Group__0__Impl rule__ScopeRule__Group__1 ; + public final void rule__ScopeRule__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6283:1: ( rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ) - // InternalScope.g:6284:2: rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 + // InternalScope.g:6496:1: ( rule__ScopeRule__Group__0__Impl rule__ScopeRule__Group__1 ) + // InternalScope.g:6497:2: rule__ScopeRule__Group__0__Impl rule__ScopeRule__Group__1 { - pushFollow(FOLLOW_17); - rule__ChainExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_25); + rule__ScopeRule__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__2(); + rule__ScopeRule__Group__1(); state._fsp--; if (state.failed) return ; @@ -21224,28 +23724,28 @@ public final void rule__ChainExpression__Group_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__1" + // $ANTLR end "rule__ScopeRule__Group__0" - // $ANTLR start "rule__ChainExpression__Group_1__1__Impl" - // InternalScope.g:6291:1: rule__ChainExpression__Group_1__1__Impl : ( '->' ) ; - public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__0__Impl" + // InternalScope.g:6504:1: rule__ScopeRule__Group__0__Impl : ( 'context' ) ; + public final void rule__ScopeRule__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6295:1: ( ( '->' ) ) - // InternalScope.g:6296:1: ( '->' ) + // InternalScope.g:6508:1: ( ( 'context' ) ) + // InternalScope.g:6509:1: ( 'context' ) { - // InternalScope.g:6296:1: ( '->' ) - // InternalScope.g:6297:2: '->' + // InternalScope.g:6509:1: ( 'context' ) + // InternalScope.g:6510:2: 'context' { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); + before(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); } - match(input,71,FOLLOW_2); if (state.failed) return ; + match(input,80,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); + after(grammarAccess.getScopeRuleAccess().getContextKeyword_0()); } } @@ -21265,21 +23765,26 @@ public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__1__Impl" + // $ANTLR end "rule__ScopeRule__Group__0__Impl" - // $ANTLR start "rule__ChainExpression__Group_1__2" - // InternalScope.g:6306:1: rule__ChainExpression__Group_1__2 : rule__ChainExpression__Group_1__2__Impl ; - public final void rule__ChainExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__1" + // InternalScope.g:6519:1: rule__ScopeRule__Group__1 : rule__ScopeRule__Group__1__Impl rule__ScopeRule__Group__2 ; + public final void rule__ScopeRule__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6310:1: ( rule__ChainExpression__Group_1__2__Impl ) - // InternalScope.g:6311:2: rule__ChainExpression__Group_1__2__Impl + // InternalScope.g:6523:1: ( rule__ScopeRule__Group__1__Impl rule__ScopeRule__Group__2 ) + // InternalScope.g:6524:2: rule__ScopeRule__Group__1__Impl rule__ScopeRule__Group__2 { + pushFollow(FOLLOW_16); + rule__ScopeRule__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ChainExpression__Group_1__2__Impl(); + rule__ScopeRule__Group__2(); state._fsp--; if (state.failed) return ; @@ -21298,30 +23803,30 @@ public final void rule__ChainExpression__Group_1__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__2" + // $ANTLR end "rule__ScopeRule__Group__1" - // $ANTLR start "rule__ChainExpression__Group_1__2__Impl" - // InternalScope.g:6317:1: rule__ChainExpression__Group_1__2__Impl : ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ; - public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__1__Impl" + // InternalScope.g:6531:1: rule__ScopeRule__Group__1__Impl : ( ( rule__ScopeRule__ContextAssignment_1 ) ) ; + public final void rule__ScopeRule__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6321:1: ( ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ) - // InternalScope.g:6322:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) + // InternalScope.g:6535:1: ( ( ( rule__ScopeRule__ContextAssignment_1 ) ) ) + // InternalScope.g:6536:1: ( ( rule__ScopeRule__ContextAssignment_1 ) ) { - // InternalScope.g:6322:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) - // InternalScope.g:6323:2: ( rule__ChainExpression__NextAssignment_1_2 ) + // InternalScope.g:6536:1: ( ( rule__ScopeRule__ContextAssignment_1 ) ) + // InternalScope.g:6537:2: ( rule__ScopeRule__ContextAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); + before(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); } - // InternalScope.g:6324:2: ( rule__ChainExpression__NextAssignment_1_2 ) - // InternalScope.g:6324:3: rule__ChainExpression__NextAssignment_1_2 + // InternalScope.g:6538:2: ( rule__ScopeRule__ContextAssignment_1 ) + // InternalScope.g:6538:3: rule__ScopeRule__ContextAssignment_1 { pushFollow(FOLLOW_2); - rule__ChainExpression__NextAssignment_1_2(); + rule__ScopeRule__ContextAssignment_1(); state._fsp--; if (state.failed) return ; @@ -21329,7 +23834,7 @@ public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); + after(grammarAccess.getScopeRuleAccess().getContextAssignment_1()); } } @@ -21349,26 +23854,26 @@ public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ChainExpression__Group_1__2__Impl" + // $ANTLR end "rule__ScopeRule__Group__1__Impl" - // $ANTLR start "rule__IfExpressionTri__Group__0" - // InternalScope.g:6333:1: rule__IfExpressionTri__Group__0 : rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ; - public final void rule__IfExpressionTri__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__2" + // InternalScope.g:6546:1: rule__ScopeRule__Group__2 : rule__ScopeRule__Group__2__Impl rule__ScopeRule__Group__3 ; + public final void rule__ScopeRule__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6337:1: ( rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ) - // InternalScope.g:6338:2: rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 + // InternalScope.g:6550:1: ( rule__ScopeRule__Group__2__Impl rule__ScopeRule__Group__3 ) + // InternalScope.g:6551:2: rule__ScopeRule__Group__2__Impl rule__ScopeRule__Group__3 { - pushFollow(FOLLOW_51); - rule__IfExpressionTri__Group__0__Impl(); + pushFollow(FOLLOW_26); + rule__ScopeRule__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group__1(); + rule__ScopeRule__Group__3(); state._fsp--; if (state.failed) return ; @@ -21387,32 +23892,28 @@ public final void rule__IfExpressionTri__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__0" + // $ANTLR end "rule__ScopeRule__Group__2" - // $ANTLR start "rule__IfExpressionTri__Group__0__Impl" - // InternalScope.g:6345:1: rule__IfExpressionTri__Group__0__Impl : ( ruleOrExpression ) ; - public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__2__Impl" + // InternalScope.g:6558:1: rule__ScopeRule__Group__2__Impl : ( '=' ) ; + public final void rule__ScopeRule__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6349:1: ( ( ruleOrExpression ) ) - // InternalScope.g:6350:1: ( ruleOrExpression ) + // InternalScope.g:6562:1: ( ( '=' ) ) + // InternalScope.g:6563:1: ( '=' ) { - // InternalScope.g:6350:1: ( ruleOrExpression ) - // InternalScope.g:6351:2: ruleOrExpression + // InternalScope.g:6563:1: ( '=' ) + // InternalScope.g:6564:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); + before(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); } - pushFollow(FOLLOW_2); - ruleOrExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); + after(grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); } } @@ -21432,21 +23933,26 @@ public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__0__Impl" + // $ANTLR end "rule__ScopeRule__Group__2__Impl" - // $ANTLR start "rule__IfExpressionTri__Group__1" - // InternalScope.g:6360:1: rule__IfExpressionTri__Group__1 : rule__IfExpressionTri__Group__1__Impl ; - public final void rule__IfExpressionTri__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__3" + // InternalScope.g:6573:1: rule__ScopeRule__Group__3 : rule__ScopeRule__Group__3__Impl rule__ScopeRule__Group__4 ; + public final void rule__ScopeRule__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6364:1: ( rule__IfExpressionTri__Group__1__Impl ) - // InternalScope.g:6365:2: rule__IfExpressionTri__Group__1__Impl + // InternalScope.g:6577:1: ( rule__ScopeRule__Group__3__Impl rule__ScopeRule__Group__4 ) + // InternalScope.g:6578:2: rule__ScopeRule__Group__3__Impl rule__ScopeRule__Group__4 { + pushFollow(FOLLOW_27); + rule__ScopeRule__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group__1__Impl(); + rule__ScopeRule__Group__4(); state._fsp--; if (state.failed) return ; @@ -21465,49 +23971,38 @@ public final void rule__IfExpressionTri__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__1" + // $ANTLR end "rule__ScopeRule__Group__3" - // $ANTLR start "rule__IfExpressionTri__Group__1__Impl" - // InternalScope.g:6371:1: rule__IfExpressionTri__Group__1__Impl : ( ( rule__IfExpressionTri__Group_1__0 )? ) ; - public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__3__Impl" + // InternalScope.g:6585:1: rule__ScopeRule__Group__3__Impl : ( ( rule__ScopeRule__ExprsAssignment_3 ) ) ; + public final void rule__ScopeRule__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6375:1: ( ( ( rule__IfExpressionTri__Group_1__0 )? ) ) - // InternalScope.g:6376:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) + // InternalScope.g:6589:1: ( ( ( rule__ScopeRule__ExprsAssignment_3 ) ) ) + // InternalScope.g:6590:1: ( ( rule__ScopeRule__ExprsAssignment_3 ) ) { - // InternalScope.g:6376:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) - // InternalScope.g:6377:2: ( rule__IfExpressionTri__Group_1__0 )? + // InternalScope.g:6590:1: ( ( rule__ScopeRule__ExprsAssignment_3 ) ) + // InternalScope.g:6591:2: ( rule__ScopeRule__ExprsAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); - } - // InternalScope.g:6378:2: ( rule__IfExpressionTri__Group_1__0 )? - int alt55=2; - int LA55_0 = input.LA(1); - - if ( (LA55_0==72) ) { - alt55=1; + before(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); } - switch (alt55) { - case 1 : - // InternalScope.g:6378:3: rule__IfExpressionTri__Group_1__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:6592:2: ( rule__ScopeRule__ExprsAssignment_3 ) + // InternalScope.g:6592:3: rule__ScopeRule__ExprsAssignment_3 + { + pushFollow(FOLLOW_2); + rule__ScopeRule__ExprsAssignment_3(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); + after(grammarAccess.getScopeRuleAccess().getExprsAssignment_3()); } } @@ -21527,26 +24022,26 @@ public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__IfExpressionTri__Group__1__Impl" + // $ANTLR end "rule__ScopeRule__Group__3__Impl" - // $ANTLR start "rule__IfExpressionTri__Group_1__0" - // InternalScope.g:6387:1: rule__IfExpressionTri__Group_1__0 : rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ; - public final void rule__IfExpressionTri__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__4" + // InternalScope.g:6600:1: rule__ScopeRule__Group__4 : rule__ScopeRule__Group__4__Impl rule__ScopeRule__Group__5 ; + public final void rule__ScopeRule__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6391:1: ( rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ) - // InternalScope.g:6392:2: rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 + // InternalScope.g:6604:1: ( rule__ScopeRule__Group__4__Impl rule__ScopeRule__Group__5 ) + // InternalScope.g:6605:2: rule__ScopeRule__Group__4__Impl rule__ScopeRule__Group__5 { - pushFollow(FOLLOW_51); - rule__IfExpressionTri__Group_1__0__Impl(); + pushFollow(FOLLOW_27); + rule__ScopeRule__Group__4__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__1(); + rule__ScopeRule__Group__5(); state._fsp--; if (state.failed) return ; @@ -21565,32 +24060,56 @@ public final void rule__IfExpressionTri__Group_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__0" + // $ANTLR end "rule__ScopeRule__Group__4" - // $ANTLR start "rule__IfExpressionTri__Group_1__0__Impl" - // InternalScope.g:6399:1: rule__IfExpressionTri__Group_1__0__Impl : ( () ) ; - public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__4__Impl" + // InternalScope.g:6612:1: rule__ScopeRule__Group__4__Impl : ( ( rule__ScopeRule__Group_4__0 )* ) ; + public final void rule__ScopeRule__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6403:1: ( ( () ) ) - // InternalScope.g:6404:1: ( () ) + // InternalScope.g:6616:1: ( ( ( rule__ScopeRule__Group_4__0 )* ) ) + // InternalScope.g:6617:1: ( ( rule__ScopeRule__Group_4__0 )* ) { - // InternalScope.g:6404:1: ( () ) - // InternalScope.g:6405:2: () + // InternalScope.g:6617:1: ( ( rule__ScopeRule__Group_4__0 )* ) + // InternalScope.g:6618:2: ( rule__ScopeRule__Group_4__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); - } - // InternalScope.g:6406:2: () - // InternalScope.g:6406:3: - { + before(grammarAccess.getScopeRuleAccess().getGroup_4()); } + // InternalScope.g:6619:2: ( rule__ScopeRule__Group_4__0 )* + loop79: + do { + int alt79=2; + int LA79_0 = input.LA(1); + + if ( (LA79_0==81) ) { + alt79=1; + } + + + switch (alt79) { + case 1 : + // InternalScope.g:6619:3: rule__ScopeRule__Group_4__0 + { + pushFollow(FOLLOW_28); + rule__ScopeRule__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop79; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); + after(grammarAccess.getScopeRuleAccess().getGroup_4()); } } @@ -21599,6 +24118,10 @@ public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionEx } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -21606,26 +24129,21 @@ public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__0__Impl" + // $ANTLR end "rule__ScopeRule__Group__4__Impl" - // $ANTLR start "rule__IfExpressionTri__Group_1__1" - // InternalScope.g:6414:1: rule__IfExpressionTri__Group_1__1 : rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ; - public final void rule__IfExpressionTri__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__5" + // InternalScope.g:6627:1: rule__ScopeRule__Group__5 : rule__ScopeRule__Group__5__Impl ; + public final void rule__ScopeRule__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6418:1: ( rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ) - // InternalScope.g:6419:2: rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 + // InternalScope.g:6631:1: ( rule__ScopeRule__Group__5__Impl ) + // InternalScope.g:6632:2: rule__ScopeRule__Group__5__Impl { - pushFollow(FOLLOW_17); - rule__IfExpressionTri__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__2(); + rule__ScopeRule__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -21644,28 +24162,28 @@ public final void rule__IfExpressionTri__Group_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__1" + // $ANTLR end "rule__ScopeRule__Group__5" - // $ANTLR start "rule__IfExpressionTri__Group_1__1__Impl" - // InternalScope.g:6426:1: rule__IfExpressionTri__Group_1__1__Impl : ( '?' ) ; - public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group__5__Impl" + // InternalScope.g:6638:1: rule__ScopeRule__Group__5__Impl : ( ';' ) ; + public final void rule__ScopeRule__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6430:1: ( ( '?' ) ) - // InternalScope.g:6431:1: ( '?' ) + // InternalScope.g:6642:1: ( ( ';' ) ) + // InternalScope.g:6643:1: ( ';' ) { - // InternalScope.g:6431:1: ( '?' ) - // InternalScope.g:6432:2: '?' + // InternalScope.g:6643:1: ( ';' ) + // InternalScope.g:6644:2: ';' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); + before(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); } - match(input,72,FOLLOW_2); if (state.failed) return ; + match(input,75,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); + after(grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); } } @@ -21685,26 +24203,26 @@ public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__1__Impl" + // $ANTLR end "rule__ScopeRule__Group__5__Impl" - // $ANTLR start "rule__IfExpressionTri__Group_1__2" - // InternalScope.g:6441:1: rule__IfExpressionTri__Group_1__2 : rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ; - public final void rule__IfExpressionTri__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group_4__0" + // InternalScope.g:6654:1: rule__ScopeRule__Group_4__0 : rule__ScopeRule__Group_4__0__Impl rule__ScopeRule__Group_4__1 ; + public final void rule__ScopeRule__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6445:1: ( rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ) - // InternalScope.g:6446:2: rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 + // InternalScope.g:6658:1: ( rule__ScopeRule__Group_4__0__Impl rule__ScopeRule__Group_4__1 ) + // InternalScope.g:6659:2: rule__ScopeRule__Group_4__0__Impl rule__ScopeRule__Group_4__1 { - pushFollow(FOLLOW_47); - rule__IfExpressionTri__Group_1__2__Impl(); + pushFollow(FOLLOW_26); + rule__ScopeRule__Group_4__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__3(); + rule__ScopeRule__Group_4__1(); state._fsp--; if (state.failed) return ; @@ -21723,38 +24241,28 @@ public final void rule__IfExpressionTri__Group_1__2() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__2" + // $ANTLR end "rule__ScopeRule__Group_4__0" - // $ANTLR start "rule__IfExpressionTri__Group_1__2__Impl" - // InternalScope.g:6453:1: rule__IfExpressionTri__Group_1__2__Impl : ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ; - public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group_4__0__Impl" + // InternalScope.g:6666:1: rule__ScopeRule__Group_4__0__Impl : ( '>>' ) ; + public final void rule__ScopeRule__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6457:1: ( ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ) - // InternalScope.g:6458:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) + // InternalScope.g:6670:1: ( ( '>>' ) ) + // InternalScope.g:6671:1: ( '>>' ) { - // InternalScope.g:6458:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) - // InternalScope.g:6459:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) + // InternalScope.g:6671:1: ( '>>' ) + // InternalScope.g:6672:2: '>>' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); - } - // InternalScope.g:6460:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) - // InternalScope.g:6460:3: rule__IfExpressionTri__ThenPartAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__IfExpressionTri__ThenPartAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); } - + match(input,81,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); + after(grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); } } @@ -21774,26 +24282,21 @@ public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__2__Impl" + // $ANTLR end "rule__ScopeRule__Group_4__0__Impl" - // $ANTLR start "rule__IfExpressionTri__Group_1__3" - // InternalScope.g:6468:1: rule__IfExpressionTri__Group_1__3 : rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ; - public final void rule__IfExpressionTri__Group_1__3() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group_4__1" + // InternalScope.g:6681:1: rule__ScopeRule__Group_4__1 : rule__ScopeRule__Group_4__1__Impl ; + public final void rule__ScopeRule__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6472:1: ( rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ) - // InternalScope.g:6473:2: rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 + // InternalScope.g:6685:1: ( rule__ScopeRule__Group_4__1__Impl ) + // InternalScope.g:6686:2: rule__ScopeRule__Group_4__1__Impl { - pushFollow(FOLLOW_17); - rule__IfExpressionTri__Group_1__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__4(); + rule__ScopeRule__Group_4__1__Impl(); state._fsp--; if (state.failed) return ; @@ -21812,28 +24315,38 @@ public final void rule__IfExpressionTri__Group_1__3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__3" + // $ANTLR end "rule__ScopeRule__Group_4__1" - // $ANTLR start "rule__IfExpressionTri__Group_1__3__Impl" - // InternalScope.g:6480:1: rule__IfExpressionTri__Group_1__3__Impl : ( ':' ) ; - public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeRule__Group_4__1__Impl" + // InternalScope.g:6692:1: rule__ScopeRule__Group_4__1__Impl : ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) ; + public final void rule__ScopeRule__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6484:1: ( ( ':' ) ) - // InternalScope.g:6485:1: ( ':' ) + // InternalScope.g:6696:1: ( ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) ) + // InternalScope.g:6697:1: ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) { - // InternalScope.g:6485:1: ( ':' ) - // InternalScope.g:6486:2: ':' + // InternalScope.g:6697:1: ( ( rule__ScopeRule__ExprsAssignment_4_1 ) ) + // InternalScope.g:6698:2: ( rule__ScopeRule__ExprsAssignment_4_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); + before(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); } - match(input,70,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:6699:2: ( rule__ScopeRule__ExprsAssignment_4_1 ) + // InternalScope.g:6699:3: rule__ScopeRule__ExprsAssignment_4_1 + { + pushFollow(FOLLOW_2); + rule__ScopeRule__ExprsAssignment_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); + after(grammarAccess.getScopeRuleAccess().getExprsAssignment_4_1()); } } @@ -21853,21 +24366,26 @@ public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__3__Impl" + // $ANTLR end "rule__ScopeRule__Group_4__1__Impl" - // $ANTLR start "rule__IfExpressionTri__Group_1__4" - // InternalScope.g:6495:1: rule__IfExpressionTri__Group_1__4 : rule__IfExpressionTri__Group_1__4__Impl ; - public final void rule__IfExpressionTri__Group_1__4() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group__0" + // InternalScope.g:6708:1: rule__ScopeContext__Group__0 : rule__ScopeContext__Group__0__Impl rule__ScopeContext__Group__1 ; + public final void rule__ScopeContext__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6499:1: ( rule__IfExpressionTri__Group_1__4__Impl ) - // InternalScope.g:6500:2: rule__IfExpressionTri__Group_1__4__Impl + // InternalScope.g:6712:1: ( rule__ScopeContext__Group__0__Impl rule__ScopeContext__Group__1 ) + // InternalScope.g:6713:2: rule__ScopeContext__Group__0__Impl rule__ScopeContext__Group__1 { + pushFollow(FOLLOW_29); + rule__ScopeContext__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionTri__Group_1__4__Impl(); + rule__ScopeContext__Group__1(); state._fsp--; if (state.failed) return ; @@ -21886,30 +24404,30 @@ public final void rule__IfExpressionTri__Group_1__4() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__4" + // $ANTLR end "rule__ScopeContext__Group__0" - // $ANTLR start "rule__IfExpressionTri__Group_1__4__Impl" - // InternalScope.g:6506:1: rule__IfExpressionTri__Group_1__4__Impl : ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ; - public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group__0__Impl" + // InternalScope.g:6720:1: rule__ScopeContext__Group__0__Impl : ( ( rule__ScopeContext__Alternatives_0 ) ) ; + public final void rule__ScopeContext__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6510:1: ( ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ) - // InternalScope.g:6511:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) + // InternalScope.g:6724:1: ( ( ( rule__ScopeContext__Alternatives_0 ) ) ) + // InternalScope.g:6725:1: ( ( rule__ScopeContext__Alternatives_0 ) ) { - // InternalScope.g:6511:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) - // InternalScope.g:6512:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) + // InternalScope.g:6725:1: ( ( rule__ScopeContext__Alternatives_0 ) ) + // InternalScope.g:6726:2: ( rule__ScopeContext__Alternatives_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + before(grammarAccess.getScopeContextAccess().getAlternatives_0()); } - // InternalScope.g:6513:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) - // InternalScope.g:6513:3: rule__IfExpressionTri__ElsePartAssignment_1_4 + // InternalScope.g:6727:2: ( rule__ScopeContext__Alternatives_0 ) + // InternalScope.g:6727:3: rule__ScopeContext__Alternatives_0 { pushFollow(FOLLOW_2); - rule__IfExpressionTri__ElsePartAssignment_1_4(); + rule__ScopeContext__Alternatives_0(); state._fsp--; if (state.failed) return ; @@ -21917,7 +24435,7 @@ public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + after(grammarAccess.getScopeContextAccess().getAlternatives_0()); } } @@ -21937,26 +24455,21 @@ public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__IfExpressionTri__Group_1__4__Impl" + // $ANTLR end "rule__ScopeContext__Group__0__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__0" - // InternalScope.g:6522:1: rule__IfExpressionKw__Group__0 : rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ; - public final void rule__IfExpressionKw__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group__1" + // InternalScope.g:6735:1: rule__ScopeContext__Group__1 : rule__ScopeContext__Group__1__Impl ; + public final void rule__ScopeContext__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6526:1: ( rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ) - // InternalScope.g:6527:2: rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 + // InternalScope.g:6739:1: ( rule__ScopeContext__Group__1__Impl ) + // InternalScope.g:6740:2: rule__ScopeContext__Group__1__Impl { - pushFollow(FOLLOW_17); - rule__IfExpressionKw__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__1(); + rule__ScopeContext__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -21975,28 +24488,49 @@ public final void rule__IfExpressionKw__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__0" + // $ANTLR end "rule__ScopeContext__Group__1" - // $ANTLR start "rule__IfExpressionKw__Group__0__Impl" - // InternalScope.g:6534:1: rule__IfExpressionKw__Group__0__Impl : ( 'if' ) ; - public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group__1__Impl" + // InternalScope.g:6746:1: rule__ScopeContext__Group__1__Impl : ( ( rule__ScopeContext__Group_1__0 )? ) ; + public final void rule__ScopeContext__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6538:1: ( ( 'if' ) ) - // InternalScope.g:6539:1: ( 'if' ) + // InternalScope.g:6750:1: ( ( ( rule__ScopeContext__Group_1__0 )? ) ) + // InternalScope.g:6751:1: ( ( rule__ScopeContext__Group_1__0 )? ) { - // InternalScope.g:6539:1: ( 'if' ) - // InternalScope.g:6540:2: 'if' + // InternalScope.g:6751:1: ( ( rule__ScopeContext__Group_1__0 )? ) + // InternalScope.g:6752:2: ( rule__ScopeContext__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + before(grammarAccess.getScopeContextAccess().getGroup_1()); } - match(input,73,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:6753:2: ( rule__ScopeContext__Group_1__0 )? + int alt80=2; + int LA80_0 = input.LA(1); + + if ( (LA80_0==82) ) { + alt80=1; + } + switch (alt80) { + case 1 : + // InternalScope.g:6753:3: rule__ScopeContext__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__ScopeContext__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); + after(grammarAccess.getScopeContextAccess().getGroup_1()); } } @@ -22016,26 +24550,26 @@ public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__0__Impl" + // $ANTLR end "rule__ScopeContext__Group__1__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__1" - // InternalScope.g:6549:1: rule__IfExpressionKw__Group__1 : rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ; - public final void rule__IfExpressionKw__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group_1__0" + // InternalScope.g:6762:1: rule__ScopeContext__Group_1__0 : rule__ScopeContext__Group_1__0__Impl rule__ScopeContext__Group_1__1 ; + public final void rule__ScopeContext__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6553:1: ( rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ) - // InternalScope.g:6554:2: rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 + // InternalScope.g:6766:1: ( rule__ScopeContext__Group_1__0__Impl rule__ScopeContext__Group_1__1 ) + // InternalScope.g:6767:2: rule__ScopeContext__Group_1__0__Impl rule__ScopeContext__Group_1__1 { - pushFollow(FOLLOW_52); - rule__IfExpressionKw__Group__1__Impl(); + pushFollow(FOLLOW_17); + rule__ScopeContext__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__2(); + rule__ScopeContext__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -22054,38 +24588,28 @@ public final void rule__IfExpressionKw__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__1" + // $ANTLR end "rule__ScopeContext__Group_1__0" - // $ANTLR start "rule__IfExpressionKw__Group__1__Impl" - // InternalScope.g:6561:1: rule__IfExpressionKw__Group__1__Impl : ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ; - public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group_1__0__Impl" + // InternalScope.g:6774:1: rule__ScopeContext__Group_1__0__Impl : ( '[' ) ; + public final void rule__ScopeContext__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6565:1: ( ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ) - // InternalScope.g:6566:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) + // InternalScope.g:6778:1: ( ( '[' ) ) + // InternalScope.g:6779:1: ( '[' ) { - // InternalScope.g:6566:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) - // InternalScope.g:6567:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) + // InternalScope.g:6779:1: ( '[' ) + // InternalScope.g:6780:2: '[' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); - } - // InternalScope.g:6568:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) - // InternalScope.g:6568:3: rule__IfExpressionKw__ConditionAssignment_1 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__ConditionAssignment_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); } - + match(input,82,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); + after(grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); } } @@ -22105,26 +24629,26 @@ public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__1__Impl" + // $ANTLR end "rule__ScopeContext__Group_1__0__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__2" - // InternalScope.g:6576:1: rule__IfExpressionKw__Group__2 : rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ; - public final void rule__IfExpressionKw__Group__2() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group_1__1" + // InternalScope.g:6789:1: rule__ScopeContext__Group_1__1 : rule__ScopeContext__Group_1__1__Impl rule__ScopeContext__Group_1__2 ; + public final void rule__ScopeContext__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6580:1: ( rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ) - // InternalScope.g:6581:2: rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 + // InternalScope.g:6793:1: ( rule__ScopeContext__Group_1__1__Impl rule__ScopeContext__Group_1__2 ) + // InternalScope.g:6794:2: rule__ScopeContext__Group_1__1__Impl rule__ScopeContext__Group_1__2 { - pushFollow(FOLLOW_17); - rule__IfExpressionKw__Group__2__Impl(); + pushFollow(FOLLOW_30); + rule__ScopeContext__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__3(); + rule__ScopeContext__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -22143,28 +24667,38 @@ public final void rule__IfExpressionKw__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__2" + // $ANTLR end "rule__ScopeContext__Group_1__1" - // $ANTLR start "rule__IfExpressionKw__Group__2__Impl" - // InternalScope.g:6588:1: rule__IfExpressionKw__Group__2__Impl : ( 'then' ) ; - public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group_1__1__Impl" + // InternalScope.g:6801:1: rule__ScopeContext__Group_1__1__Impl : ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) ; + public final void rule__ScopeContext__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6592:1: ( ( 'then' ) ) - // InternalScope.g:6593:1: ( 'then' ) + // InternalScope.g:6805:1: ( ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) ) + // InternalScope.g:6806:1: ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) { - // InternalScope.g:6593:1: ( 'then' ) - // InternalScope.g:6594:2: 'then' + // InternalScope.g:6806:1: ( ( rule__ScopeContext__GuardAssignment_1_1 ) ) + // InternalScope.g:6807:2: ( rule__ScopeContext__GuardAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); + before(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); } - match(input,74,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:6808:2: ( rule__ScopeContext__GuardAssignment_1_1 ) + // InternalScope.g:6808:3: rule__ScopeContext__GuardAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__ScopeContext__GuardAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); + after(grammarAccess.getScopeContextAccess().getGuardAssignment_1_1()); } } @@ -22184,26 +24718,21 @@ public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__2__Impl" + // $ANTLR end "rule__ScopeContext__Group_1__1__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__3" - // InternalScope.g:6603:1: rule__IfExpressionKw__Group__3 : rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ; - public final void rule__IfExpressionKw__Group__3() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group_1__2" + // InternalScope.g:6816:1: rule__ScopeContext__Group_1__2 : rule__ScopeContext__Group_1__2__Impl ; + public final void rule__ScopeContext__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6607:1: ( rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ) - // InternalScope.g:6608:2: rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 + // InternalScope.g:6820:1: ( rule__ScopeContext__Group_1__2__Impl ) + // InternalScope.g:6821:2: rule__ScopeContext__Group_1__2__Impl { - pushFollow(FOLLOW_53); - rule__IfExpressionKw__Group__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__4(); + rule__ScopeContext__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -22222,38 +24751,28 @@ public final void rule__IfExpressionKw__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__3" + // $ANTLR end "rule__ScopeContext__Group_1__2" - // $ANTLR start "rule__IfExpressionKw__Group__3__Impl" - // InternalScope.g:6615:1: rule__IfExpressionKw__Group__3__Impl : ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ; - public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeContext__Group_1__2__Impl" + // InternalScope.g:6827:1: rule__ScopeContext__Group_1__2__Impl : ( ']' ) ; + public final void rule__ScopeContext__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6619:1: ( ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ) - // InternalScope.g:6620:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) + // InternalScope.g:6831:1: ( ( ']' ) ) + // InternalScope.g:6832:1: ( ']' ) { - // InternalScope.g:6620:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) - // InternalScope.g:6621:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) + // InternalScope.g:6832:1: ( ']' ) + // InternalScope.g:6833:2: ']' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); - } - // InternalScope.g:6622:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) - // InternalScope.g:6622:3: rule__IfExpressionKw__ThenPartAssignment_3 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__ThenPartAssignment_3(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); } - + match(input,83,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); + after(grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); } } @@ -22273,21 +24792,26 @@ public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__3__Impl" + // $ANTLR end "rule__ScopeContext__Group_1__2__Impl" - // $ANTLR start "rule__IfExpressionKw__Group__4" - // InternalScope.g:6630:1: rule__IfExpressionKw__Group__4 : rule__IfExpressionKw__Group__4__Impl ; - public final void rule__IfExpressionKw__Group__4() throws RecognitionException { + // $ANTLR start "rule__FactoryExpression__Group__0" + // InternalScope.g:6843:1: rule__FactoryExpression__Group__0 : rule__FactoryExpression__Group__0__Impl rule__FactoryExpression__Group__1 ; + public final void rule__FactoryExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6634:1: ( rule__IfExpressionKw__Group__4__Impl ) - // InternalScope.g:6635:2: rule__IfExpressionKw__Group__4__Impl + // InternalScope.g:6847:1: ( rule__FactoryExpression__Group__0__Impl rule__FactoryExpression__Group__1 ) + // InternalScope.g:6848:2: rule__FactoryExpression__Group__0__Impl rule__FactoryExpression__Group__1 { + pushFollow(FOLLOW_17); + rule__FactoryExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group__4__Impl(); + rule__FactoryExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -22306,53 +24830,28 @@ public final void rule__IfExpressionKw__Group__4() throws RecognitionException { } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__4" + // $ANTLR end "rule__FactoryExpression__Group__0" - // $ANTLR start "rule__IfExpressionKw__Group__4__Impl" - // InternalScope.g:6641:1: rule__IfExpressionKw__Group__4__Impl : ( ( rule__IfExpressionKw__Group_4__0 )? ) ; - public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__FactoryExpression__Group__0__Impl" + // InternalScope.g:6855:1: rule__FactoryExpression__Group__0__Impl : ( 'factory' ) ; + public final void rule__FactoryExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6645:1: ( ( ( rule__IfExpressionKw__Group_4__0 )? ) ) - // InternalScope.g:6646:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) + // InternalScope.g:6859:1: ( ( 'factory' ) ) + // InternalScope.g:6860:1: ( 'factory' ) { - // InternalScope.g:6646:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) - // InternalScope.g:6647:2: ( rule__IfExpressionKw__Group_4__0 )? + // InternalScope.g:6860:1: ( 'factory' ) + // InternalScope.g:6861:2: 'factory' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); - } - // InternalScope.g:6648:2: ( rule__IfExpressionKw__Group_4__0 )? - int alt56=2; - int LA56_0 = input.LA(1); - - if ( (LA56_0==75) ) { - int LA56_1 = input.LA(2); - - if ( (synpred88_InternalScope()) ) { - alt56=1; - } - } - switch (alt56) { - case 1 : - // InternalScope.g:6648:3: rule__IfExpressionKw__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); } - + match(input,84,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); + after(grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); } } @@ -22372,21 +24871,21 @@ public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__IfExpressionKw__Group__4__Impl" + // $ANTLR end "rule__FactoryExpression__Group__0__Impl" - // $ANTLR start "rule__IfExpressionKw__Group_4__0" - // InternalScope.g:6657:1: rule__IfExpressionKw__Group_4__0 : rule__IfExpressionKw__Group_4__0__Impl ; - public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException { + // $ANTLR start "rule__FactoryExpression__Group__1" + // InternalScope.g:6870:1: rule__FactoryExpression__Group__1 : rule__FactoryExpression__Group__1__Impl ; + public final void rule__FactoryExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6661:1: ( rule__IfExpressionKw__Group_4__0__Impl ) - // InternalScope.g:6662:2: rule__IfExpressionKw__Group_4__0__Impl + // InternalScope.g:6874:1: ( rule__FactoryExpression__Group__1__Impl ) + // InternalScope.g:6875:2: rule__FactoryExpression__Group__1__Impl { pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0__Impl(); + rule__FactoryExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -22405,30 +24904,30 @@ public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4__0" + // $ANTLR end "rule__FactoryExpression__Group__1" - // $ANTLR start "rule__IfExpressionKw__Group_4__0__Impl" - // InternalScope.g:6668:1: rule__IfExpressionKw__Group_4__0__Impl : ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ; - public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__FactoryExpression__Group__1__Impl" + // InternalScope.g:6881:1: rule__FactoryExpression__Group__1__Impl : ( ( rule__FactoryExpression__ExprAssignment_1 ) ) ; + public final void rule__FactoryExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6672:1: ( ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ) - // InternalScope.g:6673:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) + // InternalScope.g:6885:1: ( ( ( rule__FactoryExpression__ExprAssignment_1 ) ) ) + // InternalScope.g:6886:1: ( ( rule__FactoryExpression__ExprAssignment_1 ) ) { - // InternalScope.g:6673:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) - // InternalScope.g:6674:2: ( rule__IfExpressionKw__Group_4_0__0 ) + // InternalScope.g:6886:1: ( ( rule__FactoryExpression__ExprAssignment_1 ) ) + // InternalScope.g:6887:2: ( rule__FactoryExpression__ExprAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + before(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); } - // InternalScope.g:6675:2: ( rule__IfExpressionKw__Group_4_0__0 ) - // InternalScope.g:6675:3: rule__IfExpressionKw__Group_4_0__0 + // InternalScope.g:6888:2: ( rule__FactoryExpression__ExprAssignment_1 ) + // InternalScope.g:6888:3: rule__FactoryExpression__ExprAssignment_1 { pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__0(); + rule__FactoryExpression__ExprAssignment_1(); state._fsp--; if (state.failed) return ; @@ -22436,7 +24935,7 @@ public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); + after(grammarAccess.getFactoryExpressionAccess().getExprAssignment_1()); } } @@ -22456,26 +24955,26 @@ public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4__0__Impl" + // $ANTLR end "rule__FactoryExpression__Group__1__Impl" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__0" - // InternalScope.g:6684:1: rule__IfExpressionKw__Group_4_0__0 : rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ; - public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__0" + // InternalScope.g:6897:1: rule__ScopeDelegation__Group__0 : rule__ScopeDelegation__Group__0__Impl rule__ScopeDelegation__Group__1 ; + public final void rule__ScopeDelegation__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6688:1: ( rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ) - // InternalScope.g:6689:2: rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 + // InternalScope.g:6901:1: ( rule__ScopeDelegation__Group__0__Impl rule__ScopeDelegation__Group__1 ) + // InternalScope.g:6902:2: rule__ScopeDelegation__Group__0__Impl rule__ScopeDelegation__Group__1 { - pushFollow(FOLLOW_17); - rule__IfExpressionKw__Group_4_0__0__Impl(); + pushFollow(FOLLOW_31); + rule__ScopeDelegation__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__1(); + rule__ScopeDelegation__Group__1(); state._fsp--; if (state.failed) return ; @@ -22494,28 +24993,28 @@ public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__0" + // $ANTLR end "rule__ScopeDelegation__Group__0" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__0__Impl" - // InternalScope.g:6696:1: rule__IfExpressionKw__Group_4_0__0__Impl : ( 'else' ) ; - public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__0__Impl" + // InternalScope.g:6909:1: rule__ScopeDelegation__Group__0__Impl : ( 'scopeof' ) ; + public final void rule__ScopeDelegation__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6700:1: ( ( 'else' ) ) - // InternalScope.g:6701:1: ( 'else' ) + // InternalScope.g:6913:1: ( ( 'scopeof' ) ) + // InternalScope.g:6914:1: ( 'scopeof' ) { - // InternalScope.g:6701:1: ( 'else' ) - // InternalScope.g:6702:2: 'else' + // InternalScope.g:6914:1: ( 'scopeof' ) + // InternalScope.g:6915:2: 'scopeof' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); + before(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } - match(input,75,FOLLOW_2); if (state.failed) return ; + match(input,85,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); + after(grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } } @@ -22535,21 +25034,26 @@ public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__0__Impl" + // $ANTLR end "rule__ScopeDelegation__Group__0__Impl" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__1" - // InternalScope.g:6711:1: rule__IfExpressionKw__Group_4_0__1 : rule__IfExpressionKw__Group_4_0__1__Impl ; - public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__1" + // InternalScope.g:6924:1: rule__ScopeDelegation__Group__1 : rule__ScopeDelegation__Group__1__Impl rule__ScopeDelegation__Group__2 ; + public final void rule__ScopeDelegation__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6715:1: ( rule__IfExpressionKw__Group_4_0__1__Impl ) - // InternalScope.g:6716:2: rule__IfExpressionKw__Group_4_0__1__Impl + // InternalScope.g:6928:1: ( rule__ScopeDelegation__Group__1__Impl rule__ScopeDelegation__Group__2 ) + // InternalScope.g:6929:2: rule__ScopeDelegation__Group__1__Impl rule__ScopeDelegation__Group__2 { + pushFollow(FOLLOW_32); + rule__ScopeDelegation__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4_0__1__Impl(); + rule__ScopeDelegation__Group__2(); state._fsp--; if (state.failed) return ; @@ -22568,38 +25072,28 @@ public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__1" + // $ANTLR end "rule__ScopeDelegation__Group__1" - // $ANTLR start "rule__IfExpressionKw__Group_4_0__1__Impl" - // InternalScope.g:6722:1: rule__IfExpressionKw__Group_4_0__1__Impl : ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ; - public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__1__Impl" + // InternalScope.g:6936:1: rule__ScopeDelegation__Group__1__Impl : ( '(' ) ; + public final void rule__ScopeDelegation__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6726:1: ( ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ) - // InternalScope.g:6727:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) + // InternalScope.g:6940:1: ( ( '(' ) ) + // InternalScope.g:6941:1: ( '(' ) { - // InternalScope.g:6727:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) - // InternalScope.g:6728:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) + // InternalScope.g:6941:1: ( '(' ) + // InternalScope.g:6942:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); - } - // InternalScope.g:6729:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) - // InternalScope.g:6729:3: rule__IfExpressionKw__ElsePartAssignment_4_0_1 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__ElsePartAssignment_4_0_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); } - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); + after(grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); } } @@ -22619,26 +25113,26 @@ public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__IfExpressionKw__Group_4_0__1__Impl" + // $ANTLR end "rule__ScopeDelegation__Group__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group__0" - // InternalScope.g:6738:1: rule__SwitchExpression__Group__0 : rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ; - public final void rule__SwitchExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__2" + // InternalScope.g:6951:1: rule__ScopeDelegation__Group__2 : rule__ScopeDelegation__Group__2__Impl rule__ScopeDelegation__Group__3 ; + public final void rule__ScopeDelegation__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6742:1: ( rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ) - // InternalScope.g:6743:2: rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 + // InternalScope.g:6955:1: ( rule__ScopeDelegation__Group__2__Impl rule__ScopeDelegation__Group__3 ) + // InternalScope.g:6956:2: rule__ScopeDelegation__Group__2__Impl rule__ScopeDelegation__Group__3 { - pushFollow(FOLLOW_54); - rule__SwitchExpression__Group__0__Impl(); + pushFollow(FOLLOW_33); + rule__ScopeDelegation__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__1(); + rule__ScopeDelegation__Group__3(); state._fsp--; if (state.failed) return ; @@ -22657,28 +25151,38 @@ public final void rule__SwitchExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__0" + // $ANTLR end "rule__ScopeDelegation__Group__2" - // $ANTLR start "rule__SwitchExpression__Group__0__Impl" - // InternalScope.g:6750:1: rule__SwitchExpression__Group__0__Impl : ( 'switch' ) ; - public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__2__Impl" + // InternalScope.g:6963:1: rule__ScopeDelegation__Group__2__Impl : ( ( rule__ScopeDelegation__Alternatives_2 ) ) ; + public final void rule__ScopeDelegation__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6754:1: ( ( 'switch' ) ) - // InternalScope.g:6755:1: ( 'switch' ) + // InternalScope.g:6967:1: ( ( ( rule__ScopeDelegation__Alternatives_2 ) ) ) + // InternalScope.g:6968:1: ( ( rule__ScopeDelegation__Alternatives_2 ) ) { - // InternalScope.g:6755:1: ( 'switch' ) - // InternalScope.g:6756:2: 'switch' + // InternalScope.g:6968:1: ( ( rule__ScopeDelegation__Alternatives_2 ) ) + // InternalScope.g:6969:2: ( rule__ScopeDelegation__Alternatives_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); + before(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); } - match(input,76,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:6970:2: ( rule__ScopeDelegation__Alternatives_2 ) + // InternalScope.g:6970:3: rule__ScopeDelegation__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__ScopeDelegation__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); + after(grammarAccess.getScopeDelegationAccess().getAlternatives_2()); } } @@ -22698,26 +25202,26 @@ public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__0__Impl" + // $ANTLR end "rule__ScopeDelegation__Group__2__Impl" - // $ANTLR start "rule__SwitchExpression__Group__1" - // InternalScope.g:6765:1: rule__SwitchExpression__Group__1 : rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ; - public final void rule__SwitchExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__3" + // InternalScope.g:6978:1: rule__ScopeDelegation__Group__3 : rule__ScopeDelegation__Group__3__Impl rule__ScopeDelegation__Group__4 ; + public final void rule__ScopeDelegation__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6769:1: ( rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ) - // InternalScope.g:6770:2: rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 + // InternalScope.g:6982:1: ( rule__ScopeDelegation__Group__3__Impl rule__ScopeDelegation__Group__4 ) + // InternalScope.g:6983:2: rule__ScopeDelegation__Group__3__Impl rule__ScopeDelegation__Group__4 { - pushFollow(FOLLOW_54); - rule__SwitchExpression__Group__1__Impl(); + pushFollow(FOLLOW_33); + rule__ScopeDelegation__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__2(); + rule__ScopeDelegation__Group__4(); state._fsp--; if (state.failed) return ; @@ -22736,38 +25240,38 @@ public final void rule__SwitchExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__1" + // $ANTLR end "rule__ScopeDelegation__Group__3" - // $ANTLR start "rule__SwitchExpression__Group__1__Impl" - // InternalScope.g:6777:1: rule__SwitchExpression__Group__1__Impl : ( ( rule__SwitchExpression__Group_1__0 )? ) ; - public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__3__Impl" + // InternalScope.g:6990:1: rule__ScopeDelegation__Group__3__Impl : ( ( rule__ScopeDelegation__Group_3__0 )? ) ; + public final void rule__ScopeDelegation__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6781:1: ( ( ( rule__SwitchExpression__Group_1__0 )? ) ) - // InternalScope.g:6782:1: ( ( rule__SwitchExpression__Group_1__0 )? ) + // InternalScope.g:6994:1: ( ( ( rule__ScopeDelegation__Group_3__0 )? ) ) + // InternalScope.g:6995:1: ( ( rule__ScopeDelegation__Group_3__0 )? ) { - // InternalScope.g:6782:1: ( ( rule__SwitchExpression__Group_1__0 )? ) - // InternalScope.g:6783:2: ( rule__SwitchExpression__Group_1__0 )? + // InternalScope.g:6995:1: ( ( rule__ScopeDelegation__Group_3__0 )? ) + // InternalScope.g:6996:2: ( rule__ScopeDelegation__Group_3__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); + before(grammarAccess.getScopeDelegationAccess().getGroup_3()); } - // InternalScope.g:6784:2: ( rule__SwitchExpression__Group_1__0 )? - int alt57=2; - int LA57_0 = input.LA(1); + // InternalScope.g:6997:2: ( rule__ScopeDelegation__Group_3__0 )? + int alt81=2; + int LA81_0 = input.LA(1); - if ( (LA57_0==51) ) { - alt57=1; + if ( (LA81_0==86) ) { + alt81=1; } - switch (alt57) { + switch (alt81) { case 1 : - // InternalScope.g:6784:3: rule__SwitchExpression__Group_1__0 + // InternalScope.g:6997:3: rule__ScopeDelegation__Group_3__0 { pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__0(); + rule__ScopeDelegation__Group_3__0(); state._fsp--; if (state.failed) return ; @@ -22778,7 +25282,7 @@ public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionExc } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); + after(grammarAccess.getScopeDelegationAccess().getGroup_3()); } } @@ -22798,26 +25302,21 @@ public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__1__Impl" - + // $ANTLR end "rule__ScopeDelegation__Group__3__Impl" - // $ANTLR start "rule__SwitchExpression__Group__2" - // InternalScope.g:6792:1: rule__SwitchExpression__Group__2 : rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ; - public final void rule__SwitchExpression__Group__2() throws RecognitionException { + + // $ANTLR start "rule__ScopeDelegation__Group__4" + // InternalScope.g:7005:1: rule__ScopeDelegation__Group__4 : rule__ScopeDelegation__Group__4__Impl ; + public final void rule__ScopeDelegation__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6796:1: ( rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ) - // InternalScope.g:6797:2: rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 + // InternalScope.g:7009:1: ( rule__ScopeDelegation__Group__4__Impl ) + // InternalScope.g:7010:2: rule__ScopeDelegation__Group__4__Impl { - pushFollow(FOLLOW_55); - rule__SwitchExpression__Group__2__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__3(); + rule__ScopeDelegation__Group__4__Impl(); state._fsp--; if (state.failed) return ; @@ -22836,28 +25335,28 @@ public final void rule__SwitchExpression__Group__2() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__2" + // $ANTLR end "rule__ScopeDelegation__Group__4" - // $ANTLR start "rule__SwitchExpression__Group__2__Impl" - // InternalScope.g:6804:1: rule__SwitchExpression__Group__2__Impl : ( '{' ) ; - public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group__4__Impl" + // InternalScope.g:7016:1: rule__ScopeDelegation__Group__4__Impl : ( ')' ) ; + public final void rule__ScopeDelegation__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6808:1: ( ( '{' ) ) - // InternalScope.g:6809:1: ( '{' ) + // InternalScope.g:7020:1: ( ( ')' ) ) + // InternalScope.g:7021:1: ( ')' ) { - // InternalScope.g:6809:1: ( '{' ) - // InternalScope.g:6810:2: '{' + // InternalScope.g:7021:1: ( ')' ) + // InternalScope.g:7022:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); + before(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); } - match(input,45,FOLLOW_2); if (state.failed) return ; + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); + after(grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); } } @@ -22877,26 +25376,26 @@ public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__2__Impl" + // $ANTLR end "rule__ScopeDelegation__Group__4__Impl" - // $ANTLR start "rule__SwitchExpression__Group__3" - // InternalScope.g:6819:1: rule__SwitchExpression__Group__3 : rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ; - public final void rule__SwitchExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group_3__0" + // InternalScope.g:7032:1: rule__ScopeDelegation__Group_3__0 : rule__ScopeDelegation__Group_3__0__Impl rule__ScopeDelegation__Group_3__1 ; + public final void rule__ScopeDelegation__Group_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6823:1: ( rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ) - // InternalScope.g:6824:2: rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 + // InternalScope.g:7036:1: ( rule__ScopeDelegation__Group_3__0__Impl rule__ScopeDelegation__Group_3__1 ) + // InternalScope.g:7037:2: rule__ScopeDelegation__Group_3__0__Impl rule__ScopeDelegation__Group_3__1 { - pushFollow(FOLLOW_55); - rule__SwitchExpression__Group__3__Impl(); + pushFollow(FOLLOW_4); + rule__ScopeDelegation__Group_3__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__4(); + rule__ScopeDelegation__Group_3__1(); state._fsp--; if (state.failed) return ; @@ -22915,56 +25414,28 @@ public final void rule__SwitchExpression__Group__3() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__3" + // $ANTLR end "rule__ScopeDelegation__Group_3__0" - // $ANTLR start "rule__SwitchExpression__Group__3__Impl" - // InternalScope.g:6831:1: rule__SwitchExpression__Group__3__Impl : ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ; - public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group_3__0__Impl" + // InternalScope.g:7044:1: rule__ScopeDelegation__Group_3__0__Impl : ( ',' ) ; + public final void rule__ScopeDelegation__Group_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6835:1: ( ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ) - // InternalScope.g:6836:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) + // InternalScope.g:7048:1: ( ( ',' ) ) + // InternalScope.g:7049:1: ( ',' ) { - // InternalScope.g:6836:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) - // InternalScope.g:6837:2: ( rule__SwitchExpression__CaseAssignment_3 )* + // InternalScope.g:7049:1: ( ',' ) + // InternalScope.g:7050:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); + before(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); } - // InternalScope.g:6838:2: ( rule__SwitchExpression__CaseAssignment_3 )* - loop58: - do { - int alt58=2; - int LA58_0 = input.LA(1); - - if ( (LA58_0==47) ) { - alt58=1; - } - - - switch (alt58) { - case 1 : - // InternalScope.g:6838:3: rule__SwitchExpression__CaseAssignment_3 - { - pushFollow(FOLLOW_56); - rule__SwitchExpression__CaseAssignment_3(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop58; - } - } while (true); - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); + after(grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); } } @@ -22984,26 +25455,21 @@ public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__3__Impl" + // $ANTLR end "rule__ScopeDelegation__Group_3__0__Impl" - // $ANTLR start "rule__SwitchExpression__Group__4" - // InternalScope.g:6846:1: rule__SwitchExpression__Group__4 : rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ; - public final void rule__SwitchExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group_3__1" + // InternalScope.g:7059:1: rule__ScopeDelegation__Group_3__1 : rule__ScopeDelegation__Group_3__1__Impl ; + public final void rule__ScopeDelegation__Group_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6850:1: ( rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ) - // InternalScope.g:6851:2: rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 + // InternalScope.g:7063:1: ( rule__ScopeDelegation__Group_3__1__Impl ) + // InternalScope.g:7064:2: rule__ScopeDelegation__Group_3__1__Impl { - pushFollow(FOLLOW_47); - rule__SwitchExpression__Group__4__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__5(); + rule__ScopeDelegation__Group_3__1__Impl(); state._fsp--; if (state.failed) return ; @@ -23022,28 +25488,38 @@ public final void rule__SwitchExpression__Group__4() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__4" + // $ANTLR end "rule__ScopeDelegation__Group_3__1" - // $ANTLR start "rule__SwitchExpression__Group__4__Impl" - // InternalScope.g:6858:1: rule__SwitchExpression__Group__4__Impl : ( 'default' ) ; - public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__ScopeDelegation__Group_3__1__Impl" + // InternalScope.g:7070:1: rule__ScopeDelegation__Group_3__1__Impl : ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) ; + public final void rule__ScopeDelegation__Group_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6862:1: ( ( 'default' ) ) - // InternalScope.g:6863:1: ( 'default' ) + // InternalScope.g:7074:1: ( ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) ) + // InternalScope.g:7075:1: ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) { - // InternalScope.g:6863:1: ( 'default' ) - // InternalScope.g:6864:2: 'default' + // InternalScope.g:7075:1: ( ( rule__ScopeDelegation__ScopeAssignment_3_1 ) ) + // InternalScope.g:7076:2: ( rule__ScopeDelegation__ScopeAssignment_3_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); + before(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); } - match(input,77,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:7077:2: ( rule__ScopeDelegation__ScopeAssignment_3_1 ) + // InternalScope.g:7077:3: rule__ScopeDelegation__ScopeAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__ScopeDelegation__ScopeAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); + after(grammarAccess.getScopeDelegationAccess().getScopeAssignment_3_1()); } } @@ -23063,26 +25539,26 @@ public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__4__Impl" + // $ANTLR end "rule__ScopeDelegation__Group_3__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group__5" - // InternalScope.g:6873:1: rule__SwitchExpression__Group__5 : rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ; - public final void rule__SwitchExpression__Group__5() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group__0" + // InternalScope.g:7086:1: rule__NamedScopeExpression__Group__0 : rule__NamedScopeExpression__Group__0__Impl rule__NamedScopeExpression__Group__1 ; + public final void rule__NamedScopeExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6877:1: ( rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ) - // InternalScope.g:6878:2: rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 + // InternalScope.g:7090:1: ( rule__NamedScopeExpression__Group__0__Impl rule__NamedScopeExpression__Group__1 ) + // InternalScope.g:7091:2: rule__NamedScopeExpression__Group__0__Impl rule__NamedScopeExpression__Group__1 { - pushFollow(FOLLOW_57); - rule__SwitchExpression__Group__5__Impl(); + pushFollow(FOLLOW_34); + rule__NamedScopeExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__6(); + rule__NamedScopeExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -23101,28 +25577,38 @@ public final void rule__SwitchExpression__Group__5() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__5" + // $ANTLR end "rule__NamedScopeExpression__Group__0" - // $ANTLR start "rule__SwitchExpression__Group__5__Impl" - // InternalScope.g:6885:1: rule__SwitchExpression__Group__5__Impl : ( ':' ) ; - public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group__0__Impl" + // InternalScope.g:7098:1: rule__NamedScopeExpression__Group__0__Impl : ( ( rule__NamedScopeExpression__Alternatives_0 ) ) ; + public final void rule__NamedScopeExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6889:1: ( ( ':' ) ) - // InternalScope.g:6890:1: ( ':' ) + // InternalScope.g:7102:1: ( ( ( rule__NamedScopeExpression__Alternatives_0 ) ) ) + // InternalScope.g:7103:1: ( ( rule__NamedScopeExpression__Alternatives_0 ) ) { - // InternalScope.g:6890:1: ( ':' ) - // InternalScope.g:6891:2: ':' + // InternalScope.g:7103:1: ( ( rule__NamedScopeExpression__Alternatives_0 ) ) + // InternalScope.g:7104:2: ( rule__NamedScopeExpression__Alternatives_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); + before(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); } - match(input,70,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:7105:2: ( rule__NamedScopeExpression__Alternatives_0 ) + // InternalScope.g:7105:3: rule__NamedScopeExpression__Alternatives_0 + { + pushFollow(FOLLOW_2); + rule__NamedScopeExpression__Alternatives_0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); + after(grammarAccess.getNamedScopeExpressionAccess().getAlternatives_0()); } } @@ -23142,26 +25628,26 @@ public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__5__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group__0__Impl" - // $ANTLR start "rule__SwitchExpression__Group__6" - // InternalScope.g:6900:1: rule__SwitchExpression__Group__6 : rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ; - public final void rule__SwitchExpression__Group__6() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group__1" + // InternalScope.g:7113:1: rule__NamedScopeExpression__Group__1 : rule__NamedScopeExpression__Group__1__Impl rule__NamedScopeExpression__Group__2 ; + public final void rule__NamedScopeExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6904:1: ( rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ) - // InternalScope.g:6905:2: rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 + // InternalScope.g:7117:1: ( rule__NamedScopeExpression__Group__1__Impl rule__NamedScopeExpression__Group__2 ) + // InternalScope.g:7118:2: rule__NamedScopeExpression__Group__1__Impl rule__NamedScopeExpression__Group__2 { - pushFollow(FOLLOW_21); - rule__SwitchExpression__Group__6__Impl(); + pushFollow(FOLLOW_34); + rule__NamedScopeExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__7(); + rule__NamedScopeExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -23180,38 +25666,49 @@ public final void rule__SwitchExpression__Group__6() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__6" + // $ANTLR end "rule__NamedScopeExpression__Group__1" - // $ANTLR start "rule__SwitchExpression__Group__6__Impl" - // InternalScope.g:6912:1: rule__SwitchExpression__Group__6__Impl : ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ; - public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group__1__Impl" + // InternalScope.g:7125:1: rule__NamedScopeExpression__Group__1__Impl : ( ( rule__NamedScopeExpression__Group_1__0 )? ) ; + public final void rule__NamedScopeExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6916:1: ( ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ) - // InternalScope.g:6917:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) + // InternalScope.g:7129:1: ( ( ( rule__NamedScopeExpression__Group_1__0 )? ) ) + // InternalScope.g:7130:1: ( ( rule__NamedScopeExpression__Group_1__0 )? ) { - // InternalScope.g:6917:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) - // InternalScope.g:6918:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) + // InternalScope.g:7130:1: ( ( rule__NamedScopeExpression__Group_1__0 )? ) + // InternalScope.g:7131:2: ( rule__NamedScopeExpression__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + before(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); } - // InternalScope.g:6919:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) - // InternalScope.g:6919:3: rule__SwitchExpression__DefaultExprAssignment_6 - { - pushFollow(FOLLOW_2); - rule__SwitchExpression__DefaultExprAssignment_6(); + // InternalScope.g:7132:2: ( rule__NamedScopeExpression__Group_1__0 )? + int alt82=2; + int LA82_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA82_0==74) ) { + alt82=1; + } + switch (alt82) { + case 1 : + // InternalScope.g:7132:3: rule__NamedScopeExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__NamedScopeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + after(grammarAccess.getNamedScopeExpressionAccess().getGroup_1()); } } @@ -23231,21 +25728,21 @@ public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__6__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group__7" - // InternalScope.g:6927:1: rule__SwitchExpression__Group__7 : rule__SwitchExpression__Group__7__Impl ; - public final void rule__SwitchExpression__Group__7() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group__2" + // InternalScope.g:7140:1: rule__NamedScopeExpression__Group__2 : rule__NamedScopeExpression__Group__2__Impl ; + public final void rule__NamedScopeExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6931:1: ( rule__SwitchExpression__Group__7__Impl ) - // InternalScope.g:6932:2: rule__SwitchExpression__Group__7__Impl + // InternalScope.g:7144:1: ( rule__NamedScopeExpression__Group__2__Impl ) + // InternalScope.g:7145:2: rule__NamedScopeExpression__Group__2__Impl { pushFollow(FOLLOW_2); - rule__SwitchExpression__Group__7__Impl(); + rule__NamedScopeExpression__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -23264,28 +25761,49 @@ public final void rule__SwitchExpression__Group__7() throws RecognitionException } return ; } - // $ANTLR end "rule__SwitchExpression__Group__7" + // $ANTLR end "rule__NamedScopeExpression__Group__2" - // $ANTLR start "rule__SwitchExpression__Group__7__Impl" - // InternalScope.g:6938:1: rule__SwitchExpression__Group__7__Impl : ( '}' ) ; - public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group__2__Impl" + // InternalScope.g:7151:1: rule__NamedScopeExpression__Group__2__Impl : ( ( rule__NamedScopeExpression__Group_2__0 )? ) ; + public final void rule__NamedScopeExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6942:1: ( ( '}' ) ) - // InternalScope.g:6943:1: ( '}' ) + // InternalScope.g:7155:1: ( ( ( rule__NamedScopeExpression__Group_2__0 )? ) ) + // InternalScope.g:7156:1: ( ( rule__NamedScopeExpression__Group_2__0 )? ) { - // InternalScope.g:6943:1: ( '}' ) - // InternalScope.g:6944:2: '}' + // InternalScope.g:7156:1: ( ( rule__NamedScopeExpression__Group_2__0 )? ) + // InternalScope.g:7157:2: ( rule__NamedScopeExpression__Group_2__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); + before(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); + } + // InternalScope.g:7158:2: ( rule__NamedScopeExpression__Group_2__0 )? + int alt83=2; + int LA83_0 = input.LA(1); + + if ( (LA83_0==69) ) { + alt83=1; + } + switch (alt83) { + case 1 : + // InternalScope.g:7158:3: rule__NamedScopeExpression__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__NamedScopeExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } - match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); + after(grammarAccess.getNamedScopeExpressionAccess().getGroup_2()); } } @@ -23305,26 +25823,26 @@ public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionExc } return ; } - // $ANTLR end "rule__SwitchExpression__Group__7__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group__2__Impl" - // $ANTLR start "rule__SwitchExpression__Group_1__0" - // InternalScope.g:6954:1: rule__SwitchExpression__Group_1__0 : rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ; - public final void rule__SwitchExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_1__0" + // InternalScope.g:7167:1: rule__NamedScopeExpression__Group_1__0 : rule__NamedScopeExpression__Group_1__0__Impl rule__NamedScopeExpression__Group_1__1 ; + public final void rule__NamedScopeExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6958:1: ( rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ) - // InternalScope.g:6959:2: rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 + // InternalScope.g:7171:1: ( rule__NamedScopeExpression__Group_1__0__Impl rule__NamedScopeExpression__Group_1__1 ) + // InternalScope.g:7172:2: rule__NamedScopeExpression__Group_1__0__Impl rule__NamedScopeExpression__Group_1__1 { - pushFollow(FOLLOW_57); - rule__SwitchExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_15); + rule__NamedScopeExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__1(); + rule__NamedScopeExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -23343,28 +25861,38 @@ public final void rule__SwitchExpression__Group_1__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__0" + // $ANTLR end "rule__NamedScopeExpression__Group_1__0" - // $ANTLR start "rule__SwitchExpression__Group_1__0__Impl" - // InternalScope.g:6966:1: rule__SwitchExpression__Group_1__0__Impl : ( '(' ) ; - public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_1__0__Impl" + // InternalScope.g:7179:1: rule__NamedScopeExpression__Group_1__0__Impl : ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) ; + public final void rule__NamedScopeExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6970:1: ( ( '(' ) ) - // InternalScope.g:6971:1: ( '(' ) + // InternalScope.g:7183:1: ( ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) ) + // InternalScope.g:7184:1: ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) { - // InternalScope.g:6971:1: ( '(' ) - // InternalScope.g:6972:2: '(' + // InternalScope.g:7184:1: ( ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) ) + // InternalScope.g:7185:2: ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); + before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:7186:2: ( rule__NamedScopeExpression__CaseDefAssignment_1_0 ) + // InternalScope.g:7186:3: rule__NamedScopeExpression__CaseDefAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__NamedScopeExpression__CaseDefAssignment_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); + after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefAssignment_1_0()); } } @@ -23384,26 +25912,21 @@ public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__0__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group_1__0__Impl" - // $ANTLR start "rule__SwitchExpression__Group_1__1" - // InternalScope.g:6981:1: rule__SwitchExpression__Group_1__1 : rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ; - public final void rule__SwitchExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_1__1" + // InternalScope.g:7194:1: rule__NamedScopeExpression__Group_1__1 : rule__NamedScopeExpression__Group_1__1__Impl ; + public final void rule__NamedScopeExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6985:1: ( rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ) - // InternalScope.g:6986:2: rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 + // InternalScope.g:7198:1: ( rule__NamedScopeExpression__Group_1__1__Impl ) + // InternalScope.g:7199:2: rule__NamedScopeExpression__Group_1__1__Impl { - pushFollow(FOLLOW_23); - rule__SwitchExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__2(); + rule__NamedScopeExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -23422,30 +25945,30 @@ public final void rule__SwitchExpression__Group_1__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__1" + // $ANTLR end "rule__NamedScopeExpression__Group_1__1" - // $ANTLR start "rule__SwitchExpression__Group_1__1__Impl" - // InternalScope.g:6993:1: rule__SwitchExpression__Group_1__1__Impl : ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ; - public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_1__1__Impl" + // InternalScope.g:7205:1: rule__NamedScopeExpression__Group_1__1__Impl : ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) ; + public final void rule__NamedScopeExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:6997:1: ( ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ) - // InternalScope.g:6998:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) + // InternalScope.g:7209:1: ( ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) ) + // InternalScope.g:7210:1: ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) { - // InternalScope.g:6998:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) - // InternalScope.g:6999:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) + // InternalScope.g:7210:1: ( ( rule__NamedScopeExpression__CasingAssignment_1_1 ) ) + // InternalScope.g:7211:2: ( rule__NamedScopeExpression__CasingAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); + before(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); } - // InternalScope.g:7000:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) - // InternalScope.g:7000:3: rule__SwitchExpression__SwitchExprAssignment_1_1 + // InternalScope.g:7212:2: ( rule__NamedScopeExpression__CasingAssignment_1_1 ) + // InternalScope.g:7212:3: rule__NamedScopeExpression__CasingAssignment_1_1 { pushFollow(FOLLOW_2); - rule__SwitchExpression__SwitchExprAssignment_1_1(); + rule__NamedScopeExpression__CasingAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -23453,7 +25976,7 @@ public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionE } if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); + after(grammarAccess.getNamedScopeExpressionAccess().getCasingAssignment_1_1()); } } @@ -23473,21 +25996,26 @@ public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__1__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group_1__1__Impl" - // $ANTLR start "rule__SwitchExpression__Group_1__2" - // InternalScope.g:7008:1: rule__SwitchExpression__Group_1__2 : rule__SwitchExpression__Group_1__2__Impl ; - public final void rule__SwitchExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_2__0" + // InternalScope.g:7221:1: rule__NamedScopeExpression__Group_2__0 : rule__NamedScopeExpression__Group_2__0__Impl rule__NamedScopeExpression__Group_2__1 ; + public final void rule__NamedScopeExpression__Group_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7012:1: ( rule__SwitchExpression__Group_1__2__Impl ) - // InternalScope.g:7013:2: rule__SwitchExpression__Group_1__2__Impl + // InternalScope.g:7225:1: ( rule__NamedScopeExpression__Group_2__0__Impl rule__NamedScopeExpression__Group_2__1 ) + // InternalScope.g:7226:2: rule__NamedScopeExpression__Group_2__0__Impl rule__NamedScopeExpression__Group_2__1 { + pushFollow(FOLLOW_17); + rule__NamedScopeExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SwitchExpression__Group_1__2__Impl(); + rule__NamedScopeExpression__Group_2__1(); state._fsp--; if (state.failed) return ; @@ -23506,28 +26034,28 @@ public final void rule__SwitchExpression__Group_1__2() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__2" + // $ANTLR end "rule__NamedScopeExpression__Group_2__0" - // $ANTLR start "rule__SwitchExpression__Group_1__2__Impl" - // InternalScope.g:7019:1: rule__SwitchExpression__Group_1__2__Impl : ( ')' ) ; - public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_2__0__Impl" + // InternalScope.g:7233:1: rule__NamedScopeExpression__Group_2__0__Impl : ( 'as' ) ; + public final void rule__NamedScopeExpression__Group_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7023:1: ( ( ')' ) ) - // InternalScope.g:7024:1: ( ')' ) + // InternalScope.g:7237:1: ( ( 'as' ) ) + // InternalScope.g:7238:1: ( 'as' ) { - // InternalScope.g:7024:1: ( ')' ) - // InternalScope.g:7025:2: ')' + // InternalScope.g:7238:1: ( 'as' ) + // InternalScope.g:7239:2: 'as' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); + before(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,69,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); + after(grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); } } @@ -23547,26 +26075,21 @@ public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__Group_1__2__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group_2__0__Impl" - // $ANTLR start "rule__Case__Group__0" - // InternalScope.g:7035:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; - public final void rule__Case__Group__0() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_2__1" + // InternalScope.g:7248:1: rule__NamedScopeExpression__Group_2__1 : rule__NamedScopeExpression__Group_2__1__Impl ; + public final void rule__NamedScopeExpression__Group_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7039:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) - // InternalScope.g:7040:2: rule__Case__Group__0__Impl rule__Case__Group__1 + // InternalScope.g:7252:1: ( rule__NamedScopeExpression__Group_2__1__Impl ) + // InternalScope.g:7253:2: rule__NamedScopeExpression__Group_2__1__Impl { - pushFollow(FOLLOW_57); - rule__Case__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__1(); + rule__NamedScopeExpression__Group_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -23585,28 +26108,38 @@ public final void rule__Case__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__0" + // $ANTLR end "rule__NamedScopeExpression__Group_2__1" - // $ANTLR start "rule__Case__Group__0__Impl" - // InternalScope.g:7047:1: rule__Case__Group__0__Impl : ( 'case' ) ; - public final void rule__Case__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamedScopeExpression__Group_2__1__Impl" + // InternalScope.g:7259:1: rule__NamedScopeExpression__Group_2__1__Impl : ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) ; + public final void rule__NamedScopeExpression__Group_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7051:1: ( ( 'case' ) ) - // InternalScope.g:7052:1: ( 'case' ) + // InternalScope.g:7263:1: ( ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) ) + // InternalScope.g:7264:1: ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) { - // InternalScope.g:7052:1: ( 'case' ) - // InternalScope.g:7053:2: 'case' + // InternalScope.g:7264:1: ( ( rule__NamedScopeExpression__NamingAssignment_2_1 ) ) + // InternalScope.g:7265:2: ( rule__NamedScopeExpression__NamingAssignment_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getCaseKeyword_0()); + before(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); + } + // InternalScope.g:7266:2: ( rule__NamedScopeExpression__NamingAssignment_2_1 ) + // InternalScope.g:7266:3: rule__NamedScopeExpression__NamingAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__NamedScopeExpression__NamingAssignment_2_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getCaseKeyword_0()); + after(grammarAccess.getNamedScopeExpressionAccess().getNamingAssignment_2_1()); } } @@ -23626,26 +26159,26 @@ public final void rule__Case__Group__0__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__0__Impl" + // $ANTLR end "rule__NamedScopeExpression__Group_2__1__Impl" - // $ANTLR start "rule__Case__Group__1" - // InternalScope.g:7062:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; - public final void rule__Case__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__0" + // InternalScope.g:7275:1: rule__GlobalScopeExpression__Group__0 : rule__GlobalScopeExpression__Group__0__Impl rule__GlobalScopeExpression__Group__1 ; + public final void rule__GlobalScopeExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7066:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) - // InternalScope.g:7067:2: rule__Case__Group__1__Impl rule__Case__Group__2 + // InternalScope.g:7279:1: ( rule__GlobalScopeExpression__Group__0__Impl rule__GlobalScopeExpression__Group__1 ) + // InternalScope.g:7280:2: rule__GlobalScopeExpression__Group__0__Impl rule__GlobalScopeExpression__Group__1 { - pushFollow(FOLLOW_47); - rule__Case__Group__1__Impl(); + pushFollow(FOLLOW_31); + rule__GlobalScopeExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__2(); + rule__GlobalScopeExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -23664,38 +26197,28 @@ public final void rule__Case__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group__0" - // $ANTLR start "rule__Case__Group__1__Impl" - // InternalScope.g:7074:1: rule__Case__Group__1__Impl : ( ( rule__Case__ConditionAssignment_1 ) ) ; - public final void rule__Case__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__0__Impl" + // InternalScope.g:7287:1: rule__GlobalScopeExpression__Group__0__Impl : ( 'find' ) ; + public final void rule__GlobalScopeExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7078:1: ( ( ( rule__Case__ConditionAssignment_1 ) ) ) - // InternalScope.g:7079:1: ( ( rule__Case__ConditionAssignment_1 ) ) + // InternalScope.g:7291:1: ( ( 'find' ) ) + // InternalScope.g:7292:1: ( 'find' ) { - // InternalScope.g:7079:1: ( ( rule__Case__ConditionAssignment_1 ) ) - // InternalScope.g:7080:2: ( rule__Case__ConditionAssignment_1 ) + // InternalScope.g:7292:1: ( 'find' ) + // InternalScope.g:7293:2: 'find' { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getConditionAssignment_1()); - } - // InternalScope.g:7081:2: ( rule__Case__ConditionAssignment_1 ) - // InternalScope.g:7081:3: rule__Case__ConditionAssignment_1 - { - pushFollow(FOLLOW_2); - rule__Case__ConditionAssignment_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } - + match(input,87,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getConditionAssignment_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } } @@ -23715,26 +26238,26 @@ public final void rule__Case__Group__1__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__0__Impl" - // $ANTLR start "rule__Case__Group__2" - // InternalScope.g:7089:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ; - public final void rule__Case__Group__2() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__1" + // InternalScope.g:7302:1: rule__GlobalScopeExpression__Group__1 : rule__GlobalScopeExpression__Group__1__Impl rule__GlobalScopeExpression__Group__2 ; + public final void rule__GlobalScopeExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7093:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 ) - // InternalScope.g:7094:2: rule__Case__Group__2__Impl rule__Case__Group__3 + // InternalScope.g:7306:1: ( rule__GlobalScopeExpression__Group__1__Impl rule__GlobalScopeExpression__Group__2 ) + // InternalScope.g:7307:2: rule__GlobalScopeExpression__Group__1__Impl rule__GlobalScopeExpression__Group__2 { - pushFollow(FOLLOW_57); - rule__Case__Group__2__Impl(); + pushFollow(FOLLOW_4); + rule__GlobalScopeExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__3(); + rule__GlobalScopeExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -23753,28 +26276,28 @@ public final void rule__Case__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__2" + // $ANTLR end "rule__GlobalScopeExpression__Group__1" - // $ANTLR start "rule__Case__Group__2__Impl" - // InternalScope.g:7101:1: rule__Case__Group__2__Impl : ( ':' ) ; - public final void rule__Case__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__1__Impl" + // InternalScope.g:7314:1: rule__GlobalScopeExpression__Group__1__Impl : ( '(' ) ; + public final void rule__GlobalScopeExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7105:1: ( ( ':' ) ) - // InternalScope.g:7106:1: ( ':' ) + // InternalScope.g:7318:1: ( ( '(' ) ) + // InternalScope.g:7319:1: ( '(' ) { - // InternalScope.g:7106:1: ( ':' ) - // InternalScope.g:7107:2: ':' + // InternalScope.g:7319:1: ( '(' ) + // InternalScope.g:7320:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getColonKeyword_2()); + before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); } - match(input,70,FOLLOW_2); if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getColonKeyword_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); } } @@ -23794,21 +26317,26 @@ public final void rule__Case__Group__2__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__1__Impl" - // $ANTLR start "rule__Case__Group__3" - // InternalScope.g:7116:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ; - public final void rule__Case__Group__3() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__2" + // InternalScope.g:7329:1: rule__GlobalScopeExpression__Group__2 : rule__GlobalScopeExpression__Group__2__Impl rule__GlobalScopeExpression__Group__3 ; + public final void rule__GlobalScopeExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7120:1: ( rule__Case__Group__3__Impl ) - // InternalScope.g:7121:2: rule__Case__Group__3__Impl + // InternalScope.g:7333:1: ( rule__GlobalScopeExpression__Group__2__Impl rule__GlobalScopeExpression__Group__3 ) + // InternalScope.g:7334:2: rule__GlobalScopeExpression__Group__2__Impl rule__GlobalScopeExpression__Group__3 { + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__Case__Group__3__Impl(); + rule__GlobalScopeExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -23827,30 +26355,30 @@ public final void rule__Case__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__3" + // $ANTLR end "rule__GlobalScopeExpression__Group__2" - // $ANTLR start "rule__Case__Group__3__Impl" - // InternalScope.g:7127:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenParAssignment_3 ) ) ; - public final void rule__Case__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__2__Impl" + // InternalScope.g:7341:1: rule__GlobalScopeExpression__Group__2__Impl : ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) ; + public final void rule__GlobalScopeExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7131:1: ( ( ( rule__Case__ThenParAssignment_3 ) ) ) - // InternalScope.g:7132:1: ( ( rule__Case__ThenParAssignment_3 ) ) + // InternalScope.g:7345:1: ( ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) ) + // InternalScope.g:7346:1: ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) { - // InternalScope.g:7132:1: ( ( rule__Case__ThenParAssignment_3 ) ) - // InternalScope.g:7133:2: ( rule__Case__ThenParAssignment_3 ) + // InternalScope.g:7346:1: ( ( rule__GlobalScopeExpression__TypeAssignment_2 ) ) + // InternalScope.g:7347:2: ( rule__GlobalScopeExpression__TypeAssignment_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getThenParAssignment_3()); + before(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); } - // InternalScope.g:7134:2: ( rule__Case__ThenParAssignment_3 ) - // InternalScope.g:7134:3: rule__Case__ThenParAssignment_3 + // InternalScope.g:7348:2: ( rule__GlobalScopeExpression__TypeAssignment_2 ) + // InternalScope.g:7348:3: rule__GlobalScopeExpression__TypeAssignment_2 { pushFollow(FOLLOW_2); - rule__Case__ThenParAssignment_3(); + rule__GlobalScopeExpression__TypeAssignment_2(); state._fsp--; if (state.failed) return ; @@ -23858,7 +26386,7 @@ public final void rule__Case__Group__3__Impl() throws RecognitionException { } if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getThenParAssignment_3()); + after(grammarAccess.getGlobalScopeExpressionAccess().getTypeAssignment_2()); } } @@ -23878,26 +26406,26 @@ public final void rule__Case__Group__3__Impl() throws RecognitionException { } return ; } - // $ANTLR end "rule__Case__Group__3__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__2__Impl" - // $ANTLR start "rule__OrExpression__Group__0" - // InternalScope.g:7143:1: rule__OrExpression__Group__0 : rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ; - public final void rule__OrExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__3" + // InternalScope.g:7356:1: rule__GlobalScopeExpression__Group__3 : rule__GlobalScopeExpression__Group__3__Impl rule__GlobalScopeExpression__Group__4 ; + public final void rule__GlobalScopeExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7147:1: ( rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ) - // InternalScope.g:7148:2: rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 + // InternalScope.g:7360:1: ( rule__GlobalScopeExpression__Group__3__Impl rule__GlobalScopeExpression__Group__4 ) + // InternalScope.g:7361:2: rule__GlobalScopeExpression__Group__3__Impl rule__GlobalScopeExpression__Group__4 { - pushFollow(FOLLOW_58); - rule__OrExpression__Group__0__Impl(); + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group__1(); + rule__GlobalScopeExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -23916,32 +26444,53 @@ public final void rule__OrExpression__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group__3" - // $ANTLR start "rule__OrExpression__Group__0__Impl" - // InternalScope.g:7155:1: rule__OrExpression__Group__0__Impl : ( ruleAndExpression ) ; - public final void rule__OrExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__3__Impl" + // InternalScope.g:7368:1: rule__GlobalScopeExpression__Group__3__Impl : ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) ; + public final void rule__GlobalScopeExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7159:1: ( ( ruleAndExpression ) ) - // InternalScope.g:7160:1: ( ruleAndExpression ) + // InternalScope.g:7372:1: ( ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) ) + // InternalScope.g:7373:1: ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) { - // InternalScope.g:7160:1: ( ruleAndExpression ) - // InternalScope.g:7161:2: ruleAndExpression + // InternalScope.g:7373:1: ( ( rule__GlobalScopeExpression__Alternatives_3 )? ) + // InternalScope.g:7374:2: ( rule__GlobalScopeExpression__Alternatives_3 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); + } + // InternalScope.g:7375:2: ( rule__GlobalScopeExpression__Alternatives_3 )? + int alt84=2; + int LA84_0 = input.LA(1); + + if ( (LA84_0==86) ) { + int LA84_1 = input.LA(2); + + if ( ((LA84_1>=88 && LA84_1<=89)||LA84_1==117) ) { + alt84=1; + } + } + switch (alt84) { + case 1 : + // InternalScope.g:7375:3: rule__GlobalScopeExpression__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } - pushFollow(FOLLOW_2); - ruleAndExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_3()); } } @@ -23961,21 +26510,26 @@ public final void rule__OrExpression__Group__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__OrExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__3__Impl" - // $ANTLR start "rule__OrExpression__Group__1" - // InternalScope.g:7170:1: rule__OrExpression__Group__1 : rule__OrExpression__Group__1__Impl ; - public final void rule__OrExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__4" + // InternalScope.g:7383:1: rule__GlobalScopeExpression__Group__4 : rule__GlobalScopeExpression__Group__4__Impl rule__GlobalScopeExpression__Group__5 ; + public final void rule__GlobalScopeExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7174:1: ( rule__OrExpression__Group__1__Impl ) - // InternalScope.g:7175:2: rule__OrExpression__Group__1__Impl + // InternalScope.g:7387:1: ( rule__GlobalScopeExpression__Group__4__Impl rule__GlobalScopeExpression__Group__5 ) + // InternalScope.g:7388:2: rule__GlobalScopeExpression__Group__4__Impl rule__GlobalScopeExpression__Group__5 { + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -23994,56 +26548,53 @@ public final void rule__OrExpression__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group__4" - // $ANTLR start "rule__OrExpression__Group__1__Impl" - // InternalScope.g:7181:1: rule__OrExpression__Group__1__Impl : ( ( rule__OrExpression__Group_1__0 )* ) ; - public final void rule__OrExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__4__Impl" + // InternalScope.g:7395:1: rule__GlobalScopeExpression__Group__4__Impl : ( ( rule__GlobalScopeExpression__Group_4__0 )? ) ; + public final void rule__GlobalScopeExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7185:1: ( ( ( rule__OrExpression__Group_1__0 )* ) ) - // InternalScope.g:7186:1: ( ( rule__OrExpression__Group_1__0 )* ) + // InternalScope.g:7399:1: ( ( ( rule__GlobalScopeExpression__Group_4__0 )? ) ) + // InternalScope.g:7400:1: ( ( rule__GlobalScopeExpression__Group_4__0 )? ) { - // InternalScope.g:7186:1: ( ( rule__OrExpression__Group_1__0 )* ) - // InternalScope.g:7187:2: ( rule__OrExpression__Group_1__0 )* + // InternalScope.g:7400:1: ( ( rule__GlobalScopeExpression__Group_4__0 )? ) + // InternalScope.g:7401:2: ( rule__GlobalScopeExpression__Group_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getGroup_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); } - // InternalScope.g:7188:2: ( rule__OrExpression__Group_1__0 )* - loop59: - do { - int alt59=2; - int LA59_0 = input.LA(1); - - if ( (LA59_0==82) ) { - alt59=1; - } + // InternalScope.g:7402:2: ( rule__GlobalScopeExpression__Group_4__0 )? + int alt85=2; + int LA85_0 = input.LA(1); + if ( (LA85_0==86) ) { + int LA85_1 = input.LA(2); - switch (alt59) { - case 1 : - // InternalScope.g:7188:3: rule__OrExpression__Group_1__0 - { - pushFollow(FOLLOW_59); - rule__OrExpression__Group_1__0(); + if ( (LA85_1==90) ) { + alt85=1; + } + } + switch (alt85) { + case 1 : + // InternalScope.g:7402:3: rule__GlobalScopeExpression__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__Group_4__0(); - state._fsp--; - if (state.failed) return ; + state._fsp--; + if (state.failed) return ; - } - break; + } + break; - default : - break loop59; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getGroup_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4()); } } @@ -24063,26 +26614,26 @@ public final void rule__OrExpression__Group__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__OrExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__4__Impl" - // $ANTLR start "rule__OrExpression__Group_1__0" - // InternalScope.g:7197:1: rule__OrExpression__Group_1__0 : rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ; - public final void rule__OrExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__5" + // InternalScope.g:7410:1: rule__GlobalScopeExpression__Group__5 : rule__GlobalScopeExpression__Group__5__Impl rule__GlobalScopeExpression__Group__6 ; + public final void rule__GlobalScopeExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7201:1: ( rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ) - // InternalScope.g:7202:2: rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 + // InternalScope.g:7414:1: ( rule__GlobalScopeExpression__Group__5__Impl rule__GlobalScopeExpression__Group__6 ) + // InternalScope.g:7415:2: rule__GlobalScopeExpression__Group__5__Impl rule__GlobalScopeExpression__Group__6 { - pushFollow(FOLLOW_58); - rule__OrExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__1(); + rule__GlobalScopeExpression__Group__6(); state._fsp--; if (state.failed) return ; @@ -24101,40 +26652,61 @@ public final void rule__OrExpression__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group_1__0" + // $ANTLR end "rule__GlobalScopeExpression__Group__5" - // $ANTLR start "rule__OrExpression__Group_1__0__Impl" - // InternalScope.g:7209:1: rule__OrExpression__Group_1__0__Impl : ( () ) ; - public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__5__Impl" + // InternalScope.g:7422:1: rule__GlobalScopeExpression__Group__5__Impl : ( ( rule__GlobalScopeExpression__Group_5__0 )? ) ; + public final void rule__GlobalScopeExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7213:1: ( ( () ) ) - // InternalScope.g:7214:1: ( () ) + // InternalScope.g:7426:1: ( ( ( rule__GlobalScopeExpression__Group_5__0 )? ) ) + // InternalScope.g:7427:1: ( ( rule__GlobalScopeExpression__Group_5__0 )? ) { - // InternalScope.g:7214:1: ( () ) - // InternalScope.g:7215:2: () + // InternalScope.g:7427:1: ( ( rule__GlobalScopeExpression__Group_5__0 )? ) + // InternalScope.g:7428:2: ( rule__GlobalScopeExpression__Group_5__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); - } - // InternalScope.g:7216:2: () - // InternalScope.g:7216:3: - { + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); } + // InternalScope.g:7429:2: ( rule__GlobalScopeExpression__Group_5__0 )? + int alt86=2; + int LA86_0 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); + if ( (LA86_0==86) ) { + alt86=1; } + switch (alt86) { + case 1 : + // InternalScope.g:7429:3: rule__GlobalScopeExpression__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__Group_5__0(); - } + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5()); + } + + } } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -24142,26 +26714,21 @@ public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__5__Impl" - // $ANTLR start "rule__OrExpression__Group_1__1" - // InternalScope.g:7224:1: rule__OrExpression__Group_1__1 : rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ; - public final void rule__OrExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__6" + // InternalScope.g:7437:1: rule__GlobalScopeExpression__Group__6 : rule__GlobalScopeExpression__Group__6__Impl ; + public final void rule__GlobalScopeExpression__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7228:1: ( rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ) - // InternalScope.g:7229:2: rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 + // InternalScope.g:7441:1: ( rule__GlobalScopeExpression__Group__6__Impl ) + // InternalScope.g:7442:2: rule__GlobalScopeExpression__Group__6__Impl { - pushFollow(FOLLOW_57); - rule__OrExpression__Group_1__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__2(); + rule__GlobalScopeExpression__Group__6__Impl(); state._fsp--; if (state.failed) return ; @@ -24180,38 +26747,28 @@ public final void rule__OrExpression__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group_1__1" + // $ANTLR end "rule__GlobalScopeExpression__Group__6" - // $ANTLR start "rule__OrExpression__Group_1__1__Impl" - // InternalScope.g:7236:1: rule__OrExpression__Group_1__1__Impl : ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group__6__Impl" + // InternalScope.g:7448:1: rule__GlobalScopeExpression__Group__6__Impl : ( ')' ) ; + public final void rule__GlobalScopeExpression__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7240:1: ( ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ) - // InternalScope.g:7241:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:7452:1: ( ( ')' ) ) + // InternalScope.g:7453:1: ( ')' ) { - // InternalScope.g:7241:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) - // InternalScope.g:7242:2: ( rule__OrExpression__OperatorAssignment_1_1 ) + // InternalScope.g:7453:1: ( ')' ) + // InternalScope.g:7454:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalScope.g:7243:2: ( rule__OrExpression__OperatorAssignment_1_1 ) - // InternalScope.g:7243:3: rule__OrExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__OrExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); } } @@ -24231,21 +26788,26 @@ public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group__6__Impl" - // $ANTLR start "rule__OrExpression__Group_1__2" - // InternalScope.g:7251:1: rule__OrExpression__Group_1__2 : rule__OrExpression__Group_1__2__Impl ; - public final void rule__OrExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__0" + // InternalScope.g:7464:1: rule__GlobalScopeExpression__Group_3_0__0 : rule__GlobalScopeExpression__Group_3_0__0__Impl rule__GlobalScopeExpression__Group_3_0__1 ; + public final void rule__GlobalScopeExpression__Group_3_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7255:1: ( rule__OrExpression__Group_1__2__Impl ) - // InternalScope.g:7256:2: rule__OrExpression__Group_1__2__Impl + // InternalScope.g:7468:1: ( rule__GlobalScopeExpression__Group_3_0__0__Impl rule__GlobalScopeExpression__Group_3_0__1 ) + // InternalScope.g:7469:2: rule__GlobalScopeExpression__Group_3_0__0__Impl rule__GlobalScopeExpression__Group_3_0__1 { + pushFollow(FOLLOW_35); + rule__GlobalScopeExpression__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OrExpression__Group_1__2__Impl(); + rule__GlobalScopeExpression__Group_3_0__1(); state._fsp--; if (state.failed) return ; @@ -24264,38 +26826,28 @@ public final void rule__OrExpression__Group_1__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__OrExpression__Group_1__2" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__0" - // $ANTLR start "rule__OrExpression__Group_1__2__Impl" - // InternalScope.g:7262:1: rule__OrExpression__Group_1__2__Impl : ( ( rule__OrExpression__RightAssignment_1_2 ) ) ; - public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__0__Impl" + // InternalScope.g:7476:1: rule__GlobalScopeExpression__Group_3_0__0__Impl : ( ',' ) ; + public final void rule__GlobalScopeExpression__Group_3_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7266:1: ( ( ( rule__OrExpression__RightAssignment_1_2 ) ) ) - // InternalScope.g:7267:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) + // InternalScope.g:7480:1: ( ( ',' ) ) + // InternalScope.g:7481:1: ( ',' ) { - // InternalScope.g:7267:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) - // InternalScope.g:7268:2: ( rule__OrExpression__RightAssignment_1_2 ) + // InternalScope.g:7481:1: ( ',' ) + // InternalScope.g:7482:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); - } - // InternalScope.g:7269:2: ( rule__OrExpression__RightAssignment_1_2 ) - // InternalScope.g:7269:3: rule__OrExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__OrExpression__RightAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } } @@ -24315,26 +26867,26 @@ public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__OrExpression__Group_1__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__0__Impl" - // $ANTLR start "rule__AndExpression__Group__0" - // InternalScope.g:7278:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ; - public final void rule__AndExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__1" + // InternalScope.g:7491:1: rule__GlobalScopeExpression__Group_3_0__1 : rule__GlobalScopeExpression__Group_3_0__1__Impl rule__GlobalScopeExpression__Group_3_0__2 ; + public final void rule__GlobalScopeExpression__Group_3_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7282:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ) - // InternalScope.g:7283:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 + // InternalScope.g:7495:1: ( rule__GlobalScopeExpression__Group_3_0__1__Impl rule__GlobalScopeExpression__Group_3_0__2 ) + // InternalScope.g:7496:2: rule__GlobalScopeExpression__Group_3_0__1__Impl rule__GlobalScopeExpression__Group_3_0__2 { - pushFollow(FOLLOW_60); - rule__AndExpression__Group__0__Impl(); + pushFollow(FOLLOW_16); + rule__GlobalScopeExpression__Group_3_0__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group__1(); + rule__GlobalScopeExpression__Group_3_0__2(); state._fsp--; if (state.failed) return ; @@ -24353,32 +26905,28 @@ public final void rule__AndExpression__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__AndExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__1" - // $ANTLR start "rule__AndExpression__Group__0__Impl" - // InternalScope.g:7290:1: rule__AndExpression__Group__0__Impl : ( ruleImpliesExpression ) ; - public final void rule__AndExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__1__Impl" + // InternalScope.g:7503:1: rule__GlobalScopeExpression__Group_3_0__1__Impl : ( 'key' ) ; + public final void rule__GlobalScopeExpression__Group_3_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7294:1: ( ( ruleImpliesExpression ) ) - // InternalScope.g:7295:1: ( ruleImpliesExpression ) + // InternalScope.g:7507:1: ( ( 'key' ) ) + // InternalScope.g:7508:1: ( 'key' ) { - // InternalScope.g:7295:1: ( ruleImpliesExpression ) - // InternalScope.g:7296:2: ruleImpliesExpression + // InternalScope.g:7508:1: ( 'key' ) + // InternalScope.g:7509:2: 'key' { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } - pushFollow(FOLLOW_2); - ruleImpliesExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,88,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } } @@ -24398,21 +26946,26 @@ public final void rule__AndExpression__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__AndExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__1__Impl" - // $ANTLR start "rule__AndExpression__Group__1" - // InternalScope.g:7305:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ; - public final void rule__AndExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__2" + // InternalScope.g:7518:1: rule__GlobalScopeExpression__Group_3_0__2 : rule__GlobalScopeExpression__Group_3_0__2__Impl rule__GlobalScopeExpression__Group_3_0__3 ; + public final void rule__GlobalScopeExpression__Group_3_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7309:1: ( rule__AndExpression__Group__1__Impl ) - // InternalScope.g:7310:2: rule__AndExpression__Group__1__Impl + // InternalScope.g:7522:1: ( rule__GlobalScopeExpression__Group_3_0__2__Impl rule__GlobalScopeExpression__Group_3_0__3 ) + // InternalScope.g:7523:2: rule__GlobalScopeExpression__Group_3_0__2__Impl rule__GlobalScopeExpression__Group_3_0__3 { + pushFollow(FOLLOW_17); + rule__GlobalScopeExpression__Group_3_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group_3_0__3(); state._fsp--; if (state.failed) return ; @@ -24431,56 +26984,28 @@ public final void rule__AndExpression__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__AndExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__2" - // $ANTLR start "rule__AndExpression__Group__1__Impl" - // InternalScope.g:7316:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ; - public final void rule__AndExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__2__Impl" + // InternalScope.g:7530:1: rule__GlobalScopeExpression__Group_3_0__2__Impl : ( '=' ) ; + public final void rule__GlobalScopeExpression__Group_3_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7320:1: ( ( ( rule__AndExpression__Group_1__0 )* ) ) - // InternalScope.g:7321:1: ( ( rule__AndExpression__Group_1__0 )* ) + // InternalScope.g:7534:1: ( ( '=' ) ) + // InternalScope.g:7535:1: ( '=' ) { - // InternalScope.g:7321:1: ( ( rule__AndExpression__Group_1__0 )* ) - // InternalScope.g:7322:2: ( rule__AndExpression__Group_1__0 )* + // InternalScope.g:7535:1: ( '=' ) + // InternalScope.g:7536:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getGroup_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); } - // InternalScope.g:7323:2: ( rule__AndExpression__Group_1__0 )* - loop60: - do { - int alt60=2; - int LA60_0 = input.LA(1); - - if ( (LA60_0==83) ) { - alt60=1; - } - - - switch (alt60) { - case 1 : - // InternalScope.g:7323:3: rule__AndExpression__Group_1__0 - { - pushFollow(FOLLOW_61); - rule__AndExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop60; - } - } while (true); - + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getGroup_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); } } @@ -24500,26 +27025,21 @@ public final void rule__AndExpression__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__AndExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__2__Impl" - // $ANTLR start "rule__AndExpression__Group_1__0" - // InternalScope.g:7332:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ; - public final void rule__AndExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__3" + // InternalScope.g:7545:1: rule__GlobalScopeExpression__Group_3_0__3 : rule__GlobalScopeExpression__Group_3_0__3__Impl ; + public final void rule__GlobalScopeExpression__Group_3_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7336:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ) - // InternalScope.g:7337:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 + // InternalScope.g:7549:1: ( rule__GlobalScopeExpression__Group_3_0__3__Impl ) + // InternalScope.g:7550:2: rule__GlobalScopeExpression__Group_3_0__3__Impl { - pushFollow(FOLLOW_60); - rule__AndExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__1(); + rule__GlobalScopeExpression__Group_3_0__3__Impl(); state._fsp--; if (state.failed) return ; @@ -24538,32 +27058,38 @@ public final void rule__AndExpression__Group_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__AndExpression__Group_1__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__3" - // $ANTLR start "rule__AndExpression__Group_1__0__Impl" - // InternalScope.g:7344:1: rule__AndExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_0__3__Impl" + // InternalScope.g:7556:1: rule__GlobalScopeExpression__Group_3_0__3__Impl : ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) ; + public final void rule__GlobalScopeExpression__Group_3_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7348:1: ( ( () ) ) - // InternalScope.g:7349:1: ( () ) + // InternalScope.g:7560:1: ( ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) ) + // InternalScope.g:7561:1: ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) { - // InternalScope.g:7349:1: ( () ) - // InternalScope.g:7350:2: () + // InternalScope.g:7561:1: ( ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) ) + // InternalScope.g:7562:2: ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); } - // InternalScope.g:7351:2: () - // InternalScope.g:7351:3: + // InternalScope.g:7563:2: ( rule__GlobalScopeExpression__NameAssignment_3_0_3 ) + // InternalScope.g:7563:3: rule__GlobalScopeExpression__NameAssignment_3_0_3 { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__NameAssignment_3_0_3(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getNameAssignment_3_0_3()); } } @@ -24572,6 +27098,10 @@ public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionExce } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -24579,26 +27109,26 @@ public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_0__3__Impl" - // $ANTLR start "rule__AndExpression__Group_1__1" - // InternalScope.g:7359:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ; - public final void rule__AndExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__0" + // InternalScope.g:7572:1: rule__GlobalScopeExpression__Group_3_1__0 : rule__GlobalScopeExpression__Group_3_1__0__Impl rule__GlobalScopeExpression__Group_3_1__1 ; + public final void rule__GlobalScopeExpression__Group_3_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7363:1: ( rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ) - // InternalScope.g:7364:2: rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 + // InternalScope.g:7576:1: ( rule__GlobalScopeExpression__Group_3_1__0__Impl rule__GlobalScopeExpression__Group_3_1__1 ) + // InternalScope.g:7577:2: rule__GlobalScopeExpression__Group_3_1__0__Impl rule__GlobalScopeExpression__Group_3_1__1 { - pushFollow(FOLLOW_57); - rule__AndExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_36); + rule__GlobalScopeExpression__Group_3_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__2(); + rule__GlobalScopeExpression__Group_3_1__1(); state._fsp--; if (state.failed) return ; @@ -24617,38 +27147,28 @@ public final void rule__AndExpression__Group_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__AndExpression__Group_1__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__0" - // $ANTLR start "rule__AndExpression__Group_1__1__Impl" - // InternalScope.g:7371:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__0__Impl" + // InternalScope.g:7584:1: rule__GlobalScopeExpression__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__GlobalScopeExpression__Group_3_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7375:1: ( ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ) - // InternalScope.g:7376:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:7588:1: ( ( ',' ) ) + // InternalScope.g:7589:1: ( ',' ) { - // InternalScope.g:7376:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) - // InternalScope.g:7377:2: ( rule__AndExpression__OperatorAssignment_1_1 ) + // InternalScope.g:7589:1: ( ',' ) + // InternalScope.g:7590:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalScope.g:7378:2: ( rule__AndExpression__OperatorAssignment_1_1 ) - // InternalScope.g:7378:3: rule__AndExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__AndExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); } - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); } } @@ -24668,21 +27188,26 @@ public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__0__Impl" - // $ANTLR start "rule__AndExpression__Group_1__2" - // InternalScope.g:7386:1: rule__AndExpression__Group_1__2 : rule__AndExpression__Group_1__2__Impl ; - public final void rule__AndExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__1" + // InternalScope.g:7599:1: rule__GlobalScopeExpression__Group_3_1__1 : rule__GlobalScopeExpression__Group_3_1__1__Impl rule__GlobalScopeExpression__Group_3_1__2 ; + public final void rule__GlobalScopeExpression__Group_3_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7390:1: ( rule__AndExpression__Group_1__2__Impl ) - // InternalScope.g:7391:2: rule__AndExpression__Group_1__2__Impl + // InternalScope.g:7603:1: ( rule__GlobalScopeExpression__Group_3_1__1__Impl rule__GlobalScopeExpression__Group_3_1__2 ) + // InternalScope.g:7604:2: rule__GlobalScopeExpression__Group_3_1__1__Impl rule__GlobalScopeExpression__Group_3_1__2 { + pushFollow(FOLLOW_36); + rule__GlobalScopeExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AndExpression__Group_1__2__Impl(); + rule__GlobalScopeExpression__Group_3_1__2(); state._fsp--; if (state.failed) return ; @@ -24701,38 +27226,49 @@ public final void rule__AndExpression__Group_1__2() throws RecognitionException } return ; } - // $ANTLR end "rule__AndExpression__Group_1__2" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__1" - // $ANTLR start "rule__AndExpression__Group_1__2__Impl" - // InternalScope.g:7397:1: rule__AndExpression__Group_1__2__Impl : ( ( rule__AndExpression__RightAssignment_1_2 ) ) ; - public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__1__Impl" + // InternalScope.g:7611:1: rule__GlobalScopeExpression__Group_3_1__1__Impl : ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) ; + public final void rule__GlobalScopeExpression__Group_3_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7401:1: ( ( ( rule__AndExpression__RightAssignment_1_2 ) ) ) - // InternalScope.g:7402:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) + // InternalScope.g:7615:1: ( ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) ) + // InternalScope.g:7616:1: ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) { - // InternalScope.g:7402:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) - // InternalScope.g:7403:2: ( rule__AndExpression__RightAssignment_1_2 ) + // InternalScope.g:7616:1: ( ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? ) + // InternalScope.g:7617:2: ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); + before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); } - // InternalScope.g:7404:2: ( rule__AndExpression__RightAssignment_1_2 ) - // InternalScope.g:7404:3: rule__AndExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__AndExpression__RightAssignment_1_2(); + // InternalScope.g:7618:2: ( rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 )? + int alt87=2; + int LA87_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA87_0==117) ) { + alt87=1; + } + switch (alt87) { + case 1 : + // InternalScope.g:7618:3: rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixAssignment_3_1_1()); } } @@ -24752,26 +27288,26 @@ public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__AndExpression__Group_1__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__1__Impl" - // $ANTLR start "rule__ImpliesExpression__Group__0" - // InternalScope.g:7413:1: rule__ImpliesExpression__Group__0 : rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ; - public final void rule__ImpliesExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__2" + // InternalScope.g:7626:1: rule__GlobalScopeExpression__Group_3_1__2 : rule__GlobalScopeExpression__Group_3_1__2__Impl rule__GlobalScopeExpression__Group_3_1__3 ; + public final void rule__GlobalScopeExpression__Group_3_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7417:1: ( rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ) - // InternalScope.g:7418:2: rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 + // InternalScope.g:7630:1: ( rule__GlobalScopeExpression__Group_3_1__2__Impl rule__GlobalScopeExpression__Group_3_1__3 ) + // InternalScope.g:7631:2: rule__GlobalScopeExpression__Group_3_1__2__Impl rule__GlobalScopeExpression__Group_3_1__3 { - pushFollow(FOLLOW_62); - rule__ImpliesExpression__Group__0__Impl(); + pushFollow(FOLLOW_16); + rule__GlobalScopeExpression__Group_3_1__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group__1(); + rule__GlobalScopeExpression__Group_3_1__3(); state._fsp--; if (state.failed) return ; @@ -24790,32 +27326,28 @@ public final void rule__ImpliesExpression__Group__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__2" - // $ANTLR start "rule__ImpliesExpression__Group__0__Impl" - // InternalScope.g:7425:1: rule__ImpliesExpression__Group__0__Impl : ( ruleRelationalExpression ) ; - public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__2__Impl" + // InternalScope.g:7638:1: rule__GlobalScopeExpression__Group_3_1__2__Impl : ( 'prefix' ) ; + public final void rule__GlobalScopeExpression__Group_3_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7429:1: ( ( ruleRelationalExpression ) ) - // InternalScope.g:7430:1: ( ruleRelationalExpression ) + // InternalScope.g:7642:1: ( ( 'prefix' ) ) + // InternalScope.g:7643:1: ( 'prefix' ) { - // InternalScope.g:7430:1: ( ruleRelationalExpression ) - // InternalScope.g:7431:2: ruleRelationalExpression + // InternalScope.g:7643:1: ( 'prefix' ) + // InternalScope.g:7644:2: 'prefix' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } - pushFollow(FOLLOW_2); - ruleRelationalExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,89,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } } @@ -24835,21 +27367,26 @@ public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__2__Impl" - // $ANTLR start "rule__ImpliesExpression__Group__1" - // InternalScope.g:7440:1: rule__ImpliesExpression__Group__1 : rule__ImpliesExpression__Group__1__Impl ; - public final void rule__ImpliesExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__3" + // InternalScope.g:7653:1: rule__GlobalScopeExpression__Group_3_1__3 : rule__GlobalScopeExpression__Group_3_1__3__Impl rule__GlobalScopeExpression__Group_3_1__4 ; + public final void rule__GlobalScopeExpression__Group_3_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7444:1: ( rule__ImpliesExpression__Group__1__Impl ) - // InternalScope.g:7445:2: rule__ImpliesExpression__Group__1__Impl + // InternalScope.g:7657:1: ( rule__GlobalScopeExpression__Group_3_1__3__Impl rule__GlobalScopeExpression__Group_3_1__4 ) + // InternalScope.g:7658:2: rule__GlobalScopeExpression__Group_3_1__3__Impl rule__GlobalScopeExpression__Group_3_1__4 { + pushFollow(FOLLOW_17); + rule__GlobalScopeExpression__Group_3_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group_3_1__4(); state._fsp--; if (state.failed) return ; @@ -24868,56 +27405,28 @@ public final void rule__ImpliesExpression__Group__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__3" - // $ANTLR start "rule__ImpliesExpression__Group__1__Impl" - // InternalScope.g:7451:1: rule__ImpliesExpression__Group__1__Impl : ( ( rule__ImpliesExpression__Group_1__0 )* ) ; - public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__3__Impl" + // InternalScope.g:7665:1: rule__GlobalScopeExpression__Group_3_1__3__Impl : ( '=' ) ; + public final void rule__GlobalScopeExpression__Group_3_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7455:1: ( ( ( rule__ImpliesExpression__Group_1__0 )* ) ) - // InternalScope.g:7456:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) + // InternalScope.g:7669:1: ( ( '=' ) ) + // InternalScope.g:7670:1: ( '=' ) { - // InternalScope.g:7456:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) - // InternalScope.g:7457:2: ( rule__ImpliesExpression__Group_1__0 )* + // InternalScope.g:7670:1: ( '=' ) + // InternalScope.g:7671:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); } - // InternalScope.g:7458:2: ( rule__ImpliesExpression__Group_1__0 )* - loop61: - do { - int alt61=2; - int LA61_0 = input.LA(1); - - if ( (LA61_0==84) ) { - alt61=1; - } - - - switch (alt61) { - case 1 : - // InternalScope.g:7458:3: rule__ImpliesExpression__Group_1__0 - { - pushFollow(FOLLOW_63); - rule__ImpliesExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop61; - } - } while (true); - + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); } } @@ -24937,26 +27446,21 @@ public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__ImpliesExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__3__Impl" - // $ANTLR start "rule__ImpliesExpression__Group_1__0" - // InternalScope.g:7467:1: rule__ImpliesExpression__Group_1__0 : rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ; - public final void rule__ImpliesExpression__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__4" + // InternalScope.g:7680:1: rule__GlobalScopeExpression__Group_3_1__4 : rule__GlobalScopeExpression__Group_3_1__4__Impl ; + public final void rule__GlobalScopeExpression__Group_3_1__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7471:1: ( rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ) - // InternalScope.g:7472:2: rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 + // InternalScope.g:7684:1: ( rule__GlobalScopeExpression__Group_3_1__4__Impl ) + // InternalScope.g:7685:2: rule__GlobalScopeExpression__Group_3_1__4__Impl { - pushFollow(FOLLOW_62); - rule__ImpliesExpression__Group_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__1(); + rule__GlobalScopeExpression__Group_3_1__4__Impl(); state._fsp--; if (state.failed) return ; @@ -24975,32 +27479,38 @@ public final void rule__ImpliesExpression__Group_1__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__4" - // $ANTLR start "rule__ImpliesExpression__Group_1__0__Impl" - // InternalScope.g:7479:1: rule__ImpliesExpression__Group_1__0__Impl : ( () ) ; - public final void rule__ImpliesExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_3_1__4__Impl" + // InternalScope.g:7691:1: rule__GlobalScopeExpression__Group_3_1__4__Impl : ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) ; + public final void rule__GlobalScopeExpression__Group_3_1__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7483:1: ( ( () ) ) - // InternalScope.g:7484:1: ( () ) + // InternalScope.g:7695:1: ( ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) ) + // InternalScope.g:7696:1: ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) { - // InternalScope.g:7484:1: ( () ) - // InternalScope.g:7485:2: () + // InternalScope.g:7696:1: ( ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) ) + // InternalScope.g:7697:2: ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); } - // InternalScope.g:7486:2: () - // InternalScope.g:7486:3: + // InternalScope.g:7698:2: ( rule__GlobalScopeExpression__PrefixAssignment_3_1_4 ) + // InternalScope.g:7698:3: rule__GlobalScopeExpression__PrefixAssignment_3_1_4 { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__PrefixAssignment_3_1_4(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixAssignment_3_1_4()); } } @@ -25009,6 +27519,10 @@ public final void rule__ImpliesExpression__Group_1__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -25016,26 +27530,26 @@ public final void rule__ImpliesExpression__Group_1__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_3_1__4__Impl" - // $ANTLR start "rule__ImpliesExpression__Group_1__1" - // InternalScope.g:7494:1: rule__ImpliesExpression__Group_1__1 : rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ; - public final void rule__ImpliesExpression__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__0" + // InternalScope.g:7707:1: rule__GlobalScopeExpression__Group_4__0 : rule__GlobalScopeExpression__Group_4__0__Impl rule__GlobalScopeExpression__Group_4__1 ; + public final void rule__GlobalScopeExpression__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7498:1: ( rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ) - // InternalScope.g:7499:2: rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 + // InternalScope.g:7711:1: ( rule__GlobalScopeExpression__Group_4__0__Impl rule__GlobalScopeExpression__Group_4__1 ) + // InternalScope.g:7712:2: rule__GlobalScopeExpression__Group_4__0__Impl rule__GlobalScopeExpression__Group_4__1 { - pushFollow(FOLLOW_57); - rule__ImpliesExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_37); + rule__GlobalScopeExpression__Group_4__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__2(); + rule__GlobalScopeExpression__Group_4__1(); state._fsp--; if (state.failed) return ; @@ -25054,38 +27568,28 @@ public final void rule__ImpliesExpression__Group_1__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__0" - // $ANTLR start "rule__ImpliesExpression__Group_1__1__Impl" - // InternalScope.g:7506:1: rule__ImpliesExpression__Group_1__1__Impl : ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ; - public final void rule__ImpliesExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__0__Impl" + // InternalScope.g:7719:1: rule__GlobalScopeExpression__Group_4__0__Impl : ( ',' ) ; + public final void rule__GlobalScopeExpression__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7510:1: ( ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ) - // InternalScope.g:7511:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:7723:1: ( ( ',' ) ) + // InternalScope.g:7724:1: ( ',' ) { - // InternalScope.g:7511:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) - // InternalScope.g:7512:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) + // InternalScope.g:7724:1: ( ',' ) + // InternalScope.g:7725:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); - } - // InternalScope.g:7513:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) - // InternalScope.g:7513:3: rule__ImpliesExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__OperatorAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } } @@ -25105,21 +27609,26 @@ public final void rule__ImpliesExpression__Group_1__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__0__Impl" - // $ANTLR start "rule__ImpliesExpression__Group_1__2" - // InternalScope.g:7521:1: rule__ImpliesExpression__Group_1__2 : rule__ImpliesExpression__Group_1__2__Impl ; - public final void rule__ImpliesExpression__Group_1__2() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__1" + // InternalScope.g:7734:1: rule__GlobalScopeExpression__Group_4__1 : rule__GlobalScopeExpression__Group_4__1__Impl rule__GlobalScopeExpression__Group_4__2 ; + public final void rule__GlobalScopeExpression__Group_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7525:1: ( rule__ImpliesExpression__Group_1__2__Impl ) - // InternalScope.g:7526:2: rule__ImpliesExpression__Group_1__2__Impl + // InternalScope.g:7738:1: ( rule__GlobalScopeExpression__Group_4__1__Impl rule__GlobalScopeExpression__Group_4__2 ) + // InternalScope.g:7739:2: rule__GlobalScopeExpression__Group_4__1__Impl rule__GlobalScopeExpression__Group_4__2 { + pushFollow(FOLLOW_16); + rule__GlobalScopeExpression__Group_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ImpliesExpression__Group_1__2__Impl(); + rule__GlobalScopeExpression__Group_4__2(); state._fsp--; if (state.failed) return ; @@ -25138,38 +27647,28 @@ public final void rule__ImpliesExpression__Group_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__2" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__1" - // $ANTLR start "rule__ImpliesExpression__Group_1__2__Impl" - // InternalScope.g:7532:1: rule__ImpliesExpression__Group_1__2__Impl : ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ; - public final void rule__ImpliesExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__1__Impl" + // InternalScope.g:7746:1: rule__GlobalScopeExpression__Group_4__1__Impl : ( 'data' ) ; + public final void rule__GlobalScopeExpression__Group_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7536:1: ( ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ) - // InternalScope.g:7537:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) + // InternalScope.g:7750:1: ( ( 'data' ) ) + // InternalScope.g:7751:1: ( 'data' ) { - // InternalScope.g:7537:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) - // InternalScope.g:7538:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) + // InternalScope.g:7751:1: ( 'data' ) + // InternalScope.g:7752:2: 'data' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); - } - // InternalScope.g:7539:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) - // InternalScope.g:7539:3: rule__ImpliesExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__ImpliesExpression__RightAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } - + match(input,90,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } } @@ -25189,26 +27688,26 @@ public final void rule__ImpliesExpression__Group_1__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__ImpliesExpression__Group_1__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__1__Impl" - // $ANTLR start "rule__RelationalExpression__Group__0" - // InternalScope.g:7548: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__GlobalScopeExpression__Group_4__2" + // InternalScope.g:7761:1: rule__GlobalScopeExpression__Group_4__2 : rule__GlobalScopeExpression__Group_4__2__Impl rule__GlobalScopeExpression__Group_4__3 ; + public final void rule__GlobalScopeExpression__Group_4__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7552:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) - // InternalScope.g:7553:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 + // InternalScope.g:7765:1: ( rule__GlobalScopeExpression__Group_4__2__Impl rule__GlobalScopeExpression__Group_4__3 ) + // InternalScope.g:7766:2: rule__GlobalScopeExpression__Group_4__2__Impl rule__GlobalScopeExpression__Group_4__3 { - pushFollow(FOLLOW_64); - rule__RelationalExpression__Group__0__Impl(); + pushFollow(FOLLOW_31); + rule__GlobalScopeExpression__Group_4__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group__1(); + rule__GlobalScopeExpression__Group_4__3(); state._fsp--; if (state.failed) return ; @@ -25227,32 +27726,28 @@ public final void rule__RelationalExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__2" - // $ANTLR start "rule__RelationalExpression__Group__0__Impl" - // InternalScope.g:7560:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__2__Impl" + // InternalScope.g:7773:1: rule__GlobalScopeExpression__Group_4__2__Impl : ( '=' ) ; + public final void rule__GlobalScopeExpression__Group_4__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7564:1: ( ( ruleAdditiveExpression ) ) - // InternalScope.g:7565:1: ( ruleAdditiveExpression ) + // InternalScope.g:7777:1: ( ( '=' ) ) + // InternalScope.g:7778:1: ( '=' ) { - // InternalScope.g:7565:1: ( ruleAdditiveExpression ) - // InternalScope.g:7566:2: ruleAdditiveExpression + // InternalScope.g:7778:1: ( '=' ) + // InternalScope.g:7779:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } - pushFollow(FOLLOW_2); - ruleAdditiveExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } } @@ -25272,21 +27767,26 @@ public final void rule__RelationalExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__2__Impl" - // $ANTLR start "rule__RelationalExpression__Group__1" - // InternalScope.g:7575:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; - public final void rule__RelationalExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__3" + // InternalScope.g:7788:1: rule__GlobalScopeExpression__Group_4__3 : rule__GlobalScopeExpression__Group_4__3__Impl rule__GlobalScopeExpression__Group_4__4 ; + public final void rule__GlobalScopeExpression__Group_4__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7579:1: ( rule__RelationalExpression__Group__1__Impl ) - // InternalScope.g:7580:2: rule__RelationalExpression__Group__1__Impl + // InternalScope.g:7792:1: ( rule__GlobalScopeExpression__Group_4__3__Impl rule__GlobalScopeExpression__Group_4__4 ) + // InternalScope.g:7793:2: rule__GlobalScopeExpression__Group_4__3__Impl rule__GlobalScopeExpression__Group_4__4 { + pushFollow(FOLLOW_38); + rule__GlobalScopeExpression__Group_4__3__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group_4__4(); state._fsp--; if (state.failed) return ; @@ -25305,56 +27805,28 @@ public final void rule__RelationalExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__3" - // $ANTLR start "rule__RelationalExpression__Group__1__Impl" - // InternalScope.g:7586:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )* ) ; - public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4__3__Impl" + // InternalScope.g:7800:1: rule__GlobalScopeExpression__Group_4__3__Impl : ( '(' ) ; + public final void rule__GlobalScopeExpression__Group_4__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7590:1: ( ( ( rule__RelationalExpression__Group_1__0 )* ) ) - // InternalScope.g:7591:1: ( ( rule__RelationalExpression__Group_1__0 )* ) + // InternalScope.g:7804:1: ( ( '(' ) ) + // InternalScope.g:7805:1: ( '(' ) { - // InternalScope.g:7591:1: ( ( rule__RelationalExpression__Group_1__0 )* ) - // InternalScope.g:7592:2: ( rule__RelationalExpression__Group_1__0 )* + // InternalScope.g:7805:1: ( '(' ) + // InternalScope.g:7806:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); } - // InternalScope.g:7593:2: ( rule__RelationalExpression__Group_1__0 )* - loop62: - do { - int alt62=2; - int LA62_0 = input.LA(1); - - if ( ((LA62_0>=12 && LA62_0<=17)) ) { - alt62=1; - } - - - switch (alt62) { - case 1 : - // InternalScope.g:7593:3: rule__RelationalExpression__Group_1__0 - { - pushFollow(FOLLOW_65); - rule__RelationalExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop62; - } - } while (true); - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); } } @@ -25374,26 +27846,26 @@ public final void rule__RelationalExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__RelationalExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__3__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__0" - // InternalScope.g:7602: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__GlobalScopeExpression__Group_4__4" + // InternalScope.g:7815:1: rule__GlobalScopeExpression__Group_4__4 : rule__GlobalScopeExpression__Group_4__4__Impl rule__GlobalScopeExpression__Group_4__5 ; + public final void rule__GlobalScopeExpression__Group_4__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7606:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) - // InternalScope.g:7607:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 + // InternalScope.g:7819:1: ( rule__GlobalScopeExpression__Group_4__4__Impl rule__GlobalScopeExpression__Group_4__5 ) + // InternalScope.g:7820:2: rule__GlobalScopeExpression__Group_4__4__Impl rule__GlobalScopeExpression__Group_4__5 { - pushFollow(FOLLOW_64); - rule__RelationalExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group_4__4__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__1(); + rule__GlobalScopeExpression__Group_4__5(); state._fsp--; if (state.failed) return ; @@ -25412,32 +27884,38 @@ public final void rule__RelationalExpression__Group_1__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__0" - + // $ANTLR end "rule__GlobalScopeExpression__Group_4__4" - // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" - // InternalScope.g:7614:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; - public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { + + // $ANTLR start "rule__GlobalScopeExpression__Group_4__4__Impl" + // InternalScope.g:7827:1: rule__GlobalScopeExpression__Group_4__4__Impl : ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) ; + public final void rule__GlobalScopeExpression__Group_4__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7618:1: ( ( () ) ) - // InternalScope.g:7619:1: ( () ) + // InternalScope.g:7831:1: ( ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) ) + // InternalScope.g:7832:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) { - // InternalScope.g:7619:1: ( () ) - // InternalScope.g:7620:2: () + // InternalScope.g:7832:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_4 ) ) + // InternalScope.g:7833:2: ( rule__GlobalScopeExpression__DataAssignment_4_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); } - // InternalScope.g:7621:2: () - // InternalScope.g:7621:3: + // InternalScope.g:7834:2: ( rule__GlobalScopeExpression__DataAssignment_4_4 ) + // InternalScope.g:7834:3: rule__GlobalScopeExpression__DataAssignment_4_4 { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__DataAssignment_4_4(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_4()); } } @@ -25446,6 +27924,10 @@ public final void rule__RelationalExpression__Group_1__0__Impl() throws Recognit } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -25453,26 +27935,26 @@ public final void rule__RelationalExpression__Group_1__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__4__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__1" - // InternalScope.g:7629: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__GlobalScopeExpression__Group_4__5" + // InternalScope.g:7842:1: rule__GlobalScopeExpression__Group_4__5 : rule__GlobalScopeExpression__Group_4__5__Impl rule__GlobalScopeExpression__Group_4__6 ; + public final void rule__GlobalScopeExpression__Group_4__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7633:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) - // InternalScope.g:7634:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 + // InternalScope.g:7846:1: ( rule__GlobalScopeExpression__Group_4__5__Impl rule__GlobalScopeExpression__Group_4__6 ) + // InternalScope.g:7847:2: rule__GlobalScopeExpression__Group_4__5__Impl rule__GlobalScopeExpression__Group_4__6 { - pushFollow(FOLLOW_57); - rule__RelationalExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group_4__5__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__2(); + rule__GlobalScopeExpression__Group_4__6(); state._fsp--; if (state.failed) return ; @@ -25491,38 +27973,56 @@ public final void rule__RelationalExpression__Group_1__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__5" - // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" - // InternalScope.g:7641: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__GlobalScopeExpression__Group_4__5__Impl" + // InternalScope.g:7854:1: rule__GlobalScopeExpression__Group_4__5__Impl : ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) ; + public final void rule__GlobalScopeExpression__Group_4__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7645:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) - // InternalScope.g:7646:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:7858:1: ( ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) ) + // InternalScope.g:7859:1: ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) { - // InternalScope.g:7646:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) - // InternalScope.g:7647:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) + // InternalScope.g:7859:1: ( ( rule__GlobalScopeExpression__Group_4_5__0 )* ) + // InternalScope.g:7860:2: ( rule__GlobalScopeExpression__Group_4_5__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); } - // InternalScope.g:7648:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) - // InternalScope.g:7648:3: rule__RelationalExpression__OperatorAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__OperatorAssignment_1_1(); + // InternalScope.g:7861:2: ( rule__GlobalScopeExpression__Group_4_5__0 )* + loop88: + do { + int alt88=2; + int LA88_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA88_0==86) ) { + alt88=1; + } - } + + switch (alt88) { + case 1 : + // InternalScope.g:7861:3: rule__GlobalScopeExpression__Group_4_5__0 + { + pushFollow(FOLLOW_39); + rule__GlobalScopeExpression__Group_4_5__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop88; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_4_5()); } } @@ -25542,21 +28042,21 @@ public final void rule__RelationalExpression__Group_1__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__5__Impl" - // $ANTLR start "rule__RelationalExpression__Group_1__2" - // InternalScope.g:7656: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__GlobalScopeExpression__Group_4__6" + // InternalScope.g:7869:1: rule__GlobalScopeExpression__Group_4__6 : rule__GlobalScopeExpression__Group_4__6__Impl ; + public final void rule__GlobalScopeExpression__Group_4__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7660:1: ( rule__RelationalExpression__Group_1__2__Impl ) - // InternalScope.g:7661:2: rule__RelationalExpression__Group_1__2__Impl + // InternalScope.g:7873:1: ( rule__GlobalScopeExpression__Group_4__6__Impl ) + // InternalScope.g:7874:2: rule__GlobalScopeExpression__Group_4__6__Impl { pushFollow(FOLLOW_2); - rule__RelationalExpression__Group_1__2__Impl(); + rule__GlobalScopeExpression__Group_4__6__Impl(); state._fsp--; if (state.failed) return ; @@ -25575,38 +28075,28 @@ public final void rule__RelationalExpression__Group_1__2() throws RecognitionExc } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__2" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__6" - // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" - // InternalScope.g:7667: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__GlobalScopeExpression__Group_4__6__Impl" + // InternalScope.g:7880:1: rule__GlobalScopeExpression__Group_4__6__Impl : ( ')' ) ; + public final void rule__GlobalScopeExpression__Group_4__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7671:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) - // InternalScope.g:7672:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) + // InternalScope.g:7884:1: ( ( ')' ) ) + // InternalScope.g:7885:1: ( ')' ) { - // InternalScope.g:7672:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) - // InternalScope.g:7673:2: ( rule__RelationalExpression__RightAssignment_1_2 ) + // InternalScope.g:7885:1: ( ')' ) + // InternalScope.g:7886:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); - } - // InternalScope.g:7674:2: ( rule__RelationalExpression__RightAssignment_1_2 ) - // InternalScope.g:7674:3: rule__RelationalExpression__RightAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__RelationalExpression__RightAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); } } @@ -25626,26 +28116,26 @@ public final void rule__RelationalExpression__Group_1__2__Impl() throws Recognit } return ; } - // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4__6__Impl" - // $ANTLR start "rule__AdditiveExpression__Group__0" - // InternalScope.g:7683: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__GlobalScopeExpression__Group_4_5__0" + // InternalScope.g:7896:1: rule__GlobalScopeExpression__Group_4_5__0 : rule__GlobalScopeExpression__Group_4_5__0__Impl rule__GlobalScopeExpression__Group_4_5__1 ; + public final void rule__GlobalScopeExpression__Group_4_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7687:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) - // InternalScope.g:7688:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 + // InternalScope.g:7900:1: ( rule__GlobalScopeExpression__Group_4_5__0__Impl rule__GlobalScopeExpression__Group_4_5__1 ) + // InternalScope.g:7901:2: rule__GlobalScopeExpression__Group_4_5__0__Impl rule__GlobalScopeExpression__Group_4_5__1 { - pushFollow(FOLLOW_66); - rule__AdditiveExpression__Group__0__Impl(); + pushFollow(FOLLOW_38); + rule__GlobalScopeExpression__Group_4_5__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group__1(); + rule__GlobalScopeExpression__Group_4_5__1(); state._fsp--; if (state.failed) return ; @@ -25664,32 +28154,28 @@ public final void rule__AdditiveExpression__Group__0() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__0" - // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" - // InternalScope.g:7695:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__0__Impl" + // InternalScope.g:7908:1: rule__GlobalScopeExpression__Group_4_5__0__Impl : ( ',' ) ; + public final void rule__GlobalScopeExpression__Group_4_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7699:1: ( ( ruleMultiplicativeExpression ) ) - // InternalScope.g:7700:1: ( ruleMultiplicativeExpression ) + // InternalScope.g:7912:1: ( ( ',' ) ) + // InternalScope.g:7913:1: ( ',' ) { - // InternalScope.g:7700:1: ( ruleMultiplicativeExpression ) - // InternalScope.g:7701:2: ruleMultiplicativeExpression + // InternalScope.g:7913:1: ( ',' ) + // InternalScope.g:7914:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); } - pushFollow(FOLLOW_2); - ruleMultiplicativeExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); } } @@ -25709,21 +28195,21 @@ public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__0__Impl" - // $ANTLR start "rule__AdditiveExpression__Group__1" - // InternalScope.g:7710:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; - public final void rule__AdditiveExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__1" + // InternalScope.g:7923:1: rule__GlobalScopeExpression__Group_4_5__1 : rule__GlobalScopeExpression__Group_4_5__1__Impl ; + public final void rule__GlobalScopeExpression__Group_4_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7714:1: ( rule__AdditiveExpression__Group__1__Impl ) - // InternalScope.g:7715:2: rule__AdditiveExpression__Group__1__Impl + // InternalScope.g:7927:1: ( rule__GlobalScopeExpression__Group_4_5__1__Impl ) + // InternalScope.g:7928:2: rule__GlobalScopeExpression__Group_4_5__1__Impl { pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group_4_5__1__Impl(); state._fsp--; if (state.failed) return ; @@ -25742,56 +28228,38 @@ public final void rule__AdditiveExpression__Group__1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__1" - // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" - // InternalScope.g:7721:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; - public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_4_5__1__Impl" + // InternalScope.g:7934:1: rule__GlobalScopeExpression__Group_4_5__1__Impl : ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) ; + public final void rule__GlobalScopeExpression__Group_4_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7725:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) - // InternalScope.g:7726:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) + // InternalScope.g:7938:1: ( ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) ) + // InternalScope.g:7939:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) { - // InternalScope.g:7726:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) - // InternalScope.g:7727:2: ( rule__AdditiveExpression__Group_1__0 )* + // InternalScope.g:7939:1: ( ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) ) + // InternalScope.g:7940:2: ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); } - // InternalScope.g:7728:2: ( rule__AdditiveExpression__Group_1__0 )* - loop63: - do { - int alt63=2; - int LA63_0 = input.LA(1); - - if ( ((LA63_0>=18 && LA63_0<=19)) ) { - alt63=1; - } - - - switch (alt63) { - case 1 : - // InternalScope.g:7728:3: rule__AdditiveExpression__Group_1__0 - { - pushFollow(FOLLOW_67); - rule__AdditiveExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:7941:2: ( rule__GlobalScopeExpression__DataAssignment_4_5_1 ) + // InternalScope.g:7941:3: rule__GlobalScopeExpression__DataAssignment_4_5_1 + { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__DataAssignment_4_5_1(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop63; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getDataAssignment_4_5_1()); } } @@ -25811,26 +28279,26 @@ public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionE } return ; } - // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_4_5__1__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__0" - // InternalScope.g:7737: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__GlobalScopeExpression__Group_5__0" + // InternalScope.g:7950:1: rule__GlobalScopeExpression__Group_5__0 : rule__GlobalScopeExpression__Group_5__0__Impl rule__GlobalScopeExpression__Group_5__1 ; + public final void rule__GlobalScopeExpression__Group_5__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7741:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) - // InternalScope.g:7742:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 + // InternalScope.g:7954:1: ( rule__GlobalScopeExpression__Group_5__0__Impl rule__GlobalScopeExpression__Group_5__1 ) + // InternalScope.g:7955:2: rule__GlobalScopeExpression__Group_5__0__Impl rule__GlobalScopeExpression__Group_5__1 { - pushFollow(FOLLOW_66); - rule__AdditiveExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_40); + rule__GlobalScopeExpression__Group_5__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__1(); + rule__GlobalScopeExpression__Group_5__1(); state._fsp--; if (state.failed) return ; @@ -25849,32 +28317,28 @@ public final void rule__AdditiveExpression__Group_1__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__0" - // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" - // InternalScope.g:7749:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; - public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5__0__Impl" + // InternalScope.g:7962:1: rule__GlobalScopeExpression__Group_5__0__Impl : ( ',' ) ; + public final void rule__GlobalScopeExpression__Group_5__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7753:1: ( ( () ) ) - // InternalScope.g:7754:1: ( () ) + // InternalScope.g:7966:1: ( ( ',' ) ) + // InternalScope.g:7967:1: ( ',' ) { - // InternalScope.g:7754:1: ( () ) - // InternalScope.g:7755:2: () + // InternalScope.g:7967:1: ( ',' ) + // InternalScope.g:7968:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); - } - // InternalScope.g:7756:2: () - // InternalScope.g:7756:3: - { + before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } } @@ -25883,6 +28347,10 @@ public final void rule__AdditiveExpression__Group_1__0__Impl() throws Recognitio } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -25890,26 +28358,26 @@ public final void rule__AdditiveExpression__Group_1__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__0__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__1" - // InternalScope.g:7764: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__GlobalScopeExpression__Group_5__1" + // InternalScope.g:7977:1: rule__GlobalScopeExpression__Group_5__1 : rule__GlobalScopeExpression__Group_5__1__Impl rule__GlobalScopeExpression__Group_5__2 ; + public final void rule__GlobalScopeExpression__Group_5__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7768:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) - // InternalScope.g:7769:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 + // InternalScope.g:7981:1: ( rule__GlobalScopeExpression__Group_5__1__Impl rule__GlobalScopeExpression__Group_5__2 ) + // InternalScope.g:7982:2: rule__GlobalScopeExpression__Group_5__1__Impl rule__GlobalScopeExpression__Group_5__2 { - pushFollow(FOLLOW_57); - rule__AdditiveExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_16); + rule__GlobalScopeExpression__Group_5__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__2(); + rule__GlobalScopeExpression__Group_5__2(); state._fsp--; if (state.failed) return ; @@ -25928,38 +28396,28 @@ public final void rule__AdditiveExpression__Group_1__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__1" - // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" - // InternalScope.g:7776:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ; - public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5__1__Impl" + // InternalScope.g:7989:1: rule__GlobalScopeExpression__Group_5__1__Impl : ( 'domains' ) ; + public final void rule__GlobalScopeExpression__Group_5__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7780:1: ( ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ) - // InternalScope.g:7781:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) + // InternalScope.g:7993:1: ( ( 'domains' ) ) + // InternalScope.g:7994:1: ( 'domains' ) { - // InternalScope.g:7781:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) - // InternalScope.g:7782:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) + // InternalScope.g:7994:1: ( 'domains' ) + // InternalScope.g:7995:2: 'domains' { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); - } - // InternalScope.g:7783:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) - // InternalScope.g:7783:3: rule__AdditiveExpression__NameAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__NameAssignment_1_1(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } - + match(input,91,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } } @@ -25979,21 +28437,26 @@ public final void rule__AdditiveExpression__Group_1__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__1__Impl" - // $ANTLR start "rule__AdditiveExpression__Group_1__2" - // InternalScope.g:7791: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__GlobalScopeExpression__Group_5__2" + // InternalScope.g:8004:1: rule__GlobalScopeExpression__Group_5__2 : rule__GlobalScopeExpression__Group_5__2__Impl rule__GlobalScopeExpression__Group_5__3 ; + public final void rule__GlobalScopeExpression__Group_5__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7795:1: ( rule__AdditiveExpression__Group_1__2__Impl ) - // InternalScope.g:7796:2: rule__AdditiveExpression__Group_1__2__Impl + // InternalScope.g:8008:1: ( rule__GlobalScopeExpression__Group_5__2__Impl rule__GlobalScopeExpression__Group_5__3 ) + // InternalScope.g:8009:2: rule__GlobalScopeExpression__Group_5__2__Impl rule__GlobalScopeExpression__Group_5__3 { + pushFollow(FOLLOW_41); + rule__GlobalScopeExpression__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__AdditiveExpression__Group_1__2__Impl(); + rule__GlobalScopeExpression__Group_5__3(); state._fsp--; if (state.failed) return ; @@ -26012,38 +28475,28 @@ public final void rule__AdditiveExpression__Group_1__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__2" - // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" - // InternalScope.g:7802:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ; - public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5__2__Impl" + // InternalScope.g:8016:1: rule__GlobalScopeExpression__Group_5__2__Impl : ( '=' ) ; + public final void rule__GlobalScopeExpression__Group_5__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7806:1: ( ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ) - // InternalScope.g:7807:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) + // InternalScope.g:8020:1: ( ( '=' ) ) + // InternalScope.g:8021:1: ( '=' ) { - // InternalScope.g:7807:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) - // InternalScope.g:7808:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) + // InternalScope.g:8021:1: ( '=' ) + // InternalScope.g:8022:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); - } - // InternalScope.g:7809:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) - // InternalScope.g:7809:3: rule__AdditiveExpression__ParamsAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__ParamsAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); } - + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); } } @@ -26063,26 +28516,21 @@ public final void rule__AdditiveExpression__Group_1__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__2__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group__0" - // InternalScope.g:7818: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__GlobalScopeExpression__Group_5__3" + // InternalScope.g:8031:1: rule__GlobalScopeExpression__Group_5__3 : rule__GlobalScopeExpression__Group_5__3__Impl ; + public final void rule__GlobalScopeExpression__Group_5__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7822:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) - // InternalScope.g:7823:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 + // InternalScope.g:8035:1: ( rule__GlobalScopeExpression__Group_5__3__Impl ) + // InternalScope.g:8036:2: rule__GlobalScopeExpression__Group_5__3__Impl { - pushFollow(FOLLOW_68); - rule__MultiplicativeExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group__1(); + rule__GlobalScopeExpression__Group_5__3__Impl(); state._fsp--; if (state.failed) return ; @@ -26101,32 +28549,38 @@ public final void rule__MultiplicativeExpression__Group__0() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__3" - // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" - // InternalScope.g:7830:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleUnaryOrInfixExpression ) ; - public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5__3__Impl" + // InternalScope.g:8042:1: rule__GlobalScopeExpression__Group_5__3__Impl : ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) ; + public final void rule__GlobalScopeExpression__Group_5__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7834:1: ( ( ruleUnaryOrInfixExpression ) ) - // InternalScope.g:7835:1: ( ruleUnaryOrInfixExpression ) + // InternalScope.g:8046:1: ( ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) ) + // InternalScope.g:8047:1: ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) { - // InternalScope.g:7835:1: ( ruleUnaryOrInfixExpression ) - // InternalScope.g:7836:2: ruleUnaryOrInfixExpression + // InternalScope.g:8047:1: ( ( rule__GlobalScopeExpression__Alternatives_5_3 ) ) + // InternalScope.g:8048:2: ( rule__GlobalScopeExpression__Alternatives_5_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); } + // InternalScope.g:8049:2: ( rule__GlobalScopeExpression__Alternatives_5_3 ) + // InternalScope.g:8049:3: rule__GlobalScopeExpression__Alternatives_5_3 + { pushFollow(FOLLOW_2); - ruleUnaryOrInfixExpression(); + rule__GlobalScopeExpression__Alternatives_5_3(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getAlternatives_5_3()); } } @@ -26146,21 +28600,26 @@ public final void rule__MultiplicativeExpression__Group__0__Impl() throws Recogn } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5__3__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group__1" - // InternalScope.g:7845:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; - public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__0" + // InternalScope.g:8058:1: rule__GlobalScopeExpression__Group_5_3_2__0 : rule__GlobalScopeExpression__Group_5_3_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2__1 ; + public final void rule__GlobalScopeExpression__Group_5_3_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7849:1: ( rule__MultiplicativeExpression__Group__1__Impl ) - // InternalScope.g:7850:2: rule__MultiplicativeExpression__Group__1__Impl + // InternalScope.g:8062:1: ( rule__GlobalScopeExpression__Group_5_3_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2__1 ) + // InternalScope.g:8063:2: rule__GlobalScopeExpression__Group_5_3_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2__1 { + pushFollow(FOLLOW_4); + rule__GlobalScopeExpression__Group_5_3_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group_5_3_2__1(); state._fsp--; if (state.failed) return ; @@ -26179,56 +28638,28 @@ public final void rule__MultiplicativeExpression__Group__1() throws RecognitionE } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__0" - // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" - // InternalScope.g:7856:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; - public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__0__Impl" + // InternalScope.g:8070:1: rule__GlobalScopeExpression__Group_5_3_2__0__Impl : ( '(' ) ; + public final void rule__GlobalScopeExpression__Group_5_3_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7860:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) - // InternalScope.g:7861:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) + // InternalScope.g:8074:1: ( ( '(' ) ) + // InternalScope.g:8075:1: ( '(' ) { - // InternalScope.g:7861:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) - // InternalScope.g:7862:2: ( rule__MultiplicativeExpression__Group_1__0 )* + // InternalScope.g:8075:1: ( '(' ) + // InternalScope.g:8076:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); } - // InternalScope.g:7863:2: ( rule__MultiplicativeExpression__Group_1__0 )* - loop64: - do { - int alt64=2; - int LA64_0 = input.LA(1); - - if ( ((LA64_0>=20 && LA64_0<=21)) ) { - alt64=1; - } - - - switch (alt64) { - case 1 : - // InternalScope.g:7863:3: rule__MultiplicativeExpression__Group_1__0 - { - pushFollow(FOLLOW_69); - rule__MultiplicativeExpression__Group_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop64; - } - } while (true); - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); } } @@ -26248,26 +28679,26 @@ public final void rule__MultiplicativeExpression__Group__1__Impl() throws Recogn } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__0__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" - // InternalScope.g:7872: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__GlobalScopeExpression__Group_5_3_2__1" + // InternalScope.g:8085:1: rule__GlobalScopeExpression__Group_5_3_2__1 : rule__GlobalScopeExpression__Group_5_3_2__1__Impl rule__GlobalScopeExpression__Group_5_3_2__2 ; + public final void rule__GlobalScopeExpression__Group_5_3_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7876:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) - // InternalScope.g:7877:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 + // InternalScope.g:8089:1: ( rule__GlobalScopeExpression__Group_5_3_2__1__Impl rule__GlobalScopeExpression__Group_5_3_2__2 ) + // InternalScope.g:8090:2: rule__GlobalScopeExpression__Group_5_3_2__1__Impl rule__GlobalScopeExpression__Group_5_3_2__2 { - pushFollow(FOLLOW_68); - rule__MultiplicativeExpression__Group_1__0__Impl(); + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group_5_3_2__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__1(); + rule__GlobalScopeExpression__Group_5_3_2__2(); state._fsp--; if (state.failed) return ; @@ -26286,32 +28717,38 @@ public final void rule__MultiplicativeExpression__Group_1__0() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__1" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" - // InternalScope.g:7884:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; - public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__1__Impl" + // InternalScope.g:8097:1: rule__GlobalScopeExpression__Group_5_3_2__1__Impl : ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) ; + public final void rule__GlobalScopeExpression__Group_5_3_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7888:1: ( ( () ) ) - // InternalScope.g:7889:1: ( () ) + // InternalScope.g:8101:1: ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) ) + // InternalScope.g:8102:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) { - // InternalScope.g:7889:1: ( () ) - // InternalScope.g:7890:2: () + // InternalScope.g:8102:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) ) + // InternalScope.g:8103:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); } - // InternalScope.g:7891:2: () - // InternalScope.g:7891:3: + // InternalScope.g:8104:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 ) + // InternalScope.g:8104:3: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 { + pushFollow(FOLLOW_2); + rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_1()); } } @@ -26320,6 +28757,10 @@ public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws Reco } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -26327,26 +28768,26 @@ public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__1__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" - // InternalScope.g:7899: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__GlobalScopeExpression__Group_5_3_2__2" + // InternalScope.g:8112:1: rule__GlobalScopeExpression__Group_5_3_2__2 : rule__GlobalScopeExpression__Group_5_3_2__2__Impl rule__GlobalScopeExpression__Group_5_3_2__3 ; + public final void rule__GlobalScopeExpression__Group_5_3_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7903:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) - // InternalScope.g:7904:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 + // InternalScope.g:8116:1: ( rule__GlobalScopeExpression__Group_5_3_2__2__Impl rule__GlobalScopeExpression__Group_5_3_2__3 ) + // InternalScope.g:8117:2: rule__GlobalScopeExpression__Group_5_3_2__2__Impl rule__GlobalScopeExpression__Group_5_3_2__3 { - pushFollow(FOLLOW_57); - rule__MultiplicativeExpression__Group_1__1__Impl(); + pushFollow(FOLLOW_33); + rule__GlobalScopeExpression__Group_5_3_2__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2(); + rule__GlobalScopeExpression__Group_5_3_2__3(); state._fsp--; if (state.failed) return ; @@ -26365,38 +28806,56 @@ public final void rule__MultiplicativeExpression__Group_1__1() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__2" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" - // InternalScope.g:7911:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__2__Impl" + // InternalScope.g:8124:1: rule__GlobalScopeExpression__Group_5_3_2__2__Impl : ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) ; + public final void rule__GlobalScopeExpression__Group_5_3_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7915:1: ( ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ) - // InternalScope.g:7916:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) + // InternalScope.g:8128:1: ( ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) ) + // InternalScope.g:8129:1: ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) { - // InternalScope.g:7916:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) - // InternalScope.g:7917:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) + // InternalScope.g:8129:1: ( ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* ) + // InternalScope.g:8130:2: ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); } - // InternalScope.g:7918:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) - // InternalScope.g:7918:3: rule__MultiplicativeExpression__NameAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__NameAssignment_1_1(); + // InternalScope.g:8131:2: ( rule__GlobalScopeExpression__Group_5_3_2_2__0 )* + loop89: + do { + int alt89=2; + int LA89_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA89_0==86) ) { + alt89=1; + } - } + + switch (alt89) { + case 1 : + // InternalScope.g:8131:3: rule__GlobalScopeExpression__Group_5_3_2_2__0 + { + pushFollow(FOLLOW_39); + rule__GlobalScopeExpression__Group_5_3_2_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop89; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getGroup_5_3_2_2()); } } @@ -26416,21 +28875,21 @@ public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__2__Impl" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" - // InternalScope.g:7926: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__GlobalScopeExpression__Group_5_3_2__3" + // InternalScope.g:8139:1: rule__GlobalScopeExpression__Group_5_3_2__3 : rule__GlobalScopeExpression__Group_5_3_2__3__Impl ; + public final void rule__GlobalScopeExpression__Group_5_3_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7930:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) - // InternalScope.g:7931:2: rule__MultiplicativeExpression__Group_1__2__Impl + // InternalScope.g:8143:1: ( rule__GlobalScopeExpression__Group_5_3_2__3__Impl ) + // InternalScope.g:8144:2: rule__GlobalScopeExpression__Group_5_3_2__3__Impl { pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__Group_1__2__Impl(); + rule__GlobalScopeExpression__Group_5_3_2__3__Impl(); state._fsp--; if (state.failed) return ; @@ -26449,38 +28908,28 @@ public final void rule__MultiplicativeExpression__Group_1__2() throws Recognitio } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__3" - // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" - // InternalScope.g:7937:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ; - public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2__3__Impl" + // InternalScope.g:8150:1: rule__GlobalScopeExpression__Group_5_3_2__3__Impl : ( ')' ) ; + public final void rule__GlobalScopeExpression__Group_5_3_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7941:1: ( ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ) - // InternalScope.g:7942:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) + // InternalScope.g:8154:1: ( ( ')' ) ) + // InternalScope.g:8155:1: ( ')' ) { - // InternalScope.g:7942:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) - // InternalScope.g:7943:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) + // InternalScope.g:8155:1: ( ')' ) + // InternalScope.g:8156:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); - } - // InternalScope.g:7944:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) - // InternalScope.g:7944:3: rule__MultiplicativeExpression__ParamsAssignment_1_2 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__ParamsAssignment_1_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); + after(grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); } } @@ -26500,26 +28949,26 @@ public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws Reco } return ; } - // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2__3__Impl" - // $ANTLR start "rule__UnaryExpression__Group__0" - // InternalScope.g:7953:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ; - public final void rule__UnaryExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__0" + // InternalScope.g:8166:1: rule__GlobalScopeExpression__Group_5_3_2_2__0 : rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2_2__1 ; + public final void rule__GlobalScopeExpression__Group_5_3_2_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7957:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ) - // InternalScope.g:7958:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 + // InternalScope.g:8170:1: ( rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2_2__1 ) + // InternalScope.g:8171:2: rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl rule__GlobalScopeExpression__Group_5_3_2_2__1 { - pushFollow(FOLLOW_57); - rule__UnaryExpression__Group__0__Impl(); + pushFollow(FOLLOW_4); + rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__UnaryExpression__Group__1(); + rule__GlobalScopeExpression__Group_5_3_2_2__1(); state._fsp--; if (state.failed) return ; @@ -26538,38 +28987,28 @@ public final void rule__UnaryExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__UnaryExpression__Group__0" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__0" - // $ANTLR start "rule__UnaryExpression__Group__0__Impl" - // InternalScope.g:7965:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__NameAssignment_0 ) ) ; - public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl" + // InternalScope.g:8178:1: rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl : ( ',' ) ; + public final void rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7969:1: ( ( ( rule__UnaryExpression__NameAssignment_0 ) ) ) - // InternalScope.g:7970:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) + // InternalScope.g:8182:1: ( ( ',' ) ) + // InternalScope.g:8183:1: ( ',' ) { - // InternalScope.g:7970:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) - // InternalScope.g:7971:2: ( rule__UnaryExpression__NameAssignment_0 ) + // InternalScope.g:8183:1: ( ',' ) + // InternalScope.g:8184:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); - } - // InternalScope.g:7972:2: ( rule__UnaryExpression__NameAssignment_0 ) - // InternalScope.g:7972:3: rule__UnaryExpression__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__UnaryExpression__NameAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); } - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); } } @@ -26589,21 +29028,21 @@ public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__UnaryExpression__Group__0__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__0__Impl" - // $ANTLR start "rule__UnaryExpression__Group__1" - // InternalScope.g:7980:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ; - public final void rule__UnaryExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__1" + // InternalScope.g:8193:1: rule__GlobalScopeExpression__Group_5_3_2_2__1 : rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl ; + public final void rule__GlobalScopeExpression__Group_5_3_2_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7984:1: ( rule__UnaryExpression__Group__1__Impl ) - // InternalScope.g:7985:2: rule__UnaryExpression__Group__1__Impl + // InternalScope.g:8197:1: ( rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl ) + // InternalScope.g:8198:2: rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl { pushFollow(FOLLOW_2); - rule__UnaryExpression__Group__1__Impl(); + rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -26622,30 +29061,30 @@ public final void rule__UnaryExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__UnaryExpression__Group__1" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__1" - // $ANTLR start "rule__UnaryExpression__Group__1__Impl" - // InternalScope.g:7991:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ; - public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl" + // InternalScope.g:8204:1: rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl : ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) ; + public final void rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:7995:1: ( ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ) - // InternalScope.g:7996:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) + // InternalScope.g:8208:1: ( ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) ) + // InternalScope.g:8209:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) { - // InternalScope.g:7996:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) - // InternalScope.g:7997:2: ( rule__UnaryExpression__ParamsAssignment_1 ) + // InternalScope.g:8209:1: ( ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) ) + // InternalScope.g:8210:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); } - // InternalScope.g:7998:2: ( rule__UnaryExpression__ParamsAssignment_1 ) - // InternalScope.g:7998:3: rule__UnaryExpression__ParamsAssignment_1 + // InternalScope.g:8211:2: ( rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 ) + // InternalScope.g:8211:3: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 { pushFollow(FOLLOW_2); - rule__UnaryExpression__ParamsAssignment_1(); + rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1(); state._fsp--; if (state.failed) return ; @@ -26653,7 +29092,7 @@ public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAssignment_5_3_2_2_1()); } } @@ -26673,26 +29112,26 @@ public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__UnaryExpression__Group__1__Impl" + // $ANTLR end "rule__GlobalScopeExpression__Group_5_3_2_2__1__Impl" - // $ANTLR start "rule__InfixExpression__Group__0" - // InternalScope.g:8007:1: rule__InfixExpression__Group__0 : rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ; - public final void rule__InfixExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__MatchDataExpression__Group__0" + // InternalScope.g:8220:1: rule__MatchDataExpression__Group__0 : rule__MatchDataExpression__Group__0__Impl rule__MatchDataExpression__Group__1 ; + public final void rule__MatchDataExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8011:1: ( rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ) - // InternalScope.g:8012:2: rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 + // InternalScope.g:8224:1: ( rule__MatchDataExpression__Group__0__Impl rule__MatchDataExpression__Group__1 ) + // InternalScope.g:8225:2: rule__MatchDataExpression__Group__0__Impl rule__MatchDataExpression__Group__1 { - pushFollow(FOLLOW_45); - rule__InfixExpression__Group__0__Impl(); + pushFollow(FOLLOW_16); + rule__MatchDataExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group__1(); + rule__MatchDataExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -26711,32 +29150,38 @@ public final void rule__InfixExpression__Group__0() throws RecognitionException } return ; } - // $ANTLR end "rule__InfixExpression__Group__0" + // $ANTLR end "rule__MatchDataExpression__Group__0" - // $ANTLR start "rule__InfixExpression__Group__0__Impl" - // InternalScope.g:8019:1: rule__InfixExpression__Group__0__Impl : ( rulePrimaryExpression ) ; - public final void rule__InfixExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__MatchDataExpression__Group__0__Impl" + // InternalScope.g:8232:1: rule__MatchDataExpression__Group__0__Impl : ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) ; + public final void rule__MatchDataExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8023:1: ( ( rulePrimaryExpression ) ) - // InternalScope.g:8024:1: ( rulePrimaryExpression ) + // InternalScope.g:8236:1: ( ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) ) + // InternalScope.g:8237:1: ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) { - // InternalScope.g:8024:1: ( rulePrimaryExpression ) - // InternalScope.g:8025:2: rulePrimaryExpression + // InternalScope.g:8237:1: ( ( rule__MatchDataExpression__KeyAssignment_0 ) ) + // InternalScope.g:8238:2: ( rule__MatchDataExpression__KeyAssignment_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + before(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); } + // InternalScope.g:8239:2: ( rule__MatchDataExpression__KeyAssignment_0 ) + // InternalScope.g:8239:3: rule__MatchDataExpression__KeyAssignment_0 + { pushFollow(FOLLOW_2); - rulePrimaryExpression(); + rule__MatchDataExpression__KeyAssignment_0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); + after(grammarAccess.getMatchDataExpressionAccess().getKeyAssignment_0()); } } @@ -26756,21 +29201,26 @@ public final void rule__InfixExpression__Group__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group__0__Impl" + // $ANTLR end "rule__MatchDataExpression__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__Group__1" - // InternalScope.g:8034:1: rule__InfixExpression__Group__1 : rule__InfixExpression__Group__1__Impl ; - public final void rule__InfixExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__MatchDataExpression__Group__1" + // InternalScope.g:8247:1: rule__MatchDataExpression__Group__1 : rule__MatchDataExpression__Group__1__Impl rule__MatchDataExpression__Group__2 ; + public final void rule__MatchDataExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8038:1: ( rule__InfixExpression__Group__1__Impl ) - // InternalScope.g:8039:2: rule__InfixExpression__Group__1__Impl + // InternalScope.g:8251:1: ( rule__MatchDataExpression__Group__1__Impl rule__MatchDataExpression__Group__2 ) + // InternalScope.g:8252:2: rule__MatchDataExpression__Group__1__Impl rule__MatchDataExpression__Group__2 { + pushFollow(FOLLOW_17); + rule__MatchDataExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group__1__Impl(); + rule__MatchDataExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -26789,56 +29239,28 @@ public final void rule__InfixExpression__Group__1() throws RecognitionException } return ; } - // $ANTLR end "rule__InfixExpression__Group__1" + // $ANTLR end "rule__MatchDataExpression__Group__1" - // $ANTLR start "rule__InfixExpression__Group__1__Impl" - // InternalScope.g:8045:1: rule__InfixExpression__Group__1__Impl : ( ( rule__InfixExpression__Alternatives_1 )* ) ; - public final void rule__InfixExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__MatchDataExpression__Group__1__Impl" + // InternalScope.g:8259:1: rule__MatchDataExpression__Group__1__Impl : ( '=' ) ; + public final void rule__MatchDataExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8049:1: ( ( ( rule__InfixExpression__Alternatives_1 )* ) ) - // InternalScope.g:8050:1: ( ( rule__InfixExpression__Alternatives_1 )* ) + // InternalScope.g:8263:1: ( ( '=' ) ) + // InternalScope.g:8264:1: ( '=' ) { - // InternalScope.g:8050:1: ( ( rule__InfixExpression__Alternatives_1 )* ) - // InternalScope.g:8051:2: ( rule__InfixExpression__Alternatives_1 )* + // InternalScope.g:8264:1: ( '=' ) + // InternalScope.g:8265:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + before(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); } - // InternalScope.g:8052:2: ( rule__InfixExpression__Alternatives_1 )* - loop65: - do { - int alt65=2; - int LA65_0 = input.LA(1); - - if ( (LA65_0==68) ) { - alt65=1; - } - - - switch (alt65) { - case 1 : - // InternalScope.g:8052:3: rule__InfixExpression__Alternatives_1 - { - pushFollow(FOLLOW_46); - rule__InfixExpression__Alternatives_1(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop65; - } - } while (true); - + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); + after(grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); } } @@ -26858,26 +29280,21 @@ public final void rule__InfixExpression__Group__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group__1__Impl" + // $ANTLR end "rule__MatchDataExpression__Group__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__0" - // InternalScope.g:8061:1: rule__InfixExpression__Group_1_0__0 : rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ; - public final void rule__InfixExpression__Group_1_0__0() throws RecognitionException { + // $ANTLR start "rule__MatchDataExpression__Group__2" + // InternalScope.g:8274:1: rule__MatchDataExpression__Group__2 : rule__MatchDataExpression__Group__2__Impl ; + public final void rule__MatchDataExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8065:1: ( rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ) - // InternalScope.g:8066:2: rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 + // InternalScope.g:8278:1: ( rule__MatchDataExpression__Group__2__Impl ) + // InternalScope.g:8279:2: rule__MatchDataExpression__Group__2__Impl { - pushFollow(FOLLOW_45); - rule__InfixExpression__Group_1_0__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__1(); + rule__MatchDataExpression__Group__2__Impl(); state._fsp--; if (state.failed) return ; @@ -26896,32 +29313,38 @@ public final void rule__InfixExpression__Group_1_0__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__0" + // $ANTLR end "rule__MatchDataExpression__Group__2" - // $ANTLR start "rule__InfixExpression__Group_1_0__0__Impl" - // InternalScope.g:8073:1: rule__InfixExpression__Group_1_0__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_0__0__Impl() throws RecognitionException { + // $ANTLR start "rule__MatchDataExpression__Group__2__Impl" + // InternalScope.g:8285:1: rule__MatchDataExpression__Group__2__Impl : ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) ; + public final void rule__MatchDataExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8077:1: ( ( () ) ) - // InternalScope.g:8078:1: ( () ) + // InternalScope.g:8289:1: ( ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) ) + // InternalScope.g:8290:1: ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) { - // InternalScope.g:8078:1: ( () ) - // InternalScope.g:8079:2: () + // InternalScope.g:8290:1: ( ( rule__MatchDataExpression__ValueAssignment_2 ) ) + // InternalScope.g:8291:2: ( rule__MatchDataExpression__ValueAssignment_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + before(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); } - // InternalScope.g:8080:2: () - // InternalScope.g:8080:3: + // InternalScope.g:8292:2: ( rule__MatchDataExpression__ValueAssignment_2 ) + // InternalScope.g:8292:3: rule__MatchDataExpression__ValueAssignment_2 { + pushFollow(FOLLOW_2); + rule__MatchDataExpression__ValueAssignment_2(); + + state._fsp--; + if (state.failed) return ; + } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + after(grammarAccess.getMatchDataExpressionAccess().getValueAssignment_2()); } } @@ -26930,6 +29353,10 @@ public final void rule__InfixExpression__Group_1_0__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -26937,26 +29364,26 @@ public final void rule__InfixExpression__Group_1_0__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__0__Impl" + // $ANTLR end "rule__MatchDataExpression__Group__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__1" - // InternalScope.g:8088:1: rule__InfixExpression__Group_1_0__1 : rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ; - public final void rule__InfixExpression__Group_1_0__1() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__0" + // InternalScope.g:8301:1: rule__LambdaDataExpression__Group__0 : rule__LambdaDataExpression__Group__0__Impl rule__LambdaDataExpression__Group__1 ; + public final void rule__LambdaDataExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8092:1: ( rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ) - // InternalScope.g:8093:2: rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 + // InternalScope.g:8305:1: ( rule__LambdaDataExpression__Group__0__Impl rule__LambdaDataExpression__Group__1 ) + // InternalScope.g:8306:2: rule__LambdaDataExpression__Group__0__Impl rule__LambdaDataExpression__Group__1 { - pushFollow(FOLLOW_3); - rule__InfixExpression__Group_1_0__1__Impl(); + pushFollow(FOLLOW_4); + rule__LambdaDataExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__2(); + rule__LambdaDataExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -26975,28 +29402,28 @@ public final void rule__InfixExpression__Group_1_0__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__1" + // $ANTLR end "rule__LambdaDataExpression__Group__0" - // $ANTLR start "rule__InfixExpression__Group_1_0__1__Impl" - // InternalScope.g:8100:1: rule__InfixExpression__Group_1_0__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_0__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__0__Impl" + // InternalScope.g:8313:1: rule__LambdaDataExpression__Group__0__Impl : ( '[' ) ; + public final void rule__LambdaDataExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8104:1: ( ( '.' ) ) - // InternalScope.g:8105:1: ( '.' ) + // InternalScope.g:8317:1: ( ( '[' ) ) + // InternalScope.g:8318:1: ( '[' ) { - // InternalScope.g:8105:1: ( '.' ) - // InternalScope.g:8106:2: '.' + // InternalScope.g:8318:1: ( '[' ) + // InternalScope.g:8319:2: '[' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + before(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,82,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); + after(grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); } } @@ -27016,26 +29443,26 @@ public final void rule__InfixExpression__Group_1_0__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__1__Impl" + // $ANTLR end "rule__LambdaDataExpression__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__2" - // InternalScope.g:8115:1: rule__InfixExpression__Group_1_0__2 : rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ; - public final void rule__InfixExpression__Group_1_0__2() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__1" + // InternalScope.g:8328:1: rule__LambdaDataExpression__Group__1 : rule__LambdaDataExpression__Group__1__Impl rule__LambdaDataExpression__Group__2 ; + public final void rule__LambdaDataExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8119:1: ( rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ) - // InternalScope.g:8120:2: rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 + // InternalScope.g:8332:1: ( rule__LambdaDataExpression__Group__1__Impl rule__LambdaDataExpression__Group__2 ) + // InternalScope.g:8333:2: rule__LambdaDataExpression__Group__1__Impl rule__LambdaDataExpression__Group__2 { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_0__2__Impl(); + pushFollow(FOLLOW_42); + rule__LambdaDataExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__3(); + rule__LambdaDataExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -27054,30 +29481,30 @@ public final void rule__InfixExpression__Group_1_0__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__2" + // $ANTLR end "rule__LambdaDataExpression__Group__1" - // $ANTLR start "rule__InfixExpression__Group_1_0__2__Impl" - // InternalScope.g:8127:1: rule__InfixExpression__Group_1_0__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ; - public final void rule__InfixExpression__Group_1_0__2__Impl() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__1__Impl" + // InternalScope.g:8340:1: rule__LambdaDataExpression__Group__1__Impl : ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) ; + public final void rule__LambdaDataExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8131:1: ( ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ) - // InternalScope.g:8132:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) + // InternalScope.g:8344:1: ( ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) ) + // InternalScope.g:8345:1: ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) { - // InternalScope.g:8132:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) - // InternalScope.g:8133:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) + // InternalScope.g:8345:1: ( ( rule__LambdaDataExpression__DescAssignment_1 ) ) + // InternalScope.g:8346:2: ( rule__LambdaDataExpression__DescAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + before(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); } - // InternalScope.g:8134:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) - // InternalScope.g:8134:3: rule__InfixExpression__NameAssignment_1_0_2 + // InternalScope.g:8347:2: ( rule__LambdaDataExpression__DescAssignment_1 ) + // InternalScope.g:8347:3: rule__LambdaDataExpression__DescAssignment_1 { pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_0_2(); + rule__LambdaDataExpression__DescAssignment_1(); state._fsp--; if (state.failed) return ; @@ -27085,7 +29512,7 @@ public final void rule__InfixExpression__Group_1_0__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); + after(grammarAccess.getLambdaDataExpressionAccess().getDescAssignment_1()); } } @@ -27105,26 +29532,26 @@ public final void rule__InfixExpression__Group_1_0__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__2__Impl" + // $ANTLR end "rule__LambdaDataExpression__Group__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__3" - // InternalScope.g:8142:1: rule__InfixExpression__Group_1_0__3 : rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ; - public final void rule__InfixExpression__Group_1_0__3() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__2" + // InternalScope.g:8355:1: rule__LambdaDataExpression__Group__2 : rule__LambdaDataExpression__Group__2__Impl rule__LambdaDataExpression__Group__3 ; + public final void rule__LambdaDataExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8146:1: ( rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ) - // InternalScope.g:8147:2: rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 + // InternalScope.g:8359:1: ( rule__LambdaDataExpression__Group__2__Impl rule__LambdaDataExpression__Group__3 ) + // InternalScope.g:8360:2: rule__LambdaDataExpression__Group__2__Impl rule__LambdaDataExpression__Group__3 { - pushFollow(FOLLOW_70); - rule__InfixExpression__Group_1_0__3__Impl(); + pushFollow(FOLLOW_17); + rule__LambdaDataExpression__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__4(); + rule__LambdaDataExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -27143,28 +29570,28 @@ public final void rule__InfixExpression__Group_1_0__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__3" + // $ANTLR end "rule__LambdaDataExpression__Group__2" - // $ANTLR start "rule__InfixExpression__Group_1_0__3__Impl" - // InternalScope.g:8154:1: rule__InfixExpression__Group_1_0__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_0__3__Impl() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__2__Impl" + // InternalScope.g:8367:1: rule__LambdaDataExpression__Group__2__Impl : ( '|' ) ; + public final void rule__LambdaDataExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8158:1: ( ( '(' ) ) - // InternalScope.g:8159:1: ( '(' ) + // InternalScope.g:8371:1: ( ( '|' ) ) + // InternalScope.g:8372:1: ( '|' ) { - // InternalScope.g:8159:1: ( '(' ) - // InternalScope.g:8160:2: '(' + // InternalScope.g:8372:1: ( '|' ) + // InternalScope.g:8373:2: '|' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + before(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + match(input,92,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); + after(grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); } } @@ -27184,26 +29611,26 @@ public final void rule__InfixExpression__Group_1_0__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__3__Impl" + // $ANTLR end "rule__LambdaDataExpression__Group__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__4" - // InternalScope.g:8169:1: rule__InfixExpression__Group_1_0__4 : rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ; - public final void rule__InfixExpression__Group_1_0__4() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__3" + // InternalScope.g:8382:1: rule__LambdaDataExpression__Group__3 : rule__LambdaDataExpression__Group__3__Impl rule__LambdaDataExpression__Group__4 ; + public final void rule__LambdaDataExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8173:1: ( rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ) - // InternalScope.g:8174:2: rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 + // InternalScope.g:8386:1: ( rule__LambdaDataExpression__Group__3__Impl rule__LambdaDataExpression__Group__4 ) + // InternalScope.g:8387:2: rule__LambdaDataExpression__Group__3__Impl rule__LambdaDataExpression__Group__4 { - pushFollow(FOLLOW_70); - rule__InfixExpression__Group_1_0__4__Impl(); + pushFollow(FOLLOW_30); + rule__LambdaDataExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__5(); + rule__LambdaDataExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -27222,49 +29649,38 @@ public final void rule__InfixExpression__Group_1_0__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__4" + // $ANTLR end "rule__LambdaDataExpression__Group__3" - // $ANTLR start "rule__InfixExpression__Group_1_0__4__Impl" - // InternalScope.g:8181:1: rule__InfixExpression__Group_1_0__4__Impl : ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ; - public final void rule__InfixExpression__Group_1_0__4__Impl() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__3__Impl" + // InternalScope.g:8394:1: rule__LambdaDataExpression__Group__3__Impl : ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) ; + public final void rule__LambdaDataExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8185:1: ( ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ) - // InternalScope.g:8186:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) + // InternalScope.g:8398:1: ( ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) ) + // InternalScope.g:8399:1: ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) { - // InternalScope.g:8186:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) - // InternalScope.g:8187:2: ( rule__InfixExpression__Group_1_0_4__0 )? + // InternalScope.g:8399:1: ( ( rule__LambdaDataExpression__ValueAssignment_3 ) ) + // InternalScope.g:8400:2: ( rule__LambdaDataExpression__ValueAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); - } - // InternalScope.g:8188:2: ( rule__InfixExpression__Group_1_0_4__0 )? - int alt66=2; - int LA66_0 = input.LA(1); - - if ( ((LA66_0>=RULE_ID && LA66_0<=RULE_REAL)||LA66_0==19||(LA66_0>=22 && LA66_0<=35)||LA66_0==45||LA66_0==51||LA66_0==69||LA66_0==73||LA66_0==76||(LA66_0>=78 && LA66_0<=79)||(LA66_0>=85 && LA66_0<=86)) ) { - alt66=1; + before(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); } - switch (alt66) { - case 1 : - // InternalScope.g:8188:3: rule__InfixExpression__Group_1_0_4__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:8401:2: ( rule__LambdaDataExpression__ValueAssignment_3 ) + // InternalScope.g:8401:3: rule__LambdaDataExpression__ValueAssignment_3 + { + pushFollow(FOLLOW_2); + rule__LambdaDataExpression__ValueAssignment_3(); - } - break; + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); + after(grammarAccess.getLambdaDataExpressionAccess().getValueAssignment_3()); } } @@ -27284,21 +29700,21 @@ public final void rule__InfixExpression__Group_1_0__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__4__Impl" + // $ANTLR end "rule__LambdaDataExpression__Group__3__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0__5" - // InternalScope.g:8196:1: rule__InfixExpression__Group_1_0__5 : rule__InfixExpression__Group_1_0__5__Impl ; - public final void rule__InfixExpression__Group_1_0__5() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__4" + // InternalScope.g:8409:1: rule__LambdaDataExpression__Group__4 : rule__LambdaDataExpression__Group__4__Impl ; + public final void rule__LambdaDataExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8200:1: ( rule__InfixExpression__Group_1_0__5__Impl ) - // InternalScope.g:8201:2: rule__InfixExpression__Group_1_0__5__Impl + // InternalScope.g:8413:1: ( rule__LambdaDataExpression__Group__4__Impl ) + // InternalScope.g:8414:2: rule__LambdaDataExpression__Group__4__Impl { pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0__5__Impl(); + rule__LambdaDataExpression__Group__4__Impl(); state._fsp--; if (state.failed) return ; @@ -27317,28 +29733,28 @@ public final void rule__InfixExpression__Group_1_0__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__5" + // $ANTLR end "rule__LambdaDataExpression__Group__4" - // $ANTLR start "rule__InfixExpression__Group_1_0__5__Impl" - // InternalScope.g:8207:1: rule__InfixExpression__Group_1_0__5__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_0__5__Impl() throws RecognitionException { + // $ANTLR start "rule__LambdaDataExpression__Group__4__Impl" + // InternalScope.g:8420:1: rule__LambdaDataExpression__Group__4__Impl : ( ']' ) ; + public final void rule__LambdaDataExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8211:1: ( ( ')' ) ) - // InternalScope.g:8212:1: ( ')' ) + // InternalScope.g:8424:1: ( ( ']' ) ) + // InternalScope.g:8425:1: ( ']' ) { - // InternalScope.g:8212:1: ( ')' ) - // InternalScope.g:8213:2: ')' + // InternalScope.g:8425:1: ( ']' ) + // InternalScope.g:8426:2: ']' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + before(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,83,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); + after(grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); } } @@ -27358,26 +29774,21 @@ public final void rule__InfixExpression__Group_1_0__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0__5__Impl" + // $ANTLR end "rule__LambdaDataExpression__Group__4__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__0" - // InternalScope.g:8223:1: rule__InfixExpression__Group_1_0_4__0 : rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ; - public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0__0" + // InternalScope.g:8436:1: rule__Naming__Group_0__0 : rule__Naming__Group_0__0__Impl ; + public final void rule__Naming__Group_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8227:1: ( rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ) - // InternalScope.g:8228:2: rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 + // InternalScope.g:8440:1: ( rule__Naming__Group_0__0__Impl ) + // InternalScope.g:8441:2: rule__Naming__Group_0__0__Impl { - pushFollow(FOLLOW_71); - rule__InfixExpression__Group_1_0_4__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__1(); + rule__Naming__Group_0__0__Impl(); state._fsp--; if (state.failed) return ; @@ -27396,30 +29807,30 @@ public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__0" + // $ANTLR end "rule__Naming__Group_0__0" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__0__Impl" - // InternalScope.g:8235:1: rule__InfixExpression__Group_1_0_4__0__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ; - public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0__0__Impl" + // InternalScope.g:8447:1: rule__Naming__Group_0__0__Impl : ( ( rule__Naming__Group_0_0__0 ) ) ; + public final void rule__Naming__Group_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8239:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ) - // InternalScope.g:8240:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) + // InternalScope.g:8451:1: ( ( ( rule__Naming__Group_0_0__0 ) ) ) + // InternalScope.g:8452:1: ( ( rule__Naming__Group_0_0__0 ) ) { - // InternalScope.g:8240:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) - // InternalScope.g:8241:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) + // InternalScope.g:8452:1: ( ( rule__Naming__Group_0_0__0 ) ) + // InternalScope.g:8453:2: ( rule__Naming__Group_0_0__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); + before(grammarAccess.getNamingAccess().getGroup_0_0()); } - // InternalScope.g:8242:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) - // InternalScope.g:8242:3: rule__InfixExpression__ParamsAssignment_1_0_4_0 + // InternalScope.g:8454:2: ( rule__Naming__Group_0_0__0 ) + // InternalScope.g:8454:3: rule__Naming__Group_0_0__0 { pushFollow(FOLLOW_2); - rule__InfixExpression__ParamsAssignment_1_0_4_0(); + rule__Naming__Group_0_0__0(); state._fsp--; if (state.failed) return ; @@ -27427,7 +29838,7 @@ public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws Recogniti } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); + after(grammarAccess.getNamingAccess().getGroup_0_0()); } } @@ -27447,21 +29858,26 @@ public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__0__Impl" + // $ANTLR end "rule__Naming__Group_0__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__1" - // InternalScope.g:8250:1: rule__InfixExpression__Group_1_0_4__1 : rule__InfixExpression__Group_1_0_4__1__Impl ; - public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__0" + // InternalScope.g:8463:1: rule__Naming__Group_0_0__0 : rule__Naming__Group_0_0__0__Impl rule__Naming__Group_0_0__1 ; + public final void rule__Naming__Group_0_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8254:1: ( rule__InfixExpression__Group_1_0_4__1__Impl ) - // InternalScope.g:8255:2: rule__InfixExpression__Group_1_0_4__1__Impl + // InternalScope.g:8467:1: ( rule__Naming__Group_0_0__0__Impl rule__Naming__Group_0_0__1 ) + // InternalScope.g:8468:2: rule__Naming__Group_0_0__0__Impl rule__Naming__Group_0_0__1 { + pushFollow(FOLLOW_17); + rule__Naming__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4__1__Impl(); + rule__Naming__Group_0_0__1(); state._fsp--; if (state.failed) return ; @@ -27480,56 +29896,28 @@ public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__1" + // $ANTLR end "rule__Naming__Group_0_0__0" - // $ANTLR start "rule__InfixExpression__Group_1_0_4__1__Impl" - // InternalScope.g:8261:1: rule__InfixExpression__Group_1_0_4__1__Impl : ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ; - public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__0__Impl" + // InternalScope.g:8475:1: rule__Naming__Group_0_0__0__Impl : ( '(' ) ; + public final void rule__Naming__Group_0_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8265:1: ( ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ) - // InternalScope.g:8266:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + // InternalScope.g:8479:1: ( ( '(' ) ) + // InternalScope.g:8480:1: ( '(' ) { - // InternalScope.g:8266:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) - // InternalScope.g:8267:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + // InternalScope.g:8480:1: ( '(' ) + // InternalScope.g:8481:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + before(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); } - // InternalScope.g:8268:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* - loop67: - do { - int alt67=2; - int LA67_0 = input.LA(1); - - if ( (LA67_0==60) ) { - alt67=1; - } - - - switch (alt67) { - case 1 : - // InternalScope.g:8268:3: rule__InfixExpression__Group_1_0_4_1__0 - { - pushFollow(FOLLOW_39); - rule__InfixExpression__Group_1_0_4_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop67; - } - } while (true); - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); + after(grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); } } @@ -27549,26 +29937,26 @@ public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4__1__Impl" + // $ANTLR end "rule__Naming__Group_0_0__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0" - // InternalScope.g:8277:1: rule__InfixExpression__Group_1_0_4_1__0 : rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ; - public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__1" + // InternalScope.g:8490:1: rule__Naming__Group_0_0__1 : rule__Naming__Group_0_0__1__Impl rule__Naming__Group_0_0__2 ; + public final void rule__Naming__Group_0_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8281:1: ( rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ) - // InternalScope.g:8282:2: rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 + // InternalScope.g:8494:1: ( rule__Naming__Group_0_0__1__Impl rule__Naming__Group_0_0__2 ) + // InternalScope.g:8495:2: rule__Naming__Group_0_0__1__Impl rule__Naming__Group_0_0__2 { - pushFollow(FOLLOW_17); - rule__InfixExpression__Group_1_0_4_1__0__Impl(); + pushFollow(FOLLOW_33); + rule__Naming__Group_0_0__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4_1__1(); + rule__Naming__Group_0_0__2(); state._fsp--; if (state.failed) return ; @@ -27587,28 +29975,38 @@ public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0" + // $ANTLR end "rule__Naming__Group_0_0__1" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0__Impl" - // InternalScope.g:8289:1: rule__InfixExpression__Group_1_0_4_1__0__Impl : ( ',' ) ; - public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__1__Impl" + // InternalScope.g:8502:1: rule__Naming__Group_0_0__1__Impl : ( ( rule__Naming__NamesAssignment_0_0_1 ) ) ; + public final void rule__Naming__Group_0_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8293:1: ( ( ',' ) ) - // InternalScope.g:8294:1: ( ',' ) + // InternalScope.g:8506:1: ( ( ( rule__Naming__NamesAssignment_0_0_1 ) ) ) + // InternalScope.g:8507:1: ( ( rule__Naming__NamesAssignment_0_0_1 ) ) { - // InternalScope.g:8294:1: ( ',' ) - // InternalScope.g:8295:2: ',' + // InternalScope.g:8507:1: ( ( rule__Naming__NamesAssignment_0_0_1 ) ) + // InternalScope.g:8508:2: ( rule__Naming__NamesAssignment_0_0_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); } - match(input,60,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:8509:2: ( rule__Naming__NamesAssignment_0_0_1 ) + // InternalScope.g:8509:3: rule__Naming__NamesAssignment_0_0_1 + { + pushFollow(FOLLOW_2); + rule__Naming__NamesAssignment_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); + after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_1()); } } @@ -27628,21 +30026,26 @@ public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws Recogni } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0__Impl" + // $ANTLR end "rule__Naming__Group_0_0__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1" - // InternalScope.g:8304:1: rule__InfixExpression__Group_1_0_4_1__1 : rule__InfixExpression__Group_1_0_4_1__1__Impl ; - public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__2" + // InternalScope.g:8517:1: rule__Naming__Group_0_0__2 : rule__Naming__Group_0_0__2__Impl rule__Naming__Group_0_0__3 ; + public final void rule__Naming__Group_0_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8308:1: ( rule__InfixExpression__Group_1_0_4_1__1__Impl ) - // InternalScope.g:8309:2: rule__InfixExpression__Group_1_0_4_1__1__Impl + // InternalScope.g:8521:1: ( rule__Naming__Group_0_0__2__Impl rule__Naming__Group_0_0__3 ) + // InternalScope.g:8522:2: rule__Naming__Group_0_0__2__Impl rule__Naming__Group_0_0__3 { + pushFollow(FOLLOW_33); + rule__Naming__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_0_4_1__1__Impl(); + rule__Naming__Group_0_0__3(); state._fsp--; if (state.failed) return ; @@ -27661,38 +30064,56 @@ public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1" + // $ANTLR end "rule__Naming__Group_0_0__2" - // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1__Impl" - // InternalScope.g:8315:1: rule__InfixExpression__Group_1_0_4_1__1__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ; - public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__2__Impl" + // InternalScope.g:8529:1: rule__Naming__Group_0_0__2__Impl : ( ( rule__Naming__Group_0_0_2__0 )* ) ; + public final void rule__Naming__Group_0_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8319:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ) - // InternalScope.g:8320:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + // InternalScope.g:8533:1: ( ( ( rule__Naming__Group_0_0_2__0 )* ) ) + // InternalScope.g:8534:1: ( ( rule__Naming__Group_0_0_2__0 )* ) { - // InternalScope.g:8320:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) - // InternalScope.g:8321:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + // InternalScope.g:8534:1: ( ( rule__Naming__Group_0_0_2__0 )* ) + // InternalScope.g:8535:2: ( rule__Naming__Group_0_0_2__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + before(grammarAccess.getNamingAccess().getGroup_0_0_2()); } - // InternalScope.g:8322:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) - // InternalScope.g:8322:3: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__ParamsAssignment_1_0_4_1_1(); + // InternalScope.g:8536:2: ( rule__Naming__Group_0_0_2__0 )* + loop90: + do { + int alt90=2; + int LA90_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA90_0==86) ) { + alt90=1; + } - } + + switch (alt90) { + case 1 : + // InternalScope.g:8536:3: rule__Naming__Group_0_0_2__0 + { + pushFollow(FOLLOW_39); + rule__Naming__Group_0_0_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop90; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); + after(grammarAccess.getNamingAccess().getGroup_0_0_2()); } } @@ -27712,26 +30133,21 @@ public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws Recogni } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1__Impl" + // $ANTLR end "rule__Naming__Group_0_0__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_1__0" - // InternalScope.g:8331:1: rule__InfixExpression__Group_1_1__0 : rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ; - public final void rule__InfixExpression__Group_1_1__0() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__3" + // InternalScope.g:8544:1: rule__Naming__Group_0_0__3 : rule__Naming__Group_0_0__3__Impl ; + public final void rule__Naming__Group_0_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8335:1: ( rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ) - // InternalScope.g:8336:2: rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 + // InternalScope.g:8548:1: ( rule__Naming__Group_0_0__3__Impl ) + // InternalScope.g:8549:2: rule__Naming__Group_0_0__3__Impl { - pushFollow(FOLLOW_45); - rule__InfixExpression__Group_1_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__1(); + rule__Naming__Group_0_0__3__Impl(); state._fsp--; if (state.failed) return ; @@ -27750,32 +30166,28 @@ public final void rule__InfixExpression__Group_1_1__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__0" + // $ANTLR end "rule__Naming__Group_0_0__3" - // $ANTLR start "rule__InfixExpression__Group_1_1__0__Impl" - // InternalScope.g:8343:1: rule__InfixExpression__Group_1_1__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0__3__Impl" + // InternalScope.g:8555:1: rule__Naming__Group_0_0__3__Impl : ( ')' ) ; + public final void rule__Naming__Group_0_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8347:1: ( ( () ) ) - // InternalScope.g:8348:1: ( () ) + // InternalScope.g:8559:1: ( ( ')' ) ) + // InternalScope.g:8560:1: ( ')' ) { - // InternalScope.g:8348:1: ( () ) - // InternalScope.g:8349:2: () + // InternalScope.g:8560:1: ( ')' ) + // InternalScope.g:8561:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); - } - // InternalScope.g:8350:2: () - // InternalScope.g:8350:3: - { + before(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + after(grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); } } @@ -27784,6 +30196,10 @@ public final void rule__InfixExpression__Group_1_1__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -27791,26 +30207,26 @@ public final void rule__InfixExpression__Group_1_1__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__0__Impl" + // $ANTLR end "rule__Naming__Group_0_0__3__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_1__1" - // InternalScope.g:8358:1: rule__InfixExpression__Group_1_1__1 : rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ; - public final void rule__InfixExpression__Group_1_1__1() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0_2__0" + // InternalScope.g:8571:1: rule__Naming__Group_0_0_2__0 : rule__Naming__Group_0_0_2__0__Impl rule__Naming__Group_0_0_2__1 ; + public final void rule__Naming__Group_0_0_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8362:1: ( rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ) - // InternalScope.g:8363:2: rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 + // InternalScope.g:8575:1: ( rule__Naming__Group_0_0_2__0__Impl rule__Naming__Group_0_0_2__1 ) + // InternalScope.g:8576:2: rule__Naming__Group_0_0_2__0__Impl rule__Naming__Group_0_0_2__1 { - pushFollow(FOLLOW_48); - rule__InfixExpression__Group_1_1__1__Impl(); + pushFollow(FOLLOW_17); + rule__Naming__Group_0_0_2__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__2(); + rule__Naming__Group_0_0_2__1(); state._fsp--; if (state.failed) return ; @@ -27829,28 +30245,28 @@ public final void rule__InfixExpression__Group_1_1__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__1" + // $ANTLR end "rule__Naming__Group_0_0_2__0" - // $ANTLR start "rule__InfixExpression__Group_1_1__1__Impl" - // InternalScope.g:8370:1: rule__InfixExpression__Group_1_1__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0_2__0__Impl" + // InternalScope.g:8583:1: rule__Naming__Group_0_0_2__0__Impl : ( ',' ) ; + public final void rule__Naming__Group_0_0_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8374:1: ( ( '.' ) ) - // InternalScope.g:8375:1: ( '.' ) + // InternalScope.g:8587:1: ( ( ',' ) ) + // InternalScope.g:8588:1: ( ',' ) { - // InternalScope.g:8375:1: ( '.' ) - // InternalScope.g:8376:2: '.' + // InternalScope.g:8588:1: ( ',' ) + // InternalScope.g:8589:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + before(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); + after(grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); } } @@ -27870,21 +30286,21 @@ public final void rule__InfixExpression__Group_1_1__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__1__Impl" + // $ANTLR end "rule__Naming__Group_0_0_2__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_1__2" - // InternalScope.g:8385:1: rule__InfixExpression__Group_1_1__2 : rule__InfixExpression__Group_1_1__2__Impl ; - public final void rule__InfixExpression__Group_1_1__2() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0_2__1" + // InternalScope.g:8598:1: rule__Naming__Group_0_0_2__1 : rule__Naming__Group_0_0_2__1__Impl ; + public final void rule__Naming__Group_0_0_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8389:1: ( rule__InfixExpression__Group_1_1__2__Impl ) - // InternalScope.g:8390:2: rule__InfixExpression__Group_1_1__2__Impl + // InternalScope.g:8602:1: ( rule__Naming__Group_0_0_2__1__Impl ) + // InternalScope.g:8603:2: rule__Naming__Group_0_0_2__1__Impl { pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_1__2__Impl(); + rule__Naming__Group_0_0_2__1__Impl(); state._fsp--; if (state.failed) return ; @@ -27903,30 +30319,30 @@ public final void rule__InfixExpression__Group_1_1__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__2" + // $ANTLR end "rule__Naming__Group_0_0_2__1" - // $ANTLR start "rule__InfixExpression__Group_1_1__2__Impl" - // InternalScope.g:8396:1: rule__InfixExpression__Group_1_1__2__Impl : ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ; - public final void rule__InfixExpression__Group_1_1__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Naming__Group_0_0_2__1__Impl" + // InternalScope.g:8609:1: rule__Naming__Group_0_0_2__1__Impl : ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) ; + public final void rule__Naming__Group_0_0_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8400:1: ( ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ) - // InternalScope.g:8401:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + // InternalScope.g:8613:1: ( ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) ) + // InternalScope.g:8614:1: ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) { - // InternalScope.g:8401:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) - // InternalScope.g:8402:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + // InternalScope.g:8614:1: ( ( rule__Naming__NamesAssignment_0_0_2_1 ) ) + // InternalScope.g:8615:2: ( rule__Naming__NamesAssignment_0_0_2_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + before(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); } - // InternalScope.g:8403:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) - // InternalScope.g:8403:3: rule__InfixExpression__TypeAssignment_1_1_2 + // InternalScope.g:8616:2: ( rule__Naming__NamesAssignment_0_0_2_1 ) + // InternalScope.g:8616:3: rule__Naming__NamesAssignment_0_0_2_1 { pushFollow(FOLLOW_2); - rule__InfixExpression__TypeAssignment_1_1_2(); + rule__Naming__NamesAssignment_0_0_2_1(); state._fsp--; if (state.failed) return ; @@ -27934,7 +30350,7 @@ public final void rule__InfixExpression__Group_1_1__2__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); + after(grammarAccess.getNamingAccess().getNamesAssignment_0_0_2_1()); } } @@ -27954,26 +30370,26 @@ public final void rule__InfixExpression__Group_1_1__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_1__2__Impl" + // $ANTLR end "rule__Naming__Group_0_0_2__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__0" - // InternalScope.g:8412:1: rule__InfixExpression__Group_1_2__0 : rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ; - public final void rule__InfixExpression__Group_1_2__0() throws RecognitionException { + // $ANTLR start "rule__NamingExpression__Group_1__0" + // InternalScope.g:8625:1: rule__NamingExpression__Group_1__0 : rule__NamingExpression__Group_1__0__Impl rule__NamingExpression__Group_1__1 ; + public final void rule__NamingExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8416:1: ( rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ) - // InternalScope.g:8417:2: rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 + // InternalScope.g:8629:1: ( rule__NamingExpression__Group_1__0__Impl rule__NamingExpression__Group_1__1 ) + // InternalScope.g:8630:2: rule__NamingExpression__Group_1__0__Impl rule__NamingExpression__Group_1__1 { - pushFollow(FOLLOW_45); - rule__InfixExpression__Group_1_2__0__Impl(); + pushFollow(FOLLOW_17); + rule__NamingExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__1(); + rule__NamingExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -27992,32 +30408,49 @@ public final void rule__InfixExpression__Group_1_2__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__0" + // $ANTLR end "rule__NamingExpression__Group_1__0" - // $ANTLR start "rule__InfixExpression__Group_1_2__0__Impl" - // InternalScope.g:8424:1: rule__InfixExpression__Group_1_2__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingExpression__Group_1__0__Impl" + // InternalScope.g:8637:1: rule__NamingExpression__Group_1__0__Impl : ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) ; + public final void rule__NamingExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8428:1: ( ( () ) ) - // InternalScope.g:8429:1: ( () ) + // InternalScope.g:8641:1: ( ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) ) + // InternalScope.g:8642:1: ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) { - // InternalScope.g:8429:1: ( () ) - // InternalScope.g:8430:2: () + // InternalScope.g:8642:1: ( ( rule__NamingExpression__FactoryAssignment_1_0 )? ) + // InternalScope.g:8643:2: ( rule__NamingExpression__FactoryAssignment_1_0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + before(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); } - // InternalScope.g:8431:2: () - // InternalScope.g:8431:3: - { + // InternalScope.g:8644:2: ( rule__NamingExpression__FactoryAssignment_1_0 )? + int alt91=2; + int LA91_0 = input.LA(1); + + if ( (LA91_0==84) ) { + alt91=1; + } + switch (alt91) { + case 1 : + // InternalScope.g:8644:3: rule__NamingExpression__FactoryAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__NamingExpression__FactoryAssignment_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); + after(grammarAccess.getNamingExpressionAccess().getFactoryAssignment_1_0()); } } @@ -28026,6 +30459,10 @@ public final void rule__InfixExpression__Group_1_2__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -28033,26 +30470,21 @@ public final void rule__InfixExpression__Group_1_2__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__0__Impl" + // $ANTLR end "rule__NamingExpression__Group_1__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__1" - // InternalScope.g:8439:1: rule__InfixExpression__Group_1_2__1 : rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ; - public final void rule__InfixExpression__Group_1_2__1() throws RecognitionException { + // $ANTLR start "rule__NamingExpression__Group_1__1" + // InternalScope.g:8652:1: rule__NamingExpression__Group_1__1 : rule__NamingExpression__Group_1__1__Impl ; + public final void rule__NamingExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8443:1: ( rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ) - // InternalScope.g:8444:2: rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 + // InternalScope.g:8656:1: ( rule__NamingExpression__Group_1__1__Impl ) + // InternalScope.g:8657:2: rule__NamingExpression__Group_1__1__Impl { - pushFollow(FOLLOW_72); - rule__InfixExpression__Group_1_2__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__2(); + rule__NamingExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -28071,28 +30503,38 @@ public final void rule__InfixExpression__Group_1_2__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__1" + // $ANTLR end "rule__NamingExpression__Group_1__1" - // $ANTLR start "rule__InfixExpression__Group_1_2__1__Impl" - // InternalScope.g:8451:1: rule__InfixExpression__Group_1_2__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__NamingExpression__Group_1__1__Impl" + // InternalScope.g:8663:1: rule__NamingExpression__Group_1__1__Impl : ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) ; + public final void rule__NamingExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8455:1: ( ( '.' ) ) - // InternalScope.g:8456:1: ( '.' ) + // InternalScope.g:8667:1: ( ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) ) + // InternalScope.g:8668:1: ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) { - // InternalScope.g:8456:1: ( '.' ) - // InternalScope.g:8457:2: '.' + // InternalScope.g:8668:1: ( ( rule__NamingExpression__ExpressionAssignment_1_1 ) ) + // InternalScope.g:8669:2: ( rule__NamingExpression__ExpressionAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + before(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:8670:2: ( rule__NamingExpression__ExpressionAssignment_1_1 ) + // InternalScope.g:8670:3: rule__NamingExpression__ExpressionAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__NamingExpression__ExpressionAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); + after(grammarAccess.getNamingExpressionAccess().getExpressionAssignment_1_1()); } } @@ -28112,26 +30554,26 @@ public final void rule__InfixExpression__Group_1_2__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__1__Impl" + // $ANTLR end "rule__NamingExpression__Group_1__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__2" - // InternalScope.g:8466:1: rule__InfixExpression__Group_1_2__2 : rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ; - public final void rule__InfixExpression__Group_1_2__2() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__0" + // InternalScope.g:8679:1: rule__QualifiedID__Group__0 : rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ; + public final void rule__QualifiedID__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8470:1: ( rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ) - // InternalScope.g:8471:2: rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 + // InternalScope.g:8683:1: ( rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 ) + // InternalScope.g:8684:2: rule__QualifiedID__Group__0__Impl rule__QualifiedID__Group__1 { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_2__2__Impl(); + pushFollow(FOLLOW_43); + rule__QualifiedID__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__3(); + rule__QualifiedID__Group__1(); state._fsp--; if (state.failed) return ; @@ -28150,38 +30592,32 @@ public final void rule__InfixExpression__Group_1_2__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__2" + // $ANTLR end "rule__QualifiedID__Group__0" - // $ANTLR start "rule__InfixExpression__Group_1_2__2__Impl" - // InternalScope.g:8478:1: rule__InfixExpression__Group_1_2__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ; - public final void rule__InfixExpression__Group_1_2__2__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__0__Impl" + // InternalScope.g:8691:1: rule__QualifiedID__Group__0__Impl : ( ruleIdentifier ) ; + public final void rule__QualifiedID__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8482:1: ( ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ) - // InternalScope.g:8483:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + // InternalScope.g:8695:1: ( ( ruleIdentifier ) ) + // InternalScope.g:8696:1: ( ruleIdentifier ) { - // InternalScope.g:8483:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) - // InternalScope.g:8484:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + // InternalScope.g:8696:1: ( ruleIdentifier ) + // InternalScope.g:8697:2: ruleIdentifier { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); } - // InternalScope.g:8485:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) - // InternalScope.g:8485:3: rule__InfixExpression__NameAssignment_1_2_2 - { pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_2_2(); + ruleIdentifier(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); + after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_0()); } } @@ -28201,26 +30637,21 @@ public final void rule__InfixExpression__Group_1_2__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__2__Impl" + // $ANTLR end "rule__QualifiedID__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__3" - // InternalScope.g:8493:1: rule__InfixExpression__Group_1_2__3 : rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ; - public final void rule__InfixExpression__Group_1_2__3() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__1" + // InternalScope.g:8706:1: rule__QualifiedID__Group__1 : rule__QualifiedID__Group__1__Impl ; + public final void rule__QualifiedID__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8497:1: ( rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ) - // InternalScope.g:8498:2: rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 + // InternalScope.g:8710:1: ( rule__QualifiedID__Group__1__Impl ) + // InternalScope.g:8711:2: rule__QualifiedID__Group__1__Impl { - pushFollow(FOLLOW_48); - rule__InfixExpression__Group_1_2__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__4(); + rule__QualifiedID__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -28239,28 +30670,56 @@ public final void rule__InfixExpression__Group_1_2__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__3" + // $ANTLR end "rule__QualifiedID__Group__1" - // $ANTLR start "rule__InfixExpression__Group_1_2__3__Impl" - // InternalScope.g:8505:1: rule__InfixExpression__Group_1_2__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_2__3__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group__1__Impl" + // InternalScope.g:8717:1: rule__QualifiedID__Group__1__Impl : ( ( rule__QualifiedID__Group_1__0 )* ) ; + public final void rule__QualifiedID__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8509:1: ( ( '(' ) ) - // InternalScope.g:8510:1: ( '(' ) + // InternalScope.g:8721:1: ( ( ( rule__QualifiedID__Group_1__0 )* ) ) + // InternalScope.g:8722:1: ( ( rule__QualifiedID__Group_1__0 )* ) { - // InternalScope.g:8510:1: ( '(' ) - // InternalScope.g:8511:2: '(' + // InternalScope.g:8722:1: ( ( rule__QualifiedID__Group_1__0 )* ) + // InternalScope.g:8723:2: ( rule__QualifiedID__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + before(grammarAccess.getQualifiedIDAccess().getGroup_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:8724:2: ( rule__QualifiedID__Group_1__0 )* + loop92: + do { + int alt92=2; + int LA92_0 = input.LA(1); + + if ( (LA92_0==93) ) { + alt92=1; + } + + + switch (alt92) { + case 1 : + // InternalScope.g:8724:3: rule__QualifiedID__Group_1__0 + { + pushFollow(FOLLOW_44); + rule__QualifiedID__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop92; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); + after(grammarAccess.getQualifiedIDAccess().getGroup_1()); } } @@ -28280,26 +30739,26 @@ public final void rule__InfixExpression__Group_1_2__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__3__Impl" + // $ANTLR end "rule__QualifiedID__Group__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__4" - // InternalScope.g:8520:1: rule__InfixExpression__Group_1_2__4 : rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ; - public final void rule__InfixExpression__Group_1_2__4() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__0" + // InternalScope.g:8733:1: rule__QualifiedID__Group_1__0 : rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ; + public final void rule__QualifiedID__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8524:1: ( rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ) - // InternalScope.g:8525:2: rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 + // InternalScope.g:8737:1: ( rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 ) + // InternalScope.g:8738:2: rule__QualifiedID__Group_1__0__Impl rule__QualifiedID__Group_1__1 { - pushFollow(FOLLOW_23); - rule__InfixExpression__Group_1_2__4__Impl(); + pushFollow(FOLLOW_4); + rule__QualifiedID__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__5(); + rule__QualifiedID__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -28318,38 +30777,28 @@ public final void rule__InfixExpression__Group_1_2__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__4" + // $ANTLR end "rule__QualifiedID__Group_1__0" - // $ANTLR start "rule__InfixExpression__Group_1_2__4__Impl" - // InternalScope.g:8532:1: rule__InfixExpression__Group_1_2__4__Impl : ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ; - public final void rule__InfixExpression__Group_1_2__4__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__0__Impl" + // InternalScope.g:8745:1: rule__QualifiedID__Group_1__0__Impl : ( '::' ) ; + public final void rule__QualifiedID__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8536:1: ( ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ) - // InternalScope.g:8537:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + // InternalScope.g:8749:1: ( ( '::' ) ) + // InternalScope.g:8750:1: ( '::' ) { - // InternalScope.g:8537:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) - // InternalScope.g:8538:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + // InternalScope.g:8750:1: ( '::' ) + // InternalScope.g:8751:2: '::' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); - } - // InternalScope.g:8539:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) - // InternalScope.g:8539:3: rule__InfixExpression__TypeAssignment_1_2_4 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__TypeAssignment_1_2_4(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } - + match(input,93,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); + after(grammarAccess.getQualifiedIDAccess().getColonColonKeyword_1_0()); } } @@ -28369,21 +30818,21 @@ public final void rule__InfixExpression__Group_1_2__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__4__Impl" + // $ANTLR end "rule__QualifiedID__Group_1__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_2__5" - // InternalScope.g:8547:1: rule__InfixExpression__Group_1_2__5 : rule__InfixExpression__Group_1_2__5__Impl ; - public final void rule__InfixExpression__Group_1_2__5() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__1" + // InternalScope.g:8760:1: rule__QualifiedID__Group_1__1 : rule__QualifiedID__Group_1__1__Impl ; + public final void rule__QualifiedID__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8551:1: ( rule__InfixExpression__Group_1_2__5__Impl ) - // InternalScope.g:8552:2: rule__InfixExpression__Group_1_2__5__Impl + // InternalScope.g:8764:1: ( rule__QualifiedID__Group_1__1__Impl ) + // InternalScope.g:8765:2: rule__QualifiedID__Group_1__1__Impl { pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_2__5__Impl(); + rule__QualifiedID__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -28402,28 +30851,32 @@ public final void rule__InfixExpression__Group_1_2__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__5" + // $ANTLR end "rule__QualifiedID__Group_1__1" - // $ANTLR start "rule__InfixExpression__Group_1_2__5__Impl" - // InternalScope.g:8558:1: rule__InfixExpression__Group_1_2__5__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_2__5__Impl() throws RecognitionException { + // $ANTLR start "rule__QualifiedID__Group_1__1__Impl" + // InternalScope.g:8771:1: rule__QualifiedID__Group_1__1__Impl : ( ruleIdentifier ) ; + public final void rule__QualifiedID__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8562:1: ( ( ')' ) ) - // InternalScope.g:8563:1: ( ')' ) + // InternalScope.g:8775:1: ( ( ruleIdentifier ) ) + // InternalScope.g:8776:1: ( ruleIdentifier ) { - // InternalScope.g:8563:1: ( ')' ) - // InternalScope.g:8564:2: ')' + // InternalScope.g:8776:1: ( ruleIdentifier ) + // InternalScope.g:8777:2: ruleIdentifier { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + before(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); + after(grammarAccess.getQualifiedIDAccess().getIdentifierParserRuleCall_1_1()); } } @@ -28443,26 +30896,26 @@ public final void rule__InfixExpression__Group_1_2__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_2__5__Impl" + // $ANTLR end "rule__QualifiedID__Group_1__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__0" - // InternalScope.g:8574:1: rule__InfixExpression__Group_1_3__0 : rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ; - public final void rule__InfixExpression__Group_1_3__0() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group__0" + // InternalScope.g:8787:1: rule__DottedID__Group__0 : rule__DottedID__Group__0__Impl rule__DottedID__Group__1 ; + public final void rule__DottedID__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8578:1: ( rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ) - // InternalScope.g:8579:2: rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 + // InternalScope.g:8791:1: ( rule__DottedID__Group__0__Impl rule__DottedID__Group__1 ) + // InternalScope.g:8792:2: rule__DottedID__Group__0__Impl rule__DottedID__Group__1 { pushFollow(FOLLOW_45); - rule__InfixExpression__Group_1_3__0__Impl(); + rule__DottedID__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__1(); + rule__DottedID__Group__1(); state._fsp--; if (state.failed) return ; @@ -28481,32 +30934,32 @@ public final void rule__InfixExpression__Group_1_3__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__0" + // $ANTLR end "rule__DottedID__Group__0" - // $ANTLR start "rule__InfixExpression__Group_1_3__0__Impl" - // InternalScope.g:8586:1: rule__InfixExpression__Group_1_3__0__Impl : ( () ) ; - public final void rule__InfixExpression__Group_1_3__0__Impl() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group__0__Impl" + // InternalScope.g:8799:1: rule__DottedID__Group__0__Impl : ( ruleIdentifier ) ; + public final void rule__DottedID__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8590:1: ( ( () ) ) - // InternalScope.g:8591:1: ( () ) + // InternalScope.g:8803:1: ( ( ruleIdentifier ) ) + // InternalScope.g:8804:1: ( ruleIdentifier ) { - // InternalScope.g:8591:1: ( () ) - // InternalScope.g:8592:2: () + // InternalScope.g:8804:1: ( ruleIdentifier ) + // InternalScope.g:8805:2: ruleIdentifier { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); - } - // InternalScope.g:8593:2: () - // InternalScope.g:8593:3: - { + before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); } + pushFollow(FOLLOW_2); + ruleIdentifier(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_0()); } } @@ -28515,6 +30968,10 @@ public final void rule__InfixExpression__Group_1_3__0__Impl() throws Recognition } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -28522,26 +30979,21 @@ public final void rule__InfixExpression__Group_1_3__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__0__Impl" + // $ANTLR end "rule__DottedID__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__1" - // InternalScope.g:8601:1: rule__InfixExpression__Group_1_3__1 : rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ; - public final void rule__InfixExpression__Group_1_3__1() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group__1" + // InternalScope.g:8814:1: rule__DottedID__Group__1 : rule__DottedID__Group__1__Impl ; + public final void rule__DottedID__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8605:1: ( rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ) - // InternalScope.g:8606:2: rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 + // InternalScope.g:8818:1: ( rule__DottedID__Group__1__Impl ) + // InternalScope.g:8819:2: rule__DottedID__Group__1__Impl { - pushFollow(FOLLOW_73); - rule__InfixExpression__Group_1_3__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__2(); + rule__DottedID__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -28560,28 +31012,56 @@ public final void rule__InfixExpression__Group_1_3__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__1" + // $ANTLR end "rule__DottedID__Group__1" - // $ANTLR start "rule__InfixExpression__Group_1_3__1__Impl" - // InternalScope.g:8613:1: rule__InfixExpression__Group_1_3__1__Impl : ( '.' ) ; - public final void rule__InfixExpression__Group_1_3__1__Impl() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group__1__Impl" + // InternalScope.g:8825:1: rule__DottedID__Group__1__Impl : ( ( rule__DottedID__Group_1__0 )* ) ; + public final void rule__DottedID__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8617:1: ( ( '.' ) ) - // InternalScope.g:8618:1: ( '.' ) + // InternalScope.g:8829:1: ( ( ( rule__DottedID__Group_1__0 )* ) ) + // InternalScope.g:8830:1: ( ( rule__DottedID__Group_1__0 )* ) { - // InternalScope.g:8618:1: ( '.' ) - // InternalScope.g:8619:2: '.' + // InternalScope.g:8830:1: ( ( rule__DottedID__Group_1__0 )* ) + // InternalScope.g:8831:2: ( rule__DottedID__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + before(grammarAccess.getDottedIDAccess().getGroup_1()); } - match(input,68,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:8832:2: ( rule__DottedID__Group_1__0 )* + loop93: + do { + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==58) ) { + alt93=1; + } + + + switch (alt93) { + case 1 : + // InternalScope.g:8832:3: rule__DottedID__Group_1__0 + { + pushFollow(FOLLOW_46); + rule__DottedID__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop93; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); + after(grammarAccess.getDottedIDAccess().getGroup_1()); } } @@ -28601,26 +31081,26 @@ public final void rule__InfixExpression__Group_1_3__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__1__Impl" + // $ANTLR end "rule__DottedID__Group__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__2" - // InternalScope.g:8628:1: rule__InfixExpression__Group_1_3__2 : rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ; - public final void rule__InfixExpression__Group_1_3__2() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group_1__0" + // InternalScope.g:8841:1: rule__DottedID__Group_1__0 : rule__DottedID__Group_1__0__Impl rule__DottedID__Group_1__1 ; + public final void rule__DottedID__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8632:1: ( rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ) - // InternalScope.g:8633:2: rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 + // InternalScope.g:8845:1: ( rule__DottedID__Group_1__0__Impl rule__DottedID__Group_1__1 ) + // InternalScope.g:8846:2: rule__DottedID__Group_1__0__Impl rule__DottedID__Group_1__1 { - pushFollow(FOLLOW_31); - rule__InfixExpression__Group_1_3__2__Impl(); + pushFollow(FOLLOW_4); + rule__DottedID__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__3(); + rule__DottedID__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -28639,38 +31119,28 @@ public final void rule__InfixExpression__Group_1_3__2() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__2" + // $ANTLR end "rule__DottedID__Group_1__0" - // $ANTLR start "rule__InfixExpression__Group_1_3__2__Impl" - // InternalScope.g:8640:1: rule__InfixExpression__Group_1_3__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ; - public final void rule__InfixExpression__Group_1_3__2__Impl() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group_1__0__Impl" + // InternalScope.g:8853:1: rule__DottedID__Group_1__0__Impl : ( '.' ) ; + public final void rule__DottedID__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8644:1: ( ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ) - // InternalScope.g:8645:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + // InternalScope.g:8857:1: ( ( '.' ) ) + // InternalScope.g:8858:1: ( '.' ) { - // InternalScope.g:8645:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) - // InternalScope.g:8646:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + // InternalScope.g:8858:1: ( '.' ) + // InternalScope.g:8859:2: '.' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); - } - // InternalScope.g:8647:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) - // InternalScope.g:8647:3: rule__InfixExpression__NameAssignment_1_3_2 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAssignment_1_3_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); } - + match(input,58,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); + after(grammarAccess.getDottedIDAccess().getFullStopKeyword_1_0()); } } @@ -28690,26 +31160,21 @@ public final void rule__InfixExpression__Group_1_3__2__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__2__Impl" + // $ANTLR end "rule__DottedID__Group_1__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__3" - // InternalScope.g:8655:1: rule__InfixExpression__Group_1_3__3 : rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ; - public final void rule__InfixExpression__Group_1_3__3() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group_1__1" + // InternalScope.g:8868:1: rule__DottedID__Group_1__1 : rule__DottedID__Group_1__1__Impl ; + public final void rule__DottedID__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8659:1: ( rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ) - // InternalScope.g:8660:2: rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 + // InternalScope.g:8872:1: ( rule__DottedID__Group_1__1__Impl ) + // InternalScope.g:8873:2: rule__DottedID__Group_1__1__Impl { - pushFollow(FOLLOW_17); - rule__InfixExpression__Group_1_3__3__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__4(); + rule__DottedID__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; @@ -28728,28 +31193,32 @@ public final void rule__InfixExpression__Group_1_3__3() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__3" + // $ANTLR end "rule__DottedID__Group_1__1" - // $ANTLR start "rule__InfixExpression__Group_1_3__3__Impl" - // InternalScope.g:8667:1: rule__InfixExpression__Group_1_3__3__Impl : ( '(' ) ; - public final void rule__InfixExpression__Group_1_3__3__Impl() throws RecognitionException { + // $ANTLR start "rule__DottedID__Group_1__1__Impl" + // InternalScope.g:8879:1: rule__DottedID__Group_1__1__Impl : ( ruleIdentifier ) ; + public final void rule__DottedID__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8671:1: ( ( '(' ) ) - // InternalScope.g:8672:1: ( '(' ) + // InternalScope.g:8883:1: ( ( ruleIdentifier ) ) + // InternalScope.g:8884:1: ( ruleIdentifier ) { - // InternalScope.g:8672:1: ( '(' ) - // InternalScope.g:8673:2: '(' + // InternalScope.g:8884:1: ( ruleIdentifier ) + // InternalScope.g:8885:2: ruleIdentifier { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + before(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + after(grammarAccess.getDottedIDAccess().getIdentifierParserRuleCall_1_1()); } } @@ -28769,26 +31238,26 @@ public final void rule__InfixExpression__Group_1_3__3__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__3__Impl" + // $ANTLR end "rule__DottedID__Group_1__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__4" - // InternalScope.g:8682:1: rule__InfixExpression__Group_1_3__4 : rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ; - public final void rule__InfixExpression__Group_1_3__4() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__0" + // InternalScope.g:8895:1: rule__LetExpression__Group__0 : rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ; + public final void rule__LetExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8686:1: ( rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ) - // InternalScope.g:8687:2: rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 + // InternalScope.g:8899:1: ( rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 ) + // InternalScope.g:8900:2: rule__LetExpression__Group__0__Impl rule__LetExpression__Group__1 { - pushFollow(FOLLOW_17); - rule__InfixExpression__Group_1_3__4__Impl(); + pushFollow(FOLLOW_4); + rule__LetExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__5(); + rule__LetExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -28807,53 +31276,28 @@ public final void rule__InfixExpression__Group_1_3__4() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__4" + // $ANTLR end "rule__LetExpression__Group__0" - // $ANTLR start "rule__InfixExpression__Group_1_3__4__Impl" - // InternalScope.g:8694:1: rule__InfixExpression__Group_1_3__4__Impl : ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ; - public final void rule__InfixExpression__Group_1_3__4__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__0__Impl" + // InternalScope.g:8907:1: rule__LetExpression__Group__0__Impl : ( 'let' ) ; + public final void rule__LetExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8698:1: ( ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ) - // InternalScope.g:8699:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + // InternalScope.g:8911:1: ( ( 'let' ) ) + // InternalScope.g:8912:1: ( 'let' ) { - // InternalScope.g:8699:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) - // InternalScope.g:8700:2: ( rule__InfixExpression__Group_1_3_4__0 )? + // InternalScope.g:8912:1: ( 'let' ) + // InternalScope.g:8913:2: 'let' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); - } - // InternalScope.g:8701:2: ( rule__InfixExpression__Group_1_3_4__0 )? - int alt68=2; - int LA68_0 = input.LA(1); - - if ( (LA68_0==RULE_ID) ) { - int LA68_1 = input.LA(2); - - if ( (LA68_1==66) ) { - alt68=1; - } - } - switch (alt68) { - case 1 : - // InternalScope.g:8701:3: rule__InfixExpression__Group_1_3_4__0 - { - pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } - + match(input,94,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + after(grammarAccess.getLetExpressionAccess().getLetKeyword_0()); } } @@ -28873,26 +31317,26 @@ public final void rule__InfixExpression__Group_1_3__4__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__4__Impl" + // $ANTLR end "rule__LetExpression__Group__0__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__5" - // InternalScope.g:8709:1: rule__InfixExpression__Group_1_3__5 : rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ; - public final void rule__InfixExpression__Group_1_3__5() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__1" + // InternalScope.g:8922:1: rule__LetExpression__Group__1 : rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ; + public final void rule__LetExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8713:1: ( rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ) - // InternalScope.g:8714:2: rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 + // InternalScope.g:8926:1: ( rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 ) + // InternalScope.g:8927:2: rule__LetExpression__Group__1__Impl rule__LetExpression__Group__2 { - pushFollow(FOLLOW_23); - rule__InfixExpression__Group_1_3__5__Impl(); + pushFollow(FOLLOW_16); + rule__LetExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__6(); + rule__LetExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -28911,30 +31355,30 @@ public final void rule__InfixExpression__Group_1_3__5() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__5" + // $ANTLR end "rule__LetExpression__Group__1" - // $ANTLR start "rule__InfixExpression__Group_1_3__5__Impl" - // InternalScope.g:8721:1: rule__InfixExpression__Group_1_3__5__Impl : ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ; - public final void rule__InfixExpression__Group_1_3__5__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__1__Impl" + // InternalScope.g:8934:1: rule__LetExpression__Group__1__Impl : ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ; + public final void rule__LetExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8725:1: ( ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ) - // InternalScope.g:8726:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + // InternalScope.g:8938:1: ( ( ( rule__LetExpression__IdentifierAssignment_1 ) ) ) + // InternalScope.g:8939:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) { - // InternalScope.g:8726:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) - // InternalScope.g:8727:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + // InternalScope.g:8939:1: ( ( rule__LetExpression__IdentifierAssignment_1 ) ) + // InternalScope.g:8940:2: ( rule__LetExpression__IdentifierAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + before(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } - // InternalScope.g:8728:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) - // InternalScope.g:8728:3: rule__InfixExpression__ExpAssignment_1_3_5 + // InternalScope.g:8941:2: ( rule__LetExpression__IdentifierAssignment_1 ) + // InternalScope.g:8941:3: rule__LetExpression__IdentifierAssignment_1 { pushFollow(FOLLOW_2); - rule__InfixExpression__ExpAssignment_1_3_5(); + rule__LetExpression__IdentifierAssignment_1(); state._fsp--; if (state.failed) return ; @@ -28942,7 +31386,7 @@ public final void rule__InfixExpression__Group_1_3__5__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); + after(grammarAccess.getLetExpressionAccess().getIdentifierAssignment_1()); } } @@ -28962,21 +31406,26 @@ public final void rule__InfixExpression__Group_1_3__5__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__5__Impl" + // $ANTLR end "rule__LetExpression__Group__1__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3__6" - // InternalScope.g:8736:1: rule__InfixExpression__Group_1_3__6 : rule__InfixExpression__Group_1_3__6__Impl ; - public final void rule__InfixExpression__Group_1_3__6() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__2" + // InternalScope.g:8949:1: rule__LetExpression__Group__2 : rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ; + public final void rule__LetExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8740:1: ( rule__InfixExpression__Group_1_3__6__Impl ) - // InternalScope.g:8741:2: rule__InfixExpression__Group_1_3__6__Impl + // InternalScope.g:8953:1: ( rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 ) + // InternalScope.g:8954:2: rule__LetExpression__Group__2__Impl rule__LetExpression__Group__3 { + pushFollow(FOLLOW_17); + rule__LetExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3__6__Impl(); + rule__LetExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -28995,28 +31444,28 @@ public final void rule__InfixExpression__Group_1_3__6() throws RecognitionExcept } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__6" + // $ANTLR end "rule__LetExpression__Group__2" - // $ANTLR start "rule__InfixExpression__Group_1_3__6__Impl" - // InternalScope.g:8747:1: rule__InfixExpression__Group_1_3__6__Impl : ( ')' ) ; - public final void rule__InfixExpression__Group_1_3__6__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__2__Impl" + // InternalScope.g:8961:1: rule__LetExpression__Group__2__Impl : ( '=' ) ; + public final void rule__LetExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8751:1: ( ( ')' ) ) - // InternalScope.g:8752:1: ( ')' ) + // InternalScope.g:8965:1: ( ( '=' ) ) + // InternalScope.g:8966:1: ( '=' ) { - // InternalScope.g:8752:1: ( ')' ) - // InternalScope.g:8753:2: ')' + // InternalScope.g:8966:1: ( '=' ) + // InternalScope.g:8967:2: '=' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + before(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,14,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + after(grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); } } @@ -29036,26 +31485,26 @@ public final void rule__InfixExpression__Group_1_3__6__Impl() throws Recognition } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3__6__Impl" + // $ANTLR end "rule__LetExpression__Group__2__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__0" - // InternalScope.g:8763:1: rule__InfixExpression__Group_1_3_4__0 : rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ; - public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__3" + // InternalScope.g:8976:1: rule__LetExpression__Group__3 : rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ; + public final void rule__LetExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8767:1: ( rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ) - // InternalScope.g:8768:2: rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 + // InternalScope.g:8980:1: ( rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 ) + // InternalScope.g:8981:2: rule__LetExpression__Group__3__Impl rule__LetExpression__Group__4 { - pushFollow(FOLLOW_42); - rule__InfixExpression__Group_1_3_4__0__Impl(); + pushFollow(FOLLOW_47); + rule__LetExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__1(); + rule__LetExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -29074,30 +31523,30 @@ public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__0" + // $ANTLR end "rule__LetExpression__Group__3" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__0__Impl" - // InternalScope.g:8775:1: rule__InfixExpression__Group_1_3_4__0__Impl : ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ; - public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__3__Impl" + // InternalScope.g:8988:1: rule__LetExpression__Group__3__Impl : ( ( rule__LetExpression__VarExprAssignment_3 ) ) ; + public final void rule__LetExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8779:1: ( ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ) - // InternalScope.g:8780:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + // InternalScope.g:8992:1: ( ( ( rule__LetExpression__VarExprAssignment_3 ) ) ) + // InternalScope.g:8993:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) { - // InternalScope.g:8780:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) - // InternalScope.g:8781:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + // InternalScope.g:8993:1: ( ( rule__LetExpression__VarExprAssignment_3 ) ) + // InternalScope.g:8994:2: ( rule__LetExpression__VarExprAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + before(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } - // InternalScope.g:8782:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) - // InternalScope.g:8782:3: rule__InfixExpression__VarAssignment_1_3_4_0 + // InternalScope.g:8995:2: ( rule__LetExpression__VarExprAssignment_3 ) + // InternalScope.g:8995:3: rule__LetExpression__VarExprAssignment_3 { pushFollow(FOLLOW_2); - rule__InfixExpression__VarAssignment_1_3_4_0(); + rule__LetExpression__VarExprAssignment_3(); state._fsp--; if (state.failed) return ; @@ -29105,7 +31554,7 @@ public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws Recogniti } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + after(grammarAccess.getLetExpressionAccess().getVarExprAssignment_3()); } } @@ -29125,21 +31574,26 @@ public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__0__Impl" + // $ANTLR end "rule__LetExpression__Group__3__Impl" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__1" - // InternalScope.g:8790:1: rule__InfixExpression__Group_1_3_4__1 : rule__InfixExpression__Group_1_3_4__1__Impl ; - public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__4" + // InternalScope.g:9003:1: rule__LetExpression__Group__4 : rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ; + public final void rule__LetExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8794:1: ( rule__InfixExpression__Group_1_3_4__1__Impl ) - // InternalScope.g:8795:2: rule__InfixExpression__Group_1_3_4__1__Impl + // InternalScope.g:9007:1: ( rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 ) + // InternalScope.g:9008:2: rule__LetExpression__Group__4__Impl rule__LetExpression__Group__5 { + pushFollow(FOLLOW_17); + rule__LetExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__InfixExpression__Group_1_3_4__1__Impl(); + rule__LetExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -29158,28 +31612,28 @@ public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionExce } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__1" + // $ANTLR end "rule__LetExpression__Group__4" - // $ANTLR start "rule__InfixExpression__Group_1_3_4__1__Impl" - // InternalScope.g:8801:1: rule__InfixExpression__Group_1_3_4__1__Impl : ( '|' ) ; - public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__4__Impl" + // InternalScope.g:9015:1: rule__LetExpression__Group__4__Impl : ( ':' ) ; + public final void rule__LetExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8805:1: ( ( '|' ) ) - // InternalScope.g:8806:1: ( '|' ) + // InternalScope.g:9019:1: ( ( ':' ) ) + // InternalScope.g:9020:1: ( ':' ) { - // InternalScope.g:8806:1: ( '|' ) - // InternalScope.g:8807:2: '|' + // InternalScope.g:9020:1: ( ':' ) + // InternalScope.g:9021:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + before(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } - match(input,66,FOLLOW_2); if (state.failed) return ; + match(input,95,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + after(grammarAccess.getLetExpressionAccess().getColonKeyword_4()); } } @@ -29199,26 +31653,21 @@ public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__Group_1_3_4__1__Impl" + // $ANTLR end "rule__LetExpression__Group__4__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__0" - // InternalScope.g:8817:1: rule__ParanthesizedExpression__Group__0 : rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ; - public final void rule__ParanthesizedExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__5" + // InternalScope.g:9030:1: rule__LetExpression__Group__5 : rule__LetExpression__Group__5__Impl ; + public final void rule__LetExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8821:1: ( rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ) - // InternalScope.g:8822:2: rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 + // InternalScope.g:9034:1: ( rule__LetExpression__Group__5__Impl ) + // InternalScope.g:9035:2: rule__LetExpression__Group__5__Impl { - pushFollow(FOLLOW_17); - rule__ParanthesizedExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__1(); + rule__LetExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; @@ -29237,28 +31686,38 @@ public final void rule__ParanthesizedExpression__Group__0() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__0" + // $ANTLR end "rule__LetExpression__Group__5" - // $ANTLR start "rule__ParanthesizedExpression__Group__0__Impl" - // InternalScope.g:8829:1: rule__ParanthesizedExpression__Group__0__Impl : ( '(' ) ; - public final void rule__ParanthesizedExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__LetExpression__Group__5__Impl" + // InternalScope.g:9041:1: rule__LetExpression__Group__5__Impl : ( ( rule__LetExpression__TargetAssignment_5 ) ) ; + public final void rule__LetExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8833:1: ( ( '(' ) ) - // InternalScope.g:8834:1: ( '(' ) + // InternalScope.g:9045:1: ( ( ( rule__LetExpression__TargetAssignment_5 ) ) ) + // InternalScope.g:9046:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) { - // InternalScope.g:8834:1: ( '(' ) - // InternalScope.g:8835:2: '(' + // InternalScope.g:9046:1: ( ( rule__LetExpression__TargetAssignment_5 ) ) + // InternalScope.g:9047:2: ( rule__LetExpression__TargetAssignment_5 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + before(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:9048:2: ( rule__LetExpression__TargetAssignment_5 ) + // InternalScope.g:9048:3: rule__LetExpression__TargetAssignment_5 + { + pushFollow(FOLLOW_2); + rule__LetExpression__TargetAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + after(grammarAccess.getLetExpressionAccess().getTargetAssignment_5()); } } @@ -29278,26 +31737,26 @@ public final void rule__ParanthesizedExpression__Group__0__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__0__Impl" + // $ANTLR end "rule__LetExpression__Group__5__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__1" - // InternalScope.g:8844:1: rule__ParanthesizedExpression__Group__1 : rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ; - public final void rule__ParanthesizedExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__0" + // InternalScope.g:9057:1: rule__CastedExpression__Group__0 : rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ; + public final void rule__CastedExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8848:1: ( rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ) - // InternalScope.g:8849:2: rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 + // InternalScope.g:9061:1: ( rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 ) + // InternalScope.g:9062:2: rule__CastedExpression__Group__0__Impl rule__CastedExpression__Group__1 { - pushFollow(FOLLOW_23); - rule__ParanthesizedExpression__Group__1__Impl(); + pushFollow(FOLLOW_48); + rule__CastedExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__2(); + rule__CastedExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -29316,32 +31775,28 @@ public final void rule__ParanthesizedExpression__Group__1() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__1" + // $ANTLR end "rule__CastedExpression__Group__0" - // $ANTLR start "rule__ParanthesizedExpression__Group__1__Impl" - // InternalScope.g:8856:1: rule__ParanthesizedExpression__Group__1__Impl : ( ruleExpression ) ; - public final void rule__ParanthesizedExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__0__Impl" + // InternalScope.g:9069:1: rule__CastedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__CastedExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8860:1: ( ( ruleExpression ) ) - // InternalScope.g:8861:1: ( ruleExpression ) + // InternalScope.g:9073:1: ( ( '(' ) ) + // InternalScope.g:9074:1: ( '(' ) { - // InternalScope.g:8861:1: ( ruleExpression ) - // InternalScope.g:8862:2: ruleExpression + // InternalScope.g:9074:1: ( '(' ) + // InternalScope.g:9075:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + before(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + after(grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); } } @@ -29361,21 +31816,26 @@ public final void rule__ParanthesizedExpression__Group__1__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__1__Impl" + // $ANTLR end "rule__CastedExpression__Group__0__Impl" - // $ANTLR start "rule__ParanthesizedExpression__Group__2" - // InternalScope.g:8871:1: rule__ParanthesizedExpression__Group__2 : rule__ParanthesizedExpression__Group__2__Impl ; - public final void rule__ParanthesizedExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__1" + // InternalScope.g:9084:1: rule__CastedExpression__Group__1 : rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ; + public final void rule__CastedExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8875:1: ( rule__ParanthesizedExpression__Group__2__Impl ) - // InternalScope.g:8876:2: rule__ParanthesizedExpression__Group__2__Impl + // InternalScope.g:9088:1: ( rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 ) + // InternalScope.g:9089:2: rule__CastedExpression__Group__1__Impl rule__CastedExpression__Group__2 { + pushFollow(FOLLOW_23); + rule__CastedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ParanthesizedExpression__Group__2__Impl(); + rule__CastedExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -29394,28 +31854,38 @@ public final void rule__ParanthesizedExpression__Group__2() throws RecognitionEx } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__2" + // $ANTLR end "rule__CastedExpression__Group__1" - // $ANTLR start "rule__ParanthesizedExpression__Group__2__Impl" - // InternalScope.g:8882:1: rule__ParanthesizedExpression__Group__2__Impl : ( ')' ) ; - public final void rule__ParanthesizedExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__1__Impl" + // InternalScope.g:9096:1: rule__CastedExpression__Group__1__Impl : ( ( rule__CastedExpression__TypeAssignment_1 ) ) ; + public final void rule__CastedExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8886:1: ( ( ')' ) ) - // InternalScope.g:8887:1: ( ')' ) + // InternalScope.g:9100:1: ( ( ( rule__CastedExpression__TypeAssignment_1 ) ) ) + // InternalScope.g:9101:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) { - // InternalScope.g:8887:1: ( ')' ) - // InternalScope.g:8888:2: ')' + // InternalScope.g:9101:1: ( ( rule__CastedExpression__TypeAssignment_1 ) ) + // InternalScope.g:9102:2: ( rule__CastedExpression__TypeAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + before(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); + } + // InternalScope.g:9103:2: ( rule__CastedExpression__TypeAssignment_1 ) + // InternalScope.g:9103:3: rule__CastedExpression__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__CastedExpression__TypeAssignment_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + after(grammarAccess.getCastedExpressionAccess().getTypeAssignment_1()); } } @@ -29435,26 +31905,26 @@ public final void rule__ParanthesizedExpression__Group__2__Impl() throws Recogni } return ; } - // $ANTLR end "rule__ParanthesizedExpression__Group__2__Impl" + // $ANTLR end "rule__CastedExpression__Group__1__Impl" - // $ANTLR start "rule__GlobalVarExpression__Group__0" - // InternalScope.g:8898:1: rule__GlobalVarExpression__Group__0 : rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ; - public final void rule__GlobalVarExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__2" + // InternalScope.g:9111:1: rule__CastedExpression__Group__2 : rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ; + public final void rule__CastedExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8902:1: ( rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ) - // InternalScope.g:8903:2: rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 + // InternalScope.g:9115:1: ( rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 ) + // InternalScope.g:9116:2: rule__CastedExpression__Group__2__Impl rule__CastedExpression__Group__3 { - pushFollow(FOLLOW_3); - rule__GlobalVarExpression__Group__0__Impl(); + pushFollow(FOLLOW_17); + rule__CastedExpression__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__GlobalVarExpression__Group__1(); + rule__CastedExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -29473,28 +31943,28 @@ public final void rule__GlobalVarExpression__Group__0() throws RecognitionExcept } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__0" + // $ANTLR end "rule__CastedExpression__Group__2" - // $ANTLR start "rule__GlobalVarExpression__Group__0__Impl" - // InternalScope.g:8910:1: rule__GlobalVarExpression__Group__0__Impl : ( 'GLOBALVAR' ) ; - public final void rule__GlobalVarExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__2__Impl" + // InternalScope.g:9123:1: rule__CastedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__CastedExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8914:1: ( ( 'GLOBALVAR' ) ) - // InternalScope.g:8915:1: ( 'GLOBALVAR' ) + // InternalScope.g:9127:1: ( ( ')' ) ) + // InternalScope.g:9128:1: ( ')' ) { - // InternalScope.g:8915:1: ( 'GLOBALVAR' ) - // InternalScope.g:8916:2: 'GLOBALVAR' + // InternalScope.g:9128:1: ( ')' ) + // InternalScope.g:9129:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + before(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + after(grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); } } @@ -29514,21 +31984,21 @@ public final void rule__GlobalVarExpression__Group__0__Impl() throws Recognition } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__0__Impl" + // $ANTLR end "rule__CastedExpression__Group__2__Impl" - // $ANTLR start "rule__GlobalVarExpression__Group__1" - // InternalScope.g:8925:1: rule__GlobalVarExpression__Group__1 : rule__GlobalVarExpression__Group__1__Impl ; - public final void rule__GlobalVarExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__3" + // InternalScope.g:9138:1: rule__CastedExpression__Group__3 : rule__CastedExpression__Group__3__Impl ; + public final void rule__CastedExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8929:1: ( rule__GlobalVarExpression__Group__1__Impl ) - // InternalScope.g:8930:2: rule__GlobalVarExpression__Group__1__Impl + // InternalScope.g:9142:1: ( rule__CastedExpression__Group__3__Impl ) + // InternalScope.g:9143:2: rule__CastedExpression__Group__3__Impl { pushFollow(FOLLOW_2); - rule__GlobalVarExpression__Group__1__Impl(); + rule__CastedExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -29547,30 +32017,30 @@ public final void rule__GlobalVarExpression__Group__1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__1" + // $ANTLR end "rule__CastedExpression__Group__3" - // $ANTLR start "rule__GlobalVarExpression__Group__1__Impl" - // InternalScope.g:8936:1: rule__GlobalVarExpression__Group__1__Impl : ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ; - public final void rule__GlobalVarExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__CastedExpression__Group__3__Impl" + // InternalScope.g:9149:1: rule__CastedExpression__Group__3__Impl : ( ( rule__CastedExpression__TargetAssignment_3 ) ) ; + public final void rule__CastedExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8940:1: ( ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ) - // InternalScope.g:8941:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + // InternalScope.g:9153:1: ( ( ( rule__CastedExpression__TargetAssignment_3 ) ) ) + // InternalScope.g:9154:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) { - // InternalScope.g:8941:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) - // InternalScope.g:8942:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + // InternalScope.g:9154:1: ( ( rule__CastedExpression__TargetAssignment_3 ) ) + // InternalScope.g:9155:2: ( rule__CastedExpression__TargetAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + before(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } - // InternalScope.g:8943:2: ( rule__GlobalVarExpression__NameAssignment_1 ) - // InternalScope.g:8943:3: rule__GlobalVarExpression__NameAssignment_1 + // InternalScope.g:9156:2: ( rule__CastedExpression__TargetAssignment_3 ) + // InternalScope.g:9156:3: rule__CastedExpression__TargetAssignment_3 { pushFollow(FOLLOW_2); - rule__GlobalVarExpression__NameAssignment_1(); + rule__CastedExpression__TargetAssignment_3(); state._fsp--; if (state.failed) return ; @@ -29578,7 +32048,7 @@ public final void rule__GlobalVarExpression__Group__1__Impl() throws Recognition } if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + after(grammarAccess.getCastedExpressionAccess().getTargetAssignment_3()); } } @@ -29598,26 +32068,26 @@ public final void rule__GlobalVarExpression__Group__1__Impl() throws Recognition } return ; } - // $ANTLR end "rule__GlobalVarExpression__Group__1__Impl" + // $ANTLR end "rule__CastedExpression__Group__3__Impl" - // $ANTLR start "rule__OperationCall__Group__0" - // InternalScope.g:8952:1: rule__OperationCall__Group__0 : rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ; - public final void rule__OperationCall__Group__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__0" + // InternalScope.g:9165:1: rule__ChainExpression__Group__0 : rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ; + public final void rule__ChainExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8956:1: ( rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ) - // InternalScope.g:8957:2: rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 + // InternalScope.g:9169:1: ( rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 ) + // InternalScope.g:9170:2: rule__ChainExpression__Group__0__Impl rule__ChainExpression__Group__1 { - pushFollow(FOLLOW_31); - rule__OperationCall__Group__0__Impl(); + pushFollow(FOLLOW_49); + rule__ChainExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__1(); + rule__ChainExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -29636,38 +32106,32 @@ public final void rule__OperationCall__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__0" + // $ANTLR end "rule__ChainExpression__Group__0" - // $ANTLR start "rule__OperationCall__Group__0__Impl" - // InternalScope.g:8964:1: rule__OperationCall__Group__0__Impl : ( ( rule__OperationCall__NameAssignment_0 ) ) ; - public final void rule__OperationCall__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__0__Impl" + // InternalScope.g:9177:1: rule__ChainExpression__Group__0__Impl : ( ruleChainedExpression ) ; + public final void rule__ChainExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8968:1: ( ( ( rule__OperationCall__NameAssignment_0 ) ) ) - // InternalScope.g:8969:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + // InternalScope.g:9181:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:9182:1: ( ruleChainedExpression ) { - // InternalScope.g:8969:1: ( ( rule__OperationCall__NameAssignment_0 ) ) - // InternalScope.g:8970:2: ( rule__OperationCall__NameAssignment_0 ) + // InternalScope.g:9182:1: ( ruleChainedExpression ) + // InternalScope.g:9183:2: ruleChainedExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + before(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } - // InternalScope.g:8971:2: ( rule__OperationCall__NameAssignment_0 ) - // InternalScope.g:8971:3: rule__OperationCall__NameAssignment_0 - { pushFollow(FOLLOW_2); - rule__OperationCall__NameAssignment_0(); + ruleChainedExpression(); state._fsp--; if (state.failed) return ; - - } - if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + after(grammarAccess.getChainExpressionAccess().getChainedExpressionParserRuleCall_0()); } } @@ -29687,26 +32151,21 @@ public final void rule__OperationCall__Group__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__0__Impl" + // $ANTLR end "rule__ChainExpression__Group__0__Impl" - // $ANTLR start "rule__OperationCall__Group__1" - // InternalScope.g:8979:1: rule__OperationCall__Group__1 : rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ; - public final void rule__OperationCall__Group__1() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__1" + // InternalScope.g:9192:1: rule__ChainExpression__Group__1 : rule__ChainExpression__Group__1__Impl ; + public final void rule__ChainExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8983:1: ( rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ) - // InternalScope.g:8984:2: rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 + // InternalScope.g:9196:1: ( rule__ChainExpression__Group__1__Impl ) + // InternalScope.g:9197:2: rule__ChainExpression__Group__1__Impl { - pushFollow(FOLLOW_70); - rule__OperationCall__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__2(); + rule__ChainExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -29725,28 +32184,56 @@ public final void rule__OperationCall__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__1" + // $ANTLR end "rule__ChainExpression__Group__1" - // $ANTLR start "rule__OperationCall__Group__1__Impl" - // InternalScope.g:8991:1: rule__OperationCall__Group__1__Impl : ( '(' ) ; - public final void rule__OperationCall__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group__1__Impl" + // InternalScope.g:9203:1: rule__ChainExpression__Group__1__Impl : ( ( rule__ChainExpression__Group_1__0 )* ) ; + public final void rule__ChainExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:8995:1: ( ( '(' ) ) - // InternalScope.g:8996:1: ( '(' ) + // InternalScope.g:9207:1: ( ( ( rule__ChainExpression__Group_1__0 )* ) ) + // InternalScope.g:9208:1: ( ( rule__ChainExpression__Group_1__0 )* ) { - // InternalScope.g:8996:1: ( '(' ) - // InternalScope.g:8997:2: '(' + // InternalScope.g:9208:1: ( ( rule__ChainExpression__Group_1__0 )* ) + // InternalScope.g:9209:2: ( rule__ChainExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getChainExpressionAccess().getGroup_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:9210:2: ( rule__ChainExpression__Group_1__0 )* + loop94: + do { + int alt94=2; + int LA94_0 = input.LA(1); + + if ( (LA94_0==48) ) { + alt94=1; + } + + + switch (alt94) { + case 1 : + // InternalScope.g:9210:3: rule__ChainExpression__Group_1__0 + { + pushFollow(FOLLOW_50); + rule__ChainExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop94; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getChainExpressionAccess().getGroup_1()); } } @@ -29766,26 +32253,26 @@ public final void rule__OperationCall__Group__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__1__Impl" + // $ANTLR end "rule__ChainExpression__Group__1__Impl" - // $ANTLR start "rule__OperationCall__Group__2" - // InternalScope.g:9006:1: rule__OperationCall__Group__2 : rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ; - public final void rule__OperationCall__Group__2() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__0" + // InternalScope.g:9219:1: rule__ChainExpression__Group_1__0 : rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ; + public final void rule__ChainExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9010:1: ( rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ) - // InternalScope.g:9011:2: rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 + // InternalScope.g:9223:1: ( rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 ) + // InternalScope.g:9224:2: rule__ChainExpression__Group_1__0__Impl rule__ChainExpression__Group_1__1 { - pushFollow(FOLLOW_70); - rule__OperationCall__Group__2__Impl(); + pushFollow(FOLLOW_49); + rule__ChainExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__3(); + rule__ChainExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -29804,49 +32291,32 @@ public final void rule__OperationCall__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__2" + // $ANTLR end "rule__ChainExpression__Group_1__0" - // $ANTLR start "rule__OperationCall__Group__2__Impl" - // InternalScope.g:9018:1: rule__OperationCall__Group__2__Impl : ( ( rule__OperationCall__Group_2__0 )? ) ; - public final void rule__OperationCall__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__0__Impl" + // InternalScope.g:9231:1: rule__ChainExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ChainExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9022:1: ( ( ( rule__OperationCall__Group_2__0 )? ) ) - // InternalScope.g:9023:1: ( ( rule__OperationCall__Group_2__0 )? ) + // InternalScope.g:9235:1: ( ( () ) ) + // InternalScope.g:9236:1: ( () ) { - // InternalScope.g:9023:1: ( ( rule__OperationCall__Group_2__0 )? ) - // InternalScope.g:9024:2: ( rule__OperationCall__Group_2__0 )? + // InternalScope.g:9236:1: ( () ) + // InternalScope.g:9237:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getGroup_2()); - } - // InternalScope.g:9025:2: ( rule__OperationCall__Group_2__0 )? - int alt69=2; - int LA69_0 = input.LA(1); - - if ( ((LA69_0>=RULE_ID && LA69_0<=RULE_REAL)||LA69_0==19||(LA69_0>=22 && LA69_0<=35)||LA69_0==45||LA69_0==51||LA69_0==69||LA69_0==73||LA69_0==76||(LA69_0>=78 && LA69_0<=79)||(LA69_0>=85 && LA69_0<=86)) ) { - alt69=1; + before(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } - switch (alt69) { - case 1 : - // InternalScope.g:9025:3: rule__OperationCall__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + // InternalScope.g:9238:2: () + // InternalScope.g:9238:3: + { } if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getGroup_2()); + after(grammarAccess.getChainExpressionAccess().getChainExpressionFirstAction_1_0()); } } @@ -29855,10 +32325,6 @@ public final void rule__OperationCall__Group__2__Impl() throws RecognitionExcept } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -29866,21 +32332,26 @@ public final void rule__OperationCall__Group__2__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__2__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__0__Impl" - // $ANTLR start "rule__OperationCall__Group__3" - // InternalScope.g:9033:1: rule__OperationCall__Group__3 : rule__OperationCall__Group__3__Impl ; - public final void rule__OperationCall__Group__3() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__1" + // InternalScope.g:9246:1: rule__ChainExpression__Group_1__1 : rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ; + public final void rule__ChainExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9037:1: ( rule__OperationCall__Group__3__Impl ) - // InternalScope.g:9038:2: rule__OperationCall__Group__3__Impl + // InternalScope.g:9250:1: ( rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 ) + // InternalScope.g:9251:2: rule__ChainExpression__Group_1__1__Impl rule__ChainExpression__Group_1__2 { + pushFollow(FOLLOW_17); + rule__ChainExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group__3__Impl(); + rule__ChainExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -29899,28 +32370,28 @@ public final void rule__OperationCall__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__OperationCall__Group__3" + // $ANTLR end "rule__ChainExpression__Group_1__1" - // $ANTLR start "rule__OperationCall__Group__3__Impl" - // InternalScope.g:9044:1: rule__OperationCall__Group__3__Impl : ( ')' ) ; - public final void rule__OperationCall__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__1__Impl" + // InternalScope.g:9258:1: rule__ChainExpression__Group_1__1__Impl : ( '->' ) ; + public final void rule__ChainExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9048:1: ( ( ')' ) ) - // InternalScope.g:9049:1: ( ')' ) + // InternalScope.g:9262:1: ( ( '->' ) ) + // InternalScope.g:9263:1: ( '->' ) { - // InternalScope.g:9049:1: ( ')' ) - // InternalScope.g:9050:2: ')' + // InternalScope.g:9263:1: ( '->' ) + // InternalScope.g:9264:2: '->' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + before(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } - match(input,52,FOLLOW_2); if (state.failed) return ; + match(input,48,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + after(grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); } } @@ -29940,26 +32411,21 @@ public final void rule__OperationCall__Group__3__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__OperationCall__Group__3__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__1__Impl" - // $ANTLR start "rule__OperationCall__Group_2__0" - // InternalScope.g:9060:1: rule__OperationCall__Group_2__0 : rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ; - public final void rule__OperationCall__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__2" + // InternalScope.g:9273:1: rule__ChainExpression__Group_1__2 : rule__ChainExpression__Group_1__2__Impl ; + public final void rule__ChainExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9064:1: ( rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ) - // InternalScope.g:9065:2: rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 + // InternalScope.g:9277:1: ( rule__ChainExpression__Group_1__2__Impl ) + // InternalScope.g:9278:2: rule__ChainExpression__Group_1__2__Impl { - pushFollow(FOLLOW_71); - rule__OperationCall__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__1(); + rule__ChainExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -29978,30 +32444,30 @@ public final void rule__OperationCall__Group_2__0() throws RecognitionException } return ; } - // $ANTLR end "rule__OperationCall__Group_2__0" + // $ANTLR end "rule__ChainExpression__Group_1__2" - // $ANTLR start "rule__OperationCall__Group_2__0__Impl" - // InternalScope.g:9072:1: rule__OperationCall__Group_2__0__Impl : ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ; - public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__ChainExpression__Group_1__2__Impl" + // InternalScope.g:9284:1: rule__ChainExpression__Group_1__2__Impl : ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ; + public final void rule__ChainExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9076:1: ( ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ) - // InternalScope.g:9077:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + // InternalScope.g:9288:1: ( ( ( rule__ChainExpression__NextAssignment_1_2 ) ) ) + // InternalScope.g:9289:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) { - // InternalScope.g:9077:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) - // InternalScope.g:9078:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + // InternalScope.g:9289:1: ( ( rule__ChainExpression__NextAssignment_1_2 ) ) + // InternalScope.g:9290:2: ( rule__ChainExpression__NextAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + before(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } - // InternalScope.g:9079:2: ( rule__OperationCall__ParamsAssignment_2_0 ) - // InternalScope.g:9079:3: rule__OperationCall__ParamsAssignment_2_0 + // InternalScope.g:9291:2: ( rule__ChainExpression__NextAssignment_1_2 ) + // InternalScope.g:9291:3: rule__ChainExpression__NextAssignment_1_2 { pushFollow(FOLLOW_2); - rule__OperationCall__ParamsAssignment_2_0(); + rule__ChainExpression__NextAssignment_1_2(); state._fsp--; if (state.failed) return ; @@ -30009,7 +32475,7 @@ public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + after(grammarAccess.getChainExpressionAccess().getNextAssignment_1_2()); } } @@ -30029,21 +32495,26 @@ public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__Group_2__0__Impl" + // $ANTLR end "rule__ChainExpression__Group_1__2__Impl" - // $ANTLR start "rule__OperationCall__Group_2__1" - // InternalScope.g:9087:1: rule__OperationCall__Group_2__1 : rule__OperationCall__Group_2__1__Impl ; - public final void rule__OperationCall__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__0" + // InternalScope.g:9300:1: rule__IfExpressionTri__Group__0 : rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ; + public final void rule__IfExpressionTri__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9091:1: ( rule__OperationCall__Group_2__1__Impl ) - // InternalScope.g:9092:2: rule__OperationCall__Group_2__1__Impl + // InternalScope.g:9304:1: ( rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 ) + // InternalScope.g:9305:2: rule__IfExpressionTri__Group__0__Impl rule__IfExpressionTri__Group__1 { + pushFollow(FOLLOW_51); + rule__IfExpressionTri__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2__1__Impl(); + rule__IfExpressionTri__Group__1(); state._fsp--; if (state.failed) return ; @@ -30062,56 +32533,32 @@ public final void rule__OperationCall__Group_2__1() throws RecognitionException } return ; } - // $ANTLR end "rule__OperationCall__Group_2__1" + // $ANTLR end "rule__IfExpressionTri__Group__0" - // $ANTLR start "rule__OperationCall__Group_2__1__Impl" - // InternalScope.g:9098:1: rule__OperationCall__Group_2__1__Impl : ( ( rule__OperationCall__Group_2_1__0 )* ) ; - public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__0__Impl" + // InternalScope.g:9312:1: rule__IfExpressionTri__Group__0__Impl : ( ruleOrExpression ) ; + public final void rule__IfExpressionTri__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9102:1: ( ( ( rule__OperationCall__Group_2_1__0 )* ) ) - // InternalScope.g:9103:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + // InternalScope.g:9316:1: ( ( ruleOrExpression ) ) + // InternalScope.g:9317:1: ( ruleOrExpression ) { - // InternalScope.g:9103:1: ( ( rule__OperationCall__Group_2_1__0 )* ) - // InternalScope.g:9104:2: ( rule__OperationCall__Group_2_1__0 )* + // InternalScope.g:9317:1: ( ruleOrExpression ) + // InternalScope.g:9318:2: ruleOrExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getGroup_2_1()); + before(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } - // InternalScope.g:9105:2: ( rule__OperationCall__Group_2_1__0 )* - loop70: - do { - int alt70=2; - int LA70_0 = input.LA(1); - - if ( (LA70_0==60) ) { - alt70=1; - } - - - switch (alt70) { - case 1 : - // InternalScope.g:9105:3: rule__OperationCall__Group_2_1__0 - { - pushFollow(FOLLOW_39); - rule__OperationCall__Group_2_1__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop70; - } - } while (true); + pushFollow(FOLLOW_2); + ruleOrExpression(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getGroup_2_1()); + after(grammarAccess.getIfExpressionTriAccess().getOrExpressionParserRuleCall_0()); } } @@ -30131,26 +32578,21 @@ public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__Group_2__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group__0__Impl" - // $ANTLR start "rule__OperationCall__Group_2_1__0" - // InternalScope.g:9114:1: rule__OperationCall__Group_2_1__0 : rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ; - public final void rule__OperationCall__Group_2_1__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__1" + // InternalScope.g:9327:1: rule__IfExpressionTri__Group__1 : rule__IfExpressionTri__Group__1__Impl ; + public final void rule__IfExpressionTri__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9118:1: ( rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ) - // InternalScope.g:9119:2: rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 + // InternalScope.g:9331:1: ( rule__IfExpressionTri__Group__1__Impl ) + // InternalScope.g:9332:2: rule__IfExpressionTri__Group__1__Impl { - pushFollow(FOLLOW_17); - rule__OperationCall__Group_2_1__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2_1__1(); + rule__IfExpressionTri__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -30169,28 +32611,49 @@ public final void rule__OperationCall__Group_2_1__0() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__0" + // $ANTLR end "rule__IfExpressionTri__Group__1" - // $ANTLR start "rule__OperationCall__Group_2_1__0__Impl" - // InternalScope.g:9126:1: rule__OperationCall__Group_2_1__0__Impl : ( ',' ) ; - public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group__1__Impl" + // InternalScope.g:9338:1: rule__IfExpressionTri__Group__1__Impl : ( ( rule__IfExpressionTri__Group_1__0 )? ) ; + public final void rule__IfExpressionTri__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9130:1: ( ( ',' ) ) - // InternalScope.g:9131:1: ( ',' ) + // InternalScope.g:9342:1: ( ( ( rule__IfExpressionTri__Group_1__0 )? ) ) + // InternalScope.g:9343:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) { - // InternalScope.g:9131:1: ( ',' ) - // InternalScope.g:9132:2: ',' + // InternalScope.g:9343:1: ( ( rule__IfExpressionTri__Group_1__0 )? ) + // InternalScope.g:9344:2: ( rule__IfExpressionTri__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + before(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } - match(input,60,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:9345:2: ( rule__IfExpressionTri__Group_1__0 )? + int alt95=2; + int LA95_0 = input.LA(1); + + if ( (LA95_0==96) ) { + alt95=1; + } + switch (alt95) { + case 1 : + // InternalScope.g:9345:3: rule__IfExpressionTri__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionTri__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + after(grammarAccess.getIfExpressionTriAccess().getGroup_1()); } } @@ -30210,21 +32673,26 @@ public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__0__Impl" + // $ANTLR end "rule__IfExpressionTri__Group__1__Impl" - // $ANTLR start "rule__OperationCall__Group_2_1__1" - // InternalScope.g:9141:1: rule__OperationCall__Group_2_1__1 : rule__OperationCall__Group_2_1__1__Impl ; - public final void rule__OperationCall__Group_2_1__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__0" + // InternalScope.g:9354:1: rule__IfExpressionTri__Group_1__0 : rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ; + public final void rule__IfExpressionTri__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9145:1: ( rule__OperationCall__Group_2_1__1__Impl ) - // InternalScope.g:9146:2: rule__OperationCall__Group_2_1__1__Impl + // InternalScope.g:9358:1: ( rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 ) + // InternalScope.g:9359:2: rule__IfExpressionTri__Group_1__0__Impl rule__IfExpressionTri__Group_1__1 { + pushFollow(FOLLOW_51); + rule__IfExpressionTri__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__OperationCall__Group_2_1__1__Impl(); + rule__IfExpressionTri__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -30243,38 +32711,32 @@ public final void rule__OperationCall__Group_2_1__1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__1" + // $ANTLR end "rule__IfExpressionTri__Group_1__0" - // $ANTLR start "rule__OperationCall__Group_2_1__1__Impl" - // InternalScope.g:9152:1: rule__OperationCall__Group_2_1__1__Impl : ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ; - public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__0__Impl" + // InternalScope.g:9366:1: rule__IfExpressionTri__Group_1__0__Impl : ( () ) ; + public final void rule__IfExpressionTri__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9156:1: ( ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ) - // InternalScope.g:9157:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + // InternalScope.g:9370:1: ( ( () ) ) + // InternalScope.g:9371:1: ( () ) { - // InternalScope.g:9157:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) - // InternalScope.g:9158:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + // InternalScope.g:9371:1: ( () ) + // InternalScope.g:9372:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + before(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } - // InternalScope.g:9159:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) - // InternalScope.g:9159:3: rule__OperationCall__ParamsAssignment_2_1_1 + // InternalScope.g:9373:2: () + // InternalScope.g:9373:3: { - pushFollow(FOLLOW_2); - rule__OperationCall__ParamsAssignment_2_1_1(); - - state._fsp--; - if (state.failed) return ; - } if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + after(grammarAccess.getIfExpressionTriAccess().getIfExpressionConditionAction_1_0()); } } @@ -30283,10 +32745,6 @@ public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionEx } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -30294,26 +32752,26 @@ public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionEx } return ; } - // $ANTLR end "rule__OperationCall__Group_2_1__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__0__Impl" - // $ANTLR start "rule__ListLiteral__Group__0" - // InternalScope.g:9168:1: rule__ListLiteral__Group__0 : rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ; - public final void rule__ListLiteral__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__1" + // InternalScope.g:9381:1: rule__IfExpressionTri__Group_1__1 : rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ; + public final void rule__IfExpressionTri__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9172:1: ( rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ) - // InternalScope.g:9173:2: rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 + // InternalScope.g:9385:1: ( rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 ) + // InternalScope.g:9386:2: rule__IfExpressionTri__Group_1__1__Impl rule__IfExpressionTri__Group_1__2 { - pushFollow(FOLLOW_12); - rule__ListLiteral__Group__0__Impl(); + pushFollow(FOLLOW_17); + rule__IfExpressionTri__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__1(); + rule__IfExpressionTri__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -30332,32 +32790,28 @@ public final void rule__ListLiteral__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__0" + // $ANTLR end "rule__IfExpressionTri__Group_1__1" - // $ANTLR start "rule__ListLiteral__Group__0__Impl" - // InternalScope.g:9180:1: rule__ListLiteral__Group__0__Impl : ( () ) ; - public final void rule__ListLiteral__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__1__Impl" + // InternalScope.g:9393:1: rule__IfExpressionTri__Group_1__1__Impl : ( '?' ) ; + public final void rule__IfExpressionTri__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9184:1: ( ( () ) ) - // InternalScope.g:9185:1: ( () ) + // InternalScope.g:9397:1: ( ( '?' ) ) + // InternalScope.g:9398:1: ( '?' ) { - // InternalScope.g:9185:1: ( () ) - // InternalScope.g:9186:2: () + // InternalScope.g:9398:1: ( '?' ) + // InternalScope.g:9399:2: '?' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); - } - // InternalScope.g:9187:2: () - // InternalScope.g:9187:3: - { + before(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } - + match(input,96,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + after(grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); } } @@ -30366,6 +32820,10 @@ public final void rule__ListLiteral__Group__0__Impl() throws RecognitionExceptio } } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } finally { restoreStackSize(stackSize); @@ -30373,26 +32831,26 @@ public final void rule__ListLiteral__Group__0__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__0__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__1__Impl" - // $ANTLR start "rule__ListLiteral__Group__1" - // InternalScope.g:9195:1: rule__ListLiteral__Group__1 : rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ; - public final void rule__ListLiteral__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__2" + // InternalScope.g:9408:1: rule__IfExpressionTri__Group_1__2 : rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ; + public final void rule__IfExpressionTri__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9199:1: ( rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ) - // InternalScope.g:9200:2: rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 + // InternalScope.g:9412:1: ( rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 ) + // InternalScope.g:9413:2: rule__IfExpressionTri__Group_1__2__Impl rule__IfExpressionTri__Group_1__3 { - pushFollow(FOLLOW_74); - rule__ListLiteral__Group__1__Impl(); + pushFollow(FOLLOW_47); + rule__IfExpressionTri__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__2(); + rule__IfExpressionTri__Group_1__3(); state._fsp--; if (state.failed) return ; @@ -30411,28 +32869,38 @@ public final void rule__ListLiteral__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__1" + // $ANTLR end "rule__IfExpressionTri__Group_1__2" - // $ANTLR start "rule__ListLiteral__Group__1__Impl" - // InternalScope.g:9207:1: rule__ListLiteral__Group__1__Impl : ( '{' ) ; - public final void rule__ListLiteral__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__2__Impl" + // InternalScope.g:9420:1: rule__IfExpressionTri__Group_1__2__Impl : ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ; + public final void rule__IfExpressionTri__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9211:1: ( ( '{' ) ) - // InternalScope.g:9212:1: ( '{' ) + // InternalScope.g:9424:1: ( ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) ) + // InternalScope.g:9425:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) { - // InternalScope.g:9212:1: ( '{' ) - // InternalScope.g:9213:2: '{' + // InternalScope.g:9425:1: ( ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) ) + // InternalScope.g:9426:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + before(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); + } + // InternalScope.g:9427:2: ( rule__IfExpressionTri__ThenPartAssignment_1_2 ) + // InternalScope.g:9427:3: rule__IfExpressionTri__ThenPartAssignment_1_2 + { + pushFollow(FOLLOW_2); + rule__IfExpressionTri__ThenPartAssignment_1_2(); + + state._fsp--; + if (state.failed) return ; + } - match(input,45,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + after(grammarAccess.getIfExpressionTriAccess().getThenPartAssignment_1_2()); } } @@ -30452,26 +32920,26 @@ public final void rule__ListLiteral__Group__1__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__1__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__2__Impl" - // $ANTLR start "rule__ListLiteral__Group__2" - // InternalScope.g:9222:1: rule__ListLiteral__Group__2 : rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ; - public final void rule__ListLiteral__Group__2() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__3" + // InternalScope.g:9435:1: rule__IfExpressionTri__Group_1__3 : rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ; + public final void rule__IfExpressionTri__Group_1__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9226:1: ( rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ) - // InternalScope.g:9227:2: rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 + // InternalScope.g:9439:1: ( rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 ) + // InternalScope.g:9440:2: rule__IfExpressionTri__Group_1__3__Impl rule__IfExpressionTri__Group_1__4 { - pushFollow(FOLLOW_74); - rule__ListLiteral__Group__2__Impl(); + pushFollow(FOLLOW_17); + rule__IfExpressionTri__Group_1__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group__3(); + rule__IfExpressionTri__Group_1__4(); state._fsp--; if (state.failed) return ; @@ -30490,49 +32958,28 @@ public final void rule__ListLiteral__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__2" + // $ANTLR end "rule__IfExpressionTri__Group_1__3" - // $ANTLR start "rule__ListLiteral__Group__2__Impl" - // InternalScope.g:9234:1: rule__ListLiteral__Group__2__Impl : ( ( rule__ListLiteral__Group_2__0 )? ) ; - public final void rule__ListLiteral__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__3__Impl" + // InternalScope.g:9447:1: rule__IfExpressionTri__Group_1__3__Impl : ( ':' ) ; + public final void rule__IfExpressionTri__Group_1__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9238:1: ( ( ( rule__ListLiteral__Group_2__0 )? ) ) - // InternalScope.g:9239:1: ( ( rule__ListLiteral__Group_2__0 )? ) + // InternalScope.g:9451:1: ( ( ':' ) ) + // InternalScope.g:9452:1: ( ':' ) { - // InternalScope.g:9239:1: ( ( rule__ListLiteral__Group_2__0 )? ) - // InternalScope.g:9240:2: ( rule__ListLiteral__Group_2__0 )? + // InternalScope.g:9452:1: ( ':' ) + // InternalScope.g:9453:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getGroup_2()); - } - // InternalScope.g:9241:2: ( rule__ListLiteral__Group_2__0 )? - int alt71=2; - int LA71_0 = input.LA(1); - - if ( ((LA71_0>=RULE_ID && LA71_0<=RULE_REAL)||LA71_0==19||(LA71_0>=22 && LA71_0<=35)||LA71_0==45||LA71_0==51||LA71_0==69||LA71_0==73||LA71_0==76||(LA71_0>=78 && LA71_0<=79)||(LA71_0>=85 && LA71_0<=86)) ) { - alt71=1; - } - switch (alt71) { - case 1 : - // InternalScope.g:9241:3: rule__ListLiteral__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } - + match(input,95,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getGroup_2()); + after(grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); } } @@ -30552,21 +32999,21 @@ public final void rule__ListLiteral__Group__2__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__2__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__3__Impl" - // $ANTLR start "rule__ListLiteral__Group__3" - // InternalScope.g:9249:1: rule__ListLiteral__Group__3 : rule__ListLiteral__Group__3__Impl ; - public final void rule__ListLiteral__Group__3() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__4" + // InternalScope.g:9462:1: rule__IfExpressionTri__Group_1__4 : rule__IfExpressionTri__Group_1__4__Impl ; + public final void rule__IfExpressionTri__Group_1__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9253:1: ( rule__ListLiteral__Group__3__Impl ) - // InternalScope.g:9254:2: rule__ListLiteral__Group__3__Impl + // InternalScope.g:9466:1: ( rule__IfExpressionTri__Group_1__4__Impl ) + // InternalScope.g:9467:2: rule__IfExpressionTri__Group_1__4__Impl { pushFollow(FOLLOW_2); - rule__ListLiteral__Group__3__Impl(); + rule__IfExpressionTri__Group_1__4__Impl(); state._fsp--; if (state.failed) return ; @@ -30585,28 +33032,38 @@ public final void rule__ListLiteral__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group__3" + // $ANTLR end "rule__IfExpressionTri__Group_1__4" - // $ANTLR start "rule__ListLiteral__Group__3__Impl" - // InternalScope.g:9260:1: rule__ListLiteral__Group__3__Impl : ( '}' ) ; - public final void rule__ListLiteral__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionTri__Group_1__4__Impl" + // InternalScope.g:9473:1: rule__IfExpressionTri__Group_1__4__Impl : ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ; + public final void rule__IfExpressionTri__Group_1__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9264:1: ( ( '}' ) ) - // InternalScope.g:9265:1: ( '}' ) + // InternalScope.g:9477:1: ( ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) ) + // InternalScope.g:9478:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) { - // InternalScope.g:9265:1: ( '}' ) - // InternalScope.g:9266:2: '}' + // InternalScope.g:9478:1: ( ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) ) + // InternalScope.g:9479:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + before(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); + } + // InternalScope.g:9480:2: ( rule__IfExpressionTri__ElsePartAssignment_1_4 ) + // InternalScope.g:9480:3: rule__IfExpressionTri__ElsePartAssignment_1_4 + { + pushFollow(FOLLOW_2); + rule__IfExpressionTri__ElsePartAssignment_1_4(); + + state._fsp--; + if (state.failed) return ; + } - match(input,46,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + after(grammarAccess.getIfExpressionTriAccess().getElsePartAssignment_1_4()); } } @@ -30626,26 +33083,26 @@ public final void rule__ListLiteral__Group__3__Impl() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__ListLiteral__Group__3__Impl" + // $ANTLR end "rule__IfExpressionTri__Group_1__4__Impl" - // $ANTLR start "rule__ListLiteral__Group_2__0" - // InternalScope.g:9276:1: rule__ListLiteral__Group_2__0 : rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ; - public final void rule__ListLiteral__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__0" + // InternalScope.g:9489:1: rule__IfExpressionKw__Group__0 : rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ; + public final void rule__IfExpressionKw__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9280:1: ( rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ) - // InternalScope.g:9281:2: rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 + // InternalScope.g:9493:1: ( rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 ) + // InternalScope.g:9494:2: rule__IfExpressionKw__Group__0__Impl rule__IfExpressionKw__Group__1 { - pushFollow(FOLLOW_71); - rule__ListLiteral__Group_2__0__Impl(); + pushFollow(FOLLOW_17); + rule__IfExpressionKw__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__1(); + rule__IfExpressionKw__Group__1(); state._fsp--; if (state.failed) return ; @@ -30664,38 +33121,28 @@ public final void rule__ListLiteral__Group_2__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__0" + // $ANTLR end "rule__IfExpressionKw__Group__0" - // $ANTLR start "rule__ListLiteral__Group_2__0__Impl" - // InternalScope.g:9288:1: rule__ListLiteral__Group_2__0__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ; - public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__0__Impl" + // InternalScope.g:9501:1: rule__IfExpressionKw__Group__0__Impl : ( 'if' ) ; + public final void rule__IfExpressionKw__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9292:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ) - // InternalScope.g:9293:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + // InternalScope.g:9505:1: ( ( 'if' ) ) + // InternalScope.g:9506:1: ( 'if' ) { - // InternalScope.g:9293:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) - // InternalScope.g:9294:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + // InternalScope.g:9506:1: ( 'if' ) + // InternalScope.g:9507:2: 'if' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); - } - // InternalScope.g:9295:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) - // InternalScope.g:9295:3: rule__ListLiteral__ElementsAssignment_2_0 - { - pushFollow(FOLLOW_2); - rule__ListLiteral__ElementsAssignment_2_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } - + match(input,97,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + after(grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); } } @@ -30715,21 +33162,26 @@ public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__0__Impl" - // $ANTLR start "rule__ListLiteral__Group_2__1" - // InternalScope.g:9303:1: rule__ListLiteral__Group_2__1 : rule__ListLiteral__Group_2__1__Impl ; - public final void rule__ListLiteral__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__1" + // InternalScope.g:9516:1: rule__IfExpressionKw__Group__1 : rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ; + public final void rule__IfExpressionKw__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9307:1: ( rule__ListLiteral__Group_2__1__Impl ) - // InternalScope.g:9308:2: rule__ListLiteral__Group_2__1__Impl + // InternalScope.g:9520:1: ( rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 ) + // InternalScope.g:9521:2: rule__IfExpressionKw__Group__1__Impl rule__IfExpressionKw__Group__2 { + pushFollow(FOLLOW_52); + rule__IfExpressionKw__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2__1__Impl(); + rule__IfExpressionKw__Group__2(); state._fsp--; if (state.failed) return ; @@ -30748,56 +33200,38 @@ public final void rule__ListLiteral__Group_2__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__1" + // $ANTLR end "rule__IfExpressionKw__Group__1" - // $ANTLR start "rule__ListLiteral__Group_2__1__Impl" - // InternalScope.g:9314:1: rule__ListLiteral__Group_2__1__Impl : ( ( rule__ListLiteral__Group_2_1__0 )* ) ; - public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__1__Impl" + // InternalScope.g:9528:1: rule__IfExpressionKw__Group__1__Impl : ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ; + public final void rule__IfExpressionKw__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9318:1: ( ( ( rule__ListLiteral__Group_2_1__0 )* ) ) - // InternalScope.g:9319:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + // InternalScope.g:9532:1: ( ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) ) + // InternalScope.g:9533:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) { - // InternalScope.g:9319:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) - // InternalScope.g:9320:2: ( rule__ListLiteral__Group_2_1__0 )* + // InternalScope.g:9533:1: ( ( rule__IfExpressionKw__ConditionAssignment_1 ) ) + // InternalScope.g:9534:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getGroup_2_1()); + before(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } - // InternalScope.g:9321:2: ( rule__ListLiteral__Group_2_1__0 )* - loop72: - do { - int alt72=2; - int LA72_0 = input.LA(1); - - if ( (LA72_0==60) ) { - alt72=1; - } - - - switch (alt72) { - case 1 : - // InternalScope.g:9321:3: rule__ListLiteral__Group_2_1__0 - { - pushFollow(FOLLOW_39); - rule__ListLiteral__Group_2_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:9535:2: ( rule__IfExpressionKw__ConditionAssignment_1 ) + // InternalScope.g:9535:3: rule__IfExpressionKw__ConditionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__ConditionAssignment_1(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop72; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getGroup_2_1()); + after(grammarAccess.getIfExpressionKwAccess().getConditionAssignment_1()); } } @@ -30817,26 +33251,26 @@ public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionExcept } return ; } - // $ANTLR end "rule__ListLiteral__Group_2__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__1__Impl" - // $ANTLR start "rule__ListLiteral__Group_2_1__0" - // InternalScope.g:9330:1: rule__ListLiteral__Group_2_1__0 : rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ; - public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__2" + // InternalScope.g:9543:1: rule__IfExpressionKw__Group__2 : rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ; + public final void rule__IfExpressionKw__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9334:1: ( rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ) - // InternalScope.g:9335:2: rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 + // InternalScope.g:9547:1: ( rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 ) + // InternalScope.g:9548:2: rule__IfExpressionKw__Group__2__Impl rule__IfExpressionKw__Group__3 { pushFollow(FOLLOW_17); - rule__ListLiteral__Group_2_1__0__Impl(); + rule__IfExpressionKw__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2_1__1(); + rule__IfExpressionKw__Group__3(); state._fsp--; if (state.failed) return ; @@ -30855,28 +33289,28 @@ public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__0" + // $ANTLR end "rule__IfExpressionKw__Group__2" - // $ANTLR start "rule__ListLiteral__Group_2_1__0__Impl" - // InternalScope.g:9342:1: rule__ListLiteral__Group_2_1__0__Impl : ( ',' ) ; - public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__2__Impl" + // InternalScope.g:9555:1: rule__IfExpressionKw__Group__2__Impl : ( 'then' ) ; + public final void rule__IfExpressionKw__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9346:1: ( ( ',' ) ) - // InternalScope.g:9347:1: ( ',' ) + // InternalScope.g:9559:1: ( ( 'then' ) ) + // InternalScope.g:9560:1: ( 'then' ) { - // InternalScope.g:9347:1: ( ',' ) - // InternalScope.g:9348:2: ',' + // InternalScope.g:9560:1: ( 'then' ) + // InternalScope.g:9561:2: 'then' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + before(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } - match(input,60,FOLLOW_2); if (state.failed) return ; + match(input,98,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + after(grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); } } @@ -30896,21 +33330,26 @@ public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__2__Impl" - // $ANTLR start "rule__ListLiteral__Group_2_1__1" - // InternalScope.g:9357:1: rule__ListLiteral__Group_2_1__1 : rule__ListLiteral__Group_2_1__1__Impl ; - public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__3" + // InternalScope.g:9570:1: rule__IfExpressionKw__Group__3 : rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ; + public final void rule__IfExpressionKw__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9361:1: ( rule__ListLiteral__Group_2_1__1__Impl ) - // InternalScope.g:9362:2: rule__ListLiteral__Group_2_1__1__Impl + // InternalScope.g:9574:1: ( rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 ) + // InternalScope.g:9575:2: rule__IfExpressionKw__Group__3__Impl rule__IfExpressionKw__Group__4 { + pushFollow(FOLLOW_53); + rule__IfExpressionKw__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ListLiteral__Group_2_1__1__Impl(); + rule__IfExpressionKw__Group__4(); state._fsp--; if (state.failed) return ; @@ -30929,30 +33368,30 @@ public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__1" + // $ANTLR end "rule__IfExpressionKw__Group__3" - // $ANTLR start "rule__ListLiteral__Group_2_1__1__Impl" - // InternalScope.g:9368:1: rule__ListLiteral__Group_2_1__1__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ; - public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__3__Impl" + // InternalScope.g:9582:1: rule__IfExpressionKw__Group__3__Impl : ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ; + public final void rule__IfExpressionKw__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9372:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ) - // InternalScope.g:9373:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + // InternalScope.g:9586:1: ( ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) ) + // InternalScope.g:9587:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) { - // InternalScope.g:9373:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) - // InternalScope.g:9374:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + // InternalScope.g:9587:1: ( ( rule__IfExpressionKw__ThenPartAssignment_3 ) ) + // InternalScope.g:9588:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + before(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } - // InternalScope.g:9375:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) - // InternalScope.g:9375:3: rule__ListLiteral__ElementsAssignment_2_1_1 + // InternalScope.g:9589:2: ( rule__IfExpressionKw__ThenPartAssignment_3 ) + // InternalScope.g:9589:3: rule__IfExpressionKw__ThenPartAssignment_3 { pushFollow(FOLLOW_2); - rule__ListLiteral__ElementsAssignment_2_1_1(); + rule__IfExpressionKw__ThenPartAssignment_3(); state._fsp--; if (state.failed) return ; @@ -30960,7 +33399,7 @@ public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionExce } if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + after(grammarAccess.getIfExpressionKwAccess().getThenPartAssignment_3()); } } @@ -30980,26 +33419,21 @@ public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionExce } return ; } - // $ANTLR end "rule__ListLiteral__Group_2_1__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__3__Impl" - // $ANTLR start "rule__ConstructorCallExpression__Group__0" - // InternalScope.g:9384:1: rule__ConstructorCallExpression__Group__0 : rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ; - public final void rule__ConstructorCallExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__4" + // InternalScope.g:9597:1: rule__IfExpressionKw__Group__4 : rule__IfExpressionKw__Group__4__Impl ; + public final void rule__IfExpressionKw__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9388:1: ( rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ) - // InternalScope.g:9389:2: rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 + // InternalScope.g:9601:1: ( rule__IfExpressionKw__Group__4__Impl ) + // InternalScope.g:9602:2: rule__IfExpressionKw__Group__4__Impl { - pushFollow(FOLLOW_48); - rule__ConstructorCallExpression__Group__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__Group__1(); + rule__IfExpressionKw__Group__4__Impl(); state._fsp--; if (state.failed) return ; @@ -31018,28 +33452,53 @@ public final void rule__ConstructorCallExpression__Group__0() throws Recognition } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__0" + // $ANTLR end "rule__IfExpressionKw__Group__4" - // $ANTLR start "rule__ConstructorCallExpression__Group__0__Impl" - // InternalScope.g:9396:1: rule__ConstructorCallExpression__Group__0__Impl : ( 'new' ) ; - public final void rule__ConstructorCallExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group__4__Impl" + // InternalScope.g:9608:1: rule__IfExpressionKw__Group__4__Impl : ( ( rule__IfExpressionKw__Group_4__0 )? ) ; + public final void rule__IfExpressionKw__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9400:1: ( ( 'new' ) ) - // InternalScope.g:9401:1: ( 'new' ) + // InternalScope.g:9612:1: ( ( ( rule__IfExpressionKw__Group_4__0 )? ) ) + // InternalScope.g:9613:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) { - // InternalScope.g:9401:1: ( 'new' ) - // InternalScope.g:9402:2: 'new' + // InternalScope.g:9613:1: ( ( rule__IfExpressionKw__Group_4__0 )? ) + // InternalScope.g:9614:2: ( rule__IfExpressionKw__Group_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + before(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } - match(input,79,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:9615:2: ( rule__IfExpressionKw__Group_4__0 )? + int alt96=2; + int LA96_0 = input.LA(1); + + if ( (LA96_0==99) ) { + int LA96_1 = input.LA(2); + + if ( (synpred171_InternalScope()) ) { + alt96=1; + } + } + switch (alt96) { + case 1 : + // InternalScope.g:9615:3: rule__IfExpressionKw__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + after(grammarAccess.getIfExpressionKwAccess().getGroup_4()); } } @@ -31059,21 +33518,21 @@ public final void rule__ConstructorCallExpression__Group__0__Impl() throws Recog } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group__4__Impl" - // $ANTLR start "rule__ConstructorCallExpression__Group__1" - // InternalScope.g:9411:1: rule__ConstructorCallExpression__Group__1 : rule__ConstructorCallExpression__Group__1__Impl ; - public final void rule__ConstructorCallExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4__0" + // InternalScope.g:9624:1: rule__IfExpressionKw__Group_4__0 : rule__IfExpressionKw__Group_4__0__Impl ; + public final void rule__IfExpressionKw__Group_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9415:1: ( rule__ConstructorCallExpression__Group__1__Impl ) - // InternalScope.g:9416:2: rule__ConstructorCallExpression__Group__1__Impl + // InternalScope.g:9628:1: ( rule__IfExpressionKw__Group_4__0__Impl ) + // InternalScope.g:9629:2: rule__IfExpressionKw__Group_4__0__Impl { pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__Group__1__Impl(); + rule__IfExpressionKw__Group_4__0__Impl(); state._fsp--; if (state.failed) return ; @@ -31092,30 +33551,30 @@ public final void rule__ConstructorCallExpression__Group__1() throws Recognition } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__1" + // $ANTLR end "rule__IfExpressionKw__Group_4__0" - // $ANTLR start "rule__ConstructorCallExpression__Group__1__Impl" - // InternalScope.g:9422:1: rule__ConstructorCallExpression__Group__1__Impl : ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ; - public final void rule__ConstructorCallExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4__0__Impl" + // InternalScope.g:9635:1: rule__IfExpressionKw__Group_4__0__Impl : ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ; + public final void rule__IfExpressionKw__Group_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9426:1: ( ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ) - // InternalScope.g:9427:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + // InternalScope.g:9639:1: ( ( ( rule__IfExpressionKw__Group_4_0__0 ) ) ) + // InternalScope.g:9640:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) { - // InternalScope.g:9427:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) - // InternalScope.g:9428:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + // InternalScope.g:9640:1: ( ( rule__IfExpressionKw__Group_4_0__0 ) ) + // InternalScope.g:9641:2: ( rule__IfExpressionKw__Group_4_0__0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + before(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } - // InternalScope.g:9429:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) - // InternalScope.g:9429:3: rule__ConstructorCallExpression__TypeAssignment_1 + // InternalScope.g:9642:2: ( rule__IfExpressionKw__Group_4_0__0 ) + // InternalScope.g:9642:3: rule__IfExpressionKw__Group_4_0__0 { pushFollow(FOLLOW_2); - rule__ConstructorCallExpression__TypeAssignment_1(); + rule__IfExpressionKw__Group_4_0__0(); state._fsp--; if (state.failed) return ; @@ -31123,7 +33582,7 @@ public final void rule__ConstructorCallExpression__Group__1__Impl() throws Recog } if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + after(grammarAccess.getIfExpressionKwAccess().getGroup_4_0()); } } @@ -31143,26 +33602,26 @@ public final void rule__ConstructorCallExpression__Group__1__Impl() throws Recog } return ; } - // $ANTLR end "rule__ConstructorCallExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4__0__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__0" - // InternalScope.g:9438:1: rule__TypeSelectExpression__Group__0 : rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ; - public final void rule__TypeSelectExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__0" + // InternalScope.g:9651:1: rule__IfExpressionKw__Group_4_0__0 : rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ; + public final void rule__IfExpressionKw__Group_4_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9442:1: ( rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ) - // InternalScope.g:9443:2: rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 + // InternalScope.g:9655:1: ( rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 ) + // InternalScope.g:9656:2: rule__IfExpressionKw__Group_4_0__0__Impl rule__IfExpressionKw__Group_4_0__1 { - pushFollow(FOLLOW_31); - rule__TypeSelectExpression__Group__0__Impl(); + pushFollow(FOLLOW_17); + rule__IfExpressionKw__Group_4_0__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__1(); + rule__IfExpressionKw__Group_4_0__1(); state._fsp--; if (state.failed) return ; @@ -31181,38 +33640,28 @@ public final void rule__TypeSelectExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__0" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__0" - // $ANTLR start "rule__TypeSelectExpression__Group__0__Impl" - // InternalScope.g:9450:1: rule__TypeSelectExpression__Group__0__Impl : ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ; - public final void rule__TypeSelectExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__0__Impl" + // InternalScope.g:9663:1: rule__IfExpressionKw__Group_4_0__0__Impl : ( 'else' ) ; + public final void rule__IfExpressionKw__Group_4_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9454:1: ( ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ) - // InternalScope.g:9455:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + // InternalScope.g:9667:1: ( ( 'else' ) ) + // InternalScope.g:9668:1: ( 'else' ) { - // InternalScope.g:9455:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) - // InternalScope.g:9456:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + // InternalScope.g:9668:1: ( 'else' ) + // InternalScope.g:9669:2: 'else' { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); - } - // InternalScope.g:9457:2: ( rule__TypeSelectExpression__NameAssignment_0 ) - // InternalScope.g:9457:3: rule__TypeSelectExpression__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__TypeSelectExpression__NameAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } - + match(input,99,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); } } @@ -31232,26 +33681,21 @@ public final void rule__TypeSelectExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__0__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__0__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__1" - // InternalScope.g:9465:1: rule__TypeSelectExpression__Group__1 : rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ; - public final void rule__TypeSelectExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__1" + // InternalScope.g:9678:1: rule__IfExpressionKw__Group_4_0__1 : rule__IfExpressionKw__Group_4_0__1__Impl ; + public final void rule__IfExpressionKw__Group_4_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9469:1: ( rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ) - // InternalScope.g:9470:2: rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 + // InternalScope.g:9682:1: ( rule__IfExpressionKw__Group_4_0__1__Impl ) + // InternalScope.g:9683:2: rule__IfExpressionKw__Group_4_0__1__Impl { - pushFollow(FOLLOW_48); - rule__TypeSelectExpression__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__2(); + rule__IfExpressionKw__Group_4_0__1__Impl(); state._fsp--; if (state.failed) return ; @@ -31270,28 +33714,38 @@ public final void rule__TypeSelectExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__1" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__1" - // $ANTLR start "rule__TypeSelectExpression__Group__1__Impl" - // InternalScope.g:9477:1: rule__TypeSelectExpression__Group__1__Impl : ( '(' ) ; - public final void rule__TypeSelectExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__IfExpressionKw__Group_4_0__1__Impl" + // InternalScope.g:9689:1: rule__IfExpressionKw__Group_4_0__1__Impl : ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ; + public final void rule__IfExpressionKw__Group_4_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9481:1: ( ( '(' ) ) - // InternalScope.g:9482:1: ( '(' ) + // InternalScope.g:9693:1: ( ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) ) + // InternalScope.g:9694:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) { - // InternalScope.g:9482:1: ( '(' ) - // InternalScope.g:9483:2: '(' + // InternalScope.g:9694:1: ( ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) ) + // InternalScope.g:9695:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:9696:2: ( rule__IfExpressionKw__ElsePartAssignment_4_0_1 ) + // InternalScope.g:9696:3: rule__IfExpressionKw__ElsePartAssignment_4_0_1 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__ElsePartAssignment_4_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getIfExpressionKwAccess().getElsePartAssignment_4_0_1()); } } @@ -31311,26 +33765,26 @@ public final void rule__TypeSelectExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__1__Impl" + // $ANTLR end "rule__IfExpressionKw__Group_4_0__1__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__2" - // InternalScope.g:9492:1: rule__TypeSelectExpression__Group__2 : rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ; - public final void rule__TypeSelectExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__0" + // InternalScope.g:9705:1: rule__SwitchExpression__Group__0 : rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ; + public final void rule__SwitchExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9496:1: ( rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ) - // InternalScope.g:9497:2: rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 + // InternalScope.g:9709:1: ( rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 ) + // InternalScope.g:9710:2: rule__SwitchExpression__Group__0__Impl rule__SwitchExpression__Group__1 { - pushFollow(FOLLOW_23); - rule__TypeSelectExpression__Group__2__Impl(); + pushFollow(FOLLOW_54); + rule__SwitchExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__3(); + rule__SwitchExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -31349,38 +33803,28 @@ public final void rule__TypeSelectExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__2" + // $ANTLR end "rule__SwitchExpression__Group__0" - // $ANTLR start "rule__TypeSelectExpression__Group__2__Impl" - // InternalScope.g:9504:1: rule__TypeSelectExpression__Group__2__Impl : ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ; - public final void rule__TypeSelectExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__0__Impl" + // InternalScope.g:9717:1: rule__SwitchExpression__Group__0__Impl : ( 'switch' ) ; + public final void rule__SwitchExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9508:1: ( ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ) - // InternalScope.g:9509:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + // InternalScope.g:9721:1: ( ( 'switch' ) ) + // InternalScope.g:9722:1: ( 'switch' ) { - // InternalScope.g:9509:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) - // InternalScope.g:9510:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + // InternalScope.g:9722:1: ( 'switch' ) + // InternalScope.g:9723:2: 'switch' { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); - } - // InternalScope.g:9511:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) - // InternalScope.g:9511:3: rule__TypeSelectExpression__TypeAssignment_2 - { - pushFollow(FOLLOW_2); - rule__TypeSelectExpression__TypeAssignment_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } - + match(input,100,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + after(grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); } } @@ -31400,21 +33844,26 @@ public final void rule__TypeSelectExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__2__Impl" + // $ANTLR end "rule__SwitchExpression__Group__0__Impl" - // $ANTLR start "rule__TypeSelectExpression__Group__3" - // InternalScope.g:9519:1: rule__TypeSelectExpression__Group__3 : rule__TypeSelectExpression__Group__3__Impl ; - public final void rule__TypeSelectExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__1" + // InternalScope.g:9732:1: rule__SwitchExpression__Group__1 : rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ; + public final void rule__SwitchExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9523:1: ( rule__TypeSelectExpression__Group__3__Impl ) - // InternalScope.g:9524:2: rule__TypeSelectExpression__Group__3__Impl + // InternalScope.g:9736:1: ( rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 ) + // InternalScope.g:9737:2: rule__SwitchExpression__Group__1__Impl rule__SwitchExpression__Group__2 { + pushFollow(FOLLOW_54); + rule__SwitchExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__TypeSelectExpression__Group__3__Impl(); + rule__SwitchExpression__Group__2(); state._fsp--; if (state.failed) return ; @@ -31433,28 +33882,49 @@ public final void rule__TypeSelectExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__3" + // $ANTLR end "rule__SwitchExpression__Group__1" - // $ANTLR start "rule__TypeSelectExpression__Group__3__Impl" - // InternalScope.g:9530:1: rule__TypeSelectExpression__Group__3__Impl : ( ')' ) ; - public final void rule__TypeSelectExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__1__Impl" + // InternalScope.g:9744:1: rule__SwitchExpression__Group__1__Impl : ( ( rule__SwitchExpression__Group_1__0 )? ) ; + public final void rule__SwitchExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9534:1: ( ( ')' ) ) - // InternalScope.g:9535:1: ( ')' ) + // InternalScope.g:9748:1: ( ( ( rule__SwitchExpression__Group_1__0 )? ) ) + // InternalScope.g:9749:1: ( ( rule__SwitchExpression__Group_1__0 )? ) { - // InternalScope.g:9535:1: ( ')' ) - // InternalScope.g:9536:2: ')' + // InternalScope.g:9749:1: ( ( rule__SwitchExpression__Group_1__0 )? ) + // InternalScope.g:9750:2: ( rule__SwitchExpression__Group_1__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + before(grammarAccess.getSwitchExpressionAccess().getGroup_1()); + } + // InternalScope.g:9751:2: ( rule__SwitchExpression__Group_1__0 )? + int alt97=2; + int LA97_0 = input.LA(1); + + if ( (LA97_0==77) ) { + alt97=1; } - match(input,52,FOLLOW_2); if (state.failed) return ; + switch (alt97) { + case 1 : + // InternalScope.g:9751:3: rule__SwitchExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__SwitchExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + after(grammarAccess.getSwitchExpressionAccess().getGroup_1()); } } @@ -31474,26 +33944,26 @@ public final void rule__TypeSelectExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__TypeSelectExpression__Group__3__Impl" + // $ANTLR end "rule__SwitchExpression__Group__1__Impl" - // $ANTLR start "rule__CollectionExpression__Group__0" - // InternalScope.g:9546:1: rule__CollectionExpression__Group__0 : rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ; - public final void rule__CollectionExpression__Group__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__2" + // InternalScope.g:9759:1: rule__SwitchExpression__Group__2 : rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ; + public final void rule__SwitchExpression__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9550:1: ( rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ) - // InternalScope.g:9551:2: rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 + // InternalScope.g:9763:1: ( rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 ) + // InternalScope.g:9764:2: rule__SwitchExpression__Group__2__Impl rule__SwitchExpression__Group__3 { - pushFollow(FOLLOW_31); - rule__CollectionExpression__Group__0__Impl(); + pushFollow(FOLLOW_55); + rule__SwitchExpression__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__1(); + rule__SwitchExpression__Group__3(); state._fsp--; if (state.failed) return ; @@ -31512,38 +33982,28 @@ public final void rule__CollectionExpression__Group__0() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__0" + // $ANTLR end "rule__SwitchExpression__Group__2" - // $ANTLR start "rule__CollectionExpression__Group__0__Impl" - // InternalScope.g:9558:1: rule__CollectionExpression__Group__0__Impl : ( ( rule__CollectionExpression__NameAssignment_0 ) ) ; - public final void rule__CollectionExpression__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__2__Impl" + // InternalScope.g:9771:1: rule__SwitchExpression__Group__2__Impl : ( '{' ) ; + public final void rule__SwitchExpression__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9562:1: ( ( ( rule__CollectionExpression__NameAssignment_0 ) ) ) - // InternalScope.g:9563:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + // InternalScope.g:9775:1: ( ( '{' ) ) + // InternalScope.g:9776:1: ( '{' ) { - // InternalScope.g:9563:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) - // InternalScope.g:9564:2: ( rule__CollectionExpression__NameAssignment_0 ) + // InternalScope.g:9776:1: ( '{' ) + // InternalScope.g:9777:2: '{' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); - } - // InternalScope.g:9565:2: ( rule__CollectionExpression__NameAssignment_0 ) - // InternalScope.g:9565:3: rule__CollectionExpression__NameAssignment_0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__NameAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } - + match(input,72,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + after(grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); } } @@ -31563,26 +34023,26 @@ public final void rule__CollectionExpression__Group__0__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group__2__Impl" - // $ANTLR start "rule__CollectionExpression__Group__1" - // InternalScope.g:9573:1: rule__CollectionExpression__Group__1 : rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ; - public final void rule__CollectionExpression__Group__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__3" + // InternalScope.g:9786:1: rule__SwitchExpression__Group__3 : rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ; + public final void rule__SwitchExpression__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9577:1: ( rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ) - // InternalScope.g:9578:2: rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 + // InternalScope.g:9790:1: ( rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 ) + // InternalScope.g:9791:2: rule__SwitchExpression__Group__3__Impl rule__SwitchExpression__Group__4 { - pushFollow(FOLLOW_17); - rule__CollectionExpression__Group__1__Impl(); + pushFollow(FOLLOW_55); + rule__SwitchExpression__Group__3__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__2(); + rule__SwitchExpression__Group__4(); state._fsp--; if (state.failed) return ; @@ -31601,28 +34061,56 @@ public final void rule__CollectionExpression__Group__1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__1" + // $ANTLR end "rule__SwitchExpression__Group__3" - // $ANTLR start "rule__CollectionExpression__Group__1__Impl" - // InternalScope.g:9585:1: rule__CollectionExpression__Group__1__Impl : ( '(' ) ; - public final void rule__CollectionExpression__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__3__Impl" + // InternalScope.g:9798:1: rule__SwitchExpression__Group__3__Impl : ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ; + public final void rule__SwitchExpression__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9589:1: ( ( '(' ) ) - // InternalScope.g:9590:1: ( '(' ) + // InternalScope.g:9802:1: ( ( ( rule__SwitchExpression__CaseAssignment_3 )* ) ) + // InternalScope.g:9803:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) { - // InternalScope.g:9590:1: ( '(' ) - // InternalScope.g:9591:2: '(' + // InternalScope.g:9803:1: ( ( rule__SwitchExpression__CaseAssignment_3 )* ) + // InternalScope.g:9804:2: ( rule__SwitchExpression__CaseAssignment_3 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + before(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } - match(input,51,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:9805:2: ( rule__SwitchExpression__CaseAssignment_3 )* + loop98: + do { + int alt98=2; + int LA98_0 = input.LA(1); + + if ( (LA98_0==74) ) { + alt98=1; + } + + + switch (alt98) { + case 1 : + // InternalScope.g:9805:3: rule__SwitchExpression__CaseAssignment_3 + { + pushFollow(FOLLOW_56); + rule__SwitchExpression__CaseAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop98; + } + } while (true); + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + after(grammarAccess.getSwitchExpressionAccess().getCaseAssignment_3()); } } @@ -31642,26 +34130,26 @@ public final void rule__CollectionExpression__Group__1__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group__3__Impl" - // $ANTLR start "rule__CollectionExpression__Group__2" - // InternalScope.g:9600:1: rule__CollectionExpression__Group__2 : rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ; - public final void rule__CollectionExpression__Group__2() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__4" + // InternalScope.g:9813:1: rule__SwitchExpression__Group__4 : rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ; + public final void rule__SwitchExpression__Group__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9604:1: ( rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ) - // InternalScope.g:9605:2: rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 + // InternalScope.g:9817:1: ( rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 ) + // InternalScope.g:9818:2: rule__SwitchExpression__Group__4__Impl rule__SwitchExpression__Group__5 { - pushFollow(FOLLOW_17); - rule__CollectionExpression__Group__2__Impl(); + pushFollow(FOLLOW_47); + rule__SwitchExpression__Group__4__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__3(); + rule__SwitchExpression__Group__5(); state._fsp--; if (state.failed) return ; @@ -31680,53 +34168,28 @@ public final void rule__CollectionExpression__Group__2() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__2" + // $ANTLR end "rule__SwitchExpression__Group__4" - // $ANTLR start "rule__CollectionExpression__Group__2__Impl" - // InternalScope.g:9612:1: rule__CollectionExpression__Group__2__Impl : ( ( rule__CollectionExpression__Group_2__0 )? ) ; - public final void rule__CollectionExpression__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__4__Impl" + // InternalScope.g:9825:1: rule__SwitchExpression__Group__4__Impl : ( 'default' ) ; + public final void rule__SwitchExpression__Group__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9616:1: ( ( ( rule__CollectionExpression__Group_2__0 )? ) ) - // InternalScope.g:9617:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + // InternalScope.g:9829:1: ( ( 'default' ) ) + // InternalScope.g:9830:1: ( 'default' ) { - // InternalScope.g:9617:1: ( ( rule__CollectionExpression__Group_2__0 )? ) - // InternalScope.g:9618:2: ( rule__CollectionExpression__Group_2__0 )? + // InternalScope.g:9830:1: ( 'default' ) + // InternalScope.g:9831:2: 'default' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); - } - // InternalScope.g:9619:2: ( rule__CollectionExpression__Group_2__0 )? - int alt73=2; - int LA73_0 = input.LA(1); - - if ( (LA73_0==RULE_ID) ) { - int LA73_1 = input.LA(2); - - if ( (LA73_1==66) ) { - alt73=1; - } - } - switch (alt73) { - case 1 : - // InternalScope.g:9619:3: rule__CollectionExpression__Group_2__0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__0(); - - state._fsp--; - if (state.failed) return ; - - } - break; - + before(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - + match(input,101,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + after(grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } } @@ -31746,26 +34209,26 @@ public final void rule__CollectionExpression__Group__2__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__2__Impl" + // $ANTLR end "rule__SwitchExpression__Group__4__Impl" - // $ANTLR start "rule__CollectionExpression__Group__3" - // InternalScope.g:9627:1: rule__CollectionExpression__Group__3 : rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ; - public final void rule__CollectionExpression__Group__3() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__5" + // InternalScope.g:9840:1: rule__SwitchExpression__Group__5 : rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ; + public final void rule__SwitchExpression__Group__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9631:1: ( rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ) - // InternalScope.g:9632:2: rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 + // InternalScope.g:9844:1: ( rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 ) + // InternalScope.g:9845:2: rule__SwitchExpression__Group__5__Impl rule__SwitchExpression__Group__6 { - pushFollow(FOLLOW_23); - rule__CollectionExpression__Group__3__Impl(); + pushFollow(FOLLOW_57); + rule__SwitchExpression__Group__5__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__4(); + rule__SwitchExpression__Group__6(); state._fsp--; if (state.failed) return ; @@ -31784,38 +34247,28 @@ public final void rule__CollectionExpression__Group__3() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__3" + // $ANTLR end "rule__SwitchExpression__Group__5" - // $ANTLR start "rule__CollectionExpression__Group__3__Impl" - // InternalScope.g:9639:1: rule__CollectionExpression__Group__3__Impl : ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ; - public final void rule__CollectionExpression__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__5__Impl" + // InternalScope.g:9852:1: rule__SwitchExpression__Group__5__Impl : ( ':' ) ; + public final void rule__SwitchExpression__Group__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9643:1: ( ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ) - // InternalScope.g:9644:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + // InternalScope.g:9856:1: ( ( ':' ) ) + // InternalScope.g:9857:1: ( ':' ) { - // InternalScope.g:9644:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) - // InternalScope.g:9645:2: ( rule__CollectionExpression__ExpAssignment_3 ) + // InternalScope.g:9857:1: ( ':' ) + // InternalScope.g:9858:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); - } - // InternalScope.g:9646:2: ( rule__CollectionExpression__ExpAssignment_3 ) - // InternalScope.g:9646:3: rule__CollectionExpression__ExpAssignment_3 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__ExpAssignment_3(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } - + match(input,95,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + after(grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); } } @@ -31835,21 +34288,26 @@ public final void rule__CollectionExpression__Group__3__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__3__Impl" + // $ANTLR end "rule__SwitchExpression__Group__5__Impl" - // $ANTLR start "rule__CollectionExpression__Group__4" - // InternalScope.g:9654:1: rule__CollectionExpression__Group__4 : rule__CollectionExpression__Group__4__Impl ; - public final void rule__CollectionExpression__Group__4() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__6" + // InternalScope.g:9867:1: rule__SwitchExpression__Group__6 : rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ; + public final void rule__SwitchExpression__Group__6() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9658:1: ( rule__CollectionExpression__Group__4__Impl ) - // InternalScope.g:9659:2: rule__CollectionExpression__Group__4__Impl + // InternalScope.g:9871:1: ( rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 ) + // InternalScope.g:9872:2: rule__SwitchExpression__Group__6__Impl rule__SwitchExpression__Group__7 { + pushFollow(FOLLOW_21); + rule__SwitchExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group__4__Impl(); + rule__SwitchExpression__Group__7(); state._fsp--; if (state.failed) return ; @@ -31868,28 +34326,38 @@ public final void rule__CollectionExpression__Group__4() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionExpression__Group__4" + // $ANTLR end "rule__SwitchExpression__Group__6" - // $ANTLR start "rule__CollectionExpression__Group__4__Impl" - // InternalScope.g:9665:1: rule__CollectionExpression__Group__4__Impl : ( ')' ) ; - public final void rule__CollectionExpression__Group__4__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__6__Impl" + // InternalScope.g:9879:1: rule__SwitchExpression__Group__6__Impl : ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ; + public final void rule__SwitchExpression__Group__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9669:1: ( ( ')' ) ) - // InternalScope.g:9670:1: ( ')' ) + // InternalScope.g:9883:1: ( ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) ) + // InternalScope.g:9884:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) { - // InternalScope.g:9670:1: ( ')' ) - // InternalScope.g:9671:2: ')' + // InternalScope.g:9884:1: ( ( rule__SwitchExpression__DefaultExprAssignment_6 ) ) + // InternalScope.g:9885:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + before(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); + } + // InternalScope.g:9886:2: ( rule__SwitchExpression__DefaultExprAssignment_6 ) + // InternalScope.g:9886:3: rule__SwitchExpression__DefaultExprAssignment_6 + { + pushFollow(FOLLOW_2); + rule__SwitchExpression__DefaultExprAssignment_6(); + + state._fsp--; + if (state.failed) return ; + } - match(input,52,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + after(grammarAccess.getSwitchExpressionAccess().getDefaultExprAssignment_6()); } } @@ -31909,26 +34377,21 @@ public final void rule__CollectionExpression__Group__4__Impl() throws Recognitio } return ; } - // $ANTLR end "rule__CollectionExpression__Group__4__Impl" + // $ANTLR end "rule__SwitchExpression__Group__6__Impl" - // $ANTLR start "rule__CollectionExpression__Group_2__0" - // InternalScope.g:9681:1: rule__CollectionExpression__Group_2__0 : rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ; - public final void rule__CollectionExpression__Group_2__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__7" + // InternalScope.g:9894:1: rule__SwitchExpression__Group__7 : rule__SwitchExpression__Group__7__Impl ; + public final void rule__SwitchExpression__Group__7() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9685:1: ( rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ) - // InternalScope.g:9686:2: rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 + // InternalScope.g:9898:1: ( rule__SwitchExpression__Group__7__Impl ) + // InternalScope.g:9899:2: rule__SwitchExpression__Group__7__Impl { - pushFollow(FOLLOW_42); - rule__CollectionExpression__Group_2__0__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__1(); + rule__SwitchExpression__Group__7__Impl(); state._fsp--; if (state.failed) return ; @@ -31947,38 +34410,28 @@ public final void rule__CollectionExpression__Group_2__0() throws RecognitionExc } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__0" + // $ANTLR end "rule__SwitchExpression__Group__7" - // $ANTLR start "rule__CollectionExpression__Group_2__0__Impl" - // InternalScope.g:9693:1: rule__CollectionExpression__Group_2__0__Impl : ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ; - public final void rule__CollectionExpression__Group_2__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group__7__Impl" + // InternalScope.g:9905:1: rule__SwitchExpression__Group__7__Impl : ( '}' ) ; + public final void rule__SwitchExpression__Group__7__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9697:1: ( ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ) - // InternalScope.g:9698:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + // InternalScope.g:9909:1: ( ( '}' ) ) + // InternalScope.g:9910:1: ( '}' ) { - // InternalScope.g:9698:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) - // InternalScope.g:9699:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + // InternalScope.g:9910:1: ( '}' ) + // InternalScope.g:9911:2: '}' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); - } - // InternalScope.g:9700:2: ( rule__CollectionExpression__VarAssignment_2_0 ) - // InternalScope.g:9700:3: rule__CollectionExpression__VarAssignment_2_0 - { - pushFollow(FOLLOW_2); - rule__CollectionExpression__VarAssignment_2_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } - + match(input,73,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + after(grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); } } @@ -31998,21 +34451,26 @@ public final void rule__CollectionExpression__Group_2__0__Impl() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group__7__Impl" - // $ANTLR start "rule__CollectionExpression__Group_2__1" - // InternalScope.g:9708:1: rule__CollectionExpression__Group_2__1 : rule__CollectionExpression__Group_2__1__Impl ; - public final void rule__CollectionExpression__Group_2__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__0" + // InternalScope.g:9921:1: rule__SwitchExpression__Group_1__0 : rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ; + public final void rule__SwitchExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9712:1: ( rule__CollectionExpression__Group_2__1__Impl ) - // InternalScope.g:9713:2: rule__CollectionExpression__Group_2__1__Impl + // InternalScope.g:9925:1: ( rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 ) + // InternalScope.g:9926:2: rule__SwitchExpression__Group_1__0__Impl rule__SwitchExpression__Group_1__1 { + pushFollow(FOLLOW_57); + rule__SwitchExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__Group_2__1__Impl(); + rule__SwitchExpression__Group_1__1(); state._fsp--; if (state.failed) return ; @@ -32031,28 +34489,28 @@ public final void rule__CollectionExpression__Group_2__1() throws RecognitionExc } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__1" + // $ANTLR end "rule__SwitchExpression__Group_1__0" - // $ANTLR start "rule__CollectionExpression__Group_2__1__Impl" - // InternalScope.g:9719:1: rule__CollectionExpression__Group_2__1__Impl : ( '|' ) ; - public final void rule__CollectionExpression__Group_2__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__0__Impl" + // InternalScope.g:9933:1: rule__SwitchExpression__Group_1__0__Impl : ( '(' ) ; + public final void rule__SwitchExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9723:1: ( ( '|' ) ) - // InternalScope.g:9724:1: ( '|' ) + // InternalScope.g:9937:1: ( ( '(' ) ) + // InternalScope.g:9938:1: ( '(' ) { - // InternalScope.g:9724:1: ( '|' ) - // InternalScope.g:9725:2: '|' + // InternalScope.g:9938:1: ( '(' ) + // InternalScope.g:9939:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + before(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } - match(input,66,FOLLOW_2); if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + after(grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); } } @@ -32072,26 +34530,26 @@ public final void rule__CollectionExpression__Group_2__1__Impl() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__Group_2__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group_1__0__Impl" - // $ANTLR start "rule__CollectionType__Group__0" - // InternalScope.g:9735:1: rule__CollectionType__Group__0 : rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ; - public final void rule__CollectionType__Group__0() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__1" + // InternalScope.g:9948:1: rule__SwitchExpression__Group_1__1 : rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ; + public final void rule__SwitchExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9739:1: ( rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ) - // InternalScope.g:9740:2: rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 + // InternalScope.g:9952:1: ( rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 ) + // InternalScope.g:9953:2: rule__SwitchExpression__Group_1__1__Impl rule__SwitchExpression__Group_1__2 { - pushFollow(FOLLOW_29); - rule__CollectionType__Group__0__Impl(); + pushFollow(FOLLOW_23); + rule__SwitchExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__1(); + rule__SwitchExpression__Group_1__2(); state._fsp--; if (state.failed) return ; @@ -32110,30 +34568,30 @@ public final void rule__CollectionType__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__0" + // $ANTLR end "rule__SwitchExpression__Group_1__1" - // $ANTLR start "rule__CollectionType__Group__0__Impl" - // InternalScope.g:9747:1: rule__CollectionType__Group__0__Impl : ( ( rule__CollectionType__ClAssignment_0 ) ) ; - public final void rule__CollectionType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__1__Impl" + // InternalScope.g:9960:1: rule__SwitchExpression__Group_1__1__Impl : ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ; + public final void rule__SwitchExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9751:1: ( ( ( rule__CollectionType__ClAssignment_0 ) ) ) - // InternalScope.g:9752:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + // InternalScope.g:9964:1: ( ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) ) + // InternalScope.g:9965:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) { - // InternalScope.g:9752:1: ( ( rule__CollectionType__ClAssignment_0 ) ) - // InternalScope.g:9753:2: ( rule__CollectionType__ClAssignment_0 ) + // InternalScope.g:9965:1: ( ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) ) + // InternalScope.g:9966:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + before(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } - // InternalScope.g:9754:2: ( rule__CollectionType__ClAssignment_0 ) - // InternalScope.g:9754:3: rule__CollectionType__ClAssignment_0 + // InternalScope.g:9967:2: ( rule__SwitchExpression__SwitchExprAssignment_1_1 ) + // InternalScope.g:9967:3: rule__SwitchExpression__SwitchExprAssignment_1_1 { pushFollow(FOLLOW_2); - rule__CollectionType__ClAssignment_0(); + rule__SwitchExpression__SwitchExprAssignment_1_1(); state._fsp--; if (state.failed) return ; @@ -32141,7 +34599,7 @@ public final void rule__CollectionType__Group__0__Impl() throws RecognitionExcep } if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + after(grammarAccess.getSwitchExpressionAccess().getSwitchExprAssignment_1_1()); } } @@ -32161,26 +34619,21 @@ public final void rule__CollectionType__Group__0__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__0__Impl" + // $ANTLR end "rule__SwitchExpression__Group_1__1__Impl" - // $ANTLR start "rule__CollectionType__Group__1" - // InternalScope.g:9762:1: rule__CollectionType__Group__1 : rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ; - public final void rule__CollectionType__Group__1() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__2" + // InternalScope.g:9975:1: rule__SwitchExpression__Group_1__2 : rule__SwitchExpression__Group_1__2__Impl ; + public final void rule__SwitchExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9766:1: ( rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ) - // InternalScope.g:9767:2: rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 + // InternalScope.g:9979:1: ( rule__SwitchExpression__Group_1__2__Impl ) + // InternalScope.g:9980:2: rule__SwitchExpression__Group_1__2__Impl { - pushFollow(FOLLOW_48); - rule__CollectionType__Group__1__Impl(); - - state._fsp--; - if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__2(); + rule__SwitchExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; @@ -32199,28 +34652,28 @@ public final void rule__CollectionType__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__1" + // $ANTLR end "rule__SwitchExpression__Group_1__2" - // $ANTLR start "rule__CollectionType__Group__1__Impl" - // InternalScope.g:9774:1: rule__CollectionType__Group__1__Impl : ( '[' ) ; - public final void rule__CollectionType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__SwitchExpression__Group_1__2__Impl" + // InternalScope.g:9986:1: rule__SwitchExpression__Group_1__2__Impl : ( ')' ) ; + public final void rule__SwitchExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9778:1: ( ( '[' ) ) - // InternalScope.g:9779:1: ( '[' ) + // InternalScope.g:9990:1: ( ( ')' ) ) + // InternalScope.g:9991:1: ( ')' ) { - // InternalScope.g:9779:1: ( '[' ) - // InternalScope.g:9780:2: '[' + // InternalScope.g:9991:1: ( ')' ) + // InternalScope.g:9992:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + before(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } - match(input,56,FOLLOW_2); if (state.failed) return ; + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + after(grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); } } @@ -32240,26 +34693,26 @@ public final void rule__CollectionType__Group__1__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__1__Impl" + // $ANTLR end "rule__SwitchExpression__Group_1__2__Impl" - // $ANTLR start "rule__CollectionType__Group__2" - // InternalScope.g:9789:1: rule__CollectionType__Group__2 : rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ; - public final void rule__CollectionType__Group__2() throws RecognitionException { + // $ANTLR start "rule__Case__Group__0" + // InternalScope.g:10002:1: rule__Case__Group__0 : rule__Case__Group__0__Impl rule__Case__Group__1 ; + public final void rule__Case__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9793:1: ( rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ) - // InternalScope.g:9794:2: rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 + // InternalScope.g:10006:1: ( rule__Case__Group__0__Impl rule__Case__Group__1 ) + // InternalScope.g:10007:2: rule__Case__Group__0__Impl rule__Case__Group__1 { - pushFollow(FOLLOW_30); - rule__CollectionType__Group__2__Impl(); + pushFollow(FOLLOW_57); + rule__Case__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__3(); + rule__Case__Group__1(); state._fsp--; if (state.failed) return ; @@ -32278,38 +34731,28 @@ public final void rule__CollectionType__Group__2() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__2" + // $ANTLR end "rule__Case__Group__0" - // $ANTLR start "rule__CollectionType__Group__2__Impl" - // InternalScope.g:9801:1: rule__CollectionType__Group__2__Impl : ( ( rule__CollectionType__Id1Assignment_2 ) ) ; - public final void rule__CollectionType__Group__2__Impl() throws RecognitionException { + // $ANTLR start "rule__Case__Group__0__Impl" + // InternalScope.g:10014:1: rule__Case__Group__0__Impl : ( 'case' ) ; + public final void rule__Case__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9805:1: ( ( ( rule__CollectionType__Id1Assignment_2 ) ) ) - // InternalScope.g:9806:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + // InternalScope.g:10018:1: ( ( 'case' ) ) + // InternalScope.g:10019:1: ( 'case' ) { - // InternalScope.g:9806:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) - // InternalScope.g:9807:2: ( rule__CollectionType__Id1Assignment_2 ) + // InternalScope.g:10019:1: ( 'case' ) + // InternalScope.g:10020:2: 'case' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); - } - // InternalScope.g:9808:2: ( rule__CollectionType__Id1Assignment_2 ) - // InternalScope.g:9808:3: rule__CollectionType__Id1Assignment_2 - { - pushFollow(FOLLOW_2); - rule__CollectionType__Id1Assignment_2(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getCaseAccess().getCaseKeyword_0()); } - + match(input,74,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + after(grammarAccess.getCaseAccess().getCaseKeyword_0()); } } @@ -32329,21 +34772,26 @@ public final void rule__CollectionType__Group__2__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__2__Impl" + // $ANTLR end "rule__Case__Group__0__Impl" - // $ANTLR start "rule__CollectionType__Group__3" - // InternalScope.g:9816:1: rule__CollectionType__Group__3 : rule__CollectionType__Group__3__Impl ; - public final void rule__CollectionType__Group__3() throws RecognitionException { + // $ANTLR start "rule__Case__Group__1" + // InternalScope.g:10029:1: rule__Case__Group__1 : rule__Case__Group__1__Impl rule__Case__Group__2 ; + public final void rule__Case__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9820:1: ( rule__CollectionType__Group__3__Impl ) - // InternalScope.g:9821:2: rule__CollectionType__Group__3__Impl + // InternalScope.g:10033:1: ( rule__Case__Group__1__Impl rule__Case__Group__2 ) + // InternalScope.g:10034:2: rule__Case__Group__1__Impl rule__Case__Group__2 { + pushFollow(FOLLOW_47); + rule__Case__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionType__Group__3__Impl(); + rule__Case__Group__2(); state._fsp--; if (state.failed) return ; @@ -32362,28 +34810,38 @@ public final void rule__CollectionType__Group__3() throws RecognitionException { } return ; } - // $ANTLR end "rule__CollectionType__Group__3" + // $ANTLR end "rule__Case__Group__1" - // $ANTLR start "rule__CollectionType__Group__3__Impl" - // InternalScope.g:9827:1: rule__CollectionType__Group__3__Impl : ( ']' ) ; - public final void rule__CollectionType__Group__3__Impl() throws RecognitionException { + // $ANTLR start "rule__Case__Group__1__Impl" + // InternalScope.g:10041:1: rule__Case__Group__1__Impl : ( ( rule__Case__ConditionAssignment_1 ) ) ; + public final void rule__Case__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9831:1: ( ( ']' ) ) - // InternalScope.g:9832:1: ( ']' ) + // InternalScope.g:10045:1: ( ( ( rule__Case__ConditionAssignment_1 ) ) ) + // InternalScope.g:10046:1: ( ( rule__Case__ConditionAssignment_1 ) ) { - // InternalScope.g:9832:1: ( ']' ) - // InternalScope.g:9833:2: ']' + // InternalScope.g:10046:1: ( ( rule__Case__ConditionAssignment_1 ) ) + // InternalScope.g:10047:2: ( rule__Case__ConditionAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + before(grammarAccess.getCaseAccess().getConditionAssignment_1()); + } + // InternalScope.g:10048:2: ( rule__Case__ConditionAssignment_1 ) + // InternalScope.g:10048:3: rule__Case__ConditionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__Case__ConditionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + } - match(input,57,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + after(grammarAccess.getCaseAccess().getConditionAssignment_1()); } } @@ -32403,26 +34861,26 @@ public final void rule__CollectionType__Group__3__Impl() throws RecognitionExcep } return ; } - // $ANTLR end "rule__CollectionType__Group__3__Impl" + // $ANTLR end "rule__Case__Group__1__Impl" - // $ANTLR start "rule__SimpleType__Group__0" - // InternalScope.g:9843:1: rule__SimpleType__Group__0 : rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ; - public final void rule__SimpleType__Group__0() throws RecognitionException { + // $ANTLR start "rule__Case__Group__2" + // InternalScope.g:10056:1: rule__Case__Group__2 : rule__Case__Group__2__Impl rule__Case__Group__3 ; + public final void rule__Case__Group__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9847:1: ( rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ) - // InternalScope.g:9848:2: rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 + // InternalScope.g:10060:1: ( rule__Case__Group__2__Impl rule__Case__Group__3 ) + // InternalScope.g:10061:2: rule__Case__Group__2__Impl rule__Case__Group__3 { - pushFollow(FOLLOW_43); - rule__SimpleType__Group__0__Impl(); + pushFollow(FOLLOW_57); + rule__Case__Group__2__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group__1(); + rule__Case__Group__3(); state._fsp--; if (state.failed) return ; @@ -32441,38 +34899,28 @@ public final void rule__SimpleType__Group__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group__0" + // $ANTLR end "rule__Case__Group__2" - // $ANTLR start "rule__SimpleType__Group__0__Impl" - // InternalScope.g:9855:1: rule__SimpleType__Group__0__Impl : ( ( rule__SimpleType__IdAssignment_0 ) ) ; - public final void rule__SimpleType__Group__0__Impl() throws RecognitionException { + // $ANTLR start "rule__Case__Group__2__Impl" + // InternalScope.g:10068:1: rule__Case__Group__2__Impl : ( ':' ) ; + public final void rule__Case__Group__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9859:1: ( ( ( rule__SimpleType__IdAssignment_0 ) ) ) - // InternalScope.g:9860:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + // InternalScope.g:10072:1: ( ( ':' ) ) + // InternalScope.g:10073:1: ( ':' ) { - // InternalScope.g:9860:1: ( ( rule__SimpleType__IdAssignment_0 ) ) - // InternalScope.g:9861:2: ( rule__SimpleType__IdAssignment_0 ) + // InternalScope.g:10073:1: ( ':' ) + // InternalScope.g:10074:2: ':' { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); - } - // InternalScope.g:9862:2: ( rule__SimpleType__IdAssignment_0 ) - // InternalScope.g:9862:3: rule__SimpleType__IdAssignment_0 - { - pushFollow(FOLLOW_2); - rule__SimpleType__IdAssignment_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getCaseAccess().getColonKeyword_2()); } - + match(input,95,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + after(grammarAccess.getCaseAccess().getColonKeyword_2()); } } @@ -32492,21 +34940,21 @@ public final void rule__SimpleType__Group__0__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__SimpleType__Group__0__Impl" + // $ANTLR end "rule__Case__Group__2__Impl" - // $ANTLR start "rule__SimpleType__Group__1" - // InternalScope.g:9870:1: rule__SimpleType__Group__1 : rule__SimpleType__Group__1__Impl ; - public final void rule__SimpleType__Group__1() throws RecognitionException { + // $ANTLR start "rule__Case__Group__3" + // InternalScope.g:10083:1: rule__Case__Group__3 : rule__Case__Group__3__Impl ; + public final void rule__Case__Group__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9874:1: ( rule__SimpleType__Group__1__Impl ) - // InternalScope.g:9875:2: rule__SimpleType__Group__1__Impl + // InternalScope.g:10087:1: ( rule__Case__Group__3__Impl ) + // InternalScope.g:10088:2: rule__Case__Group__3__Impl { pushFollow(FOLLOW_2); - rule__SimpleType__Group__1__Impl(); + rule__Case__Group__3__Impl(); state._fsp--; if (state.failed) return ; @@ -32525,56 +34973,38 @@ public final void rule__SimpleType__Group__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group__1" + // $ANTLR end "rule__Case__Group__3" - // $ANTLR start "rule__SimpleType__Group__1__Impl" - // InternalScope.g:9881:1: rule__SimpleType__Group__1__Impl : ( ( rule__SimpleType__Group_1__0 )* ) ; - public final void rule__SimpleType__Group__1__Impl() throws RecognitionException { + // $ANTLR start "rule__Case__Group__3__Impl" + // InternalScope.g:10094:1: rule__Case__Group__3__Impl : ( ( rule__Case__ThenParAssignment_3 ) ) ; + public final void rule__Case__Group__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9885:1: ( ( ( rule__SimpleType__Group_1__0 )* ) ) - // InternalScope.g:9886:1: ( ( rule__SimpleType__Group_1__0 )* ) + // InternalScope.g:10098:1: ( ( ( rule__Case__ThenParAssignment_3 ) ) ) + // InternalScope.g:10099:1: ( ( rule__Case__ThenParAssignment_3 ) ) { - // InternalScope.g:9886:1: ( ( rule__SimpleType__Group_1__0 )* ) - // InternalScope.g:9887:2: ( rule__SimpleType__Group_1__0 )* + // InternalScope.g:10099:1: ( ( rule__Case__ThenParAssignment_3 ) ) + // InternalScope.g:10100:2: ( rule__Case__ThenParAssignment_3 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getGroup_1()); + before(grammarAccess.getCaseAccess().getThenParAssignment_3()); } - // InternalScope.g:9888:2: ( rule__SimpleType__Group_1__0 )* - loop74: - do { - int alt74=2; - int LA74_0 = input.LA(1); - - if ( (LA74_0==67) ) { - alt74=1; - } - - - switch (alt74) { - case 1 : - // InternalScope.g:9888:3: rule__SimpleType__Group_1__0 - { - pushFollow(FOLLOW_44); - rule__SimpleType__Group_1__0(); - - state._fsp--; - if (state.failed) return ; + // InternalScope.g:10101:2: ( rule__Case__ThenParAssignment_3 ) + // InternalScope.g:10101:3: rule__Case__ThenParAssignment_3 + { + pushFollow(FOLLOW_2); + rule__Case__ThenParAssignment_3(); - } - break; + state._fsp--; + if (state.failed) return ; - default : - break loop74; - } - } while (true); + } if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getGroup_1()); + after(grammarAccess.getCaseAccess().getThenParAssignment_3()); } } @@ -32594,26 +35024,26 @@ public final void rule__SimpleType__Group__1__Impl() throws RecognitionException } return ; } - // $ANTLR end "rule__SimpleType__Group__1__Impl" + // $ANTLR end "rule__Case__Group__3__Impl" - // $ANTLR start "rule__SimpleType__Group_1__0" - // InternalScope.g:9897:1: rule__SimpleType__Group_1__0 : rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ; - public final void rule__SimpleType__Group_1__0() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__0" + // InternalScope.g:10110:1: rule__OrExpression__Group__0 : rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ; + public final void rule__OrExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9901:1: ( rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ) - // InternalScope.g:9902:2: rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 + // InternalScope.g:10114:1: ( rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 ) + // InternalScope.g:10115:2: rule__OrExpression__Group__0__Impl rule__OrExpression__Group__1 { - pushFollow(FOLLOW_3); - rule__SimpleType__Group_1__0__Impl(); + pushFollow(FOLLOW_58); + rule__OrExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; pushFollow(FOLLOW_2); - rule__SimpleType__Group_1__1(); + rule__OrExpression__Group__1(); state._fsp--; if (state.failed) return ; @@ -32632,28 +35062,32 @@ public final void rule__SimpleType__Group_1__0() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group_1__0" + // $ANTLR end "rule__OrExpression__Group__0" - // $ANTLR start "rule__SimpleType__Group_1__0__Impl" - // InternalScope.g:9909:1: rule__SimpleType__Group_1__0__Impl : ( '::' ) ; - public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__0__Impl" + // InternalScope.g:10122:1: rule__OrExpression__Group__0__Impl : ( ruleAndExpression ) ; + public final void rule__OrExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9913:1: ( ( '::' ) ) - // InternalScope.g:9914:1: ( '::' ) + // InternalScope.g:10126:1: ( ( ruleAndExpression ) ) + // InternalScope.g:10127:1: ( ruleAndExpression ) { - // InternalScope.g:9914:1: ( '::' ) - // InternalScope.g:9915:2: '::' + // InternalScope.g:10127:1: ( ruleAndExpression ) + // InternalScope.g:10128:2: ruleAndExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + before(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } - match(input,67,FOLLOW_2); if (state.failed) return ; + pushFollow(FOLLOW_2); + ruleAndExpression(); + + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + after(grammarAccess.getOrExpressionAccess().getAndExpressionParserRuleCall_0()); } } @@ -32673,21 +35107,21 @@ public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SimpleType__Group_1__0__Impl" + // $ANTLR end "rule__OrExpression__Group__0__Impl" - // $ANTLR start "rule__SimpleType__Group_1__1" - // InternalScope.g:9924:1: rule__SimpleType__Group_1__1 : rule__SimpleType__Group_1__1__Impl ; - public final void rule__SimpleType__Group_1__1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__1" + // InternalScope.g:10137:1: rule__OrExpression__Group__1 : rule__OrExpression__Group__1__Impl ; + public final void rule__OrExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9928:1: ( rule__SimpleType__Group_1__1__Impl ) - // InternalScope.g:9929:2: rule__SimpleType__Group_1__1__Impl + // InternalScope.g:10141:1: ( rule__OrExpression__Group__1__Impl ) + // InternalScope.g:10142:2: rule__OrExpression__Group__1__Impl { pushFollow(FOLLOW_2); - rule__SimpleType__Group_1__1__Impl(); + rule__OrExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; @@ -32706,38 +35140,56 @@ public final void rule__SimpleType__Group_1__1() throws RecognitionException { } return ; } - // $ANTLR end "rule__SimpleType__Group_1__1" + // $ANTLR end "rule__OrExpression__Group__1" - // $ANTLR start "rule__SimpleType__Group_1__1__Impl" - // InternalScope.g:9935:1: rule__SimpleType__Group_1__1__Impl : ( ( rule__SimpleType__IdAssignment_1_1 ) ) ; - public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group__1__Impl" + // InternalScope.g:10148:1: rule__OrExpression__Group__1__Impl : ( ( rule__OrExpression__Group_1__0 )* ) ; + public final void rule__OrExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9939:1: ( ( ( rule__SimpleType__IdAssignment_1_1 ) ) ) - // InternalScope.g:9940:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + // InternalScope.g:10152:1: ( ( ( rule__OrExpression__Group_1__0 )* ) ) + // InternalScope.g:10153:1: ( ( rule__OrExpression__Group_1__0 )* ) { - // InternalScope.g:9940:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) - // InternalScope.g:9941:2: ( rule__SimpleType__IdAssignment_1_1 ) + // InternalScope.g:10153:1: ( ( rule__OrExpression__Group_1__0 )* ) + // InternalScope.g:10154:2: ( rule__OrExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + before(grammarAccess.getOrExpressionAccess().getGroup_1()); } - // InternalScope.g:9942:2: ( rule__SimpleType__IdAssignment_1_1 ) - // InternalScope.g:9942:3: rule__SimpleType__IdAssignment_1_1 - { - pushFollow(FOLLOW_2); - rule__SimpleType__IdAssignment_1_1(); + // InternalScope.g:10155:2: ( rule__OrExpression__Group_1__0 )* + loop99: + do { + int alt99=2; + int LA99_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA99_0==15) ) { + alt99=1; + } - } + + switch (alt99) { + case 1 : + // InternalScope.g:10155:3: rule__OrExpression__Group_1__0 + { + pushFollow(FOLLOW_59); + rule__OrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop99; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + after(grammarAccess.getOrExpressionAccess().getGroup_1()); } } @@ -32757,36 +35209,29 @@ public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__SimpleType__Group_1__1__Impl" + // $ANTLR end "rule__OrExpression__Group__1__Impl" - // $ANTLR start "rule__ScopeModel__NameAssignment_1" - // InternalScope.g:9951:1: rule__ScopeModel__NameAssignment_1 : ( ruleDottedID ) ; - public final void rule__ScopeModel__NameAssignment_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__0" + // InternalScope.g:10164:1: rule__OrExpression__Group_1__0 : rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ; + public final void rule__OrExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9955:1: ( ( ruleDottedID ) ) - // InternalScope.g:9956:2: ( ruleDottedID ) - { - // InternalScope.g:9956:2: ( ruleDottedID ) - // InternalScope.g:9957:3: ruleDottedID + // InternalScope.g:10168:1: ( rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 ) + // InternalScope.g:10169:2: rule__OrExpression__Group_1__0__Impl rule__OrExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleDottedID(); + pushFollow(FOLLOW_58); + rule__OrExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -32802,44 +35247,32 @@ public final void rule__ScopeModel__NameAssignment_1() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ScopeModel__NameAssignment_1" + // $ANTLR end "rule__OrExpression__Group_1__0" - // $ANTLR start "rule__ScopeModel__IncludedScopesAssignment_2_1" - // InternalScope.g:9966:1: rule__ScopeModel__IncludedScopesAssignment_2_1 : ( ( ruleDottedID ) ) ; - public final void rule__ScopeModel__IncludedScopesAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__0__Impl" + // InternalScope.g:10176:1: rule__OrExpression__Group_1__0__Impl : ( () ) ; + public final void rule__OrExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9970:1: ( ( ( ruleDottedID ) ) ) - // InternalScope.g:9971:2: ( ( ruleDottedID ) ) + // InternalScope.g:10180:1: ( ( () ) ) + // InternalScope.g:10181:1: ( () ) { - // InternalScope.g:9971:2: ( ( ruleDottedID ) ) - // InternalScope.g:9972:3: ( ruleDottedID ) + // InternalScope.g:10181:1: ( () ) + // InternalScope.g:10182:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); + before(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } - // InternalScope.g:9973:3: ( ruleDottedID ) - // InternalScope.g:9974:4: ruleDottedID + // InternalScope.g:10183:2: () + // InternalScope.g:10183:3: { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); - } - pushFollow(FOLLOW_2); - ruleDottedID(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); - } - } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); + after(grammarAccess.getOrExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -32848,10 +35281,6 @@ public final void rule__ScopeModel__IncludedScopesAssignment_2_1() throws Recogn } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -32859,36 +35288,29 @@ public final void rule__ScopeModel__IncludedScopesAssignment_2_1() throws Recogn } return ; } - // $ANTLR end "rule__ScopeModel__IncludedScopesAssignment_2_1" + // $ANTLR end "rule__OrExpression__Group_1__0__Impl" - // $ANTLR start "rule__ScopeModel__ImportsAssignment_3" - // InternalScope.g:9985:1: rule__ScopeModel__ImportsAssignment_3 : ( ruleImport ) ; - public final void rule__ScopeModel__ImportsAssignment_3() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__1" + // InternalScope.g:10191:1: rule__OrExpression__Group_1__1 : rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ; + public final void rule__OrExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:9989:1: ( ( ruleImport ) ) - // InternalScope.g:9990:2: ( ruleImport ) + // InternalScope.g:10195:1: ( rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 ) + // InternalScope.g:10196:2: rule__OrExpression__Group_1__1__Impl rule__OrExpression__Group_1__2 { - // InternalScope.g:9990:2: ( ruleImport ) - // InternalScope.g:9991:3: ruleImport - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleImport(); + pushFollow(FOLLOW_57); + rule__OrExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__OrExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -32904,32 +35326,38 @@ public final void rule__ScopeModel__ImportsAssignment_3() throws RecognitionExce } return ; } - // $ANTLR end "rule__ScopeModel__ImportsAssignment_3" + // $ANTLR end "rule__OrExpression__Group_1__1" - // $ANTLR start "rule__ScopeModel__ExtensionsAssignment_4" - // InternalScope.g:10000:1: rule__ScopeModel__ExtensionsAssignment_4 : ( ruleExtension ) ; - public final void rule__ScopeModel__ExtensionsAssignment_4() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__1__Impl" + // InternalScope.g:10203:1: rule__OrExpression__Group_1__1__Impl : ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__OrExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10004:1: ( ( ruleExtension ) ) - // InternalScope.g:10005:2: ( ruleExtension ) + // InternalScope.g:10207:1: ( ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) ) + // InternalScope.g:10208:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) { - // InternalScope.g:10005:2: ( ruleExtension ) - // InternalScope.g:10006:3: ruleExtension + // InternalScope.g:10208:1: ( ( rule__OrExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:10209:2: ( rule__OrExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); + before(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } + // InternalScope.g:10210:2: ( rule__OrExpression__OperatorAssignment_1_1 ) + // InternalScope.g:10210:3: rule__OrExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleExtension(); + rule__OrExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); + after(grammarAccess.getOrExpressionAccess().getOperatorAssignment_1_1()); } } @@ -32949,36 +35377,24 @@ public final void rule__ScopeModel__ExtensionsAssignment_4() throws RecognitionE } return ; } - // $ANTLR end "rule__ScopeModel__ExtensionsAssignment_4" + // $ANTLR end "rule__OrExpression__Group_1__1__Impl" - // $ANTLR start "rule__ScopeModel__InjectionsAssignment_5" - // InternalScope.g:10015:1: rule__ScopeModel__InjectionsAssignment_5 : ( ruleInjection ) ; - public final void rule__ScopeModel__InjectionsAssignment_5() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__2" + // InternalScope.g:10218:1: rule__OrExpression__Group_1__2 : rule__OrExpression__Group_1__2__Impl ; + public final void rule__OrExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10019:1: ( ( ruleInjection ) ) - // InternalScope.g:10020:2: ( ruleInjection ) - { - // InternalScope.g:10020:2: ( ruleInjection ) - // InternalScope.g:10021:3: ruleInjection + // InternalScope.g:10222:1: ( rule__OrExpression__Group_1__2__Impl ) + // InternalScope.g:10223:2: rule__OrExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); - } pushFollow(FOLLOW_2); - ruleInjection(); + rule__OrExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); - } - - } - } @@ -32994,32 +35410,38 @@ public final void rule__ScopeModel__InjectionsAssignment_5() throws RecognitionE } return ; } - // $ANTLR end "rule__ScopeModel__InjectionsAssignment_5" + // $ANTLR end "rule__OrExpression__Group_1__2" - // $ANTLR start "rule__ScopeModel__NamingAssignment_6" - // InternalScope.g:10030:1: rule__ScopeModel__NamingAssignment_6 : ( ruleNamingSection ) ; - public final void rule__ScopeModel__NamingAssignment_6() throws RecognitionException { + // $ANTLR start "rule__OrExpression__Group_1__2__Impl" + // InternalScope.g:10229:1: rule__OrExpression__Group_1__2__Impl : ( ( rule__OrExpression__RightAssignment_1_2 ) ) ; + public final void rule__OrExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10034:1: ( ( ruleNamingSection ) ) - // InternalScope.g:10035:2: ( ruleNamingSection ) + // InternalScope.g:10233:1: ( ( ( rule__OrExpression__RightAssignment_1_2 ) ) ) + // InternalScope.g:10234:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) { - // InternalScope.g:10035:2: ( ruleNamingSection ) - // InternalScope.g:10036:3: ruleNamingSection + // InternalScope.g:10234:1: ( ( rule__OrExpression__RightAssignment_1_2 ) ) + // InternalScope.g:10235:2: ( rule__OrExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); + before(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } + // InternalScope.g:10236:2: ( rule__OrExpression__RightAssignment_1_2 ) + // InternalScope.g:10236:3: rule__OrExpression__RightAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleNamingSection(); + rule__OrExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); + after(grammarAccess.getOrExpressionAccess().getRightAssignment_1_2()); } } @@ -33039,36 +35461,29 @@ public final void rule__ScopeModel__NamingAssignment_6() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ScopeModel__NamingAssignment_6" + // $ANTLR end "rule__OrExpression__Group_1__2__Impl" - // $ANTLR start "rule__ScopeModel__ScopesAssignment_7" - // InternalScope.g:10045:1: rule__ScopeModel__ScopesAssignment_7 : ( ruleScopeDefinition ) ; - public final void rule__ScopeModel__ScopesAssignment_7() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__0" + // InternalScope.g:10245:1: rule__AndExpression__Group__0 : rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ; + public final void rule__AndExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10049:1: ( ( ruleScopeDefinition ) ) - // InternalScope.g:10050:2: ( ruleScopeDefinition ) - { - // InternalScope.g:10050:2: ( ruleScopeDefinition ) - // InternalScope.g:10051:3: ruleScopeDefinition + // InternalScope.g:10249:1: ( rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 ) + // InternalScope.g:10250:2: rule__AndExpression__Group__0__Impl rule__AndExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); - } - pushFollow(FOLLOW_2); - ruleScopeDefinition(); + pushFollow(FOLLOW_60); + rule__AndExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -33084,40 +35499,32 @@ public final void rule__ScopeModel__ScopesAssignment_7() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ScopeModel__ScopesAssignment_7" + // $ANTLR end "rule__AndExpression__Group__0" - // $ANTLR start "rule__Import__PackageAssignment_1" - // InternalScope.g:10060:1: rule__Import__PackageAssignment_1 : ( ( RULE_STRING ) ) ; - public final void rule__Import__PackageAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__0__Impl" + // InternalScope.g:10257:1: rule__AndExpression__Group__0__Impl : ( ruleImpliesExpression ) ; + public final void rule__AndExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10064:1: ( ( ( RULE_STRING ) ) ) - // InternalScope.g:10065:2: ( ( RULE_STRING ) ) + // InternalScope.g:10261:1: ( ( ruleImpliesExpression ) ) + // InternalScope.g:10262:1: ( ruleImpliesExpression ) { - // InternalScope.g:10065:2: ( ( RULE_STRING ) ) - // InternalScope.g:10066:3: ( RULE_STRING ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); - } - // InternalScope.g:10067:3: ( RULE_STRING ) - // InternalScope.g:10068:4: RULE_STRING + // InternalScope.g:10262:1: ( ruleImpliesExpression ) + // InternalScope.g:10263:2: ruleImpliesExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); - } - match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); - } - + before(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } + pushFollow(FOLLOW_2); + ruleImpliesExpression(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); + after(grammarAccess.getAndExpressionAccess().getImpliesExpressionParserRuleCall_0()); } } @@ -33137,36 +35544,24 @@ public final void rule__Import__PackageAssignment_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Import__PackageAssignment_1" + // $ANTLR end "rule__AndExpression__Group__0__Impl" - // $ANTLR start "rule__Import__NameAssignment_2_1" - // InternalScope.g:10079:1: rule__Import__NameAssignment_2_1 : ( ruleIdentifier ) ; - public final void rule__Import__NameAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__1" + // InternalScope.g:10272:1: rule__AndExpression__Group__1 : rule__AndExpression__Group__1__Impl ; + public final void rule__AndExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10083:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10084:2: ( ruleIdentifier ) + // InternalScope.g:10276:1: ( rule__AndExpression__Group__1__Impl ) + // InternalScope.g:10277:2: rule__AndExpression__Group__1__Impl { - // InternalScope.g:10084:2: ( ruleIdentifier ) - // InternalScope.g:10085:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); - } pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__AndExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); - } - - } - } @@ -33182,32 +35577,56 @@ public final void rule__Import__NameAssignment_2_1() throws RecognitionException } return ; } - // $ANTLR end "rule__Import__NameAssignment_2_1" + // $ANTLR end "rule__AndExpression__Group__1" - // $ANTLR start "rule__Extension__ExtensionAssignment_1" - // InternalScope.g:10094:1: rule__Extension__ExtensionAssignment_1 : ( ruleQualifiedID ) ; - public final void rule__Extension__ExtensionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group__1__Impl" + // InternalScope.g:10283:1: rule__AndExpression__Group__1__Impl : ( ( rule__AndExpression__Group_1__0 )* ) ; + public final void rule__AndExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10098:1: ( ( ruleQualifiedID ) ) - // InternalScope.g:10099:2: ( ruleQualifiedID ) + // InternalScope.g:10287:1: ( ( ( rule__AndExpression__Group_1__0 )* ) ) + // InternalScope.g:10288:1: ( ( rule__AndExpression__Group_1__0 )* ) { - // InternalScope.g:10099:2: ( ruleQualifiedID ) - // InternalScope.g:10100:3: ruleQualifiedID + // InternalScope.g:10288:1: ( ( rule__AndExpression__Group_1__0 )* ) + // InternalScope.g:10289:2: ( rule__AndExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + before(grammarAccess.getAndExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleQualifiedID(); + // InternalScope.g:10290:2: ( rule__AndExpression__Group_1__0 )* + loop100: + do { + int alt100=2; + int LA100_0 = input.LA(1); + + if ( (LA100_0==16) ) { + alt100=1; + } + + + switch (alt100) { + case 1 : + // InternalScope.g:10290:3: rule__AndExpression__Group_1__0 + { + pushFollow(FOLLOW_61); + rule__AndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop100; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + after(grammarAccess.getAndExpressionAccess().getGroup_1()); } } @@ -33227,36 +35646,29 @@ public final void rule__Extension__ExtensionAssignment_1() throws RecognitionExc } return ; } - // $ANTLR end "rule__Extension__ExtensionAssignment_1" + // $ANTLR end "rule__AndExpression__Group__1__Impl" - // $ANTLR start "rule__Injection__TypeAssignment_1" - // InternalScope.g:10109:1: rule__Injection__TypeAssignment_1 : ( ruleDottedID ) ; - public final void rule__Injection__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__0" + // InternalScope.g:10299:1: rule__AndExpression__Group_1__0 : rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ; + public final void rule__AndExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10113:1: ( ( ruleDottedID ) ) - // InternalScope.g:10114:2: ( ruleDottedID ) - { - // InternalScope.g:10114:2: ( ruleDottedID ) - // InternalScope.g:10115:3: ruleDottedID + // InternalScope.g:10303:1: ( rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 ) + // InternalScope.g:10304:2: rule__AndExpression__Group_1__0__Impl rule__AndExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleDottedID(); + pushFollow(FOLLOW_60); + rule__AndExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -33272,32 +35684,32 @@ public final void rule__Injection__TypeAssignment_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Injection__TypeAssignment_1" + // $ANTLR end "rule__AndExpression__Group_1__0" - // $ANTLR start "rule__Injection__NameAssignment_3" - // InternalScope.g:10124:1: rule__Injection__NameAssignment_3 : ( ruleIdentifier ) ; - public final void rule__Injection__NameAssignment_3() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__0__Impl" + // InternalScope.g:10311:1: rule__AndExpression__Group_1__0__Impl : ( () ) ; + public final void rule__AndExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10128:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10129:2: ( ruleIdentifier ) + // InternalScope.g:10315:1: ( ( () ) ) + // InternalScope.g:10316:1: ( () ) { - // InternalScope.g:10129:2: ( ruleIdentifier ) - // InternalScope.g:10130:3: ruleIdentifier + // InternalScope.g:10316:1: ( () ) + // InternalScope.g:10317:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); + before(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + // InternalScope.g:10318:2: () + // InternalScope.g:10318:3: + { } - pushFollow(FOLLOW_2); - ruleIdentifier(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); + after(grammarAccess.getAndExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -33306,10 +35718,6 @@ public final void rule__Injection__NameAssignment_3() throws RecognitionExceptio } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -33317,36 +35725,29 @@ public final void rule__Injection__NameAssignment_3() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Injection__NameAssignment_3" + // $ANTLR end "rule__AndExpression__Group_1__0__Impl" - // $ANTLR start "rule__NamingSection__CasingAssignment_1_1" - // InternalScope.g:10139:1: rule__NamingSection__CasingAssignment_1_1 : ( ruleCasing ) ; - public final void rule__NamingSection__CasingAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__1" + // InternalScope.g:10326:1: rule__AndExpression__Group_1__1 : rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ; + public final void rule__AndExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10143:1: ( ( ruleCasing ) ) - // InternalScope.g:10144:2: ( ruleCasing ) + // InternalScope.g:10330:1: ( rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 ) + // InternalScope.g:10331:2: rule__AndExpression__Group_1__1__Impl rule__AndExpression__Group_1__2 { - // InternalScope.g:10144:2: ( ruleCasing ) - // InternalScope.g:10145:3: ruleCasing - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleCasing(); + pushFollow(FOLLOW_57); + rule__AndExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AndExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -33362,32 +35763,38 @@ public final void rule__NamingSection__CasingAssignment_1_1() throws Recognition } return ; } - // $ANTLR end "rule__NamingSection__CasingAssignment_1_1" + // $ANTLR end "rule__AndExpression__Group_1__1" - // $ANTLR start "rule__NamingSection__NamingsAssignment_4" - // InternalScope.g:10154:1: rule__NamingSection__NamingsAssignment_4 : ( ruleNamingDefinition ) ; - public final void rule__NamingSection__NamingsAssignment_4() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__1__Impl" + // InternalScope.g:10338:1: rule__AndExpression__Group_1__1__Impl : ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__AndExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10158:1: ( ( ruleNamingDefinition ) ) - // InternalScope.g:10159:2: ( ruleNamingDefinition ) + // InternalScope.g:10342:1: ( ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) ) + // InternalScope.g:10343:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) { - // InternalScope.g:10159:2: ( ruleNamingDefinition ) - // InternalScope.g:10160:3: ruleNamingDefinition + // InternalScope.g:10343:1: ( ( rule__AndExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:10344:2: ( rule__AndExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); + before(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } + // InternalScope.g:10345:2: ( rule__AndExpression__OperatorAssignment_1_1 ) + // InternalScope.g:10345:3: rule__AndExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleNamingDefinition(); + rule__AndExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); + after(grammarAccess.getAndExpressionAccess().getOperatorAssignment_1_1()); } } @@ -33407,48 +35814,24 @@ public final void rule__NamingSection__NamingsAssignment_4() throws RecognitionE } return ; } - // $ANTLR end "rule__NamingSection__NamingsAssignment_4" + // $ANTLR end "rule__AndExpression__Group_1__1__Impl" - // $ANTLR start "rule__NamingDefinition__TypeAssignment_0" - // InternalScope.g:10169:1: rule__NamingDefinition__TypeAssignment_0 : ( ( ruleQualifiedID ) ) ; - public final void rule__NamingDefinition__TypeAssignment_0() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__2" + // InternalScope.g:10353:1: rule__AndExpression__Group_1__2 : rule__AndExpression__Group_1__2__Impl ; + public final void rule__AndExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10173:1: ( ( ( ruleQualifiedID ) ) ) - // InternalScope.g:10174:2: ( ( ruleQualifiedID ) ) - { - // InternalScope.g:10174:2: ( ( ruleQualifiedID ) ) - // InternalScope.g:10175:3: ( ruleQualifiedID ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); - } - // InternalScope.g:10176:3: ( ruleQualifiedID ) - // InternalScope.g:10177:4: ruleQualifiedID + // InternalScope.g:10357:1: ( rule__AndExpression__Group_1__2__Impl ) + // InternalScope.g:10358:2: rule__AndExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); - } pushFollow(FOLLOW_2); - ruleQualifiedID(); + rule__AndExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); - } - - } - } @@ -33464,32 +35847,38 @@ public final void rule__NamingDefinition__TypeAssignment_0() throws RecognitionE } return ; } - // $ANTLR end "rule__NamingDefinition__TypeAssignment_0" + // $ANTLR end "rule__AndExpression__Group_1__2" - // $ANTLR start "rule__NamingDefinition__NamingAssignment_2" - // InternalScope.g:10188:1: rule__NamingDefinition__NamingAssignment_2 : ( ruleNaming ) ; - public final void rule__NamingDefinition__NamingAssignment_2() throws RecognitionException { + // $ANTLR start "rule__AndExpression__Group_1__2__Impl" + // InternalScope.g:10364:1: rule__AndExpression__Group_1__2__Impl : ( ( rule__AndExpression__RightAssignment_1_2 ) ) ; + public final void rule__AndExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10192:1: ( ( ruleNaming ) ) - // InternalScope.g:10193:2: ( ruleNaming ) + // InternalScope.g:10368:1: ( ( ( rule__AndExpression__RightAssignment_1_2 ) ) ) + // InternalScope.g:10369:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) { - // InternalScope.g:10193:2: ( ruleNaming ) - // InternalScope.g:10194:3: ruleNaming + // InternalScope.g:10369:1: ( ( rule__AndExpression__RightAssignment_1_2 ) ) + // InternalScope.g:10370:2: ( rule__AndExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); + before(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } + // InternalScope.g:10371:2: ( rule__AndExpression__RightAssignment_1_2 ) + // InternalScope.g:10371:3: rule__AndExpression__RightAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleNaming(); + rule__AndExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); + after(grammarAccess.getAndExpressionAccess().getRightAssignment_1_2()); } } @@ -33509,36 +35898,29 @@ public final void rule__NamingDefinition__NamingAssignment_2() throws Recognitio } return ; } - // $ANTLR end "rule__NamingDefinition__NamingAssignment_2" + // $ANTLR end "rule__AndExpression__Group_1__2__Impl" - // $ANTLR start "rule__ScopeDefinition__NameAssignment_1_1" - // InternalScope.g:10203:1: rule__ScopeDefinition__NameAssignment_1_1 : ( ruleIdentifier ) ; - public final void rule__ScopeDefinition__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__0" + // InternalScope.g:10380:1: rule__ImpliesExpression__Group__0 : rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ; + public final void rule__ImpliesExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10207:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10208:2: ( ruleIdentifier ) - { - // InternalScope.g:10208:2: ( ruleIdentifier ) - // InternalScope.g:10209:3: ruleIdentifier + // InternalScope.g:10384:1: ( rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 ) + // InternalScope.g:10385:2: rule__ImpliesExpression__Group__0__Impl rule__ImpliesExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_62); + rule__ImpliesExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -33554,44 +35936,32 @@ public final void rule__ScopeDefinition__NameAssignment_1_1() throws Recognition } return ; } - // $ANTLR end "rule__ScopeDefinition__NameAssignment_1_1" + // $ANTLR end "rule__ImpliesExpression__Group__0" - // $ANTLR start "rule__ScopeDefinition__TargetTypeAssignment_2_0" - // InternalScope.g:10218:1: rule__ScopeDefinition__TargetTypeAssignment_2_0 : ( ( ruleQualifiedID ) ) ; - public final void rule__ScopeDefinition__TargetTypeAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__0__Impl" + // InternalScope.g:10392:1: rule__ImpliesExpression__Group__0__Impl : ( ruleRelationalExpression ) ; + public final void rule__ImpliesExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10222:1: ( ( ( ruleQualifiedID ) ) ) - // InternalScope.g:10223:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:10396:1: ( ( ruleRelationalExpression ) ) + // InternalScope.g:10397:1: ( ruleRelationalExpression ) { - // InternalScope.g:10223:2: ( ( ruleQualifiedID ) ) - // InternalScope.g:10224:3: ( ruleQualifiedID ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); - } - // InternalScope.g:10225:3: ( ruleQualifiedID ) - // InternalScope.g:10226:4: ruleQualifiedID + // InternalScope.g:10397:1: ( ruleRelationalExpression ) + // InternalScope.g:10398:2: ruleRelationalExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); + before(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleQualifiedID(); + ruleRelationalExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); + after(grammarAccess.getImpliesExpressionAccess().getRelationalExpressionParserRuleCall_0()); } } @@ -33611,48 +35981,24 @@ public final void rule__ScopeDefinition__TargetTypeAssignment_2_0() throws Recog } return ; } - // $ANTLR end "rule__ScopeDefinition__TargetTypeAssignment_2_0" + // $ANTLR end "rule__ImpliesExpression__Group__0__Impl" - // $ANTLR start "rule__ScopeDefinition__ContextTypeAssignment_2_1_0" - // InternalScope.g:10237:1: rule__ScopeDefinition__ContextTypeAssignment_2_1_0 : ( ( ruleQualifiedID ) ) ; - public final void rule__ScopeDefinition__ContextTypeAssignment_2_1_0() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__1" + // InternalScope.g:10407:1: rule__ImpliesExpression__Group__1 : rule__ImpliesExpression__Group__1__Impl ; + public final void rule__ImpliesExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10241:1: ( ( ( ruleQualifiedID ) ) ) - // InternalScope.g:10242:2: ( ( ruleQualifiedID ) ) - { - // InternalScope.g:10242:2: ( ( ruleQualifiedID ) ) - // InternalScope.g:10243:3: ( ruleQualifiedID ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); - } - // InternalScope.g:10244:3: ( ruleQualifiedID ) - // InternalScope.g:10245:4: ruleQualifiedID + // InternalScope.g:10411:1: ( rule__ImpliesExpression__Group__1__Impl ) + // InternalScope.g:10412:2: rule__ImpliesExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); - } pushFollow(FOLLOW_2); - ruleQualifiedID(); + rule__ImpliesExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); - } - - } - } @@ -33668,44 +36014,56 @@ public final void rule__ScopeDefinition__ContextTypeAssignment_2_1_0() throws Re } return ; } - // $ANTLR end "rule__ScopeDefinition__ContextTypeAssignment_2_1_0" + // $ANTLR end "rule__ImpliesExpression__Group__1" - // $ANTLR start "rule__ScopeDefinition__ReferenceAssignment_2_1_2" - // InternalScope.g:10256:1: rule__ScopeDefinition__ReferenceAssignment_2_1_2 : ( ( ruleIdentifier ) ) ; - public final void rule__ScopeDefinition__ReferenceAssignment_2_1_2() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group__1__Impl" + // InternalScope.g:10418:1: rule__ImpliesExpression__Group__1__Impl : ( ( rule__ImpliesExpression__Group_1__0 )* ) ; + public final void rule__ImpliesExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10260:1: ( ( ( ruleIdentifier ) ) ) - // InternalScope.g:10261:2: ( ( ruleIdentifier ) ) + // InternalScope.g:10422:1: ( ( ( rule__ImpliesExpression__Group_1__0 )* ) ) + // InternalScope.g:10423:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) { - // InternalScope.g:10261:2: ( ( ruleIdentifier ) ) - // InternalScope.g:10262:3: ( ruleIdentifier ) + // InternalScope.g:10423:1: ( ( rule__ImpliesExpression__Group_1__0 )* ) + // InternalScope.g:10424:2: ( rule__ImpliesExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); - } - // InternalScope.g:10263:3: ( ruleIdentifier ) - // InternalScope.g:10264:4: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); + before(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleIdentifier(); + // InternalScope.g:10425:2: ( rule__ImpliesExpression__Group_1__0 )* + loop101: + do { + int alt101=2; + int LA101_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); - } + if ( (LA101_0==119) ) { + alt101=1; + } - } + + switch (alt101) { + case 1 : + // InternalScope.g:10425:3: rule__ImpliesExpression__Group_1__0 + { + pushFollow(FOLLOW_63); + rule__ImpliesExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop101; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); + after(grammarAccess.getImpliesExpressionAccess().getGroup_1()); } } @@ -33725,36 +36083,29 @@ public final void rule__ScopeDefinition__ReferenceAssignment_2_1_2() throws Reco } return ; } - // $ANTLR end "rule__ScopeDefinition__ReferenceAssignment_2_1_2" + // $ANTLR end "rule__ImpliesExpression__Group__1__Impl" - // $ANTLR start "rule__ScopeDefinition__RulesAssignment_4" - // InternalScope.g:10275:1: rule__ScopeDefinition__RulesAssignment_4 : ( ruleScopeRule ) ; - public final void rule__ScopeDefinition__RulesAssignment_4() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__0" + // InternalScope.g:10434:1: rule__ImpliesExpression__Group_1__0 : rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ; + public final void rule__ImpliesExpression__Group_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10279:1: ( ( ruleScopeRule ) ) - // InternalScope.g:10280:2: ( ruleScopeRule ) - { - // InternalScope.g:10280:2: ( ruleScopeRule ) - // InternalScope.g:10281:3: ruleScopeRule + // InternalScope.g:10438:1: ( rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 ) + // InternalScope.g:10439:2: rule__ImpliesExpression__Group_1__0__Impl rule__ImpliesExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); - } - pushFollow(FOLLOW_2); - ruleScopeRule(); + pushFollow(FOLLOW_62); + rule__ImpliesExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -33770,32 +36121,32 @@ public final void rule__ScopeDefinition__RulesAssignment_4() throws RecognitionE } return ; } - // $ANTLR end "rule__ScopeDefinition__RulesAssignment_4" + // $ANTLR end "rule__ImpliesExpression__Group_1__0" - // $ANTLR start "rule__ScopeRule__ContextAssignment_1" - // InternalScope.g:10290:1: rule__ScopeRule__ContextAssignment_1 : ( ruleScopeContext ) ; - public final void rule__ScopeRule__ContextAssignment_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__0__Impl" + // InternalScope.g:10446:1: rule__ImpliesExpression__Group_1__0__Impl : ( () ) ; + public final void rule__ImpliesExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10294:1: ( ( ruleScopeContext ) ) - // InternalScope.g:10295:2: ( ruleScopeContext ) + // InternalScope.g:10450:1: ( ( () ) ) + // InternalScope.g:10451:1: ( () ) { - // InternalScope.g:10295:2: ( ruleScopeContext ) - // InternalScope.g:10296:3: ruleScopeContext + // InternalScope.g:10451:1: ( () ) + // InternalScope.g:10452:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); + } + // InternalScope.g:10453:2: () + // InternalScope.g:10453:3: + { } - pushFollow(FOLLOW_2); - ruleScopeContext(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getBooleanOperationLeftAction_1_0()); } } @@ -33804,10 +36155,6 @@ public final void rule__ScopeRule__ContextAssignment_1() throws RecognitionExcep } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -33815,36 +36162,29 @@ public final void rule__ScopeRule__ContextAssignment_1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ScopeRule__ContextAssignment_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__0__Impl" - // $ANTLR start "rule__ScopeRule__ExprsAssignment_3" - // InternalScope.g:10305:1: rule__ScopeRule__ExprsAssignment_3 : ( ruleScopeExpression ) ; - public final void rule__ScopeRule__ExprsAssignment_3() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__1" + // InternalScope.g:10461:1: rule__ImpliesExpression__Group_1__1 : rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ; + public final void rule__ImpliesExpression__Group_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10309:1: ( ( ruleScopeExpression ) ) - // InternalScope.g:10310:2: ( ruleScopeExpression ) + // InternalScope.g:10465:1: ( rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 ) + // InternalScope.g:10466:2: rule__ImpliesExpression__Group_1__1__Impl rule__ImpliesExpression__Group_1__2 { - // InternalScope.g:10310:2: ( ruleScopeExpression ) - // InternalScope.g:10311:3: ruleScopeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleScopeExpression(); + pushFollow(FOLLOW_57); + rule__ImpliesExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -33860,32 +36200,38 @@ public final void rule__ScopeRule__ExprsAssignment_3() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__ScopeRule__ExprsAssignment_3" + // $ANTLR end "rule__ImpliesExpression__Group_1__1" - // $ANTLR start "rule__ScopeRule__ExprsAssignment_4_1" - // InternalScope.g:10320:1: rule__ScopeRule__ExprsAssignment_4_1 : ( ruleScopeExpression ) ; - public final void rule__ScopeRule__ExprsAssignment_4_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__1__Impl" + // InternalScope.g:10473:1: rule__ImpliesExpression__Group_1__1__Impl : ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__ImpliesExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10324:1: ( ( ruleScopeExpression ) ) - // InternalScope.g:10325:2: ( ruleScopeExpression ) + // InternalScope.g:10477:1: ( ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) ) + // InternalScope.g:10478:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) { - // InternalScope.g:10325:2: ( ruleScopeExpression ) - // InternalScope.g:10326:3: ruleScopeExpression + // InternalScope.g:10478:1: ( ( rule__ImpliesExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:10479:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } + // InternalScope.g:10480:2: ( rule__ImpliesExpression__OperatorAssignment_1_1 ) + // InternalScope.g:10480:3: rule__ImpliesExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleScopeExpression(); + rule__ImpliesExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getOperatorAssignment_1_1()); } } @@ -33905,44 +36251,24 @@ public final void rule__ScopeRule__ExprsAssignment_4_1() throws RecognitionExcep } return ; } - // $ANTLR end "rule__ScopeRule__ExprsAssignment_4_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__1__Impl" - // $ANTLR start "rule__ScopeContext__GlobalAssignment_0_0" - // InternalScope.g:10335:1: rule__ScopeContext__GlobalAssignment_0_0 : ( ( '*' ) ) ; - public final void rule__ScopeContext__GlobalAssignment_0_0() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__2" + // InternalScope.g:10488:1: rule__ImpliesExpression__Group_1__2 : rule__ImpliesExpression__Group_1__2__Impl ; + public final void rule__ImpliesExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10339:1: ( ( ( '*' ) ) ) - // InternalScope.g:10340:2: ( ( '*' ) ) - { - // InternalScope.g:10340:2: ( ( '*' ) ) - // InternalScope.g:10341:3: ( '*' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); - } - // InternalScope.g:10342:3: ( '*' ) - // InternalScope.g:10343:4: '*' + // InternalScope.g:10492:1: ( rule__ImpliesExpression__Group_1__2__Impl ) + // InternalScope.g:10493:2: rule__ImpliesExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); - } - match(input,20,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__ImpliesExpression__Group_1__2__Impl(); + state._fsp--; + if (state.failed) return ; } @@ -33958,44 +36284,38 @@ public final void rule__ScopeContext__GlobalAssignment_0_0() throws RecognitionE } return ; } - // $ANTLR end "rule__ScopeContext__GlobalAssignment_0_0" + // $ANTLR end "rule__ImpliesExpression__Group_1__2" - // $ANTLR start "rule__ScopeContext__ContextTypeAssignment_0_1" - // InternalScope.g:10354:1: rule__ScopeContext__ContextTypeAssignment_0_1 : ( ( ruleQualifiedID ) ) ; - public final void rule__ScopeContext__ContextTypeAssignment_0_1() throws RecognitionException { + // $ANTLR start "rule__ImpliesExpression__Group_1__2__Impl" + // InternalScope.g:10499:1: rule__ImpliesExpression__Group_1__2__Impl : ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ; + public final void rule__ImpliesExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10358:1: ( ( ( ruleQualifiedID ) ) ) - // InternalScope.g:10359:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:10503:1: ( ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) ) + // InternalScope.g:10504:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) { - // InternalScope.g:10359:2: ( ( ruleQualifiedID ) ) - // InternalScope.g:10360:3: ( ruleQualifiedID ) + // InternalScope.g:10504:1: ( ( rule__ImpliesExpression__RightAssignment_1_2 ) ) + // InternalScope.g:10505:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); + before(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } - // InternalScope.g:10361:3: ( ruleQualifiedID ) - // InternalScope.g:10362:4: ruleQualifiedID + // InternalScope.g:10506:2: ( rule__ImpliesExpression__RightAssignment_1_2 ) + // InternalScope.g:10506:3: rule__ImpliesExpression__RightAssignment_1_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); - } pushFollow(FOLLOW_2); - ruleQualifiedID(); + rule__ImpliesExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); - } } if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); + after(grammarAccess.getImpliesExpressionAccess().getRightAssignment_1_2()); } } @@ -34015,36 +36335,29 @@ public final void rule__ScopeContext__ContextTypeAssignment_0_1() throws Recogni } return ; } - // $ANTLR end "rule__ScopeContext__ContextTypeAssignment_0_1" + // $ANTLR end "rule__ImpliesExpression__Group_1__2__Impl" - // $ANTLR start "rule__ScopeContext__GuardAssignment_1_1" - // InternalScope.g:10373:1: rule__ScopeContext__GuardAssignment_1_1 : ( ruleExpression ) ; - public final void rule__ScopeContext__GuardAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__0" + // InternalScope.g:10515:1: rule__RelationalExpression__Group__0 : rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ; + public final void rule__RelationalExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10377:1: ( ( ruleExpression ) ) - // InternalScope.g:10378:2: ( ruleExpression ) + // InternalScope.g:10519:1: ( rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 ) + // InternalScope.g:10520:2: rule__RelationalExpression__Group__0__Impl rule__RelationalExpression__Group__1 { - // InternalScope.g:10378:2: ( ruleExpression ) - // InternalScope.g:10379:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_64); + rule__RelationalExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -34060,32 +36373,32 @@ public final void rule__ScopeContext__GuardAssignment_1_1() throws RecognitionEx } return ; } - // $ANTLR end "rule__ScopeContext__GuardAssignment_1_1" + // $ANTLR end "rule__RelationalExpression__Group__0" - // $ANTLR start "rule__FactoryExpression__ExprAssignment_1" - // InternalScope.g:10388:1: rule__FactoryExpression__ExprAssignment_1 : ( ruleExpression ) ; - public final void rule__FactoryExpression__ExprAssignment_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__0__Impl" + // InternalScope.g:10527:1: rule__RelationalExpression__Group__0__Impl : ( ruleAdditiveExpression ) ; + public final void rule__RelationalExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10392:1: ( ( ruleExpression ) ) - // InternalScope.g:10393:2: ( ruleExpression ) + // InternalScope.g:10531:1: ( ( ruleAdditiveExpression ) ) + // InternalScope.g:10532:1: ( ruleAdditiveExpression ) { - // InternalScope.g:10393:2: ( ruleExpression ) - // InternalScope.g:10394:3: ruleExpression + // InternalScope.g:10532:1: ( ruleAdditiveExpression ) + // InternalScope.g:10533:2: ruleAdditiveExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleExpression(); + ruleAdditiveExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getAdditiveExpressionParserRuleCall_0()); } } @@ -34105,36 +36418,24 @@ public final void rule__FactoryExpression__ExprAssignment_1() throws Recognition } return ; } - // $ANTLR end "rule__FactoryExpression__ExprAssignment_1" + // $ANTLR end "rule__RelationalExpression__Group__0__Impl" - // $ANTLR start "rule__ScopeDelegation__DelegateAssignment_2_0" - // InternalScope.g:10403:1: rule__ScopeDelegation__DelegateAssignment_2_0 : ( ruleExpression ) ; - public final void rule__ScopeDelegation__DelegateAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__1" + // InternalScope.g:10542:1: rule__RelationalExpression__Group__1 : rule__RelationalExpression__Group__1__Impl ; + public final void rule__RelationalExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10407:1: ( ( ruleExpression ) ) - // InternalScope.g:10408:2: ( ruleExpression ) - { - // InternalScope.g:10408:2: ( ruleExpression ) - // InternalScope.g:10409:3: ruleExpression + // InternalScope.g:10546:1: ( rule__RelationalExpression__Group__1__Impl ) + // InternalScope.g:10547:2: rule__RelationalExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__RelationalExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); - } - - } - } @@ -34150,32 +36451,56 @@ public final void rule__ScopeDelegation__DelegateAssignment_2_0() throws Recogni } return ; } - // $ANTLR end "rule__ScopeDelegation__DelegateAssignment_2_0" + // $ANTLR end "rule__RelationalExpression__Group__1" - // $ANTLR start "rule__ScopeDelegation__ExternalAssignment_2_1" - // InternalScope.g:10418:1: rule__ScopeDelegation__ExternalAssignment_2_1 : ( ruleGlobalScopeExpression ) ; - public final void rule__ScopeDelegation__ExternalAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group__1__Impl" + // InternalScope.g:10553:1: rule__RelationalExpression__Group__1__Impl : ( ( rule__RelationalExpression__Group_1__0 )* ) ; + public final void rule__RelationalExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10422:1: ( ( ruleGlobalScopeExpression ) ) - // InternalScope.g:10423:2: ( ruleGlobalScopeExpression ) + // InternalScope.g:10557:1: ( ( ( rule__RelationalExpression__Group_1__0 )* ) ) + // InternalScope.g:10558:1: ( ( rule__RelationalExpression__Group_1__0 )* ) { - // InternalScope.g:10423:2: ( ruleGlobalScopeExpression ) - // InternalScope.g:10424:3: ruleGlobalScopeExpression + // InternalScope.g:10558:1: ( ( rule__RelationalExpression__Group_1__0 )* ) + // InternalScope.g:10559:2: ( rule__RelationalExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleGlobalScopeExpression(); + // InternalScope.g:10560:2: ( rule__RelationalExpression__Group_1__0 )* + loop102: + do { + int alt102=2; + int LA102_0 = input.LA(1); + + if ( ((LA102_0>=17 && LA102_0<=22)) ) { + alt102=1; + } + + + switch (alt102) { + case 1 : + // InternalScope.g:10560:3: rule__RelationalExpression__Group_1__0 + { + pushFollow(FOLLOW_65); + rule__RelationalExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop102; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getGroup_1()); } } @@ -34195,48 +36520,29 @@ public final void rule__ScopeDelegation__ExternalAssignment_2_1() throws Recogni } return ; } - // $ANTLR end "rule__ScopeDelegation__ExternalAssignment_2_1" + // $ANTLR end "rule__RelationalExpression__Group__1__Impl" - // $ANTLR start "rule__ScopeDelegation__ScopeAssignment_3_1" - // InternalScope.g:10433:1: rule__ScopeDelegation__ScopeAssignment_3_1 : ( ( ruleIdentifier ) ) ; - public final void rule__ScopeDelegation__ScopeAssignment_3_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__0" + // InternalScope.g:10569: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 { int stackSize = keepStackSize(); try { - // InternalScope.g:10437:1: ( ( ( ruleIdentifier ) ) ) - // InternalScope.g:10438:2: ( ( ruleIdentifier ) ) - { - // InternalScope.g:10438:2: ( ( ruleIdentifier ) ) - // InternalScope.g:10439:3: ( ruleIdentifier ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); - } - // InternalScope.g:10440:3: ( ruleIdentifier ) - // InternalScope.g:10441:4: ruleIdentifier + // InternalScope.g:10573:1: ( rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 ) + // InternalScope.g:10574:2: rule__RelationalExpression__Group_1__0__Impl rule__RelationalExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_64); + rule__RelationalExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -34252,44 +36558,70 @@ public final void rule__ScopeDelegation__ScopeAssignment_3_1() throws Recognitio } return ; } - // $ANTLR end "rule__ScopeDelegation__ScopeAssignment_3_1" + // $ANTLR end "rule__RelationalExpression__Group_1__0" - // $ANTLR start "rule__NamedScopeExpression__CaseDefAssignment_1_0" - // InternalScope.g:10452:1: rule__NamedScopeExpression__CaseDefAssignment_1_0 : ( ( 'case' ) ) ; - public final void rule__NamedScopeExpression__CaseDefAssignment_1_0() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__0__Impl" + // InternalScope.g:10581:1: rule__RelationalExpression__Group_1__0__Impl : ( () ) ; + public final void rule__RelationalExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10456:1: ( ( ( 'case' ) ) ) - // InternalScope.g:10457:2: ( ( 'case' ) ) + // InternalScope.g:10585:1: ( ( () ) ) + // InternalScope.g:10586:1: ( () ) { - // InternalScope.g:10457:2: ( ( 'case' ) ) - // InternalScope.g:10458:3: ( 'case' ) + // InternalScope.g:10586:1: ( () ) + // InternalScope.g:10587:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); + before(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } - // InternalScope.g:10459:3: ( 'case' ) - // InternalScope.g:10460:4: 'case' + // InternalScope.g:10588:2: () + // InternalScope.g:10588:3: { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); } - match(input,47,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); + after(grammarAccess.getRelationalExpressionAccess().getBooleanOperationLeftAction_1_0()); } } - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); - } } + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__RelationalExpression__Group_1__1" + // InternalScope.g:10596: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 { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:10600:1: ( rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 ) + // InternalScope.g:10601:2: rule__RelationalExpression__Group_1__1__Impl rule__RelationalExpression__Group_1__2 + { + pushFollow(FOLLOW_57); + rule__RelationalExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__RelationalExpression__Group_1__2(); + + state._fsp--; + if (state.failed) return ; } @@ -34305,32 +36637,38 @@ public final void rule__NamedScopeExpression__CaseDefAssignment_1_0() throws Rec } return ; } - // $ANTLR end "rule__NamedScopeExpression__CaseDefAssignment_1_0" + // $ANTLR end "rule__RelationalExpression__Group_1__1" - // $ANTLR start "rule__NamedScopeExpression__CasingAssignment_1_1" - // InternalScope.g:10471:1: rule__NamedScopeExpression__CasingAssignment_1_1 : ( ruleCasing ) ; - public final void rule__NamedScopeExpression__CasingAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__1__Impl" + // InternalScope.g:10608:1: rule__RelationalExpression__Group_1__1__Impl : ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ; + public final void rule__RelationalExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10475:1: ( ( ruleCasing ) ) - // InternalScope.g:10476:2: ( ruleCasing ) + // InternalScope.g:10612:1: ( ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) ) + // InternalScope.g:10613:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) { - // InternalScope.g:10476:2: ( ruleCasing ) - // InternalScope.g:10477:3: ruleCasing + // InternalScope.g:10613:1: ( ( rule__RelationalExpression__OperatorAssignment_1_1 ) ) + // InternalScope.g:10614:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); + before(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } + // InternalScope.g:10615:2: ( rule__RelationalExpression__OperatorAssignment_1_1 ) + // InternalScope.g:10615:3: rule__RelationalExpression__OperatorAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleCasing(); + rule__RelationalExpression__OperatorAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); + after(grammarAccess.getRelationalExpressionAccess().getOperatorAssignment_1_1()); } } @@ -34350,36 +36688,24 @@ public final void rule__NamedScopeExpression__CasingAssignment_1_1() throws Reco } return ; } - // $ANTLR end "rule__NamedScopeExpression__CasingAssignment_1_1" + // $ANTLR end "rule__RelationalExpression__Group_1__1__Impl" - // $ANTLR start "rule__NamedScopeExpression__NamingAssignment_2_1" - // InternalScope.g:10486:1: rule__NamedScopeExpression__NamingAssignment_2_1 : ( ruleNaming ) ; - public final void rule__NamedScopeExpression__NamingAssignment_2_1() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__2" + // InternalScope.g:10623:1: rule__RelationalExpression__Group_1__2 : rule__RelationalExpression__Group_1__2__Impl ; + public final void rule__RelationalExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10490:1: ( ( ruleNaming ) ) - // InternalScope.g:10491:2: ( ruleNaming ) - { - // InternalScope.g:10491:2: ( ruleNaming ) - // InternalScope.g:10492:3: ruleNaming + // InternalScope.g:10627:1: ( rule__RelationalExpression__Group_1__2__Impl ) + // InternalScope.g:10628:2: rule__RelationalExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); - } pushFollow(FOLLOW_2); - ruleNaming(); + rule__RelationalExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); - } - - } - } @@ -34395,44 +36721,38 @@ public final void rule__NamedScopeExpression__NamingAssignment_2_1() throws Reco } return ; } - // $ANTLR end "rule__NamedScopeExpression__NamingAssignment_2_1" + // $ANTLR end "rule__RelationalExpression__Group_1__2" - // $ANTLR start "rule__GlobalScopeExpression__TypeAssignment_2" - // InternalScope.g:10501:1: rule__GlobalScopeExpression__TypeAssignment_2 : ( ( ruleQualifiedID ) ) ; - public final void rule__GlobalScopeExpression__TypeAssignment_2() throws RecognitionException { + // $ANTLR start "rule__RelationalExpression__Group_1__2__Impl" + // InternalScope.g:10634:1: rule__RelationalExpression__Group_1__2__Impl : ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ; + public final void rule__RelationalExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10505:1: ( ( ( ruleQualifiedID ) ) ) - // InternalScope.g:10506:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:10638:1: ( ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) ) + // InternalScope.g:10639:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) { - // InternalScope.g:10506:2: ( ( ruleQualifiedID ) ) - // InternalScope.g:10507:3: ( ruleQualifiedID ) + // InternalScope.g:10639:1: ( ( rule__RelationalExpression__RightAssignment_1_2 ) ) + // InternalScope.g:10640:2: ( rule__RelationalExpression__RightAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); + before(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } - // InternalScope.g:10508:3: ( ruleQualifiedID ) - // InternalScope.g:10509:4: ruleQualifiedID + // InternalScope.g:10641:2: ( rule__RelationalExpression__RightAssignment_1_2 ) + // InternalScope.g:10641:3: rule__RelationalExpression__RightAssignment_1_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); - } pushFollow(FOLLOW_2); - ruleQualifiedID(); + rule__RelationalExpression__RightAssignment_1_2(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); - } } if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); + after(grammarAccess.getRelationalExpressionAccess().getRightAssignment_1_2()); } } @@ -34452,36 +36772,29 @@ public final void rule__GlobalScopeExpression__TypeAssignment_2() throws Recogni } return ; } - // $ANTLR end "rule__GlobalScopeExpression__TypeAssignment_2" + // $ANTLR end "rule__RelationalExpression__Group_1__2__Impl" - // $ANTLR start "rule__GlobalScopeExpression__NameAssignment_3_0_3" - // InternalScope.g:10520:1: rule__GlobalScopeExpression__NameAssignment_3_0_3 : ( ruleExpression ) ; - public final void rule__GlobalScopeExpression__NameAssignment_3_0_3() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__0" + // InternalScope.g:10650:1: rule__AdditiveExpression__Group__0 : rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ; + public final void rule__AdditiveExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10524:1: ( ( ruleExpression ) ) - // InternalScope.g:10525:2: ( ruleExpression ) - { - // InternalScope.g:10525:2: ( ruleExpression ) - // InternalScope.g:10526:3: ruleExpression + // InternalScope.g:10654:1: ( rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 ) + // InternalScope.g:10655:2: rule__AdditiveExpression__Group__0__Impl rule__AdditiveExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_66); + rule__AdditiveExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -34497,40 +36810,32 @@ public final void rule__GlobalScopeExpression__NameAssignment_3_0_3() throws Rec } return ; } - // $ANTLR end "rule__GlobalScopeExpression__NameAssignment_3_0_3" + // $ANTLR end "rule__AdditiveExpression__Group__0" - // $ANTLR start "rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1" - // InternalScope.g:10535:1: rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 : ( ( 'recursive' ) ) ; - public final void rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__0__Impl" + // InternalScope.g:10662:1: rule__AdditiveExpression__Group__0__Impl : ( ruleMultiplicativeExpression ) ; + public final void rule__AdditiveExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10539:1: ( ( ( 'recursive' ) ) ) - // InternalScope.g:10540:2: ( ( 'recursive' ) ) + // InternalScope.g:10666:1: ( ( ruleMultiplicativeExpression ) ) + // InternalScope.g:10667:1: ( ruleMultiplicativeExpression ) { - // InternalScope.g:10540:2: ( ( 'recursive' ) ) - // InternalScope.g:10541:3: ( 'recursive' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); - } - // InternalScope.g:10542:3: ( 'recursive' ) - // InternalScope.g:10543:4: 'recursive' + // InternalScope.g:10667:1: ( ruleMultiplicativeExpression ) + // InternalScope.g:10668:2: ruleMultiplicativeExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); - } - match(input,80,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); - } - + before(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } + pushFollow(FOLLOW_2); + ruleMultiplicativeExpression(); + state._fsp--; + if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getMultiplicativeExpressionParserRuleCall_0()); } } @@ -34550,36 +36855,24 @@ public final void rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1() } return ; } - // $ANTLR end "rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1" + // $ANTLR end "rule__AdditiveExpression__Group__0__Impl" - // $ANTLR start "rule__GlobalScopeExpression__PrefixAssignment_3_1_4" - // InternalScope.g:10554:1: rule__GlobalScopeExpression__PrefixAssignment_3_1_4 : ( ruleExpression ) ; - public final void rule__GlobalScopeExpression__PrefixAssignment_3_1_4() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__1" + // InternalScope.g:10677:1: rule__AdditiveExpression__Group__1 : rule__AdditiveExpression__Group__1__Impl ; + public final void rule__AdditiveExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10558:1: ( ( ruleExpression ) ) - // InternalScope.g:10559:2: ( ruleExpression ) + // InternalScope.g:10681:1: ( rule__AdditiveExpression__Group__1__Impl ) + // InternalScope.g:10682:2: rule__AdditiveExpression__Group__1__Impl { - // InternalScope.g:10559:2: ( ruleExpression ) - // InternalScope.g:10560:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__AdditiveExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); - } - - } - } @@ -34595,32 +36888,56 @@ public final void rule__GlobalScopeExpression__PrefixAssignment_3_1_4() throws R } return ; } - // $ANTLR end "rule__GlobalScopeExpression__PrefixAssignment_3_1_4" + // $ANTLR end "rule__AdditiveExpression__Group__1" - // $ANTLR start "rule__GlobalScopeExpression__DataAssignment_4_4" - // InternalScope.g:10569:1: rule__GlobalScopeExpression__DataAssignment_4_4 : ( ruleDataExpression ) ; - public final void rule__GlobalScopeExpression__DataAssignment_4_4() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group__1__Impl" + // InternalScope.g:10688:1: rule__AdditiveExpression__Group__1__Impl : ( ( rule__AdditiveExpression__Group_1__0 )* ) ; + public final void rule__AdditiveExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10573:1: ( ( ruleDataExpression ) ) - // InternalScope.g:10574:2: ( ruleDataExpression ) + // InternalScope.g:10692:1: ( ( ( rule__AdditiveExpression__Group_1__0 )* ) ) + // InternalScope.g:10693:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) { - // InternalScope.g:10574:2: ( ruleDataExpression ) - // InternalScope.g:10575:3: ruleDataExpression + // InternalScope.g:10693:1: ( ( rule__AdditiveExpression__Group_1__0 )* ) + // InternalScope.g:10694:2: ( rule__AdditiveExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); + before(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleDataExpression(); + // InternalScope.g:10695:2: ( rule__AdditiveExpression__Group_1__0 )* + loop103: + do { + int alt103=2; + int LA103_0 = input.LA(1); + + if ( ((LA103_0>=23 && LA103_0<=24)) ) { + alt103=1; + } + + + switch (alt103) { + case 1 : + // InternalScope.g:10695:3: rule__AdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_67); + rule__AdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop103; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); + after(grammarAccess.getAdditiveExpressionAccess().getGroup_1()); } } @@ -34640,36 +36957,29 @@ public final void rule__GlobalScopeExpression__DataAssignment_4_4() throws Recog } return ; } - // $ANTLR end "rule__GlobalScopeExpression__DataAssignment_4_4" + // $ANTLR end "rule__AdditiveExpression__Group__1__Impl" - // $ANTLR start "rule__GlobalScopeExpression__DataAssignment_4_5_1" - // InternalScope.g:10584:1: rule__GlobalScopeExpression__DataAssignment_4_5_1 : ( ruleDataExpression ) ; - public final void rule__GlobalScopeExpression__DataAssignment_4_5_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__0" + // InternalScope.g:10704: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 { int stackSize = keepStackSize(); try { - // InternalScope.g:10588:1: ( ( ruleDataExpression ) ) - // InternalScope.g:10589:2: ( ruleDataExpression ) - { - // InternalScope.g:10589:2: ( ruleDataExpression ) - // InternalScope.g:10590:3: ruleDataExpression + // InternalScope.g:10708:1: ( rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 ) + // InternalScope.g:10709:2: rule__AdditiveExpression__Group_1__0__Impl rule__AdditiveExpression__Group_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); - } - pushFollow(FOLLOW_2); - ruleDataExpression(); + pushFollow(FOLLOW_66); + rule__AdditiveExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -34685,40 +36995,32 @@ public final void rule__GlobalScopeExpression__DataAssignment_4_5_1() throws Rec } return ; } - // $ANTLR end "rule__GlobalScopeExpression__DataAssignment_4_5_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__0" - // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_0" - // InternalScope.g:10599:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_0 : ( ( '*' ) ) ; - public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__0__Impl" + // InternalScope.g:10716:1: rule__AdditiveExpression__Group_1__0__Impl : ( () ) ; + public final void rule__AdditiveExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10603:1: ( ( ( '*' ) ) ) - // InternalScope.g:10604:2: ( ( '*' ) ) + // InternalScope.g:10720:1: ( ( () ) ) + // InternalScope.g:10721:1: ( () ) { - // InternalScope.g:10604:2: ( ( '*' ) ) - // InternalScope.g:10605:3: ( '*' ) + // InternalScope.g:10721:1: ( () ) + // InternalScope.g:10722:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); + before(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } - // InternalScope.g:10606:3: ( '*' ) - // InternalScope.g:10607:4: '*' + // InternalScope.g:10723:2: () + // InternalScope.g:10723:3: { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); - } - match(input,20,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); - } - } if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); + after(grammarAccess.getAdditiveExpressionAccess().getOperationCallParamsAction_1_0()); } } @@ -34727,10 +37029,6 @@ public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_0() throws } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -34738,36 +37036,29 @@ public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_0() throws } return ; } - // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_0" + // $ANTLR end "rule__AdditiveExpression__Group_1__0__Impl" - // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_1" - // InternalScope.g:10618:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_1 : ( ruleIdentifier ) ; - public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__1" + // InternalScope.g:10731: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 { int stackSize = keepStackSize(); try { - // InternalScope.g:10622:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10623:2: ( ruleIdentifier ) - { - // InternalScope.g:10623:2: ( ruleIdentifier ) - // InternalScope.g:10624:3: ruleIdentifier + // InternalScope.g:10735:1: ( rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 ) + // InternalScope.g:10736:2: rule__AdditiveExpression__Group_1__1__Impl rule__AdditiveExpression__Group_1__2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_57); + rule__AdditiveExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__AdditiveExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -34783,32 +37074,38 @@ public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_1() throws } return ; } - // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__1" - // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1" - // InternalScope.g:10633:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 : ( ruleIdentifier ) ; - public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__1__Impl" + // InternalScope.g:10743:1: rule__AdditiveExpression__Group_1__1__Impl : ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ; + public final void rule__AdditiveExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10637:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10638:2: ( ruleIdentifier ) + // InternalScope.g:10747:1: ( ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) ) + // InternalScope.g:10748:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) { - // InternalScope.g:10638:2: ( ruleIdentifier ) - // InternalScope.g:10639:3: ruleIdentifier + // InternalScope.g:10748:1: ( ( rule__AdditiveExpression__NameAssignment_1_1 ) ) + // InternalScope.g:10749:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); + before(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } + // InternalScope.g:10750:2: ( rule__AdditiveExpression__NameAssignment_1_1 ) + // InternalScope.g:10750:3: rule__AdditiveExpression__NameAssignment_1_1 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__AdditiveExpression__NameAssignment_1_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); + after(grammarAccess.getAdditiveExpressionAccess().getNameAssignment_1_1()); } } @@ -34828,36 +37125,24 @@ public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1() throw } return ; } - // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__1__Impl" - // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1" - // InternalScope.g:10648:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 : ( ruleIdentifier ) ; - public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__2" + // InternalScope.g:10758:1: rule__AdditiveExpression__Group_1__2 : rule__AdditiveExpression__Group_1__2__Impl ; + public final void rule__AdditiveExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10652:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10653:2: ( ruleIdentifier ) + // InternalScope.g:10762:1: ( rule__AdditiveExpression__Group_1__2__Impl ) + // InternalScope.g:10763:2: rule__AdditiveExpression__Group_1__2__Impl { - // InternalScope.g:10653:2: ( ruleIdentifier ) - // InternalScope.g:10654:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); - } pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__AdditiveExpression__Group_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); - } - - } - } @@ -34873,32 +37158,38 @@ public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1() thr } return ; } - // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1" + // $ANTLR end "rule__AdditiveExpression__Group_1__2" - // $ANTLR start "rule__MatchDataExpression__KeyAssignment_0" - // InternalScope.g:10663:1: rule__MatchDataExpression__KeyAssignment_0 : ( ruleIdentifier ) ; - public final void rule__MatchDataExpression__KeyAssignment_0() throws RecognitionException { + // $ANTLR start "rule__AdditiveExpression__Group_1__2__Impl" + // InternalScope.g:10769:1: rule__AdditiveExpression__Group_1__2__Impl : ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ; + public final void rule__AdditiveExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10667:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10668:2: ( ruleIdentifier ) + // InternalScope.g:10773:1: ( ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) ) + // InternalScope.g:10774:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) { - // InternalScope.g:10668:2: ( ruleIdentifier ) - // InternalScope.g:10669:3: ruleIdentifier + // InternalScope.g:10774:1: ( ( rule__AdditiveExpression__ParamsAssignment_1_2 ) ) + // InternalScope.g:10775:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); + before(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } + // InternalScope.g:10776:2: ( rule__AdditiveExpression__ParamsAssignment_1_2 ) + // InternalScope.g:10776:3: rule__AdditiveExpression__ParamsAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__AdditiveExpression__ParamsAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); + after(grammarAccess.getAdditiveExpressionAccess().getParamsAssignment_1_2()); } } @@ -34918,36 +37209,29 @@ public final void rule__MatchDataExpression__KeyAssignment_0() throws Recognitio } return ; } - // $ANTLR end "rule__MatchDataExpression__KeyAssignment_0" + // $ANTLR end "rule__AdditiveExpression__Group_1__2__Impl" - // $ANTLR start "rule__MatchDataExpression__ValueAssignment_2" - // InternalScope.g:10678:1: rule__MatchDataExpression__ValueAssignment_2 : ( ruleExpression ) ; - public final void rule__MatchDataExpression__ValueAssignment_2() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__0" + // InternalScope.g:10785:1: rule__MultiplicativeExpression__Group__0 : rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ; + public final void rule__MultiplicativeExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10682:1: ( ( ruleExpression ) ) - // InternalScope.g:10683:2: ( ruleExpression ) + // InternalScope.g:10789:1: ( rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 ) + // InternalScope.g:10790:2: rule__MultiplicativeExpression__Group__0__Impl rule__MultiplicativeExpression__Group__1 { - // InternalScope.g:10683:2: ( ruleExpression ) - // InternalScope.g:10684:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_68); + rule__MultiplicativeExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -34963,32 +37247,32 @@ public final void rule__MatchDataExpression__ValueAssignment_2() throws Recognit } return ; } - // $ANTLR end "rule__MatchDataExpression__ValueAssignment_2" + // $ANTLR end "rule__MultiplicativeExpression__Group__0" - // $ANTLR start "rule__LambdaDataExpression__DescAssignment_1" - // InternalScope.g:10693:1: rule__LambdaDataExpression__DescAssignment_1 : ( ruleIdentifier ) ; - public final void rule__LambdaDataExpression__DescAssignment_1() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__0__Impl" + // InternalScope.g:10797:1: rule__MultiplicativeExpression__Group__0__Impl : ( ruleUnaryOrInfixExpression ) ; + public final void rule__MultiplicativeExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10697:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10698:2: ( ruleIdentifier ) + // InternalScope.g:10801:1: ( ( ruleUnaryOrInfixExpression ) ) + // InternalScope.g:10802:1: ( ruleUnaryOrInfixExpression ) { - // InternalScope.g:10698:2: ( ruleIdentifier ) - // InternalScope.g:10699:3: ruleIdentifier + // InternalScope.g:10802:1: ( ruleUnaryOrInfixExpression ) + // InternalScope.g:10803:2: ruleUnaryOrInfixExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleIdentifier(); + ruleUnaryOrInfixExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getUnaryOrInfixExpressionParserRuleCall_0()); } } @@ -35008,36 +37292,24 @@ public final void rule__LambdaDataExpression__DescAssignment_1() throws Recognit } return ; } - // $ANTLR end "rule__LambdaDataExpression__DescAssignment_1" + // $ANTLR end "rule__MultiplicativeExpression__Group__0__Impl" - // $ANTLR start "rule__LambdaDataExpression__ValueAssignment_3" - // InternalScope.g:10708:1: rule__LambdaDataExpression__ValueAssignment_3 : ( ruleExpression ) ; - public final void rule__LambdaDataExpression__ValueAssignment_3() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__1" + // InternalScope.g:10812:1: rule__MultiplicativeExpression__Group__1 : rule__MultiplicativeExpression__Group__1__Impl ; + public final void rule__MultiplicativeExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10712:1: ( ( ruleExpression ) ) - // InternalScope.g:10713:2: ( ruleExpression ) - { - // InternalScope.g:10713:2: ( ruleExpression ) - // InternalScope.g:10714:3: ruleExpression + // InternalScope.g:10816:1: ( rule__MultiplicativeExpression__Group__1__Impl ) + // InternalScope.g:10817:2: rule__MultiplicativeExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__MultiplicativeExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); - } - - } - } @@ -35053,32 +37325,56 @@ public final void rule__LambdaDataExpression__ValueAssignment_3() throws Recogni } return ; } - // $ANTLR end "rule__LambdaDataExpression__ValueAssignment_3" + // $ANTLR end "rule__MultiplicativeExpression__Group__1" - // $ANTLR start "rule__SimpleScopeExpression__ExprAssignment" - // InternalScope.g:10723:1: rule__SimpleScopeExpression__ExprAssignment : ( ruleExpression ) ; - public final void rule__SimpleScopeExpression__ExprAssignment() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group__1__Impl" + // InternalScope.g:10823:1: rule__MultiplicativeExpression__Group__1__Impl : ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ; + public final void rule__MultiplicativeExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10727:1: ( ( ruleExpression ) ) - // InternalScope.g:10728:2: ( ruleExpression ) + // InternalScope.g:10827:1: ( ( ( rule__MultiplicativeExpression__Group_1__0 )* ) ) + // InternalScope.g:10828:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) { - // InternalScope.g:10728:2: ( ruleExpression ) - // InternalScope.g:10729:3: ruleExpression + // InternalScope.g:10828:1: ( ( rule__MultiplicativeExpression__Group_1__0 )* ) + // InternalScope.g:10829:2: ( rule__MultiplicativeExpression__Group_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } - pushFollow(FOLLOW_2); - ruleExpression(); + // InternalScope.g:10830:2: ( rule__MultiplicativeExpression__Group_1__0 )* + loop104: + do { + int alt104=2; + int LA104_0 = input.LA(1); + + if ( ((LA104_0>=25 && LA104_0<=26)) ) { + alt104=1; + } + + + switch (alt104) { + case 1 : + // InternalScope.g:10830:3: rule__MultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_69); + rule__MultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop104; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getGroup_1()); } } @@ -35098,36 +37394,29 @@ public final void rule__SimpleScopeExpression__ExprAssignment() throws Recogniti } return ; } - // $ANTLR end "rule__SimpleScopeExpression__ExprAssignment" + // $ANTLR end "rule__MultiplicativeExpression__Group__1__Impl" - // $ANTLR start "rule__Naming__NamesAssignment_0_0_1" - // InternalScope.g:10738:1: rule__Naming__NamesAssignment_0_0_1 : ( ruleNamingExpression ) ; - public final void rule__Naming__NamesAssignment_0_0_1() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__0" + // InternalScope.g:10839: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 { int stackSize = keepStackSize(); try { - // InternalScope.g:10742:1: ( ( ruleNamingExpression ) ) - // InternalScope.g:10743:2: ( ruleNamingExpression ) + // InternalScope.g:10843:1: ( rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 ) + // InternalScope.g:10844:2: rule__MultiplicativeExpression__Group_1__0__Impl rule__MultiplicativeExpression__Group_1__1 { - // InternalScope.g:10743:2: ( ruleNamingExpression ) - // InternalScope.g:10744:3: ruleNamingExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); - } - pushFollow(FOLLOW_2); - ruleNamingExpression(); + pushFollow(FOLLOW_68); + rule__MultiplicativeExpression__Group_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -35143,32 +37432,32 @@ public final void rule__Naming__NamesAssignment_0_0_1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__Naming__NamesAssignment_0_0_1" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__0" - // $ANTLR start "rule__Naming__NamesAssignment_0_0_2_1" - // InternalScope.g:10753:1: rule__Naming__NamesAssignment_0_0_2_1 : ( ruleNamingExpression ) ; - public final void rule__Naming__NamesAssignment_0_0_2_1() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__0__Impl" + // InternalScope.g:10851:1: rule__MultiplicativeExpression__Group_1__0__Impl : ( () ) ; + public final void rule__MultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10757:1: ( ( ruleNamingExpression ) ) - // InternalScope.g:10758:2: ( ruleNamingExpression ) + // InternalScope.g:10855:1: ( ( () ) ) + // InternalScope.g:10856:1: ( () ) { - // InternalScope.g:10758:2: ( ruleNamingExpression ) - // InternalScope.g:10759:3: ruleNamingExpression + // InternalScope.g:10856:1: ( () ) + // InternalScope.g:10857:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); + } + // InternalScope.g:10858:2: () + // InternalScope.g:10858:3: + { } - pushFollow(FOLLOW_2); - ruleNamingExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getOperationCallParamsAction_1_0()); } } @@ -35177,10 +37466,6 @@ public final void rule__Naming__NamesAssignment_0_0_2_1() throws RecognitionExce } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -35188,36 +37473,29 @@ public final void rule__Naming__NamesAssignment_0_0_2_1() throws RecognitionExce } return ; } - // $ANTLR end "rule__Naming__NamesAssignment_0_0_2_1" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__0__Impl" - // $ANTLR start "rule__Naming__NamesAssignment_1" - // InternalScope.g:10768:1: rule__Naming__NamesAssignment_1 : ( ruleNamingExpression ) ; - public final void rule__Naming__NamesAssignment_1() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__1" + // InternalScope.g:10866: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 { int stackSize = keepStackSize(); try { - // InternalScope.g:10772:1: ( ( ruleNamingExpression ) ) - // InternalScope.g:10773:2: ( ruleNamingExpression ) - { - // InternalScope.g:10773:2: ( ruleNamingExpression ) - // InternalScope.g:10774:3: ruleNamingExpression + // InternalScope.g:10870:1: ( rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 ) + // InternalScope.g:10871:2: rule__MultiplicativeExpression__Group_1__1__Impl rule__MultiplicativeExpression__Group_1__2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleNamingExpression(); + pushFollow(FOLLOW_57); + rule__MultiplicativeExpression__Group_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -35233,40 +37511,38 @@ public final void rule__Naming__NamesAssignment_1() throws RecognitionException } return ; } - // $ANTLR end "rule__Naming__NamesAssignment_1" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__1" - // $ANTLR start "rule__NamingExpression__ExportAssignment_0" - // InternalScope.g:10783:1: rule__NamingExpression__ExportAssignment_0 : ( ( 'export' ) ) ; - public final void rule__NamingExpression__ExportAssignment_0() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__1__Impl" + // InternalScope.g:10878:1: rule__MultiplicativeExpression__Group_1__1__Impl : ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ; + public final void rule__MultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10787:1: ( ( ( 'export' ) ) ) - // InternalScope.g:10788:2: ( ( 'export' ) ) + // InternalScope.g:10882:1: ( ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) ) + // InternalScope.g:10883:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) { - // InternalScope.g:10788:2: ( ( 'export' ) ) - // InternalScope.g:10789:3: ( 'export' ) + // InternalScope.g:10883:1: ( ( rule__MultiplicativeExpression__NameAssignment_1_1 ) ) + // InternalScope.g:10884:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } - // InternalScope.g:10790:3: ( 'export' ) - // InternalScope.g:10791:4: 'export' + // InternalScope.g:10885:2: ( rule__MultiplicativeExpression__NameAssignment_1_1 ) + // InternalScope.g:10885:3: rule__MultiplicativeExpression__NameAssignment_1_1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); - } - match(input,81,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__NameAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAssignment_1_1()); } } @@ -35286,44 +37562,24 @@ public final void rule__NamingExpression__ExportAssignment_0() throws Recognitio } return ; } - // $ANTLR end "rule__NamingExpression__ExportAssignment_0" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__1__Impl" - // $ANTLR start "rule__NamingExpression__FactoryAssignment_1_0" - // InternalScope.g:10802:1: rule__NamingExpression__FactoryAssignment_1_0 : ( ( 'factory' ) ) ; - public final void rule__NamingExpression__FactoryAssignment_1_0() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__2" + // InternalScope.g:10893:1: rule__MultiplicativeExpression__Group_1__2 : rule__MultiplicativeExpression__Group_1__2__Impl ; + public final void rule__MultiplicativeExpression__Group_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10806:1: ( ( ( 'factory' ) ) ) - // InternalScope.g:10807:2: ( ( 'factory' ) ) - { - // InternalScope.g:10807:2: ( ( 'factory' ) ) - // InternalScope.g:10808:3: ( 'factory' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); - } - // InternalScope.g:10809:3: ( 'factory' ) - // InternalScope.g:10810:4: 'factory' + // InternalScope.g:10897:1: ( rule__MultiplicativeExpression__Group_1__2__Impl ) + // InternalScope.g:10898:2: rule__MultiplicativeExpression__Group_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); - } - match(input,58,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__Group_1__2__Impl(); + state._fsp--; + if (state.failed) return ; } @@ -35339,32 +37595,38 @@ public final void rule__NamingExpression__FactoryAssignment_1_0() throws Recogni } return ; } - // $ANTLR end "rule__NamingExpression__FactoryAssignment_1_0" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__2" - // $ANTLR start "rule__NamingExpression__ExpressionAssignment_1_1" - // InternalScope.g:10821:1: rule__NamingExpression__ExpressionAssignment_1_1 : ( ruleExpression ) ; - public final void rule__NamingExpression__ExpressionAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__MultiplicativeExpression__Group_1__2__Impl" + // InternalScope.g:10904:1: rule__MultiplicativeExpression__Group_1__2__Impl : ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ; + public final void rule__MultiplicativeExpression__Group_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10825:1: ( ( ruleExpression ) ) - // InternalScope.g:10826:2: ( ruleExpression ) + // InternalScope.g:10908:1: ( ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) ) + // InternalScope.g:10909:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) { - // InternalScope.g:10826:2: ( ruleExpression ) - // InternalScope.g:10827:3: ruleExpression + // InternalScope.g:10909:1: ( ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) ) + // InternalScope.g:10910:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); + before(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } + // InternalScope.g:10911:2: ( rule__MultiplicativeExpression__ParamsAssignment_1_2 ) + // InternalScope.g:10911:3: rule__MultiplicativeExpression__ParamsAssignment_1_2 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__MultiplicativeExpression__ParamsAssignment_1_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); + after(grammarAccess.getMultiplicativeExpressionAccess().getParamsAssignment_1_2()); } } @@ -35384,36 +37646,29 @@ public final void rule__NamingExpression__ExpressionAssignment_1_1() throws Reco } return ; } - // $ANTLR end "rule__NamingExpression__ExpressionAssignment_1_1" + // $ANTLR end "rule__MultiplicativeExpression__Group_1__2__Impl" - // $ANTLR start "rule__LetExpression__IdentifierAssignment_1" - // InternalScope.g:10836:1: rule__LetExpression__IdentifierAssignment_1 : ( ruleIdentifier ) ; - public final void rule__LetExpression__IdentifierAssignment_1() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__0" + // InternalScope.g:10920:1: rule__UnaryExpression__Group__0 : rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ; + public final void rule__UnaryExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10840:1: ( ( ruleIdentifier ) ) - // InternalScope.g:10841:2: ( ruleIdentifier ) + // InternalScope.g:10924:1: ( rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 ) + // InternalScope.g:10925:2: rule__UnaryExpression__Group__0__Impl rule__UnaryExpression__Group__1 { - // InternalScope.g:10841:2: ( ruleIdentifier ) - // InternalScope.g:10842:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_57); + rule__UnaryExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__UnaryExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -35429,32 +37684,38 @@ public final void rule__LetExpression__IdentifierAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__LetExpression__IdentifierAssignment_1" + // $ANTLR end "rule__UnaryExpression__Group__0" - // $ANTLR start "rule__LetExpression__VarExprAssignment_3" - // InternalScope.g:10851:1: rule__LetExpression__VarExprAssignment_3 : ( ruleExpression ) ; - public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__0__Impl" + // InternalScope.g:10932:1: rule__UnaryExpression__Group__0__Impl : ( ( rule__UnaryExpression__NameAssignment_0 ) ) ; + public final void rule__UnaryExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10855:1: ( ( ruleExpression ) ) - // InternalScope.g:10856:2: ( ruleExpression ) + // InternalScope.g:10936:1: ( ( ( rule__UnaryExpression__NameAssignment_0 ) ) ) + // InternalScope.g:10937:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) { - // InternalScope.g:10856:2: ( ruleExpression ) - // InternalScope.g:10857:3: ruleExpression + // InternalScope.g:10937:1: ( ( rule__UnaryExpression__NameAssignment_0 ) ) + // InternalScope.g:10938:2: ( rule__UnaryExpression__NameAssignment_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + before(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } + // InternalScope.g:10939:2: ( rule__UnaryExpression__NameAssignment_0 ) + // InternalScope.g:10939:3: rule__UnaryExpression__NameAssignment_0 + { pushFollow(FOLLOW_2); - ruleExpression(); + rule__UnaryExpression__NameAssignment_0(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + after(grammarAccess.getUnaryExpressionAccess().getNameAssignment_0()); } } @@ -35474,36 +37735,24 @@ public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionE } return ; } - // $ANTLR end "rule__LetExpression__VarExprAssignment_3" + // $ANTLR end "rule__UnaryExpression__Group__0__Impl" - // $ANTLR start "rule__LetExpression__TargetAssignment_5" - // InternalScope.g:10866:1: rule__LetExpression__TargetAssignment_5 : ( ruleExpression ) ; - public final void rule__LetExpression__TargetAssignment_5() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__1" + // InternalScope.g:10947:1: rule__UnaryExpression__Group__1 : rule__UnaryExpression__Group__1__Impl ; + public final void rule__UnaryExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10870:1: ( ( ruleExpression ) ) - // InternalScope.g:10871:2: ( ruleExpression ) - { - // InternalScope.g:10871:2: ( ruleExpression ) - // InternalScope.g:10872:3: ruleExpression + // InternalScope.g:10951:1: ( rule__UnaryExpression__Group__1__Impl ) + // InternalScope.g:10952:2: rule__UnaryExpression__Group__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); - } pushFollow(FOLLOW_2); - ruleExpression(); + rule__UnaryExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); - } - - } - } @@ -35519,32 +37768,38 @@ public final void rule__LetExpression__TargetAssignment_5() throws RecognitionEx } return ; } - // $ANTLR end "rule__LetExpression__TargetAssignment_5" + // $ANTLR end "rule__UnaryExpression__Group__1" - // $ANTLR start "rule__CastedExpression__TypeAssignment_1" - // InternalScope.g:10881:1: rule__CastedExpression__TypeAssignment_1 : ( ruleType ) ; - public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__UnaryExpression__Group__1__Impl" + // InternalScope.g:10958:1: rule__UnaryExpression__Group__1__Impl : ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ; + public final void rule__UnaryExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10885:1: ( ( ruleType ) ) - // InternalScope.g:10886:2: ( ruleType ) + // InternalScope.g:10962:1: ( ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) ) + // InternalScope.g:10963:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) { - // InternalScope.g:10886:2: ( ruleType ) - // InternalScope.g:10887:3: ruleType + // InternalScope.g:10963:1: ( ( rule__UnaryExpression__ParamsAssignment_1 ) ) + // InternalScope.g:10964:2: ( rule__UnaryExpression__ParamsAssignment_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + before(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } + // InternalScope.g:10965:2: ( rule__UnaryExpression__ParamsAssignment_1 ) + // InternalScope.g:10965:3: rule__UnaryExpression__ParamsAssignment_1 + { pushFollow(FOLLOW_2); - ruleType(); + rule__UnaryExpression__ParamsAssignment_1(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + after(grammarAccess.getUnaryExpressionAccess().getParamsAssignment_1()); } } @@ -35564,36 +37819,29 @@ public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionE } return ; } - // $ANTLR end "rule__CastedExpression__TypeAssignment_1" + // $ANTLR end "rule__UnaryExpression__Group__1__Impl" - // $ANTLR start "rule__CastedExpression__TargetAssignment_3" - // InternalScope.g:10896:1: rule__CastedExpression__TargetAssignment_3 : ( ruleExpression ) ; - public final void rule__CastedExpression__TargetAssignment_3() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__0" + // InternalScope.g:10974:1: rule__InfixExpression__Group__0 : rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ; + public final void rule__InfixExpression__Group__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10900:1: ( ( ruleExpression ) ) - // InternalScope.g:10901:2: ( ruleExpression ) - { - // InternalScope.g:10901:2: ( ruleExpression ) - // InternalScope.g:10902:3: ruleExpression + // InternalScope.g:10978:1: ( rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 ) + // InternalScope.g:10979:2: rule__InfixExpression__Group__0__Impl rule__InfixExpression__Group__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_45); + rule__InfixExpression__Group__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group__1(); + state._fsp--; + if (state.failed) return ; } @@ -35609,32 +37857,32 @@ public final void rule__CastedExpression__TargetAssignment_3() throws Recognitio } return ; } - // $ANTLR end "rule__CastedExpression__TargetAssignment_3" + // $ANTLR end "rule__InfixExpression__Group__0" - // $ANTLR start "rule__ChainExpression__NextAssignment_1_2" - // InternalScope.g:10911:1: rule__ChainExpression__NextAssignment_1_2 : ( ruleChainedExpression ) ; - public final void rule__ChainExpression__NextAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__0__Impl" + // InternalScope.g:10986:1: rule__InfixExpression__Group__0__Impl : ( rulePrimaryExpression ) ; + public final void rule__InfixExpression__Group__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10915:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:10916:2: ( ruleChainedExpression ) + // InternalScope.g:10990:1: ( ( rulePrimaryExpression ) ) + // InternalScope.g:10991:1: ( rulePrimaryExpression ) { - // InternalScope.g:10916:2: ( ruleChainedExpression ) - // InternalScope.g:10917:3: ruleChainedExpression + // InternalScope.g:10991:1: ( rulePrimaryExpression ) + // InternalScope.g:10992:2: rulePrimaryExpression { if ( state.backtracking==0 ) { - before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + before(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } pushFollow(FOLLOW_2); - ruleChainedExpression(); + rulePrimaryExpression(); state._fsp--; if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + after(grammarAccess.getInfixExpressionAccess().getPrimaryExpressionParserRuleCall_0()); } } @@ -35654,36 +37902,24 @@ public final void rule__ChainExpression__NextAssignment_1_2() throws Recognition } return ; } - // $ANTLR end "rule__ChainExpression__NextAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group__0__Impl" - // $ANTLR start "rule__IfExpressionTri__ThenPartAssignment_1_2" - // InternalScope.g:10926:1: rule__IfExpressionTri__ThenPartAssignment_1_2 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__1" + // InternalScope.g:11001:1: rule__InfixExpression__Group__1 : rule__InfixExpression__Group__1__Impl ; + public final void rule__InfixExpression__Group__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10930:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:10931:2: ( ruleChainedExpression ) + // InternalScope.g:11005:1: ( rule__InfixExpression__Group__1__Impl ) + // InternalScope.g:11006:2: rule__InfixExpression__Group__1__Impl { - // InternalScope.g:10931:2: ( ruleChainedExpression ) - // InternalScope.g:10932:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleChainedExpression(); + rule__InfixExpression__Group__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -35699,77 +37935,56 @@ public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws Recogni } return ; } - // $ANTLR end "rule__IfExpressionTri__ThenPartAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group__1" - // $ANTLR start "rule__IfExpressionTri__ElsePartAssignment_1_4" - // InternalScope.g:10941:1: rule__IfExpressionTri__ElsePartAssignment_1_4 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group__1__Impl" + // InternalScope.g:11012:1: rule__InfixExpression__Group__1__Impl : ( ( rule__InfixExpression__Alternatives_1 )* ) ; + public final void rule__InfixExpression__Group__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10945:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:10946:2: ( ruleChainedExpression ) + // InternalScope.g:11016:1: ( ( ( rule__InfixExpression__Alternatives_1 )* ) ) + // InternalScope.g:11017:1: ( ( rule__InfixExpression__Alternatives_1 )* ) { - // InternalScope.g:10946:2: ( ruleChainedExpression ) - // InternalScope.g:10947:3: ruleChainedExpression + // InternalScope.g:11017:1: ( ( rule__InfixExpression__Alternatives_1 )* ) + // InternalScope.g:11018:2: ( rule__InfixExpression__Alternatives_1 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); - } - - } - - + before(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } + // InternalScope.g:11019:2: ( rule__InfixExpression__Alternatives_1 )* + loop105: + do { + int alt105=2; + int LA105_0 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + if ( (LA105_0==58) ) { + alt105=1; + } - restoreStackSize(stackSize); - } - return ; - } - // $ANTLR end "rule__IfExpressionTri__ElsePartAssignment_1_4" + switch (alt105) { + case 1 : + // InternalScope.g:11019:3: rule__InfixExpression__Alternatives_1 + { + pushFollow(FOLLOW_46); + rule__InfixExpression__Alternatives_1(); + state._fsp--; + if (state.failed) return ; - // $ANTLR start "rule__IfExpressionKw__ConditionAssignment_1" - // InternalScope.g:10956:1: rule__IfExpressionKw__ConditionAssignment_1 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ConditionAssignment_1() throws RecognitionException { + } + break; - int stackSize = keepStackSize(); - - try { - // InternalScope.g:10960:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:10961:2: ( ruleChainedExpression ) - { - // InternalScope.g:10961:2: ( ruleChainedExpression ) - // InternalScope.g:10962:3: ruleChainedExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + default : + break loop105; + } + } while (true); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + after(grammarAccess.getInfixExpressionAccess().getAlternatives_1()); } } @@ -35789,36 +38004,29 @@ public final void rule__IfExpressionKw__ConditionAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__IfExpressionKw__ConditionAssignment_1" + // $ANTLR end "rule__InfixExpression__Group__1__Impl" - // $ANTLR start "rule__IfExpressionKw__ThenPartAssignment_3" - // InternalScope.g:10971:1: rule__IfExpressionKw__ThenPartAssignment_3 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ThenPartAssignment_3() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__0" + // InternalScope.g:11028:1: rule__InfixExpression__Group_1_0__0 : rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ; + public final void rule__InfixExpression__Group_1_0__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10975:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:10976:2: ( ruleChainedExpression ) - { - // InternalScope.g:10976:2: ( ruleChainedExpression ) - // InternalScope.g:10977:3: ruleChainedExpression + // InternalScope.g:11032:1: ( rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 ) + // InternalScope.g:11033:2: rule__InfixExpression__Group_1_0__0__Impl rule__InfixExpression__Group_1_0__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleChainedExpression(); + pushFollow(FOLLOW_45); + rule__InfixExpression__Group_1_0__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__1(); + state._fsp--; + if (state.failed) return ; } @@ -35834,32 +38042,32 @@ public final void rule__IfExpressionKw__ThenPartAssignment_3() throws Recognitio } return ; } - // $ANTLR end "rule__IfExpressionKw__ThenPartAssignment_3" + // $ANTLR end "rule__InfixExpression__Group_1_0__0" - // $ANTLR start "rule__IfExpressionKw__ElsePartAssignment_4_0_1" - // InternalScope.g:10986:1: rule__IfExpressionKw__ElsePartAssignment_4_0_1 : ( ruleChainedExpression ) ; - public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__0__Impl" + // InternalScope.g:11040:1: rule__InfixExpression__Group_1_0__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_0__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:10990:1: ( ( ruleChainedExpression ) ) - // InternalScope.g:10991:2: ( ruleChainedExpression ) + // InternalScope.g:11044:1: ( ( () ) ) + // InternalScope.g:11045:1: ( () ) { - // InternalScope.g:10991:2: ( ruleChainedExpression ) - // InternalScope.g:10992:3: ruleChainedExpression + // InternalScope.g:11045:1: ( () ) + // InternalScope.g:11046:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + before(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); + } + // InternalScope.g:11047:2: () + // InternalScope.g:11047:3: + { } - pushFollow(FOLLOW_2); - ruleChainedExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + after(grammarAccess.getInfixExpressionAccess().getOperationCallTargetAction_1_0_0()); } } @@ -35868,10 +38076,6 @@ public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws Recogn } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -35879,36 +38083,29 @@ public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws Recogn } return ; } - // $ANTLR end "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__0__Impl" - // $ANTLR start "rule__SwitchExpression__SwitchExprAssignment_1_1" - // InternalScope.g:11001:1: rule__SwitchExpression__SwitchExprAssignment_1_1 : ( ruleOrExpression ) ; - public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__1" + // InternalScope.g:11055:1: rule__InfixExpression__Group_1_0__1 : rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ; + public final void rule__InfixExpression__Group_1_0__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11005:1: ( ( ruleOrExpression ) ) - // InternalScope.g:11006:2: ( ruleOrExpression ) + // InternalScope.g:11059:1: ( rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 ) + // InternalScope.g:11060:2: rule__InfixExpression__Group_1_0__1__Impl rule__InfixExpression__Group_1_0__2 { - // InternalScope.g:11006:2: ( ruleOrExpression ) - // InternalScope.g:11007:3: ruleOrExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleOrExpression(); + pushFollow(FOLLOW_4); + rule__InfixExpression__Group_1_0__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__2(); + state._fsp--; + if (state.failed) return ; } @@ -35924,32 +38121,28 @@ public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws Reco } return ; } - // $ANTLR end "rule__SwitchExpression__SwitchExprAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__1" - // $ANTLR start "rule__SwitchExpression__CaseAssignment_3" - // InternalScope.g:11016:1: rule__SwitchExpression__CaseAssignment_3 : ( ruleCase ) ; - public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__1__Impl" + // InternalScope.g:11067:1: rule__InfixExpression__Group_1_0__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_0__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11020:1: ( ( ruleCase ) ) - // InternalScope.g:11021:2: ( ruleCase ) + // InternalScope.g:11071:1: ( ( '.' ) ) + // InternalScope.g:11072:1: ( '.' ) { - // InternalScope.g:11021:2: ( ruleCase ) - // InternalScope.g:11022:3: ruleCase + // InternalScope.g:11072:1: ( '.' ) + // InternalScope.g:11073:2: '.' { if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } - pushFollow(FOLLOW_2); - ruleCase(); - - state._fsp--; - if (state.failed) return ; + match(input,58,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); } } @@ -35969,36 +38162,29 @@ public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionE } return ; } - // $ANTLR end "rule__SwitchExpression__CaseAssignment_3" + // $ANTLR end "rule__InfixExpression__Group_1_0__1__Impl" - // $ANTLR start "rule__SwitchExpression__DefaultExprAssignment_6" - // InternalScope.g:11031:1: rule__SwitchExpression__DefaultExprAssignment_6 : ( ruleOrExpression ) ; - public final void rule__SwitchExpression__DefaultExprAssignment_6() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__2" + // InternalScope.g:11082:1: rule__InfixExpression__Group_1_0__2 : rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ; + public final void rule__InfixExpression__Group_1_0__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11035:1: ( ( ruleOrExpression ) ) - // InternalScope.g:11036:2: ( ruleOrExpression ) - { - // InternalScope.g:11036:2: ( ruleOrExpression ) - // InternalScope.g:11037:3: ruleOrExpression + // InternalScope.g:11086:1: ( rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 ) + // InternalScope.g:11087:2: rule__InfixExpression__Group_1_0__2__Impl rule__InfixExpression__Group_1_0__3 { - if ( state.backtracking==0 ) { - before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); - } - pushFollow(FOLLOW_2); - ruleOrExpression(); + pushFollow(FOLLOW_31); + rule__InfixExpression__Group_1_0__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__3(); + state._fsp--; + if (state.failed) return ; } @@ -36014,32 +38200,38 @@ public final void rule__SwitchExpression__DefaultExprAssignment_6() throws Recog } return ; } - // $ANTLR end "rule__SwitchExpression__DefaultExprAssignment_6" + // $ANTLR end "rule__InfixExpression__Group_1_0__2" - // $ANTLR start "rule__Case__ConditionAssignment_1" - // InternalScope.g:11046:1: rule__Case__ConditionAssignment_1 : ( ruleOrExpression ) ; - public final void rule__Case__ConditionAssignment_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__2__Impl" + // InternalScope.g:11094:1: rule__InfixExpression__Group_1_0__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ; + public final void rule__InfixExpression__Group_1_0__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11050:1: ( ( ruleOrExpression ) ) - // InternalScope.g:11051:2: ( ruleOrExpression ) + // InternalScope.g:11098:1: ( ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) ) + // InternalScope.g:11099:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) { - // InternalScope.g:11051:2: ( ruleOrExpression ) - // InternalScope.g:11052:3: ruleOrExpression + // InternalScope.g:11099:1: ( ( rule__InfixExpression__NameAssignment_1_0_2 ) ) + // InternalScope.g:11100:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } + // InternalScope.g:11101:2: ( rule__InfixExpression__NameAssignment_1_0_2 ) + // InternalScope.g:11101:3: rule__InfixExpression__NameAssignment_1_0_2 + { pushFollow(FOLLOW_2); - ruleOrExpression(); + rule__InfixExpression__NameAssignment_1_0_2(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_0_2()); } } @@ -36059,36 +38251,29 @@ public final void rule__Case__ConditionAssignment_1() throws RecognitionExceptio } return ; } - // $ANTLR end "rule__Case__ConditionAssignment_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__2__Impl" - // $ANTLR start "rule__Case__ThenParAssignment_3" - // InternalScope.g:11061:1: rule__Case__ThenParAssignment_3 : ( ruleOrExpression ) ; - public final void rule__Case__ThenParAssignment_3() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__3" + // InternalScope.g:11109:1: rule__InfixExpression__Group_1_0__3 : rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ; + public final void rule__InfixExpression__Group_1_0__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11065:1: ( ( ruleOrExpression ) ) - // InternalScope.g:11066:2: ( ruleOrExpression ) + // InternalScope.g:11113:1: ( rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 ) + // InternalScope.g:11114:2: rule__InfixExpression__Group_1_0__3__Impl rule__InfixExpression__Group_1_0__4 { - // InternalScope.g:11066:2: ( ruleOrExpression ) - // InternalScope.g:11067:3: ruleOrExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); - } - pushFollow(FOLLOW_2); - ruleOrExpression(); + pushFollow(FOLLOW_70); + rule__InfixExpression__Group_1_0__3__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__4(); + state._fsp--; + if (state.failed) return ; } @@ -36104,40 +38289,28 @@ public final void rule__Case__ThenParAssignment_3() throws RecognitionException } return ; } - // $ANTLR end "rule__Case__ThenParAssignment_3" + // $ANTLR end "rule__InfixExpression__Group_1_0__3" - // $ANTLR start "rule__OrExpression__OperatorAssignment_1_1" - // InternalScope.g:11076:1: rule__OrExpression__OperatorAssignment_1_1 : ( ( '||' ) ) ; - public final void rule__OrExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__3__Impl" + // InternalScope.g:11121:1: rule__InfixExpression__Group_1_0__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_0__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11080:1: ( ( ( '||' ) ) ) - // InternalScope.g:11081:2: ( ( '||' ) ) - { - // InternalScope.g:11081:2: ( ( '||' ) ) - // InternalScope.g:11082:3: ( '||' ) + // InternalScope.g:11125:1: ( ( '(' ) ) + // InternalScope.g:11126:1: ( '(' ) { - if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - // InternalScope.g:11083:3: ( '||' ) - // InternalScope.g:11084:4: '||' + // InternalScope.g:11126:1: ( '(' ) + // InternalScope.g:11127:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - match(input,82,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); - } - + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } - + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); } } @@ -36157,36 +38330,29 @@ public final void rule__OrExpression__OperatorAssignment_1_1() throws Recognitio } return ; } - // $ANTLR end "rule__OrExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__3__Impl" - // $ANTLR start "rule__OrExpression__RightAssignment_1_2" - // InternalScope.g:11095:1: rule__OrExpression__RightAssignment_1_2 : ( ruleAndExpression ) ; - public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__4" + // InternalScope.g:11136:1: rule__InfixExpression__Group_1_0__4 : rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ; + public final void rule__InfixExpression__Group_1_0__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11099:1: ( ( ruleAndExpression ) ) - // InternalScope.g:11100:2: ( ruleAndExpression ) - { - // InternalScope.g:11100:2: ( ruleAndExpression ) - // InternalScope.g:11101:3: ruleAndExpression + // InternalScope.g:11140:1: ( rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 ) + // InternalScope.g:11141:2: rule__InfixExpression__Group_1_0__4__Impl rule__InfixExpression__Group_1_0__5 { - if ( state.backtracking==0 ) { - before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleAndExpression(); + pushFollow(FOLLOW_70); + rule__InfixExpression__Group_1_0__4__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0__5(); + state._fsp--; + if (state.failed) return ; } @@ -36202,40 +38368,49 @@ public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionEx } return ; } - // $ANTLR end "rule__OrExpression__RightAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_0__4" - // $ANTLR start "rule__AndExpression__OperatorAssignment_1_1" - // InternalScope.g:11110:1: rule__AndExpression__OperatorAssignment_1_1 : ( ( '&&' ) ) ; - public final void rule__AndExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__4__Impl" + // InternalScope.g:11148:1: rule__InfixExpression__Group_1_0__4__Impl : ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ; + public final void rule__InfixExpression__Group_1_0__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11114:1: ( ( ( '&&' ) ) ) - // InternalScope.g:11115:2: ( ( '&&' ) ) + // InternalScope.g:11152:1: ( ( ( rule__InfixExpression__Group_1_0_4__0 )? ) ) + // InternalScope.g:11153:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) { - // InternalScope.g:11115:2: ( ( '&&' ) ) - // InternalScope.g:11116:3: ( '&&' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); - } - // InternalScope.g:11117:3: ( '&&' ) - // InternalScope.g:11118:4: '&&' + // InternalScope.g:11153:1: ( ( rule__InfixExpression__Group_1_0_4__0 )? ) + // InternalScope.g:11154:2: ( rule__InfixExpression__Group_1_0_4__0 )? { if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } - match(input,83,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + // InternalScope.g:11155:2: ( rule__InfixExpression__Group_1_0_4__0 )? + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==RULE_ID||LA106_0==RULE_INT||(LA106_0>=RULE_STRING && LA106_0<=RULE_REAL)||LA106_0==24||(LA106_0>=27 && LA106_0<=40)||LA106_0==72||LA106_0==77||LA106_0==94||LA106_0==97||LA106_0==100||(LA106_0>=102 && LA106_0<=103)||LA106_0==108||LA106_0==120) ) { + alt106=1; } + switch (alt106) { + case 1 : + // InternalScope.g:11155:3: rule__InfixExpression__Group_1_0_4__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; } if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4()); } } @@ -36255,36 +38430,24 @@ public final void rule__AndExpression__OperatorAssignment_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__AndExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__4__Impl" - // $ANTLR start "rule__AndExpression__RightAssignment_1_2" - // InternalScope.g:11129:1: rule__AndExpression__RightAssignment_1_2 : ( ruleImpliesExpression ) ; - public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__5" + // InternalScope.g:11163:1: rule__InfixExpression__Group_1_0__5 : rule__InfixExpression__Group_1_0__5__Impl ; + public final void rule__InfixExpression__Group_1_0__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11133:1: ( ( ruleImpliesExpression ) ) - // InternalScope.g:11134:2: ( ruleImpliesExpression ) + // InternalScope.g:11167:1: ( rule__InfixExpression__Group_1_0__5__Impl ) + // InternalScope.g:11168:2: rule__InfixExpression__Group_1_0__5__Impl { - // InternalScope.g:11134:2: ( ruleImpliesExpression ) - // InternalScope.g:11135:3: ruleImpliesExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleImpliesExpression(); + rule__InfixExpression__Group_1_0__5__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -36300,40 +38463,28 @@ public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionE } return ; } - // $ANTLR end "rule__AndExpression__RightAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_0__5" - // $ANTLR start "rule__ImpliesExpression__OperatorAssignment_1_1" - // InternalScope.g:11144:1: rule__ImpliesExpression__OperatorAssignment_1_1 : ( ( 'implies' ) ) ; - public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0__5__Impl" + // InternalScope.g:11174:1: rule__InfixExpression__Group_1_0__5__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_0__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11148:1: ( ( ( 'implies' ) ) ) - // InternalScope.g:11149:2: ( ( 'implies' ) ) + // InternalScope.g:11178:1: ( ( ')' ) ) + // InternalScope.g:11179:1: ( ')' ) { - // InternalScope.g:11149:2: ( ( 'implies' ) ) - // InternalScope.g:11150:3: ( 'implies' ) + // InternalScope.g:11179:1: ( ')' ) + // InternalScope.g:11180:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } - // InternalScope.g:11151:3: ( 'implies' ) - // InternalScope.g:11152:4: 'implies' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } - match(input,84,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); - } - + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } - + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); } } @@ -36353,36 +38504,29 @@ public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws Recog } return ; } - // $ANTLR end "rule__ImpliesExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0__5__Impl" - // $ANTLR start "rule__ImpliesExpression__RightAssignment_1_2" - // InternalScope.g:11163:1: rule__ImpliesExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; - public final void rule__ImpliesExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4__0" + // InternalScope.g:11190:1: rule__InfixExpression__Group_1_0_4__0 : rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ; + public final void rule__InfixExpression__Group_1_0_4__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11167:1: ( ( ruleRelationalExpression ) ) - // InternalScope.g:11168:2: ( ruleRelationalExpression ) + // InternalScope.g:11194:1: ( rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 ) + // InternalScope.g:11195:2: rule__InfixExpression__Group_1_0_4__0__Impl rule__InfixExpression__Group_1_0_4__1 { - // InternalScope.g:11168:2: ( ruleRelationalExpression ) - // InternalScope.g:11169:3: ruleRelationalExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleRelationalExpression(); + pushFollow(FOLLOW_71); + rule__InfixExpression__Group_1_0_4__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4__1(); + state._fsp--; + if (state.failed) return ; } @@ -36398,30 +38542,30 @@ public final void rule__ImpliesExpression__RightAssignment_1_2() throws Recognit } return ; } - // $ANTLR end "rule__ImpliesExpression__RightAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_0_4__0" - // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" - // InternalScope.g:11178: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__InfixExpression__Group_1_0_4__0__Impl" + // InternalScope.g:11202:1: rule__InfixExpression__Group_1_0_4__0__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ; + public final void rule__InfixExpression__Group_1_0_4__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11182:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) - // InternalScope.g:11183:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalScope.g:11206:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) ) + // InternalScope.g:11207:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) { - // InternalScope.g:11183:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) - // InternalScope.g:11184:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalScope.g:11207:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) ) + // InternalScope.g:11208:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } - // InternalScope.g:11185:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) - // InternalScope.g:11185:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 + // InternalScope.g:11209:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_0 ) + // InternalScope.g:11209:3: rule__InfixExpression__ParamsAssignment_1_0_4_0 { pushFollow(FOLLOW_2); - rule__RelationalExpression__OperatorAlternatives_1_1_0(); + rule__InfixExpression__ParamsAssignment_1_0_4_0(); state._fsp--; if (state.failed) return ; @@ -36429,7 +38573,7 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_0()); } } @@ -36449,36 +38593,24 @@ public final void rule__RelationalExpression__OperatorAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0_4__0__Impl" - // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" - // InternalScope.g:11193:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; - public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4__1" + // InternalScope.g:11217:1: rule__InfixExpression__Group_1_0_4__1 : rule__InfixExpression__Group_1_0_4__1__Impl ; + public final void rule__InfixExpression__Group_1_0_4__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11197:1: ( ( ruleAdditiveExpression ) ) - // InternalScope.g:11198:2: ( ruleAdditiveExpression ) - { - // InternalScope.g:11198:2: ( ruleAdditiveExpression ) - // InternalScope.g:11199:3: ruleAdditiveExpression + // InternalScope.g:11221:1: ( rule__InfixExpression__Group_1_0_4__1__Impl ) + // InternalScope.g:11222:2: rule__InfixExpression__Group_1_0_4__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleAdditiveExpression(); + rule__InfixExpression__Group_1_0_4__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -36494,38 +38626,56 @@ public final void rule__RelationalExpression__RightAssignment_1_2() throws Recog } return ; } - // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_0_4__1" - // $ANTLR start "rule__AdditiveExpression__NameAssignment_1_1" - // InternalScope.g:11208:1: rule__AdditiveExpression__NameAssignment_1_1 : ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ; - public final void rule__AdditiveExpression__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4__1__Impl" + // InternalScope.g:11228:1: rule__InfixExpression__Group_1_0_4__1__Impl : ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ; + public final void rule__InfixExpression__Group_1_0_4__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11212:1: ( ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ) - // InternalScope.g:11213:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + // InternalScope.g:11232:1: ( ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) ) + // InternalScope.g:11233:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) { - // InternalScope.g:11213:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) - // InternalScope.g:11214:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + // InternalScope.g:11233:1: ( ( rule__InfixExpression__Group_1_0_4_1__0 )* ) + // InternalScope.g:11234:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* { if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } - // InternalScope.g:11215:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) - // InternalScope.g:11215:4: rule__AdditiveExpression__NameAlternatives_1_1_0 - { - pushFollow(FOLLOW_2); - rule__AdditiveExpression__NameAlternatives_1_1_0(); + // InternalScope.g:11235:2: ( rule__InfixExpression__Group_1_0_4_1__0 )* + loop107: + do { + int alt107=2; + int LA107_0 = input.LA(1); - state._fsp--; - if (state.failed) return ; + if ( (LA107_0==86) ) { + alt107=1; + } - } + + switch (alt107) { + case 1 : + // InternalScope.g:11235:3: rule__InfixExpression__Group_1_0_4_1__0 + { + pushFollow(FOLLOW_39); + rule__InfixExpression__Group_1_0_4_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop107; + } + } while (true); if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getGroup_1_0_4_1()); } } @@ -36545,36 +38695,29 @@ public final void rule__AdditiveExpression__NameAssignment_1_1() throws Recognit } return ; } - // $ANTLR end "rule__AdditiveExpression__NameAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0_4__1__Impl" - // $ANTLR start "rule__AdditiveExpression__ParamsAssignment_1_2" - // InternalScope.g:11223:1: rule__AdditiveExpression__ParamsAssignment_1_2 : ( ruleMultiplicativeExpression ) ; - public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0" + // InternalScope.g:11244:1: rule__InfixExpression__Group_1_0_4_1__0 : rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ; + public final void rule__InfixExpression__Group_1_0_4_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11227:1: ( ( ruleMultiplicativeExpression ) ) - // InternalScope.g:11228:2: ( ruleMultiplicativeExpression ) + // InternalScope.g:11248:1: ( rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 ) + // InternalScope.g:11249:2: rule__InfixExpression__Group_1_0_4_1__0__Impl rule__InfixExpression__Group_1_0_4_1__1 { - // InternalScope.g:11228:2: ( ruleMultiplicativeExpression ) - // InternalScope.g:11229:3: ruleMultiplicativeExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); - } - pushFollow(FOLLOW_2); - ruleMultiplicativeExpression(); + pushFollow(FOLLOW_17); + rule__InfixExpression__Group_1_0_4_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_0_4_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -36590,38 +38733,28 @@ public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws Recogn } return ; } - // $ANTLR end "rule__AdditiveExpression__ParamsAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0" - // $ANTLR start "rule__MultiplicativeExpression__NameAssignment_1_1" - // InternalScope.g:11238:1: rule__MultiplicativeExpression__NameAssignment_1_1 : ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ; - public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__0__Impl" + // InternalScope.g:11256:1: rule__InfixExpression__Group_1_0_4_1__0__Impl : ( ',' ) ; + public final void rule__InfixExpression__Group_1_0_4_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11242:1: ( ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ) - // InternalScope.g:11243:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + // InternalScope.g:11260:1: ( ( ',' ) ) + // InternalScope.g:11261:1: ( ',' ) { - // InternalScope.g:11243:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) - // InternalScope.g:11244:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + // InternalScope.g:11261:1: ( ',' ) + // InternalScope.g:11262:2: ',' { if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); - } - // InternalScope.g:11245:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) - // InternalScope.g:11245:4: rule__MultiplicativeExpression__NameAlternatives_1_1_0 - { - pushFollow(FOLLOW_2); - rule__MultiplicativeExpression__NameAlternatives_1_1_0(); - - state._fsp--; - if (state.failed) return ; - + before(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } - + match(input,86,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); } } @@ -36641,36 +38774,24 @@ public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws Re } return ; } - // $ANTLR end "rule__MultiplicativeExpression__NameAssignment_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__0__Impl" - // $ANTLR start "rule__MultiplicativeExpression__ParamsAssignment_1_2" - // InternalScope.g:11253:1: rule__MultiplicativeExpression__ParamsAssignment_1_2 : ( ruleUnaryOrInfixExpression ) ; - public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1" + // InternalScope.g:11271:1: rule__InfixExpression__Group_1_0_4_1__1 : rule__InfixExpression__Group_1_0_4_1__1__Impl ; + public final void rule__InfixExpression__Group_1_0_4_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11257:1: ( ( ruleUnaryOrInfixExpression ) ) - // InternalScope.g:11258:2: ( ruleUnaryOrInfixExpression ) - { - // InternalScope.g:11258:2: ( ruleUnaryOrInfixExpression ) - // InternalScope.g:11259:3: ruleUnaryOrInfixExpression + // InternalScope.g:11275:1: ( rule__InfixExpression__Group_1_0_4_1__1__Impl ) + // InternalScope.g:11276:2: rule__InfixExpression__Group_1_0_4_1__1__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); - } pushFollow(FOLLOW_2); - ruleUnaryOrInfixExpression(); + rule__InfixExpression__Group_1_0_4_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); - } - - } - } @@ -36686,30 +38807,30 @@ public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws } return ; } - // $ANTLR end "rule__MultiplicativeExpression__ParamsAssignment_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1" - // $ANTLR start "rule__UnaryExpression__NameAssignment_0" - // InternalScope.g:11268:1: rule__UnaryExpression__NameAssignment_0 : ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ; - public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_0_4_1__1__Impl" + // InternalScope.g:11282:1: rule__InfixExpression__Group_1_0_4_1__1__Impl : ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ; + public final void rule__InfixExpression__Group_1_0_4_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11272:1: ( ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ) - // InternalScope.g:11273:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + // InternalScope.g:11286:1: ( ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) ) + // InternalScope.g:11287:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) { - // InternalScope.g:11273:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) - // InternalScope.g:11274:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + // InternalScope.g:11287:1: ( ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) ) + // InternalScope.g:11288:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + before(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } - // InternalScope.g:11275:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) - // InternalScope.g:11275:4: rule__UnaryExpression__NameAlternatives_0_0 + // InternalScope.g:11289:2: ( rule__InfixExpression__ParamsAssignment_1_0_4_1_1 ) + // InternalScope.g:11289:3: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 { pushFollow(FOLLOW_2); - rule__UnaryExpression__NameAlternatives_0_0(); + rule__InfixExpression__ParamsAssignment_1_0_4_1_1(); state._fsp--; if (state.failed) return ; @@ -36717,7 +38838,7 @@ public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionEx } if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + after(grammarAccess.getInfixExpressionAccess().getParamsAssignment_1_0_4_1_1()); } } @@ -36737,36 +38858,29 @@ public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionEx } return ; } - // $ANTLR end "rule__UnaryExpression__NameAssignment_0" + // $ANTLR end "rule__InfixExpression__Group_1_0_4_1__1__Impl" - // $ANTLR start "rule__UnaryExpression__ParamsAssignment_1" - // InternalScope.g:11283:1: rule__UnaryExpression__ParamsAssignment_1 : ( ruleInfixExpression ) ; - public final void rule__UnaryExpression__ParamsAssignment_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_1__0" + // InternalScope.g:11298:1: rule__InfixExpression__Group_1_1__0 : rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ; + public final void rule__InfixExpression__Group_1_1__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11287:1: ( ( ruleInfixExpression ) ) - // InternalScope.g:11288:2: ( ruleInfixExpression ) - { - // InternalScope.g:11288:2: ( ruleInfixExpression ) - // InternalScope.g:11289:3: ruleInfixExpression + // InternalScope.g:11302:1: ( rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 ) + // InternalScope.g:11303:2: rule__InfixExpression__Group_1_1__0__Impl rule__InfixExpression__Group_1_1__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleInfixExpression(); + pushFollow(FOLLOW_45); + rule__InfixExpression__Group_1_1__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__1(); + state._fsp--; + if (state.failed) return ; } @@ -36782,32 +38896,32 @@ public final void rule__UnaryExpression__ParamsAssignment_1() throws Recognition } return ; } - // $ANTLR end "rule__UnaryExpression__ParamsAssignment_1" + // $ANTLR end "rule__InfixExpression__Group_1_1__0" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_0_2" - // InternalScope.g:11298:1: rule__InfixExpression__NameAssignment_1_0_2 : ( ruleIdentifier ) ; - public final void rule__InfixExpression__NameAssignment_1_0_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_1__0__Impl" + // InternalScope.g:11310:1: rule__InfixExpression__Group_1_1__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_1__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11302:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11303:2: ( ruleIdentifier ) + // InternalScope.g:11314:1: ( ( () ) ) + // InternalScope.g:11315:1: ( () ) { - // InternalScope.g:11303:2: ( ruleIdentifier ) - // InternalScope.g:11304:3: ruleIdentifier + // InternalScope.g:11315:1: ( () ) + // InternalScope.g:11316:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + before(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); + } + // InternalScope.g:11317:2: () + // InternalScope.g:11317:3: + { } - pushFollow(FOLLOW_2); - ruleIdentifier(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + after(grammarAccess.getInfixExpressionAccess().getFeatureCallTargetAction_1_1_0()); } } @@ -36816,10 +38930,6 @@ public final void rule__InfixExpression__NameAssignment_1_0_2() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -36827,36 +38937,29 @@ public final void rule__InfixExpression__NameAssignment_1_0_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_0_2" + // $ANTLR end "rule__InfixExpression__Group_1_1__0__Impl" - // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_0" - // InternalScope.g:11313:1: rule__InfixExpression__ParamsAssignment_1_0_4_0 : ( ruleExpression ) ; - public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_1__1" + // InternalScope.g:11325:1: rule__InfixExpression__Group_1_1__1 : rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ; + public final void rule__InfixExpression__Group_1_1__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11317:1: ( ( ruleExpression ) ) - // InternalScope.g:11318:2: ( ruleExpression ) + // InternalScope.g:11329:1: ( rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 ) + // InternalScope.g:11330:2: rule__InfixExpression__Group_1_1__1__Impl rule__InfixExpression__Group_1_1__2 { - // InternalScope.g:11318:2: ( ruleExpression ) - // InternalScope.g:11319:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_48); + rule__InfixExpression__Group_1_1__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_1__2(); + state._fsp--; + if (state.failed) return ; } @@ -36872,32 +38975,28 @@ public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws Recog } return ; } - // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_0" + // $ANTLR end "rule__InfixExpression__Group_1_1__1" - // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" - // InternalScope.g:11328:1: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 : ( ruleExpression ) ; - public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_1__1__Impl" + // InternalScope.g:11337:1: rule__InfixExpression__Group_1_1__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_1__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11332:1: ( ( ruleExpression ) ) - // InternalScope.g:11333:2: ( ruleExpression ) + // InternalScope.g:11341:1: ( ( '.' ) ) + // InternalScope.g:11342:1: ( '.' ) { - // InternalScope.g:11333:2: ( ruleExpression ) - // InternalScope.g:11334:3: ruleExpression + // InternalScope.g:11342:1: ( '.' ) + // InternalScope.g:11343:2: '.' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,58,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); } } @@ -36917,36 +39016,24 @@ public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws Rec } return ; } - // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_1__1__Impl" - // $ANTLR start "rule__InfixExpression__TypeAssignment_1_1_2" - // InternalScope.g:11343:1: rule__InfixExpression__TypeAssignment_1_1_2 : ( ruleType ) ; - public final void rule__InfixExpression__TypeAssignment_1_1_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_1__2" + // InternalScope.g:11352:1: rule__InfixExpression__Group_1_1__2 : rule__InfixExpression__Group_1_1__2__Impl ; + public final void rule__InfixExpression__Group_1_1__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11347:1: ( ( ruleType ) ) - // InternalScope.g:11348:2: ( ruleType ) - { - // InternalScope.g:11348:2: ( ruleType ) - // InternalScope.g:11349:3: ruleType + // InternalScope.g:11356:1: ( rule__InfixExpression__Group_1_1__2__Impl ) + // InternalScope.g:11357:2: rule__InfixExpression__Group_1_1__2__Impl { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); - } pushFollow(FOLLOW_2); - ruleType(); + rule__InfixExpression__Group_1_1__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); - } - - } - } @@ -36962,40 +39049,38 @@ public final void rule__InfixExpression__TypeAssignment_1_1_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__TypeAssignment_1_1_2" + // $ANTLR end "rule__InfixExpression__Group_1_1__2" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_2_2" - // InternalScope.g:11358:1: rule__InfixExpression__NameAssignment_1_2_2 : ( ( 'typeSelect' ) ) ; - public final void rule__InfixExpression__NameAssignment_1_2_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_1__2__Impl" + // InternalScope.g:11363:1: rule__InfixExpression__Group_1_1__2__Impl : ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ; + public final void rule__InfixExpression__Group_1_1__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11362:1: ( ( ( 'typeSelect' ) ) ) - // InternalScope.g:11363:2: ( ( 'typeSelect' ) ) + // InternalScope.g:11367:1: ( ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) ) + // InternalScope.g:11368:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) { - // InternalScope.g:11363:2: ( ( 'typeSelect' ) ) - // InternalScope.g:11364:3: ( 'typeSelect' ) + // InternalScope.g:11368:1: ( ( rule__InfixExpression__TypeAssignment_1_1_2 ) ) + // InternalScope.g:11369:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } - // InternalScope.g:11365:3: ( 'typeSelect' ) - // InternalScope.g:11366:4: 'typeSelect' + // InternalScope.g:11370:2: ( rule__InfixExpression__TypeAssignment_1_1_2 ) + // InternalScope.g:11370:3: rule__InfixExpression__TypeAssignment_1_1_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } - match(input,85,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); - } + pushFollow(FOLLOW_2); + rule__InfixExpression__TypeAssignment_1_1_2(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_1_2()); } } @@ -37015,36 +39100,29 @@ public final void rule__InfixExpression__NameAssignment_1_2_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_2_2" + // $ANTLR end "rule__InfixExpression__Group_1_1__2__Impl" - // $ANTLR start "rule__InfixExpression__TypeAssignment_1_2_4" - // InternalScope.g:11377:1: rule__InfixExpression__TypeAssignment_1_2_4 : ( ruleType ) ; - public final void rule__InfixExpression__TypeAssignment_1_2_4() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__0" + // InternalScope.g:11379:1: rule__InfixExpression__Group_1_2__0 : rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ; + public final void rule__InfixExpression__Group_1_2__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11381:1: ( ( ruleType ) ) - // InternalScope.g:11382:2: ( ruleType ) - { - // InternalScope.g:11382:2: ( ruleType ) - // InternalScope.g:11383:3: ruleType + // InternalScope.g:11383:1: ( rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 ) + // InternalScope.g:11384:2: rule__InfixExpression__Group_1_2__0__Impl rule__InfixExpression__Group_1_2__1 { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); - } - pushFollow(FOLLOW_2); - ruleType(); + pushFollow(FOLLOW_45); + rule__InfixExpression__Group_1_2__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__1(); + state._fsp--; + if (state.failed) return ; } @@ -37060,38 +39138,32 @@ public final void rule__InfixExpression__TypeAssignment_1_2_4() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__TypeAssignment_1_2_4" + // $ANTLR end "rule__InfixExpression__Group_1_2__0" - // $ANTLR start "rule__InfixExpression__NameAssignment_1_3_2" - // InternalScope.g:11392:1: rule__InfixExpression__NameAssignment_1_3_2 : ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ; - public final void rule__InfixExpression__NameAssignment_1_3_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__0__Impl" + // InternalScope.g:11391:1: rule__InfixExpression__Group_1_2__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_2__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11396:1: ( ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ) - // InternalScope.g:11397:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + // InternalScope.g:11395:1: ( ( () ) ) + // InternalScope.g:11396:1: ( () ) { - // InternalScope.g:11397:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) - // InternalScope.g:11398:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + // InternalScope.g:11396:1: ( () ) + // InternalScope.g:11397:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + before(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } - // InternalScope.g:11399:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) - // InternalScope.g:11399:4: rule__InfixExpression__NameAlternatives_1_3_2_0 + // InternalScope.g:11398:2: () + // InternalScope.g:11398:3: { - pushFollow(FOLLOW_2); - rule__InfixExpression__NameAlternatives_1_3_2_0(); - - state._fsp--; - if (state.failed) return ; - } if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + after(grammarAccess.getInfixExpressionAccess().getTypeSelectExpressionTargetAction_1_2_0()); } } @@ -37100,10 +39172,6 @@ public final void rule__InfixExpression__NameAssignment_1_3_2() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -37111,36 +39179,29 @@ public final void rule__InfixExpression__NameAssignment_1_3_2() throws Recogniti } return ; } - // $ANTLR end "rule__InfixExpression__NameAssignment_1_3_2" + // $ANTLR end "rule__InfixExpression__Group_1_2__0__Impl" - // $ANTLR start "rule__InfixExpression__VarAssignment_1_3_4_0" - // InternalScope.g:11407:1: rule__InfixExpression__VarAssignment_1_3_4_0 : ( ruleIdentifier ) ; - public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__1" + // InternalScope.g:11406:1: rule__InfixExpression__Group_1_2__1 : rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ; + public final void rule__InfixExpression__Group_1_2__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11411:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11412:2: ( ruleIdentifier ) + // InternalScope.g:11410:1: ( rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 ) + // InternalScope.g:11411:2: rule__InfixExpression__Group_1_2__1__Impl rule__InfixExpression__Group_1_2__2 { - // InternalScope.g:11412:2: ( ruleIdentifier ) - // InternalScope.g:11413:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + pushFollow(FOLLOW_72); + rule__InfixExpression__Group_1_2__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__2(); + state._fsp--; + if (state.failed) return ; } @@ -37156,32 +39217,28 @@ public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws Recognit } return ; } - // $ANTLR end "rule__InfixExpression__VarAssignment_1_3_4_0" + // $ANTLR end "rule__InfixExpression__Group_1_2__1" - // $ANTLR start "rule__InfixExpression__ExpAssignment_1_3_5" - // InternalScope.g:11422:1: rule__InfixExpression__ExpAssignment_1_3_5 : ( ruleExpression ) ; - public final void rule__InfixExpression__ExpAssignment_1_3_5() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__1__Impl" + // InternalScope.g:11418:1: rule__InfixExpression__Group_1_2__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_2__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11426:1: ( ( ruleExpression ) ) - // InternalScope.g:11427:2: ( ruleExpression ) + // InternalScope.g:11422:1: ( ( '.' ) ) + // InternalScope.g:11423:1: ( '.' ) { - // InternalScope.g:11427:2: ( ruleExpression ) - // InternalScope.g:11428:3: ruleExpression + // InternalScope.g:11423:1: ( '.' ) + // InternalScope.g:11424:2: '.' { if ( state.backtracking==0 ) { - before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,58,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); } } @@ -37201,42 +39258,29 @@ public final void rule__InfixExpression__ExpAssignment_1_3_5() throws Recognitio } return ; } - // $ANTLR end "rule__InfixExpression__ExpAssignment_1_3_5" + // $ANTLR end "rule__InfixExpression__Group_1_2__1__Impl" - // $ANTLR start "rule__BooleanLiteral__ValAssignment" - // InternalScope.g:11437:1: rule__BooleanLiteral__ValAssignment : ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ; - public final void rule__BooleanLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__2" + // InternalScope.g:11433:1: rule__InfixExpression__Group_1_2__2 : rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ; + public final void rule__InfixExpression__Group_1_2__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11441:1: ( ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ) - // InternalScope.g:11442:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) - { - // InternalScope.g:11442:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) - // InternalScope.g:11443:3: ( rule__BooleanLiteral__ValAlternatives_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); - } - // InternalScope.g:11444:3: ( rule__BooleanLiteral__ValAlternatives_0 ) - // InternalScope.g:11444:4: rule__BooleanLiteral__ValAlternatives_0 + // InternalScope.g:11437:1: ( rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 ) + // InternalScope.g:11438:2: rule__InfixExpression__Group_1_2__2__Impl rule__InfixExpression__Group_1_2__3 { - pushFollow(FOLLOW_2); - rule__BooleanLiteral__ValAlternatives_0(); + pushFollow(FOLLOW_31); + rule__InfixExpression__Group_1_2__2__Impl(); state._fsp--; if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__3(); - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); - } - - } - + state._fsp--; + if (state.failed) return ; } @@ -37252,28 +39296,38 @@ public final void rule__BooleanLiteral__ValAssignment() throws RecognitionExcept } return ; } - // $ANTLR end "rule__BooleanLiteral__ValAssignment" + // $ANTLR end "rule__InfixExpression__Group_1_2__2" - // $ANTLR start "rule__IntegerLiteral__ValAssignment" - // InternalScope.g:11452:1: rule__IntegerLiteral__ValAssignment : ( RULE_INT ) ; - public final void rule__IntegerLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__2__Impl" + // InternalScope.g:11445:1: rule__InfixExpression__Group_1_2__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ; + public final void rule__InfixExpression__Group_1_2__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11456:1: ( ( RULE_INT ) ) - // InternalScope.g:11457:2: ( RULE_INT ) + // InternalScope.g:11449:1: ( ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) ) + // InternalScope.g:11450:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) { - // InternalScope.g:11457:2: ( RULE_INT ) - // InternalScope.g:11458:3: RULE_INT + // InternalScope.g:11450:1: ( ( rule__InfixExpression__NameAssignment_1_2_2 ) ) + // InternalScope.g:11451:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } - match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + // InternalScope.g:11452:2: ( rule__InfixExpression__NameAssignment_1_2_2 ) + // InternalScope.g:11452:3: rule__InfixExpression__NameAssignment_1_2_2 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_2_2(); + + state._fsp--; + if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_2_2()); } } @@ -37293,44 +39347,29 @@ public final void rule__IntegerLiteral__ValAssignment() throws RecognitionExcept } return ; } - // $ANTLR end "rule__IntegerLiteral__ValAssignment" + // $ANTLR end "rule__InfixExpression__Group_1_2__2__Impl" - // $ANTLR start "rule__NullLiteral__ValAssignment" - // InternalScope.g:11467:1: rule__NullLiteral__ValAssignment : ( ( 'null' ) ) ; - public final void rule__NullLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__3" + // InternalScope.g:11460:1: rule__InfixExpression__Group_1_2__3 : rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ; + public final void rule__InfixExpression__Group_1_2__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11471:1: ( ( ( 'null' ) ) ) - // InternalScope.g:11472:2: ( ( 'null' ) ) + // InternalScope.g:11464:1: ( rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 ) + // InternalScope.g:11465:2: rule__InfixExpression__Group_1_2__3__Impl rule__InfixExpression__Group_1_2__4 { - // InternalScope.g:11472:2: ( ( 'null' ) ) - // InternalScope.g:11473:3: ( 'null' ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - // InternalScope.g:11474:3: ( 'null' ) - // InternalScope.g:11475:4: 'null' - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - match(input,86,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } - - } - - if ( state.backtracking==0 ) { - after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); - } + pushFollow(FOLLOW_48); + rule__InfixExpression__Group_1_2__3__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__4(); + state._fsp--; + if (state.failed) return ; } @@ -37346,28 +39385,28 @@ public final void rule__NullLiteral__ValAssignment() throws RecognitionException } return ; } - // $ANTLR end "rule__NullLiteral__ValAssignment" + // $ANTLR end "rule__InfixExpression__Group_1_2__3" - // $ANTLR start "rule__RealLiteral__ValAssignment" - // InternalScope.g:11486:1: rule__RealLiteral__ValAssignment : ( RULE_REAL ) ; - public final void rule__RealLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__3__Impl" + // InternalScope.g:11472:1: rule__InfixExpression__Group_1_2__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_2__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11490:1: ( ( RULE_REAL ) ) - // InternalScope.g:11491:2: ( RULE_REAL ) + // InternalScope.g:11476:1: ( ( '(' ) ) + // InternalScope.g:11477:1: ( '(' ) { - // InternalScope.g:11491:2: ( RULE_REAL ) - // InternalScope.g:11492:3: RULE_REAL + // InternalScope.g:11477:1: ( '(' ) + // InternalScope.g:11478:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } - match(input,RULE_REAL,FOLLOW_2); if (state.failed) return ; + match(input,77,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); } } @@ -37387,32 +39426,29 @@ public final void rule__RealLiteral__ValAssignment() throws RecognitionException } return ; } - // $ANTLR end "rule__RealLiteral__ValAssignment" + // $ANTLR end "rule__InfixExpression__Group_1_2__3__Impl" - // $ANTLR start "rule__StringLiteral__ValAssignment" - // InternalScope.g:11501:1: rule__StringLiteral__ValAssignment : ( RULE_STRING ) ; - public final void rule__StringLiteral__ValAssignment() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__4" + // InternalScope.g:11487:1: rule__InfixExpression__Group_1_2__4 : rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ; + public final void rule__InfixExpression__Group_1_2__4() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11505:1: ( ( RULE_STRING ) ) - // InternalScope.g:11506:2: ( RULE_STRING ) - { - // InternalScope.g:11506:2: ( RULE_STRING ) - // InternalScope.g:11507:3: RULE_STRING + // InternalScope.g:11491:1: ( rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 ) + // InternalScope.g:11492:2: rule__InfixExpression__Group_1_2__4__Impl rule__InfixExpression__Group_1_2__5 { - if ( state.backtracking==0 ) { - before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); - } - match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); - } + pushFollow(FOLLOW_23); + rule__InfixExpression__Group_1_2__4__Impl(); - } + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_2__5(); + state._fsp--; + if (state.failed) return ; } @@ -37428,32 +39464,38 @@ public final void rule__StringLiteral__ValAssignment() throws RecognitionExcepti } return ; } - // $ANTLR end "rule__StringLiteral__ValAssignment" + // $ANTLR end "rule__InfixExpression__Group_1_2__4" - // $ANTLR start "rule__GlobalVarExpression__NameAssignment_1" - // InternalScope.g:11516:1: rule__GlobalVarExpression__NameAssignment_1 : ( ruleIdentifier ) ; - public final void rule__GlobalVarExpression__NameAssignment_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__4__Impl" + // InternalScope.g:11499:1: rule__InfixExpression__Group_1_2__4__Impl : ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ; + public final void rule__InfixExpression__Group_1_2__4__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11520:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11521:2: ( ruleIdentifier ) + // InternalScope.g:11503:1: ( ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) ) + // InternalScope.g:11504:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) { - // InternalScope.g:11521:2: ( ruleIdentifier ) - // InternalScope.g:11522:3: ruleIdentifier + // InternalScope.g:11504:1: ( ( rule__InfixExpression__TypeAssignment_1_2_4 ) ) + // InternalScope.g:11505:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + before(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } + // InternalScope.g:11506:2: ( rule__InfixExpression__TypeAssignment_1_2_4 ) + // InternalScope.g:11506:3: rule__InfixExpression__TypeAssignment_1_2_4 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__InfixExpression__TypeAssignment_1_2_4(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + after(grammarAccess.getInfixExpressionAccess().getTypeAssignment_1_2_4()); } } @@ -37473,36 +39515,24 @@ public final void rule__GlobalVarExpression__NameAssignment_1() throws Recogniti } return ; } - // $ANTLR end "rule__GlobalVarExpression__NameAssignment_1" + // $ANTLR end "rule__InfixExpression__Group_1_2__4__Impl" - // $ANTLR start "rule__FeatureCall__TypeAssignment_1" - // InternalScope.g:11531:1: rule__FeatureCall__TypeAssignment_1 : ( ruleType ) ; - public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__5" + // InternalScope.g:11514:1: rule__InfixExpression__Group_1_2__5 : rule__InfixExpression__Group_1_2__5__Impl ; + public final void rule__InfixExpression__Group_1_2__5() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11535:1: ( ( ruleType ) ) - // InternalScope.g:11536:2: ( ruleType ) + // InternalScope.g:11518:1: ( rule__InfixExpression__Group_1_2__5__Impl ) + // InternalScope.g:11519:2: rule__InfixExpression__Group_1_2__5__Impl { - // InternalScope.g:11536:2: ( ruleType ) - // InternalScope.g:11537:3: ruleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); - } pushFollow(FOLLOW_2); - ruleType(); + rule__InfixExpression__Group_1_2__5__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); - } - - } - } @@ -37518,32 +39548,28 @@ public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionExcept } return ; } - // $ANTLR end "rule__FeatureCall__TypeAssignment_1" + // $ANTLR end "rule__InfixExpression__Group_1_2__5" - // $ANTLR start "rule__OperationCall__NameAssignment_0" - // InternalScope.g:11546:1: rule__OperationCall__NameAssignment_0 : ( ruleIdentifier ) ; - public final void rule__OperationCall__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_2__5__Impl" + // InternalScope.g:11525:1: rule__InfixExpression__Group_1_2__5__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_2__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11550:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11551:2: ( ruleIdentifier ) + // InternalScope.g:11529:1: ( ( ')' ) ) + // InternalScope.g:11530:1: ( ')' ) { - // InternalScope.g:11551:2: ( ruleIdentifier ) - // InternalScope.g:11552:3: ruleIdentifier + // InternalScope.g:11530:1: ( ')' ) + // InternalScope.g:11531:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } - pushFollow(FOLLOW_2); - ruleIdentifier(); - - state._fsp--; - if (state.failed) return ; + match(input,78,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); } } @@ -37563,36 +39589,29 @@ public final void rule__OperationCall__NameAssignment_0() throws RecognitionExce } return ; } - // $ANTLR end "rule__OperationCall__NameAssignment_0" + // $ANTLR end "rule__InfixExpression__Group_1_2__5__Impl" - // $ANTLR start "rule__OperationCall__ParamsAssignment_2_0" - // InternalScope.g:11561:1: rule__OperationCall__ParamsAssignment_2_0 : ( ruleExpression ) ; - public final void rule__OperationCall__ParamsAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__0" + // InternalScope.g:11541:1: rule__InfixExpression__Group_1_3__0 : rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ; + public final void rule__InfixExpression__Group_1_3__0() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11565:1: ( ( ruleExpression ) ) - // InternalScope.g:11566:2: ( ruleExpression ) + // InternalScope.g:11545:1: ( rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 ) + // InternalScope.g:11546:2: rule__InfixExpression__Group_1_3__0__Impl rule__InfixExpression__Group_1_3__1 { - // InternalScope.g:11566:2: ( ruleExpression ) - // InternalScope.g:11567:3: ruleExpression - { - if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_45); + rule__InfixExpression__Group_1_3__0__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__1(); + state._fsp--; + if (state.failed) return ; } @@ -37608,32 +39627,32 @@ public final void rule__OperationCall__ParamsAssignment_2_0() throws Recognition } return ; } - // $ANTLR end "rule__OperationCall__ParamsAssignment_2_0" + // $ANTLR end "rule__InfixExpression__Group_1_3__0" - // $ANTLR start "rule__OperationCall__ParamsAssignment_2_1_1" - // InternalScope.g:11576:1: rule__OperationCall__ParamsAssignment_2_1_1 : ( ruleExpression ) ; - public final void rule__OperationCall__ParamsAssignment_2_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__0__Impl" + // InternalScope.g:11553:1: rule__InfixExpression__Group_1_3__0__Impl : ( () ) ; + public final void rule__InfixExpression__Group_1_3__0__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11580:1: ( ( ruleExpression ) ) - // InternalScope.g:11581:2: ( ruleExpression ) + // InternalScope.g:11557:1: ( ( () ) ) + // InternalScope.g:11558:1: ( () ) { - // InternalScope.g:11581:2: ( ruleExpression ) - // InternalScope.g:11582:3: ruleExpression + // InternalScope.g:11558:1: ( () ) + // InternalScope.g:11559:2: () { if ( state.backtracking==0 ) { - before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); + } + // InternalScope.g:11560:2: () + // InternalScope.g:11560:3: + { } - pushFollow(FOLLOW_2); - ruleExpression(); - state._fsp--; - if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getCollectionExpressionTargetAction_1_3_0()); } } @@ -37642,10 +39661,6 @@ public final void rule__OperationCall__ParamsAssignment_2_1_1() throws Recogniti } } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } finally { restoreStackSize(stackSize); @@ -37653,36 +39668,29 @@ public final void rule__OperationCall__ParamsAssignment_2_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__OperationCall__ParamsAssignment_2_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_3__0__Impl" - // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_0" - // InternalScope.g:11591:1: rule__ListLiteral__ElementsAssignment_2_0 : ( ruleExpression ) ; - public final void rule__ListLiteral__ElementsAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__1" + // InternalScope.g:11568:1: rule__InfixExpression__Group_1_3__1 : rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ; + public final void rule__InfixExpression__Group_1_3__1() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11595:1: ( ( ruleExpression ) ) - // InternalScope.g:11596:2: ( ruleExpression ) - { - // InternalScope.g:11596:2: ( ruleExpression ) - // InternalScope.g:11597:3: ruleExpression + // InternalScope.g:11572:1: ( rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 ) + // InternalScope.g:11573:2: rule__InfixExpression__Group_1_3__1__Impl rule__InfixExpression__Group_1_3__2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); - } - pushFollow(FOLLOW_2); - ruleExpression(); + pushFollow(FOLLOW_73); + rule__InfixExpression__Group_1_3__1__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__2(); + state._fsp--; + if (state.failed) return ; } @@ -37698,32 +39706,28 @@ public final void rule__ListLiteral__ElementsAssignment_2_0() throws Recognition } return ; } - // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_0" + // $ANTLR end "rule__InfixExpression__Group_1_3__1" - // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_1_1" - // InternalScope.g:11606:1: rule__ListLiteral__ElementsAssignment_2_1_1 : ( ruleExpression ) ; - public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__1__Impl" + // InternalScope.g:11580:1: rule__InfixExpression__Group_1_3__1__Impl : ( '.' ) ; + public final void rule__InfixExpression__Group_1_3__1__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11610:1: ( ( ruleExpression ) ) - // InternalScope.g:11611:2: ( ruleExpression ) + // InternalScope.g:11584:1: ( ( '.' ) ) + // InternalScope.g:11585:1: ( '.' ) { - // InternalScope.g:11611:2: ( ruleExpression ) - // InternalScope.g:11612:3: ruleExpression + // InternalScope.g:11585:1: ( '.' ) + // InternalScope.g:11586:2: '.' { if ( state.backtracking==0 ) { - before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + before(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } - pushFollow(FOLLOW_2); - ruleExpression(); - - state._fsp--; - if (state.failed) return ; + match(input,58,FOLLOW_2); if (state.failed) return ; if ( state.backtracking==0 ) { - after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + after(grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); } } @@ -37743,36 +39747,29 @@ public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws Recogniti } return ; } - // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_1_1" + // $ANTLR end "rule__InfixExpression__Group_1_3__1__Impl" - // $ANTLR start "rule__ConstructorCallExpression__TypeAssignment_1" - // InternalScope.g:11621:1: rule__ConstructorCallExpression__TypeAssignment_1 : ( ruleSimpleType ) ; - public final void rule__ConstructorCallExpression__TypeAssignment_1() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__2" + // InternalScope.g:11595:1: rule__InfixExpression__Group_1_3__2 : rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ; + public final void rule__InfixExpression__Group_1_3__2() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11625:1: ( ( ruleSimpleType ) ) - // InternalScope.g:11626:2: ( ruleSimpleType ) + // InternalScope.g:11599:1: ( rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 ) + // InternalScope.g:11600:2: rule__InfixExpression__Group_1_3__2__Impl rule__InfixExpression__Group_1_3__3 { - // InternalScope.g:11626:2: ( ruleSimpleType ) - // InternalScope.g:11627:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); + pushFollow(FOLLOW_31); + rule__InfixExpression__Group_1_3__2__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__3(); + state._fsp--; + if (state.failed) return ; } @@ -37788,40 +39785,38 @@ public final void rule__ConstructorCallExpression__TypeAssignment_1() throws Rec } return ; } - // $ANTLR end "rule__ConstructorCallExpression__TypeAssignment_1" + // $ANTLR end "rule__InfixExpression__Group_1_3__2" - // $ANTLR start "rule__TypeSelectExpression__NameAssignment_0" - // InternalScope.g:11636:1: rule__TypeSelectExpression__NameAssignment_0 : ( ( 'typeSelect' ) ) ; - public final void rule__TypeSelectExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__2__Impl" + // InternalScope.g:11607:1: rule__InfixExpression__Group_1_3__2__Impl : ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ; + public final void rule__InfixExpression__Group_1_3__2__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11640:1: ( ( ( 'typeSelect' ) ) ) - // InternalScope.g:11641:2: ( ( 'typeSelect' ) ) + // InternalScope.g:11611:1: ( ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) ) + // InternalScope.g:11612:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) { - // InternalScope.g:11641:2: ( ( 'typeSelect' ) ) - // InternalScope.g:11642:3: ( 'typeSelect' ) + // InternalScope.g:11612:1: ( ( rule__InfixExpression__NameAssignment_1_3_2 ) ) + // InternalScope.g:11613:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + before(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } - // InternalScope.g:11643:3: ( 'typeSelect' ) - // InternalScope.g:11644:4: 'typeSelect' + // InternalScope.g:11614:2: ( rule__InfixExpression__NameAssignment_1_3_2 ) + // InternalScope.g:11614:3: rule__InfixExpression__NameAssignment_1_3_2 { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); - } - match(input,85,FOLLOW_2); if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); - } + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAssignment_1_3_2(); + + state._fsp--; + if (state.failed) return ; } if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + after(grammarAccess.getInfixExpressionAccess().getNameAssignment_1_3_2()); } } @@ -37841,36 +39836,29 @@ public final void rule__TypeSelectExpression__NameAssignment_0() throws Recognit } return ; } - // $ANTLR end "rule__TypeSelectExpression__NameAssignment_0" + // $ANTLR end "rule__InfixExpression__Group_1_3__2__Impl" - // $ANTLR start "rule__TypeSelectExpression__TypeAssignment_2" - // InternalScope.g:11655:1: rule__TypeSelectExpression__TypeAssignment_2 : ( ruleType ) ; - public final void rule__TypeSelectExpression__TypeAssignment_2() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__3" + // InternalScope.g:11622:1: rule__InfixExpression__Group_1_3__3 : rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ; + public final void rule__InfixExpression__Group_1_3__3() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11659:1: ( ( ruleType ) ) - // InternalScope.g:11660:2: ( ruleType ) - { - // InternalScope.g:11660:2: ( ruleType ) - // InternalScope.g:11661:3: ruleType + // InternalScope.g:11626:1: ( rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 ) + // InternalScope.g:11627:2: rule__InfixExpression__Group_1_3__3__Impl rule__InfixExpression__Group_1_3__4 { - if ( state.backtracking==0 ) { - before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); - } - pushFollow(FOLLOW_2); - ruleType(); + pushFollow(FOLLOW_17); + rule__InfixExpression__Group_1_3__3__Impl(); state._fsp--; if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); - } - - } + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__4(); + state._fsp--; + if (state.failed) return ; } @@ -37886,38 +39874,132 @@ public final void rule__TypeSelectExpression__TypeAssignment_2() throws Recognit } return ; } - // $ANTLR end "rule__TypeSelectExpression__TypeAssignment_2" + // $ANTLR end "rule__InfixExpression__Group_1_3__3" - // $ANTLR start "rule__CollectionExpression__NameAssignment_0" - // InternalScope.g:11670:1: rule__CollectionExpression__NameAssignment_0 : ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ; - public final void rule__CollectionExpression__NameAssignment_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__3__Impl" + // InternalScope.g:11634:1: rule__InfixExpression__Group_1_3__3__Impl : ( '(' ) ; + public final void rule__InfixExpression__Group_1_3__3__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11674:1: ( ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ) - // InternalScope.g:11675:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + // InternalScope.g:11638:1: ( ( '(' ) ) + // InternalScope.g:11639:1: ( '(' ) { - // InternalScope.g:11675:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) - // InternalScope.g:11676:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + // InternalScope.g:11639:1: ( '(' ) + // InternalScope.g:11640:2: '(' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + before(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); + } + } - // InternalScope.g:11677:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) - // InternalScope.g:11677:4: rule__CollectionExpression__NameAlternatives_0_0 + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__3__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__4" + // InternalScope.g:11649:1: rule__InfixExpression__Group_1_3__4 : rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ; + public final void rule__InfixExpression__Group_1_3__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11653:1: ( rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 ) + // InternalScope.g:11654:2: rule__InfixExpression__Group_1_3__4__Impl rule__InfixExpression__Group_1_3__5 { + pushFollow(FOLLOW_17); + rule__InfixExpression__Group_1_3__4__Impl(); + + state._fsp--; + if (state.failed) return ; pushFollow(FOLLOW_2); - rule__CollectionExpression__NameAlternatives_0_0(); + rule__InfixExpression__Group_1_3__5(); state._fsp--; if (state.failed) return ; } + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__4" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__4__Impl" + // InternalScope.g:11661:1: rule__InfixExpression__Group_1_3__4__Impl : ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ; + public final void rule__InfixExpression__Group_1_3__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11665:1: ( ( ( rule__InfixExpression__Group_1_3_4__0 )? ) ) + // InternalScope.g:11666:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + { + // InternalScope.g:11666:1: ( ( rule__InfixExpression__Group_1_3_4__0 )? ) + // InternalScope.g:11667:2: ( rule__InfixExpression__Group_1_3_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); + } + // InternalScope.g:11668:2: ( rule__InfixExpression__Group_1_3_4__0 )? + int alt108=2; + int LA108_0 = input.LA(1); + + if ( (LA108_0==RULE_ID) ) { + int LA108_1 = input.LA(2); + + if ( (LA108_1==92) ) { + alt108=1; + } + } + switch (alt108) { + case 1 : + // InternalScope.g:11668:3: rule__InfixExpression__Group_1_3_4__0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + after(grammarAccess.getInfixExpressionAccess().getGroup_1_3_4()); } } @@ -37937,32 +40019,76 @@ public final void rule__CollectionExpression__NameAssignment_0() throws Recognit } return ; } - // $ANTLR end "rule__CollectionExpression__NameAssignment_0" + // $ANTLR end "rule__InfixExpression__Group_1_3__4__Impl" - // $ANTLR start "rule__CollectionExpression__VarAssignment_2_0" - // InternalScope.g:11685:1: rule__CollectionExpression__VarAssignment_2_0 : ( ruleIdentifier ) ; - public final void rule__CollectionExpression__VarAssignment_2_0() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__5" + // InternalScope.g:11676:1: rule__InfixExpression__Group_1_3__5 : rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ; + public final void rule__InfixExpression__Group_1_3__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11680:1: ( rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 ) + // InternalScope.g:11681:2: rule__InfixExpression__Group_1_3__5__Impl rule__InfixExpression__Group_1_3__6 + { + pushFollow(FOLLOW_23); + rule__InfixExpression__Group_1_3__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__5" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__5__Impl" + // InternalScope.g:11688:1: rule__InfixExpression__Group_1_3__5__Impl : ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ; + public final void rule__InfixExpression__Group_1_3__5__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11689:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11690:2: ( ruleIdentifier ) + // InternalScope.g:11692:1: ( ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) ) + // InternalScope.g:11693:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) { - // InternalScope.g:11690:2: ( ruleIdentifier ) - // InternalScope.g:11691:3: ruleIdentifier + // InternalScope.g:11693:1: ( ( rule__InfixExpression__ExpAssignment_1_3_5 ) ) + // InternalScope.g:11694:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + before(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } + // InternalScope.g:11695:2: ( rule__InfixExpression__ExpAssignment_1_3_5 ) + // InternalScope.g:11695:3: rule__InfixExpression__ExpAssignment_1_3_5 + { pushFollow(FOLLOW_2); - ruleIdentifier(); + rule__InfixExpression__ExpAssignment_1_3_5(); state._fsp--; if (state.failed) return ; + + } + if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + after(grammarAccess.getInfixExpressionAccess().getExpAssignment_1_3_5()); } } @@ -37982,408 +40108,56779 @@ public final void rule__CollectionExpression__VarAssignment_2_0() throws Recogni } return ; } - // $ANTLR end "rule__CollectionExpression__VarAssignment_2_0" + // $ANTLR end "rule__InfixExpression__Group_1_3__5__Impl" - // $ANTLR start "rule__CollectionExpression__ExpAssignment_3" - // InternalScope.g:11700:1: rule__CollectionExpression__ExpAssignment_3 : ( ruleExpression ) ; - public final void rule__CollectionExpression__ExpAssignment_3() throws RecognitionException { + // $ANTLR start "rule__InfixExpression__Group_1_3__6" + // InternalScope.g:11703:1: rule__InfixExpression__Group_1_3__6 : rule__InfixExpression__Group_1_3__6__Impl ; + public final void rule__InfixExpression__Group_1_3__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11707:1: ( rule__InfixExpression__Group_1_3__6__Impl ) + // InternalScope.g:11708:2: rule__InfixExpression__Group_1_3__6__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__6" + + + // $ANTLR start "rule__InfixExpression__Group_1_3__6__Impl" + // InternalScope.g:11714:1: rule__InfixExpression__Group_1_3__6__Impl : ( ')' ) ; + public final void rule__InfixExpression__Group_1_3__6__Impl() throws RecognitionException { int stackSize = keepStackSize(); try { - // InternalScope.g:11704:1: ( ( ruleExpression ) ) - // InternalScope.g:11705:2: ( ruleExpression ) + // InternalScope.g:11718:1: ( ( ')' ) ) + // InternalScope.g:11719:1: ( ')' ) { - // InternalScope.g:11705:2: ( ruleExpression ) - // InternalScope.g:11706:3: ruleExpression + // InternalScope.g:11719:1: ( ')' ) + // InternalScope.g:11720:2: ')' { if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + before(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3__6__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__0" + // InternalScope.g:11730:1: rule__InfixExpression__Group_1_3_4__0 : rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ; + public final void rule__InfixExpression__Group_1_3_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11734:1: ( rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 ) + // InternalScope.g:11735:2: rule__InfixExpression__Group_1_3_4__0__Impl rule__InfixExpression__Group_1_3_4__1 + { + pushFollow(FOLLOW_42); + rule__InfixExpression__Group_1_3_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__0" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__0__Impl" + // InternalScope.g:11742:1: rule__InfixExpression__Group_1_3_4__0__Impl : ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ; + public final void rule__InfixExpression__Group_1_3_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11746:1: ( ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) ) + // InternalScope.g:11747:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + { + // InternalScope.g:11747:1: ( ( rule__InfixExpression__VarAssignment_1_3_4_0 ) ) + // InternalScope.g:11748:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + } + // InternalScope.g:11749:2: ( rule__InfixExpression__VarAssignment_1_3_4_0 ) + // InternalScope.g:11749:3: rule__InfixExpression__VarAssignment_1_3_4_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__VarAssignment_1_3_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVarAssignment_1_3_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__0__Impl" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__1" + // InternalScope.g:11757:1: rule__InfixExpression__Group_1_3_4__1 : rule__InfixExpression__Group_1_3_4__1__Impl ; + public final void rule__InfixExpression__Group_1_3_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11761:1: ( rule__InfixExpression__Group_1_3_4__1__Impl ) + // InternalScope.g:11762:2: rule__InfixExpression__Group_1_3_4__1__Impl + { + pushFollow(FOLLOW_2); + rule__InfixExpression__Group_1_3_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__1" + + + // $ANTLR start "rule__InfixExpression__Group_1_3_4__1__Impl" + // InternalScope.g:11768:1: rule__InfixExpression__Group_1_3_4__1__Impl : ( '|' ) ; + public final void rule__InfixExpression__Group_1_3_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11772:1: ( ( '|' ) ) + // InternalScope.g:11773:1: ( '|' ) + { + // InternalScope.g:11773:1: ( '|' ) + // InternalScope.g:11774:2: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__Group_1_3_4__1__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__0" + // InternalScope.g:11784:1: rule__ParanthesizedExpression__Group__0 : rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ; + public final void rule__ParanthesizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11788:1: ( rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 ) + // InternalScope.g:11789:2: rule__ParanthesizedExpression__Group__0__Impl rule__ParanthesizedExpression__Group__1 + { + pushFollow(FOLLOW_17); + rule__ParanthesizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__0" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__0__Impl" + // InternalScope.g:11796:1: rule__ParanthesizedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__ParanthesizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11800:1: ( ( '(' ) ) + // InternalScope.g:11801:1: ( '(' ) + { + // InternalScope.g:11801:1: ( '(' ) + // InternalScope.g:11802:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__1" + // InternalScope.g:11811:1: rule__ParanthesizedExpression__Group__1 : rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ; + public final void rule__ParanthesizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11815:1: ( rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 ) + // InternalScope.g:11816:2: rule__ParanthesizedExpression__Group__1__Impl rule__ParanthesizedExpression__Group__2 + { + pushFollow(FOLLOW_23); + rule__ParanthesizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__1" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__1__Impl" + // InternalScope.g:11823:1: rule__ParanthesizedExpression__Group__1__Impl : ( ruleExpression ) ; + public final void rule__ParanthesizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11827:1: ( ( ruleExpression ) ) + // InternalScope.g:11828:1: ( ruleExpression ) + { + // InternalScope.g:11828:1: ( ruleExpression ) + // InternalScope.g:11829:2: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); } pushFollow(FOLLOW_2); ruleExpression(); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); - } + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getExpressionParserRuleCall_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__2" + // InternalScope.g:11838:1: rule__ParanthesizedExpression__Group__2 : rule__ParanthesizedExpression__Group__2__Impl ; + public final void rule__ParanthesizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11842:1: ( rule__ParanthesizedExpression__Group__2__Impl ) + // InternalScope.g:11843:2: rule__ParanthesizedExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__ParanthesizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__2" + + + // $ANTLR start "rule__ParanthesizedExpression__Group__2__Impl" + // InternalScope.g:11849:1: rule__ParanthesizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__ParanthesizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11853:1: ( ( ')' ) ) + // InternalScope.g:11854:1: ( ')' ) + { + // InternalScope.g:11854:1: ( ')' ) + // InternalScope.g:11855:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ParanthesizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__GlobalVarExpression__Group__0" + // InternalScope.g:11865:1: rule__GlobalVarExpression__Group__0 : rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ; + public final void rule__GlobalVarExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11869:1: ( rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 ) + // InternalScope.g:11870:2: rule__GlobalVarExpression__Group__0__Impl rule__GlobalVarExpression__Group__1 + { + pushFollow(FOLLOW_4); + rule__GlobalVarExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__0" + + + // $ANTLR start "rule__GlobalVarExpression__Group__0__Impl" + // InternalScope.g:11877:1: rule__GlobalVarExpression__Group__0__Impl : ( 'GLOBALVAR' ) ; + public final void rule__GlobalVarExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11881:1: ( ( 'GLOBALVAR' ) ) + // InternalScope.g:11882:1: ( 'GLOBALVAR' ) + { + // InternalScope.g:11882:1: ( 'GLOBALVAR' ) + // InternalScope.g:11883:2: 'GLOBALVAR' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + } + match(input,102,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__0__Impl" + + + // $ANTLR start "rule__GlobalVarExpression__Group__1" + // InternalScope.g:11892:1: rule__GlobalVarExpression__Group__1 : rule__GlobalVarExpression__Group__1__Impl ; + public final void rule__GlobalVarExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11896:1: ( rule__GlobalVarExpression__Group__1__Impl ) + // InternalScope.g:11897:2: rule__GlobalVarExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__1" + + + // $ANTLR start "rule__GlobalVarExpression__Group__1__Impl" + // InternalScope.g:11903:1: rule__GlobalVarExpression__Group__1__Impl : ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ; + public final void rule__GlobalVarExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11907:1: ( ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) ) + // InternalScope.g:11908:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + { + // InternalScope.g:11908:1: ( ( rule__GlobalVarExpression__NameAssignment_1 ) ) + // InternalScope.g:11909:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + } + // InternalScope.g:11910:2: ( rule__GlobalVarExpression__NameAssignment_1 ) + // InternalScope.g:11910:3: rule__GlobalVarExpression__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__GlobalVarExpression__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__Group__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group__0" + // InternalScope.g:11919:1: rule__OperationCall__Group__0 : rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ; + public final void rule__OperationCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11923:1: ( rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 ) + // InternalScope.g:11924:2: rule__OperationCall__Group__0__Impl rule__OperationCall__Group__1 + { + pushFollow(FOLLOW_31); + rule__OperationCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__0" + + + // $ANTLR start "rule__OperationCall__Group__0__Impl" + // InternalScope.g:11931:1: rule__OperationCall__Group__0__Impl : ( ( rule__OperationCall__NameAssignment_0 ) ) ; + public final void rule__OperationCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11935:1: ( ( ( rule__OperationCall__NameAssignment_0 ) ) ) + // InternalScope.g:11936:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + { + // InternalScope.g:11936:1: ( ( rule__OperationCall__NameAssignment_0 ) ) + // InternalScope.g:11937:2: ( rule__OperationCall__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + } + // InternalScope.g:11938:2: ( rule__OperationCall__NameAssignment_0 ) + // InternalScope.g:11938:3: rule__OperationCall__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group__1" + // InternalScope.g:11946:1: rule__OperationCall__Group__1 : rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ; + public final void rule__OperationCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11950:1: ( rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 ) + // InternalScope.g:11951:2: rule__OperationCall__Group__1__Impl rule__OperationCall__Group__2 + { + pushFollow(FOLLOW_70); + rule__OperationCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__1" + + + // $ANTLR start "rule__OperationCall__Group__1__Impl" + // InternalScope.g:11958:1: rule__OperationCall__Group__1__Impl : ( '(' ) ; + public final void rule__OperationCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11962:1: ( ( '(' ) ) + // InternalScope.g:11963:1: ( '(' ) + { + // InternalScope.g:11963:1: ( '(' ) + // InternalScope.g:11964:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group__2" + // InternalScope.g:11973:1: rule__OperationCall__Group__2 : rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ; + public final void rule__OperationCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11977:1: ( rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 ) + // InternalScope.g:11978:2: rule__OperationCall__Group__2__Impl rule__OperationCall__Group__3 + { + pushFollow(FOLLOW_70); + rule__OperationCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__2" + + + // $ANTLR start "rule__OperationCall__Group__2__Impl" + // InternalScope.g:11985:1: rule__OperationCall__Group__2__Impl : ( ( rule__OperationCall__Group_2__0 )? ) ; + public final void rule__OperationCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:11989:1: ( ( ( rule__OperationCall__Group_2__0 )? ) ) + // InternalScope.g:11990:1: ( ( rule__OperationCall__Group_2__0 )? ) + { + // InternalScope.g:11990:1: ( ( rule__OperationCall__Group_2__0 )? ) + // InternalScope.g:11991:2: ( rule__OperationCall__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getGroup_2()); + } + // InternalScope.g:11992:2: ( rule__OperationCall__Group_2__0 )? + int alt109=2; + int LA109_0 = input.LA(1); + + if ( (LA109_0==RULE_ID||LA109_0==RULE_INT||(LA109_0>=RULE_STRING && LA109_0<=RULE_REAL)||LA109_0==24||(LA109_0>=27 && LA109_0<=40)||LA109_0==72||LA109_0==77||LA109_0==94||LA109_0==97||LA109_0==100||(LA109_0>=102 && LA109_0<=103)||LA109_0==108||LA109_0==120) ) { + alt109=1; + } + switch (alt109) { + case 1 : + // InternalScope.g:11992:3: rule__OperationCall__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__2__Impl" + + + // $ANTLR start "rule__OperationCall__Group__3" + // InternalScope.g:12000:1: rule__OperationCall__Group__3 : rule__OperationCall__Group__3__Impl ; + public final void rule__OperationCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12004:1: ( rule__OperationCall__Group__3__Impl ) + // InternalScope.g:12005:2: rule__OperationCall__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__3" + + + // $ANTLR start "rule__OperationCall__Group__3__Impl" + // InternalScope.g:12011:1: rule__OperationCall__Group__3__Impl : ( ')' ) ; + public final void rule__OperationCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12015:1: ( ( ')' ) ) + // InternalScope.g:12016:1: ( ')' ) + { + // InternalScope.g:12016:1: ( ')' ) + // InternalScope.g:12017:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group__3__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2__0" + // InternalScope.g:12027:1: rule__OperationCall__Group_2__0 : rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ; + public final void rule__OperationCall__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12031:1: ( rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 ) + // InternalScope.g:12032:2: rule__OperationCall__Group_2__0__Impl rule__OperationCall__Group_2__1 + { + pushFollow(FOLLOW_71); + rule__OperationCall__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__0" + + + // $ANTLR start "rule__OperationCall__Group_2__0__Impl" + // InternalScope.g:12039:1: rule__OperationCall__Group_2__0__Impl : ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ; + public final void rule__OperationCall__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12043:1: ( ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) ) + // InternalScope.g:12044:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + { + // InternalScope.g:12044:1: ( ( rule__OperationCall__ParamsAssignment_2_0 ) ) + // InternalScope.g:12045:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + } + // InternalScope.g:12046:2: ( rule__OperationCall__ParamsAssignment_2_0 ) + // InternalScope.g:12046:3: rule__OperationCall__ParamsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__OperationCall__ParamsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2__1" + // InternalScope.g:12054:1: rule__OperationCall__Group_2__1 : rule__OperationCall__Group_2__1__Impl ; + public final void rule__OperationCall__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12058:1: ( rule__OperationCall__Group_2__1__Impl ) + // InternalScope.g:12059:2: rule__OperationCall__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__1" + + + // $ANTLR start "rule__OperationCall__Group_2__1__Impl" + // InternalScope.g:12065:1: rule__OperationCall__Group_2__1__Impl : ( ( rule__OperationCall__Group_2_1__0 )* ) ; + public final void rule__OperationCall__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12069:1: ( ( ( rule__OperationCall__Group_2_1__0 )* ) ) + // InternalScope.g:12070:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + { + // InternalScope.g:12070:1: ( ( rule__OperationCall__Group_2_1__0 )* ) + // InternalScope.g:12071:2: ( rule__OperationCall__Group_2_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getGroup_2_1()); + } + // InternalScope.g:12072:2: ( rule__OperationCall__Group_2_1__0 )* + loop110: + do { + int alt110=2; + int LA110_0 = input.LA(1); + + if ( (LA110_0==86) ) { + alt110=1; + } + + + switch (alt110) { + case 1 : + // InternalScope.g:12072:3: rule__OperationCall__Group_2_1__0 + { + pushFollow(FOLLOW_39); + rule__OperationCall__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop110; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getGroup_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2__1__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2_1__0" + // InternalScope.g:12081:1: rule__OperationCall__Group_2_1__0 : rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ; + public final void rule__OperationCall__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12085:1: ( rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 ) + // InternalScope.g:12086:2: rule__OperationCall__Group_2_1__0__Impl rule__OperationCall__Group_2_1__1 + { + pushFollow(FOLLOW_17); + rule__OperationCall__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__0" + + + // $ANTLR start "rule__OperationCall__Group_2_1__0__Impl" + // InternalScope.g:12093:1: rule__OperationCall__Group_2_1__0__Impl : ( ',' ) ; + public final void rule__OperationCall__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12097:1: ( ( ',' ) ) + // InternalScope.g:12098:1: ( ',' ) + { + // InternalScope.g:12098:1: ( ',' ) + // InternalScope.g:12099:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__0__Impl" + + + // $ANTLR start "rule__OperationCall__Group_2_1__1" + // InternalScope.g:12108:1: rule__OperationCall__Group_2_1__1 : rule__OperationCall__Group_2_1__1__Impl ; + public final void rule__OperationCall__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12112:1: ( rule__OperationCall__Group_2_1__1__Impl ) + // InternalScope.g:12113:2: rule__OperationCall__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__OperationCall__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__1" + + + // $ANTLR start "rule__OperationCall__Group_2_1__1__Impl" + // InternalScope.g:12119:1: rule__OperationCall__Group_2_1__1__Impl : ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ; + public final void rule__OperationCall__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12123:1: ( ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) ) + // InternalScope.g:12124:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + { + // InternalScope.g:12124:1: ( ( rule__OperationCall__ParamsAssignment_2_1_1 ) ) + // InternalScope.g:12125:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + } + // InternalScope.g:12126:2: ( rule__OperationCall__ParamsAssignment_2_1_1 ) + // InternalScope.g:12126:3: rule__OperationCall__ParamsAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__OperationCall__ParamsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__Group_2_1__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__0" + // InternalScope.g:12135:1: rule__ListLiteral__Group__0 : rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ; + public final void rule__ListLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12139:1: ( rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 ) + // InternalScope.g:12140:2: rule__ListLiteral__Group__0__Impl rule__ListLiteral__Group__1 + { + pushFollow(FOLLOW_13); + rule__ListLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__0" + + + // $ANTLR start "rule__ListLiteral__Group__0__Impl" + // InternalScope.g:12147:1: rule__ListLiteral__Group__0__Impl : ( () ) ; + public final void rule__ListLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12151:1: ( ( () ) ) + // InternalScope.g:12152:1: ( () ) + { + // InternalScope.g:12152:1: ( () ) + // InternalScope.g:12153:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + } + // InternalScope.g:12154:2: () + // InternalScope.g:12154:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getListLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__1" + // InternalScope.g:12162:1: rule__ListLiteral__Group__1 : rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ; + public final void rule__ListLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12166:1: ( rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 ) + // InternalScope.g:12167:2: rule__ListLiteral__Group__1__Impl rule__ListLiteral__Group__2 + { + pushFollow(FOLLOW_74); + rule__ListLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__1" + + + // $ANTLR start "rule__ListLiteral__Group__1__Impl" + // InternalScope.g:12174:1: rule__ListLiteral__Group__1__Impl : ( '{' ) ; + public final void rule__ListLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12178:1: ( ( '{' ) ) + // InternalScope.g:12179:1: ( '{' ) + { + // InternalScope.g:12179:1: ( '{' ) + // InternalScope.g:12180:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__2" + // InternalScope.g:12189:1: rule__ListLiteral__Group__2 : rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ; + public final void rule__ListLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12193:1: ( rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 ) + // InternalScope.g:12194:2: rule__ListLiteral__Group__2__Impl rule__ListLiteral__Group__3 + { + pushFollow(FOLLOW_74); + rule__ListLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__2" + + + // $ANTLR start "rule__ListLiteral__Group__2__Impl" + // InternalScope.g:12201:1: rule__ListLiteral__Group__2__Impl : ( ( rule__ListLiteral__Group_2__0 )? ) ; + public final void rule__ListLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12205:1: ( ( ( rule__ListLiteral__Group_2__0 )? ) ) + // InternalScope.g:12206:1: ( ( rule__ListLiteral__Group_2__0 )? ) + { + // InternalScope.g:12206:1: ( ( rule__ListLiteral__Group_2__0 )? ) + // InternalScope.g:12207:2: ( rule__ListLiteral__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getGroup_2()); + } + // InternalScope.g:12208:2: ( rule__ListLiteral__Group_2__0 )? + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==RULE_ID||LA111_0==RULE_INT||(LA111_0>=RULE_STRING && LA111_0<=RULE_REAL)||LA111_0==24||(LA111_0>=27 && LA111_0<=40)||LA111_0==72||LA111_0==77||LA111_0==94||LA111_0==97||LA111_0==100||(LA111_0>=102 && LA111_0<=103)||LA111_0==108||LA111_0==120) ) { + alt111=1; + } + switch (alt111) { + case 1 : + // InternalScope.g:12208:3: rule__ListLiteral__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__2__Impl" + + + // $ANTLR start "rule__ListLiteral__Group__3" + // InternalScope.g:12216:1: rule__ListLiteral__Group__3 : rule__ListLiteral__Group__3__Impl ; + public final void rule__ListLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12220:1: ( rule__ListLiteral__Group__3__Impl ) + // InternalScope.g:12221:2: rule__ListLiteral__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__3" + + + // $ANTLR start "rule__ListLiteral__Group__3__Impl" + // InternalScope.g:12227:1: rule__ListLiteral__Group__3__Impl : ( '}' ) ; + public final void rule__ListLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12231:1: ( ( '}' ) ) + // InternalScope.g:12232:1: ( '}' ) + { + // InternalScope.g:12232:1: ( '}' ) + // InternalScope.g:12233:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group__3__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2__0" + // InternalScope.g:12243:1: rule__ListLiteral__Group_2__0 : rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ; + public final void rule__ListLiteral__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12247:1: ( rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 ) + // InternalScope.g:12248:2: rule__ListLiteral__Group_2__0__Impl rule__ListLiteral__Group_2__1 + { + pushFollow(FOLLOW_71); + rule__ListLiteral__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__0" + + + // $ANTLR start "rule__ListLiteral__Group_2__0__Impl" + // InternalScope.g:12255:1: rule__ListLiteral__Group_2__0__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ; + public final void rule__ListLiteral__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12259:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) ) + // InternalScope.g:12260:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + { + // InternalScope.g:12260:1: ( ( rule__ListLiteral__ElementsAssignment_2_0 ) ) + // InternalScope.g:12261:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + } + // InternalScope.g:12262:2: ( rule__ListLiteral__ElementsAssignment_2_0 ) + // InternalScope.g:12262:3: rule__ListLiteral__ElementsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__ElementsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2__1" + // InternalScope.g:12270:1: rule__ListLiteral__Group_2__1 : rule__ListLiteral__Group_2__1__Impl ; + public final void rule__ListLiteral__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12274:1: ( rule__ListLiteral__Group_2__1__Impl ) + // InternalScope.g:12275:2: rule__ListLiteral__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__1" + + + // $ANTLR start "rule__ListLiteral__Group_2__1__Impl" + // InternalScope.g:12281:1: rule__ListLiteral__Group_2__1__Impl : ( ( rule__ListLiteral__Group_2_1__0 )* ) ; + public final void rule__ListLiteral__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12285:1: ( ( ( rule__ListLiteral__Group_2_1__0 )* ) ) + // InternalScope.g:12286:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + { + // InternalScope.g:12286:1: ( ( rule__ListLiteral__Group_2_1__0 )* ) + // InternalScope.g:12287:2: ( rule__ListLiteral__Group_2_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getGroup_2_1()); + } + // InternalScope.g:12288:2: ( rule__ListLiteral__Group_2_1__0 )* + loop112: + do { + int alt112=2; + int LA112_0 = input.LA(1); + + if ( (LA112_0==86) ) { + alt112=1; + } + + + switch (alt112) { + case 1 : + // InternalScope.g:12288:3: rule__ListLiteral__Group_2_1__0 + { + pushFollow(FOLLOW_39); + rule__ListLiteral__Group_2_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop112; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getGroup_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2__1__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__0" + // InternalScope.g:12297:1: rule__ListLiteral__Group_2_1__0 : rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ; + public final void rule__ListLiteral__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12301:1: ( rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 ) + // InternalScope.g:12302:2: rule__ListLiteral__Group_2_1__0__Impl rule__ListLiteral__Group_2_1__1 + { + pushFollow(FOLLOW_17); + rule__ListLiteral__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__0" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__0__Impl" + // InternalScope.g:12309:1: rule__ListLiteral__Group_2_1__0__Impl : ( ',' ) ; + public final void rule__ListLiteral__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12313:1: ( ( ',' ) ) + // InternalScope.g:12314:1: ( ',' ) + { + // InternalScope.g:12314:1: ( ',' ) + // InternalScope.g:12315:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__0__Impl" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__1" + // InternalScope.g:12324:1: rule__ListLiteral__Group_2_1__1 : rule__ListLiteral__Group_2_1__1__Impl ; + public final void rule__ListLiteral__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12328:1: ( rule__ListLiteral__Group_2_1__1__Impl ) + // InternalScope.g:12329:2: rule__ListLiteral__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__ListLiteral__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__1" + + + // $ANTLR start "rule__ListLiteral__Group_2_1__1__Impl" + // InternalScope.g:12335:1: rule__ListLiteral__Group_2_1__1__Impl : ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ; + public final void rule__ListLiteral__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12339:1: ( ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) ) + // InternalScope.g:12340:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + { + // InternalScope.g:12340:1: ( ( rule__ListLiteral__ElementsAssignment_2_1_1 ) ) + // InternalScope.g:12341:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + } + // InternalScope.g:12342:2: ( rule__ListLiteral__ElementsAssignment_2_1_1 ) + // InternalScope.g:12342:3: rule__ListLiteral__ElementsAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__ListLiteral__ElementsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__Group_2_1__1__Impl" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__0" + // InternalScope.g:12351:1: rule__ConstructorCallExpression__Group__0 : rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ; + public final void rule__ConstructorCallExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12355:1: ( rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 ) + // InternalScope.g:12356:2: rule__ConstructorCallExpression__Group__0__Impl rule__ConstructorCallExpression__Group__1 + { + pushFollow(FOLLOW_48); + rule__ConstructorCallExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__0" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__0__Impl" + // InternalScope.g:12363:1: rule__ConstructorCallExpression__Group__0__Impl : ( 'new' ) ; + public final void rule__ConstructorCallExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12367:1: ( ( 'new' ) ) + // InternalScope.g:12368:1: ( 'new' ) + { + // InternalScope.g:12368:1: ( 'new' ) + // InternalScope.g:12369:2: 'new' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + } + match(input,103,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__0__Impl" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__1" + // InternalScope.g:12378:1: rule__ConstructorCallExpression__Group__1 : rule__ConstructorCallExpression__Group__1__Impl ; + public final void rule__ConstructorCallExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12382:1: ( rule__ConstructorCallExpression__Group__1__Impl ) + // InternalScope.g:12383:2: rule__ConstructorCallExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__1" + + + // $ANTLR start "rule__ConstructorCallExpression__Group__1__Impl" + // InternalScope.g:12389:1: rule__ConstructorCallExpression__Group__1__Impl : ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ; + public final void rule__ConstructorCallExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12393:1: ( ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) ) + // InternalScope.g:12394:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + { + // InternalScope.g:12394:1: ( ( rule__ConstructorCallExpression__TypeAssignment_1 ) ) + // InternalScope.g:12395:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + } + // InternalScope.g:12396:2: ( rule__ConstructorCallExpression__TypeAssignment_1 ) + // InternalScope.g:12396:3: rule__ConstructorCallExpression__TypeAssignment_1 + { + pushFollow(FOLLOW_2); + rule__ConstructorCallExpression__TypeAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getTypeAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__Group__1__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__0" + // InternalScope.g:12405:1: rule__TypeSelectExpression__Group__0 : rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ; + public final void rule__TypeSelectExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12409:1: ( rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 ) + // InternalScope.g:12410:2: rule__TypeSelectExpression__Group__0__Impl rule__TypeSelectExpression__Group__1 + { + pushFollow(FOLLOW_31); + rule__TypeSelectExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__0" + + + // $ANTLR start "rule__TypeSelectExpression__Group__0__Impl" + // InternalScope.g:12417:1: rule__TypeSelectExpression__Group__0__Impl : ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ; + public final void rule__TypeSelectExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12421:1: ( ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) ) + // InternalScope.g:12422:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + { + // InternalScope.g:12422:1: ( ( rule__TypeSelectExpression__NameAssignment_0 ) ) + // InternalScope.g:12423:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + } + // InternalScope.g:12424:2: ( rule__TypeSelectExpression__NameAssignment_0 ) + // InternalScope.g:12424:3: rule__TypeSelectExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__0__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__1" + // InternalScope.g:12432:1: rule__TypeSelectExpression__Group__1 : rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ; + public final void rule__TypeSelectExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12436:1: ( rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 ) + // InternalScope.g:12437:2: rule__TypeSelectExpression__Group__1__Impl rule__TypeSelectExpression__Group__2 + { + pushFollow(FOLLOW_48); + rule__TypeSelectExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__1" + + + // $ANTLR start "rule__TypeSelectExpression__Group__1__Impl" + // InternalScope.g:12444:1: rule__TypeSelectExpression__Group__1__Impl : ( '(' ) ; + public final void rule__TypeSelectExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12448:1: ( ( '(' ) ) + // InternalScope.g:12449:1: ( '(' ) + { + // InternalScope.g:12449:1: ( '(' ) + // InternalScope.g:12450:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__1__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__2" + // InternalScope.g:12459:1: rule__TypeSelectExpression__Group__2 : rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ; + public final void rule__TypeSelectExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12463:1: ( rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 ) + // InternalScope.g:12464:2: rule__TypeSelectExpression__Group__2__Impl rule__TypeSelectExpression__Group__3 + { + pushFollow(FOLLOW_23); + rule__TypeSelectExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__2" + + + // $ANTLR start "rule__TypeSelectExpression__Group__2__Impl" + // InternalScope.g:12471:1: rule__TypeSelectExpression__Group__2__Impl : ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ; + public final void rule__TypeSelectExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12475:1: ( ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) ) + // InternalScope.g:12476:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + { + // InternalScope.g:12476:1: ( ( rule__TypeSelectExpression__TypeAssignment_2 ) ) + // InternalScope.g:12477:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + } + // InternalScope.g:12478:2: ( rule__TypeSelectExpression__TypeAssignment_2 ) + // InternalScope.g:12478:3: rule__TypeSelectExpression__TypeAssignment_2 + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__TypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getTypeAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__2__Impl" + + + // $ANTLR start "rule__TypeSelectExpression__Group__3" + // InternalScope.g:12486:1: rule__TypeSelectExpression__Group__3 : rule__TypeSelectExpression__Group__3__Impl ; + public final void rule__TypeSelectExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12490:1: ( rule__TypeSelectExpression__Group__3__Impl ) + // InternalScope.g:12491:2: rule__TypeSelectExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__TypeSelectExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__3" + + + // $ANTLR start "rule__TypeSelectExpression__Group__3__Impl" + // InternalScope.g:12497:1: rule__TypeSelectExpression__Group__3__Impl : ( ')' ) ; + public final void rule__TypeSelectExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12501:1: ( ( ')' ) ) + // InternalScope.g:12502:1: ( ')' ) + { + // InternalScope.g:12502:1: ( ')' ) + // InternalScope.g:12503:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__Group__3__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__0" + // InternalScope.g:12513:1: rule__CollectionExpression__Group__0 : rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ; + public final void rule__CollectionExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12517:1: ( rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 ) + // InternalScope.g:12518:2: rule__CollectionExpression__Group__0__Impl rule__CollectionExpression__Group__1 + { + pushFollow(FOLLOW_31); + rule__CollectionExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__0" + + + // $ANTLR start "rule__CollectionExpression__Group__0__Impl" + // InternalScope.g:12525:1: rule__CollectionExpression__Group__0__Impl : ( ( rule__CollectionExpression__NameAssignment_0 ) ) ; + public final void rule__CollectionExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12529:1: ( ( ( rule__CollectionExpression__NameAssignment_0 ) ) ) + // InternalScope.g:12530:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + { + // InternalScope.g:12530:1: ( ( rule__CollectionExpression__NameAssignment_0 ) ) + // InternalScope.g:12531:2: ( rule__CollectionExpression__NameAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + } + // InternalScope.g:12532:2: ( rule__CollectionExpression__NameAssignment_0 ) + // InternalScope.g:12532:3: rule__CollectionExpression__NameAssignment_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__NameAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__0__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__1" + // InternalScope.g:12540:1: rule__CollectionExpression__Group__1 : rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ; + public final void rule__CollectionExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12544:1: ( rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 ) + // InternalScope.g:12545:2: rule__CollectionExpression__Group__1__Impl rule__CollectionExpression__Group__2 + { + pushFollow(FOLLOW_17); + rule__CollectionExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__1" + + + // $ANTLR start "rule__CollectionExpression__Group__1__Impl" + // InternalScope.g:12552:1: rule__CollectionExpression__Group__1__Impl : ( '(' ) ; + public final void rule__CollectionExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12556:1: ( ( '(' ) ) + // InternalScope.g:12557:1: ( '(' ) + { + // InternalScope.g:12557:1: ( '(' ) + // InternalScope.g:12558:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__1__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__2" + // InternalScope.g:12567:1: rule__CollectionExpression__Group__2 : rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ; + public final void rule__CollectionExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12571:1: ( rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 ) + // InternalScope.g:12572:2: rule__CollectionExpression__Group__2__Impl rule__CollectionExpression__Group__3 + { + pushFollow(FOLLOW_17); + rule__CollectionExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__2" + + + // $ANTLR start "rule__CollectionExpression__Group__2__Impl" + // InternalScope.g:12579:1: rule__CollectionExpression__Group__2__Impl : ( ( rule__CollectionExpression__Group_2__0 )? ) ; + public final void rule__CollectionExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12583:1: ( ( ( rule__CollectionExpression__Group_2__0 )? ) ) + // InternalScope.g:12584:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + { + // InternalScope.g:12584:1: ( ( rule__CollectionExpression__Group_2__0 )? ) + // InternalScope.g:12585:2: ( rule__CollectionExpression__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + } + // InternalScope.g:12586:2: ( rule__CollectionExpression__Group_2__0 )? + int alt113=2; + int LA113_0 = input.LA(1); + + if ( (LA113_0==RULE_ID) ) { + int LA113_1 = input.LA(2); + + if ( (LA113_1==92) ) { + alt113=1; + } + } + switch (alt113) { + case 1 : + // InternalScope.g:12586:3: rule__CollectionExpression__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__2__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__3" + // InternalScope.g:12594:1: rule__CollectionExpression__Group__3 : rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ; + public final void rule__CollectionExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12598:1: ( rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 ) + // InternalScope.g:12599:2: rule__CollectionExpression__Group__3__Impl rule__CollectionExpression__Group__4 + { + pushFollow(FOLLOW_23); + rule__CollectionExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__3" + + + // $ANTLR start "rule__CollectionExpression__Group__3__Impl" + // InternalScope.g:12606:1: rule__CollectionExpression__Group__3__Impl : ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ; + public final void rule__CollectionExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12610:1: ( ( ( rule__CollectionExpression__ExpAssignment_3 ) ) ) + // InternalScope.g:12611:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + { + // InternalScope.g:12611:1: ( ( rule__CollectionExpression__ExpAssignment_3 ) ) + // InternalScope.g:12612:2: ( rule__CollectionExpression__ExpAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + } + // InternalScope.g:12613:2: ( rule__CollectionExpression__ExpAssignment_3 ) + // InternalScope.g:12613:3: rule__CollectionExpression__ExpAssignment_3 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__ExpAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getExpAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__3__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group__4" + // InternalScope.g:12621:1: rule__CollectionExpression__Group__4 : rule__CollectionExpression__Group__4__Impl ; + public final void rule__CollectionExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12625:1: ( rule__CollectionExpression__Group__4__Impl ) + // InternalScope.g:12626:2: rule__CollectionExpression__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__4" + + + // $ANTLR start "rule__CollectionExpression__Group__4__Impl" + // InternalScope.g:12632:1: rule__CollectionExpression__Group__4__Impl : ( ')' ) ; + public final void rule__CollectionExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12636:1: ( ( ')' ) ) + // InternalScope.g:12637:1: ( ')' ) + { + // InternalScope.g:12637:1: ( ')' ) + // InternalScope.g:12638:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group__4__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group_2__0" + // InternalScope.g:12648:1: rule__CollectionExpression__Group_2__0 : rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ; + public final void rule__CollectionExpression__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12652:1: ( rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 ) + // InternalScope.g:12653:2: rule__CollectionExpression__Group_2__0__Impl rule__CollectionExpression__Group_2__1 + { + pushFollow(FOLLOW_42); + rule__CollectionExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__0" + + + // $ANTLR start "rule__CollectionExpression__Group_2__0__Impl" + // InternalScope.g:12660:1: rule__CollectionExpression__Group_2__0__Impl : ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ; + public final void rule__CollectionExpression__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12664:1: ( ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) ) + // InternalScope.g:12665:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + { + // InternalScope.g:12665:1: ( ( rule__CollectionExpression__VarAssignment_2_0 ) ) + // InternalScope.g:12666:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + } + // InternalScope.g:12667:2: ( rule__CollectionExpression__VarAssignment_2_0 ) + // InternalScope.g:12667:3: rule__CollectionExpression__VarAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__VarAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVarAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__0__Impl" + + + // $ANTLR start "rule__CollectionExpression__Group_2__1" + // InternalScope.g:12675:1: rule__CollectionExpression__Group_2__1 : rule__CollectionExpression__Group_2__1__Impl ; + public final void rule__CollectionExpression__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12679:1: ( rule__CollectionExpression__Group_2__1__Impl ) + // InternalScope.g:12680:2: rule__CollectionExpression__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__1" + + + // $ANTLR start "rule__CollectionExpression__Group_2__1__Impl" + // InternalScope.g:12686:1: rule__CollectionExpression__Group_2__1__Impl : ( '|' ) ; + public final void rule__CollectionExpression__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12690:1: ( ( '|' ) ) + // InternalScope.g:12691:1: ( '|' ) + { + // InternalScope.g:12691:1: ( '|' ) + // InternalScope.g:12692:2: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__Group_2__1__Impl" + + + // $ANTLR start "rule__CollectionType__Group__0" + // InternalScope.g:12702:1: rule__CollectionType__Group__0 : rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ; + public final void rule__CollectionType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12706:1: ( rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 ) + // InternalScope.g:12707:2: rule__CollectionType__Group__0__Impl rule__CollectionType__Group__1 + { + pushFollow(FOLLOW_29); + rule__CollectionType__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__0" + + + // $ANTLR start "rule__CollectionType__Group__0__Impl" + // InternalScope.g:12714:1: rule__CollectionType__Group__0__Impl : ( ( rule__CollectionType__ClAssignment_0 ) ) ; + public final void rule__CollectionType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12718:1: ( ( ( rule__CollectionType__ClAssignment_0 ) ) ) + // InternalScope.g:12719:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + { + // InternalScope.g:12719:1: ( ( rule__CollectionType__ClAssignment_0 ) ) + // InternalScope.g:12720:2: ( rule__CollectionType__ClAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + } + // InternalScope.g:12721:2: ( rule__CollectionType__ClAssignment_0 ) + // InternalScope.g:12721:3: rule__CollectionType__ClAssignment_0 + { + pushFollow(FOLLOW_2); + rule__CollectionType__ClAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__0__Impl" + + + // $ANTLR start "rule__CollectionType__Group__1" + // InternalScope.g:12729:1: rule__CollectionType__Group__1 : rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ; + public final void rule__CollectionType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12733:1: ( rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 ) + // InternalScope.g:12734:2: rule__CollectionType__Group__1__Impl rule__CollectionType__Group__2 + { + pushFollow(FOLLOW_48); + rule__CollectionType__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__1" + + + // $ANTLR start "rule__CollectionType__Group__1__Impl" + // InternalScope.g:12741:1: rule__CollectionType__Group__1__Impl : ( '[' ) ; + public final void rule__CollectionType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12745:1: ( ( '[' ) ) + // InternalScope.g:12746:1: ( '[' ) + { + // InternalScope.g:12746:1: ( '[' ) + // InternalScope.g:12747:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__1__Impl" + + + // $ANTLR start "rule__CollectionType__Group__2" + // InternalScope.g:12756:1: rule__CollectionType__Group__2 : rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ; + public final void rule__CollectionType__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12760:1: ( rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 ) + // InternalScope.g:12761:2: rule__CollectionType__Group__2__Impl rule__CollectionType__Group__3 + { + pushFollow(FOLLOW_30); + rule__CollectionType__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__CollectionType__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__2" + + + // $ANTLR start "rule__CollectionType__Group__2__Impl" + // InternalScope.g:12768:1: rule__CollectionType__Group__2__Impl : ( ( rule__CollectionType__Id1Assignment_2 ) ) ; + public final void rule__CollectionType__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12772:1: ( ( ( rule__CollectionType__Id1Assignment_2 ) ) ) + // InternalScope.g:12773:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + { + // InternalScope.g:12773:1: ( ( rule__CollectionType__Id1Assignment_2 ) ) + // InternalScope.g:12774:2: ( rule__CollectionType__Id1Assignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + } + // InternalScope.g:12775:2: ( rule__CollectionType__Id1Assignment_2 ) + // InternalScope.g:12775:3: rule__CollectionType__Id1Assignment_2 + { + pushFollow(FOLLOW_2); + rule__CollectionType__Id1Assignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getId1Assignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__2__Impl" + + + // $ANTLR start "rule__CollectionType__Group__3" + // InternalScope.g:12783:1: rule__CollectionType__Group__3 : rule__CollectionType__Group__3__Impl ; + public final void rule__CollectionType__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12787:1: ( rule__CollectionType__Group__3__Impl ) + // InternalScope.g:12788:2: rule__CollectionType__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__CollectionType__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__3" + + + // $ANTLR start "rule__CollectionType__Group__3__Impl" + // InternalScope.g:12794:1: rule__CollectionType__Group__3__Impl : ( ']' ) ; + public final void rule__CollectionType__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12798:1: ( ( ']' ) ) + // InternalScope.g:12799:1: ( ']' ) + { + // InternalScope.g:12799:1: ( ']' ) + // InternalScope.g:12800:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Group__3__Impl" + + + // $ANTLR start "rule__SimpleType__Group__0" + // InternalScope.g:12810:1: rule__SimpleType__Group__0 : rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ; + public final void rule__SimpleType__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12814:1: ( rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 ) + // InternalScope.g:12815:2: rule__SimpleType__Group__0__Impl rule__SimpleType__Group__1 + { + pushFollow(FOLLOW_43); + rule__SimpleType__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SimpleType__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__0" + + + // $ANTLR start "rule__SimpleType__Group__0__Impl" + // InternalScope.g:12822:1: rule__SimpleType__Group__0__Impl : ( ( rule__SimpleType__IdAssignment_0 ) ) ; + public final void rule__SimpleType__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12826:1: ( ( ( rule__SimpleType__IdAssignment_0 ) ) ) + // InternalScope.g:12827:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + { + // InternalScope.g:12827:1: ( ( rule__SimpleType__IdAssignment_0 ) ) + // InternalScope.g:12828:2: ( rule__SimpleType__IdAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + } + // InternalScope.g:12829:2: ( rule__SimpleType__IdAssignment_0 ) + // InternalScope.g:12829:3: rule__SimpleType__IdAssignment_0 + { + pushFollow(FOLLOW_2); + rule__SimpleType__IdAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__0__Impl" + + + // $ANTLR start "rule__SimpleType__Group__1" + // InternalScope.g:12837:1: rule__SimpleType__Group__1 : rule__SimpleType__Group__1__Impl ; + public final void rule__SimpleType__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12841:1: ( rule__SimpleType__Group__1__Impl ) + // InternalScope.g:12842:2: rule__SimpleType__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__SimpleType__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__1" + + + // $ANTLR start "rule__SimpleType__Group__1__Impl" + // InternalScope.g:12848:1: rule__SimpleType__Group__1__Impl : ( ( rule__SimpleType__Group_1__0 )* ) ; + public final void rule__SimpleType__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12852:1: ( ( ( rule__SimpleType__Group_1__0 )* ) ) + // InternalScope.g:12853:1: ( ( rule__SimpleType__Group_1__0 )* ) + { + // InternalScope.g:12853:1: ( ( rule__SimpleType__Group_1__0 )* ) + // InternalScope.g:12854:2: ( rule__SimpleType__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getGroup_1()); + } + // InternalScope.g:12855:2: ( rule__SimpleType__Group_1__0 )* + loop114: + do { + int alt114=2; + int LA114_0 = input.LA(1); + + if ( (LA114_0==93) ) { + alt114=1; + } + + + switch (alt114) { + case 1 : + // InternalScope.g:12855:3: rule__SimpleType__Group_1__0 + { + pushFollow(FOLLOW_44); + rule__SimpleType__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop114; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group__1__Impl" + + + // $ANTLR start "rule__SimpleType__Group_1__0" + // InternalScope.g:12864:1: rule__SimpleType__Group_1__0 : rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ; + public final void rule__SimpleType__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12868:1: ( rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 ) + // InternalScope.g:12869:2: rule__SimpleType__Group_1__0__Impl rule__SimpleType__Group_1__1 + { + pushFollow(FOLLOW_4); + rule__SimpleType__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__SimpleType__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__0" + + + // $ANTLR start "rule__SimpleType__Group_1__0__Impl" + // InternalScope.g:12876:1: rule__SimpleType__Group_1__0__Impl : ( '::' ) ; + public final void rule__SimpleType__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12880:1: ( ( '::' ) ) + // InternalScope.g:12881:1: ( '::' ) + { + // InternalScope.g:12881:1: ( '::' ) + // InternalScope.g:12882:2: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__0__Impl" + + + // $ANTLR start "rule__SimpleType__Group_1__1" + // InternalScope.g:12891:1: rule__SimpleType__Group_1__1 : rule__SimpleType__Group_1__1__Impl ; + public final void rule__SimpleType__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12895:1: ( rule__SimpleType__Group_1__1__Impl ) + // InternalScope.g:12896:2: rule__SimpleType__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__SimpleType__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__1" + + + // $ANTLR start "rule__SimpleType__Group_1__1__Impl" + // InternalScope.g:12902:1: rule__SimpleType__Group_1__1__Impl : ( ( rule__SimpleType__IdAssignment_1_1 ) ) ; + public final void rule__SimpleType__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12906:1: ( ( ( rule__SimpleType__IdAssignment_1_1 ) ) ) + // InternalScope.g:12907:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + { + // InternalScope.g:12907:1: ( ( rule__SimpleType__IdAssignment_1_1 ) ) + // InternalScope.g:12908:2: ( rule__SimpleType__IdAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + } + // InternalScope.g:12909:2: ( rule__SimpleType__IdAssignment_1_1 ) + // InternalScope.g:12909:3: rule__SimpleType__IdAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__SimpleType__IdAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__Group_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__0" + // InternalScope.g:12918:1: rule__XAssignment__Group_0__0 : rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ; + public final void rule__XAssignment__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12922:1: ( rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ) + // InternalScope.g:12923:2: rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 + { + pushFollow(FOLLOW_75); + rule__XAssignment__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__0" + + + // $ANTLR start "rule__XAssignment__Group_0__0__Impl" + // InternalScope.g:12930:1: rule__XAssignment__Group_0__0__Impl : ( () ) ; + public final void rule__XAssignment__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12934:1: ( ( () ) ) + // InternalScope.g:12935:1: ( () ) + { + // InternalScope.g:12935:1: ( () ) + // InternalScope.g:12936:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); + } + // InternalScope.g:12937:2: () + // InternalScope.g:12937:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__1" + // InternalScope.g:12945:1: rule__XAssignment__Group_0__1 : rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ; + public final void rule__XAssignment__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12949:1: ( rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ) + // InternalScope.g:12950:2: rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 + { + pushFollow(FOLLOW_16); + rule__XAssignment__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__1" + + + // $ANTLR start "rule__XAssignment__Group_0__1__Impl" + // InternalScope.g:12957:1: rule__XAssignment__Group_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ; + public final void rule__XAssignment__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12961:1: ( ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ) + // InternalScope.g:12962:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) + { + // InternalScope.g:12962:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) + // InternalScope.g:12963:2: ( rule__XAssignment__FeatureAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); + } + // InternalScope.g:12964:2: ( rule__XAssignment__FeatureAssignment_0_1 ) + // InternalScope.g:12964:3: rule__XAssignment__FeatureAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__FeatureAssignment_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__2" + // InternalScope.g:12972:1: rule__XAssignment__Group_0__2 : rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ; + public final void rule__XAssignment__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12976:1: ( rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ) + // InternalScope.g:12977:2: rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 + { + pushFollow(FOLLOW_76); + rule__XAssignment__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__2" + + + // $ANTLR start "rule__XAssignment__Group_0__2__Impl" + // InternalScope.g:12984:1: rule__XAssignment__Group_0__2__Impl : ( ruleOpSingleAssign ) ; + public final void rule__XAssignment__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:12988:1: ( ( ruleOpSingleAssign ) ) + // InternalScope.g:12989:1: ( ruleOpSingleAssign ) + { + // InternalScope.g:12989:1: ( ruleOpSingleAssign ) + // InternalScope.g:12990:2: ruleOpSingleAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__2__Impl" + + + // $ANTLR start "rule__XAssignment__Group_0__3" + // InternalScope.g:12999:1: rule__XAssignment__Group_0__3 : rule__XAssignment__Group_0__3__Impl ; + public final void rule__XAssignment__Group_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13003:1: ( rule__XAssignment__Group_0__3__Impl ) + // InternalScope.g:13004:2: rule__XAssignment__Group_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__3" + + + // $ANTLR start "rule__XAssignment__Group_0__3__Impl" + // InternalScope.g:13010:1: rule__XAssignment__Group_0__3__Impl : ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ; + public final void rule__XAssignment__Group_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13014:1: ( ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ) + // InternalScope.g:13015:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) ) + { + // InternalScope.g:13015:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) ) + // InternalScope.g:13016:2: ( rule__XAssignment__ValueAssignment_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); + } + // InternalScope.g:13017:2: ( rule__XAssignment__ValueAssignment_0_3 ) + // InternalScope.g:13017:3: rule__XAssignment__ValueAssignment_0_3 + { + pushFollow(FOLLOW_2); + rule__XAssignment__ValueAssignment_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_0__3__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1__0" + // InternalScope.g:13026:1: rule__XAssignment__Group_1__0 : rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ; + public final void rule__XAssignment__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13030:1: ( rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ) + // InternalScope.g:13031:2: rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 + { + pushFollow(FOLLOW_77); + rule__XAssignment__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__0" + + + // $ANTLR start "rule__XAssignment__Group_1__0__Impl" + // InternalScope.g:13038:1: rule__XAssignment__Group_1__0__Impl : ( ruleXOrExpression ) ; + public final void rule__XAssignment__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13042:1: ( ( ruleXOrExpression ) ) + // InternalScope.g:13043:1: ( ruleXOrExpression ) + { + // InternalScope.g:13043:1: ( ruleXOrExpression ) + // InternalScope.g:13044:2: ruleXOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1__1" + // InternalScope.g:13053:1: rule__XAssignment__Group_1__1 : rule__XAssignment__Group_1__1__Impl ; + public final void rule__XAssignment__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13057:1: ( rule__XAssignment__Group_1__1__Impl ) + // InternalScope.g:13058:2: rule__XAssignment__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__1" + + + // $ANTLR start "rule__XAssignment__Group_1__1__Impl" + // InternalScope.g:13064:1: rule__XAssignment__Group_1__1__Impl : ( ( rule__XAssignment__Group_1_1__0 )? ) ; + public final void rule__XAssignment__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13068:1: ( ( ( rule__XAssignment__Group_1_1__0 )? ) ) + // InternalScope.g:13069:1: ( ( rule__XAssignment__Group_1_1__0 )? ) + { + // InternalScope.g:13069:1: ( ( rule__XAssignment__Group_1_1__0 )? ) + // InternalScope.g:13070:2: ( rule__XAssignment__Group_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); + } + // InternalScope.g:13071:2: ( rule__XAssignment__Group_1_1__0 )? + int alt115=2; + alt115 = dfa115.predict(input); + switch (alt115) { + case 1 : + // InternalScope.g:13071:3: rule__XAssignment__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1__0" + // InternalScope.g:13080:1: rule__XAssignment__Group_1_1__0 : rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ; + public final void rule__XAssignment__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13084:1: ( rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ) + // InternalScope.g:13085:2: rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 + { + pushFollow(FOLLOW_76); + rule__XAssignment__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1__0__Impl" + // InternalScope.g:13092:1: rule__XAssignment__Group_1_1__0__Impl : ( ( rule__XAssignment__Group_1_1_0__0 ) ) ; + public final void rule__XAssignment__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13096:1: ( ( ( rule__XAssignment__Group_1_1_0__0 ) ) ) + // InternalScope.g:13097:1: ( ( rule__XAssignment__Group_1_1_0__0 ) ) + { + // InternalScope.g:13097:1: ( ( rule__XAssignment__Group_1_1_0__0 ) ) + // InternalScope.g:13098:2: ( rule__XAssignment__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); + } + // InternalScope.g:13099:2: ( rule__XAssignment__Group_1_1_0__0 ) + // InternalScope.g:13099:3: rule__XAssignment__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1__1" + // InternalScope.g:13107:1: rule__XAssignment__Group_1_1__1 : rule__XAssignment__Group_1_1__1__Impl ; + public final void rule__XAssignment__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13111:1: ( rule__XAssignment__Group_1_1__1__Impl ) + // InternalScope.g:13112:2: rule__XAssignment__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__1" + + + // $ANTLR start "rule__XAssignment__Group_1_1__1__Impl" + // InternalScope.g:13118:1: rule__XAssignment__Group_1_1__1__Impl : ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ; + public final void rule__XAssignment__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13122:1: ( ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ) + // InternalScope.g:13123:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) + { + // InternalScope.g:13123:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) + // InternalScope.g:13124:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); + } + // InternalScope.g:13125:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 ) + // InternalScope.g:13125:3: rule__XAssignment__RightOperandAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__RightOperandAssignment_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0__0" + // InternalScope.g:13134:1: rule__XAssignment__Group_1_1_0__0 : rule__XAssignment__Group_1_1_0__0__Impl ; + public final void rule__XAssignment__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13138:1: ( rule__XAssignment__Group_1_1_0__0__Impl ) + // InternalScope.g:13139:2: rule__XAssignment__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0__0__Impl" + // InternalScope.g:13145:1: rule__XAssignment__Group_1_1_0__0__Impl : ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ; + public final void rule__XAssignment__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13149:1: ( ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ) + // InternalScope.g:13150:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) + { + // InternalScope.g:13150:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) + // InternalScope.g:13151:2: ( rule__XAssignment__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); + } + // InternalScope.g:13152:2: ( rule__XAssignment__Group_1_1_0_0__0 ) + // InternalScope.g:13152:3: rule__XAssignment__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0" + // InternalScope.g:13161:1: rule__XAssignment__Group_1_1_0_0__0 : rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ; + public final void rule__XAssignment__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13165:1: ( rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ) + // InternalScope.g:13166:2: rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_77); + rule__XAssignment__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0__Impl" + // InternalScope.g:13173:1: rule__XAssignment__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XAssignment__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13177:1: ( ( () ) ) + // InternalScope.g:13178:1: ( () ) + { + // InternalScope.g:13178:1: ( () ) + // InternalScope.g:13179:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + // InternalScope.g:13180:2: () + // InternalScope.g:13180:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1" + // InternalScope.g:13188:1: rule__XAssignment__Group_1_1_0_0__1 : rule__XAssignment__Group_1_1_0_0__1__Impl ; + public final void rule__XAssignment__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13192:1: ( rule__XAssignment__Group_1_1_0_0__1__Impl ) + // InternalScope.g:13193:2: rule__XAssignment__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1__Impl" + // InternalScope.g:13199:1: rule__XAssignment__Group_1_1_0_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ; + public final void rule__XAssignment__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13203:1: ( ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ) + // InternalScope.g:13204:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) + { + // InternalScope.g:13204:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) + // InternalScope.g:13205:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); + } + // InternalScope.g:13206:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) + // InternalScope.g:13206:3: rule__XAssignment__FeatureAssignment_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAssignment__FeatureAssignment_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__0" + // InternalScope.g:13215:1: rule__OpMultiAssign__Group_5__0 : rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ; + public final void rule__OpMultiAssign__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13219:1: ( rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ) + // InternalScope.g:13220:2: rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 + { + pushFollow(FOLLOW_78); + rule__OpMultiAssign__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__0" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__0__Impl" + // InternalScope.g:13227:1: rule__OpMultiAssign__Group_5__0__Impl : ( '<' ) ; + public final void rule__OpMultiAssign__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13231:1: ( ( '<' ) ) + // InternalScope.g:13232:1: ( '<' ) + { + // InternalScope.g:13232:1: ( '<' ) + // InternalScope.g:13233:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__0__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__1" + // InternalScope.g:13242:1: rule__OpMultiAssign__Group_5__1 : rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ; + public final void rule__OpMultiAssign__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13246:1: ( rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ) + // InternalScope.g:13247:2: rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 + { + pushFollow(FOLLOW_16); + rule__OpMultiAssign__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__1" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__1__Impl" + // InternalScope.g:13254:1: rule__OpMultiAssign__Group_5__1__Impl : ( '<' ) ; + public final void rule__OpMultiAssign__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13258:1: ( ( '<' ) ) + // InternalScope.g:13259:1: ( '<' ) + { + // InternalScope.g:13259:1: ( '<' ) + // InternalScope.g:13260:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__2" + // InternalScope.g:13269:1: rule__OpMultiAssign__Group_5__2 : rule__OpMultiAssign__Group_5__2__Impl ; + public final void rule__OpMultiAssign__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13273:1: ( rule__OpMultiAssign__Group_5__2__Impl ) + // InternalScope.g:13274:2: rule__OpMultiAssign__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__2" + + + // $ANTLR start "rule__OpMultiAssign__Group_5__2__Impl" + // InternalScope.g:13280:1: rule__OpMultiAssign__Group_5__2__Impl : ( '=' ) ; + public final void rule__OpMultiAssign__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13284:1: ( ( '=' ) ) + // InternalScope.g:13285:1: ( '=' ) + { + // InternalScope.g:13285:1: ( '=' ) + // InternalScope.g:13286:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_5__2__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__0" + // InternalScope.g:13296:1: rule__OpMultiAssign__Group_6__0 : rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ; + public final void rule__OpMultiAssign__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13300:1: ( rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ) + // InternalScope.g:13301:2: rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 + { + pushFollow(FOLLOW_79); + rule__OpMultiAssign__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__0" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__0__Impl" + // InternalScope.g:13308:1: rule__OpMultiAssign__Group_6__0__Impl : ( '>' ) ; + public final void rule__OpMultiAssign__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13312:1: ( ( '>' ) ) + // InternalScope.g:13313:1: ( '>' ) + { + // InternalScope.g:13313:1: ( '>' ) + // InternalScope.g:13314:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__0__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__1" + // InternalScope.g:13323:1: rule__OpMultiAssign__Group_6__1 : rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ; + public final void rule__OpMultiAssign__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13327:1: ( rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ) + // InternalScope.g:13328:2: rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 + { + pushFollow(FOLLOW_79); + rule__OpMultiAssign__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__1" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__1__Impl" + // InternalScope.g:13335:1: rule__OpMultiAssign__Group_6__1__Impl : ( ( '>' )? ) ; + public final void rule__OpMultiAssign__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13339:1: ( ( ( '>' )? ) ) + // InternalScope.g:13340:1: ( ( '>' )? ) + { + // InternalScope.g:13340:1: ( ( '>' )? ) + // InternalScope.g:13341:2: ( '>' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + // InternalScope.g:13342:2: ( '>' )? + int alt116=2; + int LA116_0 = input.LA(1); + + if ( (LA116_0==21) ) { + alt116=1; + } + switch (alt116) { + case 1 : + // InternalScope.g:13342:3: '>' + { + match(input,21,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__1__Impl" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__2" + // InternalScope.g:13350:1: rule__OpMultiAssign__Group_6__2 : rule__OpMultiAssign__Group_6__2__Impl ; + public final void rule__OpMultiAssign__Group_6__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13354:1: ( rule__OpMultiAssign__Group_6__2__Impl ) + // InternalScope.g:13355:2: rule__OpMultiAssign__Group_6__2__Impl + { + pushFollow(FOLLOW_2); + rule__OpMultiAssign__Group_6__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__2" + + + // $ANTLR start "rule__OpMultiAssign__Group_6__2__Impl" + // InternalScope.g:13361:1: rule__OpMultiAssign__Group_6__2__Impl : ( '>=' ) ; + public final void rule__OpMultiAssign__Group_6__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13365:1: ( ( '>=' ) ) + // InternalScope.g:13366:1: ( '>=' ) + { + // InternalScope.g:13366:1: ( '>=' ) + // InternalScope.g:13367:2: '>=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + match(input,19,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpMultiAssign__Group_6__2__Impl" + + + // $ANTLR start "rule__XOrExpression__Group__0" + // InternalScope.g:13377:1: rule__XOrExpression__Group__0 : rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ; + public final void rule__XOrExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13381:1: ( rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ) + // InternalScope.g:13382:2: rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 + { + pushFollow(FOLLOW_58); + rule__XOrExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__0" + + + // $ANTLR start "rule__XOrExpression__Group__0__Impl" + // InternalScope.g:13389:1: rule__XOrExpression__Group__0__Impl : ( ruleXAndExpression ) ; + public final void rule__XOrExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13393:1: ( ( ruleXAndExpression ) ) + // InternalScope.g:13394:1: ( ruleXAndExpression ) + { + // InternalScope.g:13394:1: ( ruleXAndExpression ) + // InternalScope.g:13395:2: ruleXAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group__1" + // InternalScope.g:13404:1: rule__XOrExpression__Group__1 : rule__XOrExpression__Group__1__Impl ; + public final void rule__XOrExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13408:1: ( rule__XOrExpression__Group__1__Impl ) + // InternalScope.g:13409:2: rule__XOrExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__1" + + + // $ANTLR start "rule__XOrExpression__Group__1__Impl" + // InternalScope.g:13415:1: rule__XOrExpression__Group__1__Impl : ( ( rule__XOrExpression__Group_1__0 )* ) ; + public final void rule__XOrExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13419:1: ( ( ( rule__XOrExpression__Group_1__0 )* ) ) + // InternalScope.g:13420:1: ( ( rule__XOrExpression__Group_1__0 )* ) + { + // InternalScope.g:13420:1: ( ( rule__XOrExpression__Group_1__0 )* ) + // InternalScope.g:13421:2: ( rule__XOrExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1()); + } + // InternalScope.g:13422:2: ( rule__XOrExpression__Group_1__0 )* + loop117: + do { + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==15) ) { + int LA117_2 = input.LA(2); + + if ( (synpred192_InternalScope()) ) { + alt117=1; + } + + + } + + + switch (alt117) { + case 1 : + // InternalScope.g:13422:3: rule__XOrExpression__Group_1__0 + { + pushFollow(FOLLOW_59); + rule__XOrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop117; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group__1__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1__0" + // InternalScope.g:13431:1: rule__XOrExpression__Group_1__0 : rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ; + public final void rule__XOrExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13435:1: ( rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ) + // InternalScope.g:13436:2: rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 + { + pushFollow(FOLLOW_76); + rule__XOrExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__0" + + + // $ANTLR start "rule__XOrExpression__Group_1__0__Impl" + // InternalScope.g:13443:1: rule__XOrExpression__Group_1__0__Impl : ( ( rule__XOrExpression__Group_1_0__0 ) ) ; + public final void rule__XOrExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13447:1: ( ( ( rule__XOrExpression__Group_1_0__0 ) ) ) + // InternalScope.g:13448:1: ( ( rule__XOrExpression__Group_1_0__0 ) ) + { + // InternalScope.g:13448:1: ( ( rule__XOrExpression__Group_1_0__0 ) ) + // InternalScope.g:13449:2: ( rule__XOrExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:13450:2: ( rule__XOrExpression__Group_1_0__0 ) + // InternalScope.g:13450:3: rule__XOrExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1__1" + // InternalScope.g:13458:1: rule__XOrExpression__Group_1__1 : rule__XOrExpression__Group_1__1__Impl ; + public final void rule__XOrExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13462:1: ( rule__XOrExpression__Group_1__1__Impl ) + // InternalScope.g:13463:2: rule__XOrExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__1" + + + // $ANTLR start "rule__XOrExpression__Group_1__1__Impl" + // InternalScope.g:13469:1: rule__XOrExpression__Group_1__1__Impl : ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XOrExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13473:1: ( ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ) + // InternalScope.g:13474:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) + { + // InternalScope.g:13474:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) + // InternalScope.g:13475:2: ( rule__XOrExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalScope.g:13476:2: ( rule__XOrExpression__RightOperandAssignment_1_1 ) + // InternalScope.g:13476:3: rule__XOrExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0__0" + // InternalScope.g:13485:1: rule__XOrExpression__Group_1_0__0 : rule__XOrExpression__Group_1_0__0__Impl ; + public final void rule__XOrExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13489:1: ( rule__XOrExpression__Group_1_0__0__Impl ) + // InternalScope.g:13490:2: rule__XOrExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0__0" + + + // $ANTLR start "rule__XOrExpression__Group_1_0__0__Impl" + // InternalScope.g:13496:1: rule__XOrExpression__Group_1_0__0__Impl : ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ; + public final void rule__XOrExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13500:1: ( ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:13501:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:13501:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) ) + // InternalScope.g:13502:2: ( rule__XOrExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:13503:2: ( rule__XOrExpression__Group_1_0_0__0 ) + // InternalScope.g:13503:3: rule__XOrExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__0" + // InternalScope.g:13512:1: rule__XOrExpression__Group_1_0_0__0 : rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ; + public final void rule__XOrExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13516:1: ( rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ) + // InternalScope.g:13517:2: rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_58); + rule__XOrExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__0__Impl" + // InternalScope.g:13524:1: rule__XOrExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XOrExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13528:1: ( ( () ) ) + // InternalScope.g:13529:1: ( () ) + { + // InternalScope.g:13529:1: ( () ) + // InternalScope.g:13530:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalScope.g:13531:2: () + // InternalScope.g:13531:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__1" + // InternalScope.g:13539:1: rule__XOrExpression__Group_1_0_0__1 : rule__XOrExpression__Group_1_0_0__1__Impl ; + public final void rule__XOrExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13543:1: ( rule__XOrExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:13544:2: rule__XOrExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XOrExpression__Group_1_0_0__1__Impl" + // InternalScope.g:13550:1: rule__XOrExpression__Group_1_0_0__1__Impl : ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XOrExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13554:1: ( ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalScope.g:13555:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalScope.g:13555:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalScope.g:13556:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalScope.g:13557:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) + // InternalScope.g:13557:3: rule__XOrExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group__0" + // InternalScope.g:13566:1: rule__XAndExpression__Group__0 : rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ; + public final void rule__XAndExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13570:1: ( rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ) + // InternalScope.g:13571:2: rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 + { + pushFollow(FOLLOW_60); + rule__XAndExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__0" + + + // $ANTLR start "rule__XAndExpression__Group__0__Impl" + // InternalScope.g:13578:1: rule__XAndExpression__Group__0__Impl : ( ruleXEqualityExpression ) ; + public final void rule__XAndExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13582:1: ( ( ruleXEqualityExpression ) ) + // InternalScope.g:13583:1: ( ruleXEqualityExpression ) + { + // InternalScope.g:13583:1: ( ruleXEqualityExpression ) + // InternalScope.g:13584:2: ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group__1" + // InternalScope.g:13593:1: rule__XAndExpression__Group__1 : rule__XAndExpression__Group__1__Impl ; + public final void rule__XAndExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13597:1: ( rule__XAndExpression__Group__1__Impl ) + // InternalScope.g:13598:2: rule__XAndExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__1" + + + // $ANTLR start "rule__XAndExpression__Group__1__Impl" + // InternalScope.g:13604:1: rule__XAndExpression__Group__1__Impl : ( ( rule__XAndExpression__Group_1__0 )* ) ; + public final void rule__XAndExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13608:1: ( ( ( rule__XAndExpression__Group_1__0 )* ) ) + // InternalScope.g:13609:1: ( ( rule__XAndExpression__Group_1__0 )* ) + { + // InternalScope.g:13609:1: ( ( rule__XAndExpression__Group_1__0 )* ) + // InternalScope.g:13610:2: ( rule__XAndExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1()); + } + // InternalScope.g:13611:2: ( rule__XAndExpression__Group_1__0 )* + loop118: + do { + int alt118=2; + int LA118_0 = input.LA(1); + + if ( (LA118_0==16) ) { + int LA118_2 = input.LA(2); + + if ( (synpred193_InternalScope()) ) { + alt118=1; + } + + + } + + + switch (alt118) { + case 1 : + // InternalScope.g:13611:3: rule__XAndExpression__Group_1__0 + { + pushFollow(FOLLOW_61); + rule__XAndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop118; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1__0" + // InternalScope.g:13620:1: rule__XAndExpression__Group_1__0 : rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ; + public final void rule__XAndExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13624:1: ( rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ) + // InternalScope.g:13625:2: rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 + { + pushFollow(FOLLOW_76); + rule__XAndExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__0" + + + // $ANTLR start "rule__XAndExpression__Group_1__0__Impl" + // InternalScope.g:13632:1: rule__XAndExpression__Group_1__0__Impl : ( ( rule__XAndExpression__Group_1_0__0 ) ) ; + public final void rule__XAndExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13636:1: ( ( ( rule__XAndExpression__Group_1_0__0 ) ) ) + // InternalScope.g:13637:1: ( ( rule__XAndExpression__Group_1_0__0 ) ) + { + // InternalScope.g:13637:1: ( ( rule__XAndExpression__Group_1_0__0 ) ) + // InternalScope.g:13638:2: ( rule__XAndExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:13639:2: ( rule__XAndExpression__Group_1_0__0 ) + // InternalScope.g:13639:3: rule__XAndExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1__1" + // InternalScope.g:13647:1: rule__XAndExpression__Group_1__1 : rule__XAndExpression__Group_1__1__Impl ; + public final void rule__XAndExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13651:1: ( rule__XAndExpression__Group_1__1__Impl ) + // InternalScope.g:13652:2: rule__XAndExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__1" + + + // $ANTLR start "rule__XAndExpression__Group_1__1__Impl" + // InternalScope.g:13658:1: rule__XAndExpression__Group_1__1__Impl : ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XAndExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13662:1: ( ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ) + // InternalScope.g:13663:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) + { + // InternalScope.g:13663:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) + // InternalScope.g:13664:2: ( rule__XAndExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalScope.g:13665:2: ( rule__XAndExpression__RightOperandAssignment_1_1 ) + // InternalScope.g:13665:3: rule__XAndExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0__0" + // InternalScope.g:13674:1: rule__XAndExpression__Group_1_0__0 : rule__XAndExpression__Group_1_0__0__Impl ; + public final void rule__XAndExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13678:1: ( rule__XAndExpression__Group_1_0__0__Impl ) + // InternalScope.g:13679:2: rule__XAndExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0__0" + + + // $ANTLR start "rule__XAndExpression__Group_1_0__0__Impl" + // InternalScope.g:13685:1: rule__XAndExpression__Group_1_0__0__Impl : ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ; + public final void rule__XAndExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13689:1: ( ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:13690:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:13690:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) ) + // InternalScope.g:13691:2: ( rule__XAndExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:13692:2: ( rule__XAndExpression__Group_1_0_0__0 ) + // InternalScope.g:13692:3: rule__XAndExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__0" + // InternalScope.g:13701:1: rule__XAndExpression__Group_1_0_0__0 : rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ; + public final void rule__XAndExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13705:1: ( rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ) + // InternalScope.g:13706:2: rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_60); + rule__XAndExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__0__Impl" + // InternalScope.g:13713:1: rule__XAndExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XAndExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13717:1: ( ( () ) ) + // InternalScope.g:13718:1: ( () ) + { + // InternalScope.g:13718:1: ( () ) + // InternalScope.g:13719:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalScope.g:13720:2: () + // InternalScope.g:13720:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__1" + // InternalScope.g:13728:1: rule__XAndExpression__Group_1_0_0__1 : rule__XAndExpression__Group_1_0_0__1__Impl ; + public final void rule__XAndExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13732:1: ( rule__XAndExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:13733:2: rule__XAndExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XAndExpression__Group_1_0_0__1__Impl" + // InternalScope.g:13739:1: rule__XAndExpression__Group_1_0_0__1__Impl : ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XAndExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13743:1: ( ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalScope.g:13744:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalScope.g:13744:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalScope.g:13745:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalScope.g:13746:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) + // InternalScope.g:13746:3: rule__XAndExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group__0" + // InternalScope.g:13755:1: rule__XEqualityExpression__Group__0 : rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ; + public final void rule__XEqualityExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13759:1: ( rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ) + // InternalScope.g:13760:2: rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 + { + pushFollow(FOLLOW_80); + rule__XEqualityExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__0" + + + // $ANTLR start "rule__XEqualityExpression__Group__0__Impl" + // InternalScope.g:13767:1: rule__XEqualityExpression__Group__0__Impl : ( ruleXRelationalExpression ) ; + public final void rule__XEqualityExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13771:1: ( ( ruleXRelationalExpression ) ) + // InternalScope.g:13772:1: ( ruleXRelationalExpression ) + { + // InternalScope.g:13772:1: ( ruleXRelationalExpression ) + // InternalScope.g:13773:2: ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group__1" + // InternalScope.g:13782:1: rule__XEqualityExpression__Group__1 : rule__XEqualityExpression__Group__1__Impl ; + public final void rule__XEqualityExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13786:1: ( rule__XEqualityExpression__Group__1__Impl ) + // InternalScope.g:13787:2: rule__XEqualityExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__1" + + + // $ANTLR start "rule__XEqualityExpression__Group__1__Impl" + // InternalScope.g:13793:1: rule__XEqualityExpression__Group__1__Impl : ( ( rule__XEqualityExpression__Group_1__0 )* ) ; + public final void rule__XEqualityExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13797:1: ( ( ( rule__XEqualityExpression__Group_1__0 )* ) ) + // InternalScope.g:13798:1: ( ( rule__XEqualityExpression__Group_1__0 )* ) + { + // InternalScope.g:13798:1: ( ( rule__XEqualityExpression__Group_1__0 )* ) + // InternalScope.g:13799:2: ( rule__XEqualityExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); + } + // InternalScope.g:13800:2: ( rule__XEqualityExpression__Group_1__0 )* + loop119: + do { + int alt119=2; + switch ( input.LA(1) ) { + case 17: + { + int LA119_2 = input.LA(2); + + if ( (synpred194_InternalScope()) ) { + alt119=1; + } + + + } + break; + case 18: + { + int LA119_3 = input.LA(2); + + if ( (synpred194_InternalScope()) ) { + alt119=1; + } + + + } + break; + case 46: + { + int LA119_4 = input.LA(2); + + if ( (synpred194_InternalScope()) ) { + alt119=1; + } + + + } + break; + case 47: + { + int LA119_5 = input.LA(2); + + if ( (synpred194_InternalScope()) ) { + alt119=1; + } + + + } + break; + + } + + switch (alt119) { + case 1 : + // InternalScope.g:13800:3: rule__XEqualityExpression__Group_1__0 + { + pushFollow(FOLLOW_81); + rule__XEqualityExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop119; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__0" + // InternalScope.g:13809:1: rule__XEqualityExpression__Group_1__0 : rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ; + public final void rule__XEqualityExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13813:1: ( rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ) + // InternalScope.g:13814:2: rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 + { + pushFollow(FOLLOW_76); + rule__XEqualityExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__0__Impl" + // InternalScope.g:13821:1: rule__XEqualityExpression__Group_1__0__Impl : ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ; + public final void rule__XEqualityExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13825:1: ( ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ) + // InternalScope.g:13826:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) ) + { + // InternalScope.g:13826:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) ) + // InternalScope.g:13827:2: ( rule__XEqualityExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:13828:2: ( rule__XEqualityExpression__Group_1_0__0 ) + // InternalScope.g:13828:3: rule__XEqualityExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__1" + // InternalScope.g:13836:1: rule__XEqualityExpression__Group_1__1 : rule__XEqualityExpression__Group_1__1__Impl ; + public final void rule__XEqualityExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13840:1: ( rule__XEqualityExpression__Group_1__1__Impl ) + // InternalScope.g:13841:2: rule__XEqualityExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__1" + + + // $ANTLR start "rule__XEqualityExpression__Group_1__1__Impl" + // InternalScope.g:13847:1: rule__XEqualityExpression__Group_1__1__Impl : ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XEqualityExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13851:1: ( ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ) + // InternalScope.g:13852:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) + { + // InternalScope.g:13852:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) + // InternalScope.g:13853:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalScope.g:13854:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) + // InternalScope.g:13854:3: rule__XEqualityExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0__0" + // InternalScope.g:13863:1: rule__XEqualityExpression__Group_1_0__0 : rule__XEqualityExpression__Group_1_0__0__Impl ; + public final void rule__XEqualityExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13867:1: ( rule__XEqualityExpression__Group_1_0__0__Impl ) + // InternalScope.g:13868:2: rule__XEqualityExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0__0__Impl" + // InternalScope.g:13874:1: rule__XEqualityExpression__Group_1_0__0__Impl : ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ; + public final void rule__XEqualityExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13878:1: ( ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:13879:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:13879:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) + // InternalScope.g:13880:2: ( rule__XEqualityExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:13881:2: ( rule__XEqualityExpression__Group_1_0_0__0 ) + // InternalScope.g:13881:3: rule__XEqualityExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0" + // InternalScope.g:13890:1: rule__XEqualityExpression__Group_1_0_0__0 : rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ; + public final void rule__XEqualityExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13894:1: ( rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ) + // InternalScope.g:13895:2: rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_80); + rule__XEqualityExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0__Impl" + // InternalScope.g:13902:1: rule__XEqualityExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XEqualityExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13906:1: ( ( () ) ) + // InternalScope.g:13907:1: ( () ) + { + // InternalScope.g:13907:1: ( () ) + // InternalScope.g:13908:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalScope.g:13909:2: () + // InternalScope.g:13909:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1" + // InternalScope.g:13917:1: rule__XEqualityExpression__Group_1_0_0__1 : rule__XEqualityExpression__Group_1_0_0__1__Impl ; + public final void rule__XEqualityExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13921:1: ( rule__XEqualityExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:13922:2: rule__XEqualityExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1__Impl" + // InternalScope.g:13928:1: rule__XEqualityExpression__Group_1_0_0__1__Impl : ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XEqualityExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13932:1: ( ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalScope.g:13933:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalScope.g:13933:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalScope.g:13934:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalScope.g:13935:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) + // InternalScope.g:13935:3: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group__0" + // InternalScope.g:13944:1: rule__XRelationalExpression__Group__0 : rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ; + public final void rule__XRelationalExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13948:1: ( rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ) + // InternalScope.g:13949:2: rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 + { + pushFollow(FOLLOW_82); + rule__XRelationalExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__0" + + + // $ANTLR start "rule__XRelationalExpression__Group__0__Impl" + // InternalScope.g:13956:1: rule__XRelationalExpression__Group__0__Impl : ( ruleXOtherOperatorExpression ) ; + public final void rule__XRelationalExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13960:1: ( ( ruleXOtherOperatorExpression ) ) + // InternalScope.g:13961:1: ( ruleXOtherOperatorExpression ) + { + // InternalScope.g:13961:1: ( ruleXOtherOperatorExpression ) + // InternalScope.g:13962:2: ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group__1" + // InternalScope.g:13971:1: rule__XRelationalExpression__Group__1 : rule__XRelationalExpression__Group__1__Impl ; + public final void rule__XRelationalExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13975:1: ( rule__XRelationalExpression__Group__1__Impl ) + // InternalScope.g:13976:2: rule__XRelationalExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__1" + + + // $ANTLR start "rule__XRelationalExpression__Group__1__Impl" + // InternalScope.g:13982:1: rule__XRelationalExpression__Group__1__Impl : ( ( rule__XRelationalExpression__Alternatives_1 )* ) ; + public final void rule__XRelationalExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:13986:1: ( ( ( rule__XRelationalExpression__Alternatives_1 )* ) ) + // InternalScope.g:13987:1: ( ( rule__XRelationalExpression__Alternatives_1 )* ) + { + // InternalScope.g:13987:1: ( ( rule__XRelationalExpression__Alternatives_1 )* ) + // InternalScope.g:13988:2: ( rule__XRelationalExpression__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); + } + // InternalScope.g:13989:2: ( rule__XRelationalExpression__Alternatives_1 )* + loop120: + do { + int alt120=2; + switch ( input.LA(1) ) { + case 22: + { + int LA120_2 = input.LA(2); + + if ( (synpred195_InternalScope()) ) { + alt120=1; + } + + + } + break; + case 21: + { + int LA120_3 = input.LA(2); + + if ( (synpred195_InternalScope()) ) { + alt120=1; + } + + + } + break; + case 104: + { + int LA120_4 = input.LA(2); + + if ( (synpred195_InternalScope()) ) { + alt120=1; + } + + + } + break; + case 19: + { + int LA120_5 = input.LA(2); + + if ( (synpred195_InternalScope()) ) { + alt120=1; + } + + + } + break; + + } + + switch (alt120) { + case 1 : + // InternalScope.g:13989:3: rule__XRelationalExpression__Alternatives_1 + { + pushFollow(FOLLOW_83); + rule__XRelationalExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop120; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__0" + // InternalScope.g:13998:1: rule__XRelationalExpression__Group_1_0__0 : rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ; + public final void rule__XRelationalExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14002:1: ( rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ) + // InternalScope.g:14003:2: rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 + { + pushFollow(FOLLOW_84); + rule__XRelationalExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__0__Impl" + // InternalScope.g:14010:1: rule__XRelationalExpression__Group_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14014:1: ( ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:14015:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:14015:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) + // InternalScope.g:14016:2: ( rule__XRelationalExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:14017:2: ( rule__XRelationalExpression__Group_1_0_0__0 ) + // InternalScope.g:14017:3: rule__XRelationalExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__1" + // InternalScope.g:14025:1: rule__XRelationalExpression__Group_1_0__1 : rule__XRelationalExpression__Group_1_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14029:1: ( rule__XRelationalExpression__Group_1_0__1__Impl ) + // InternalScope.g:14030:2: rule__XRelationalExpression__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0__1__Impl" + // InternalScope.g:14036:1: rule__XRelationalExpression__Group_1_0__1__Impl : ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14040:1: ( ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ) + // InternalScope.g:14041:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) + { + // InternalScope.g:14041:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) + // InternalScope.g:14042:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); + } + // InternalScope.g:14043:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) + // InternalScope.g:14043:3: rule__XRelationalExpression__TypeAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__TypeAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0" + // InternalScope.g:14052:1: rule__XRelationalExpression__Group_1_0_0__0 : rule__XRelationalExpression__Group_1_0_0__0__Impl ; + public final void rule__XRelationalExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14056:1: ( rule__XRelationalExpression__Group_1_0_0__0__Impl ) + // InternalScope.g:14057:2: rule__XRelationalExpression__Group_1_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0__Impl" + // InternalScope.g:14063:1: rule__XRelationalExpression__Group_1_0_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14067:1: ( ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ) + // InternalScope.g:14068:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) + { + // InternalScope.g:14068:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) + // InternalScope.g:14069:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); + } + // InternalScope.g:14070:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 ) + // InternalScope.g:14070:3: rule__XRelationalExpression__Group_1_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0" + // InternalScope.g:14079:1: rule__XRelationalExpression__Group_1_0_0_0__0 : rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ; + public final void rule__XRelationalExpression__Group_1_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14083:1: ( rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ) + // InternalScope.g:14084:2: rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 + { + pushFollow(FOLLOW_85); + rule__XRelationalExpression__Group_1_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0__Impl" + // InternalScope.g:14091:1: rule__XRelationalExpression__Group_1_0_0_0__0__Impl : ( () ) ; + public final void rule__XRelationalExpression__Group_1_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14095:1: ( ( () ) ) + // InternalScope.g:14096:1: ( () ) + { + // InternalScope.g:14096:1: ( () ) + // InternalScope.g:14097:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); + } + // InternalScope.g:14098:2: () + // InternalScope.g:14098:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1" + // InternalScope.g:14106:1: rule__XRelationalExpression__Group_1_0_0_0__1 : rule__XRelationalExpression__Group_1_0_0_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14110:1: ( rule__XRelationalExpression__Group_1_0_0_0__1__Impl ) + // InternalScope.g:14111:2: rule__XRelationalExpression__Group_1_0_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1__Impl" + // InternalScope.g:14117:1: rule__XRelationalExpression__Group_1_0_0_0__1__Impl : ( 'instanceof' ) ; + public final void rule__XRelationalExpression__Group_1_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14121:1: ( ( 'instanceof' ) ) + // InternalScope.g:14122:1: ( 'instanceof' ) + { + // InternalScope.g:14122:1: ( 'instanceof' ) + // InternalScope.g:14123:2: 'instanceof' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + match(input,104,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__0" + // InternalScope.g:14133:1: rule__XRelationalExpression__Group_1_1__0 : rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ; + public final void rule__XRelationalExpression__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14137:1: ( rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ) + // InternalScope.g:14138:2: rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 + { + pushFollow(FOLLOW_76); + rule__XRelationalExpression__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__0__Impl" + // InternalScope.g:14145:1: rule__XRelationalExpression__Group_1_1__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14149:1: ( ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ) + // InternalScope.g:14150:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) + { + // InternalScope.g:14150:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) + // InternalScope.g:14151:2: ( rule__XRelationalExpression__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); + } + // InternalScope.g:14152:2: ( rule__XRelationalExpression__Group_1_1_0__0 ) + // InternalScope.g:14152:3: rule__XRelationalExpression__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__1" + // InternalScope.g:14160:1: rule__XRelationalExpression__Group_1_1__1 : rule__XRelationalExpression__Group_1_1__1__Impl ; + public final void rule__XRelationalExpression__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14164:1: ( rule__XRelationalExpression__Group_1_1__1__Impl ) + // InternalScope.g:14165:2: rule__XRelationalExpression__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1__1__Impl" + // InternalScope.g:14171:1: rule__XRelationalExpression__Group_1_1__1__Impl : ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14175:1: ( ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ) + // InternalScope.g:14176:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) + { + // InternalScope.g:14176:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) + // InternalScope.g:14177:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); + } + // InternalScope.g:14178:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) + // InternalScope.g:14178:3: rule__XRelationalExpression__RightOperandAssignment_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__RightOperandAssignment_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0" + // InternalScope.g:14187:1: rule__XRelationalExpression__Group_1_1_0__0 : rule__XRelationalExpression__Group_1_1_0__0__Impl ; + public final void rule__XRelationalExpression__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14191:1: ( rule__XRelationalExpression__Group_1_1_0__0__Impl ) + // InternalScope.g:14192:2: rule__XRelationalExpression__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0__Impl" + // InternalScope.g:14198:1: rule__XRelationalExpression__Group_1_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ; + public final void rule__XRelationalExpression__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14202:1: ( ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ) + // InternalScope.g:14203:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) + { + // InternalScope.g:14203:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) + // InternalScope.g:14204:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); + } + // InternalScope.g:14205:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 ) + // InternalScope.g:14205:3: rule__XRelationalExpression__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0" + // InternalScope.g:14214:1: rule__XRelationalExpression__Group_1_1_0_0__0 : rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ; + public final void rule__XRelationalExpression__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14218:1: ( rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ) + // InternalScope.g:14219:2: rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_82); + rule__XRelationalExpression__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0__Impl" + // InternalScope.g:14226:1: rule__XRelationalExpression__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XRelationalExpression__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14230:1: ( ( () ) ) + // InternalScope.g:14231:1: ( () ) + { + // InternalScope.g:14231:1: ( () ) + // InternalScope.g:14232:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + // InternalScope.g:14233:2: () + // InternalScope.g:14233:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1" + // InternalScope.g:14241:1: rule__XRelationalExpression__Group_1_1_0_0__1 : rule__XRelationalExpression__Group_1_1_0_0__1__Impl ; + public final void rule__XRelationalExpression__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14245:1: ( rule__XRelationalExpression__Group_1_1_0_0__1__Impl ) + // InternalScope.g:14246:2: rule__XRelationalExpression__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1__Impl" + // InternalScope.g:14252:1: rule__XRelationalExpression__Group_1_1_0_0__1__Impl : ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ; + public final void rule__XRelationalExpression__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14256:1: ( ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ) + // InternalScope.g:14257:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) + { + // InternalScope.g:14257:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) + // InternalScope.g:14258:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); + } + // InternalScope.g:14259:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) + // InternalScope.g:14259:3: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpCompare__Group_1__0" + // InternalScope.g:14268:1: rule__OpCompare__Group_1__0 : rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ; + public final void rule__OpCompare__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14272:1: ( rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ) + // InternalScope.g:14273:2: rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 + { + pushFollow(FOLLOW_16); + rule__OpCompare__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__0" + + + // $ANTLR start "rule__OpCompare__Group_1__0__Impl" + // InternalScope.g:14280:1: rule__OpCompare__Group_1__0__Impl : ( '<' ) ; + public final void rule__OpCompare__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14284:1: ( ( '<' ) ) + // InternalScope.g:14285:1: ( '<' ) + { + // InternalScope.g:14285:1: ( '<' ) + // InternalScope.g:14286:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__0__Impl" + + + // $ANTLR start "rule__OpCompare__Group_1__1" + // InternalScope.g:14295:1: rule__OpCompare__Group_1__1 : rule__OpCompare__Group_1__1__Impl ; + public final void rule__OpCompare__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14299:1: ( rule__OpCompare__Group_1__1__Impl ) + // InternalScope.g:14300:2: rule__OpCompare__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpCompare__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__1" + + + // $ANTLR start "rule__OpCompare__Group_1__1__Impl" + // InternalScope.g:14306:1: rule__OpCompare__Group_1__1__Impl : ( '=' ) ; + public final void rule__OpCompare__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14310:1: ( ( '=' ) ) + // InternalScope.g:14311:1: ( '=' ) + { + // InternalScope.g:14311:1: ( '=' ) + // InternalScope.g:14312:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpCompare__Group_1__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__0" + // InternalScope.g:14322:1: rule__XOtherOperatorExpression__Group__0 : rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ; + public final void rule__XOtherOperatorExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14326:1: ( rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ) + // InternalScope.g:14327:2: rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 + { + pushFollow(FOLLOW_86); + rule__XOtherOperatorExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__0__Impl" + // InternalScope.g:14334:1: rule__XOtherOperatorExpression__Group__0__Impl : ( ruleXAdditiveExpression ) ; + public final void rule__XOtherOperatorExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14338:1: ( ( ruleXAdditiveExpression ) ) + // InternalScope.g:14339:1: ( ruleXAdditiveExpression ) + { + // InternalScope.g:14339:1: ( ruleXAdditiveExpression ) + // InternalScope.g:14340:2: ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__1" + // InternalScope.g:14349:1: rule__XOtherOperatorExpression__Group__1 : rule__XOtherOperatorExpression__Group__1__Impl ; + public final void rule__XOtherOperatorExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14353:1: ( rule__XOtherOperatorExpression__Group__1__Impl ) + // InternalScope.g:14354:2: rule__XOtherOperatorExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group__1__Impl" + // InternalScope.g:14360:1: rule__XOtherOperatorExpression__Group__1__Impl : ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ; + public final void rule__XOtherOperatorExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14364:1: ( ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ) + // InternalScope.g:14365:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) + { + // InternalScope.g:14365:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) + // InternalScope.g:14366:2: ( rule__XOtherOperatorExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); + } + // InternalScope.g:14367:2: ( rule__XOtherOperatorExpression__Group_1__0 )* + loop121: + do { + int alt121=2; + alt121 = dfa121.predict(input); + switch (alt121) { + case 1 : + // InternalScope.g:14367:3: rule__XOtherOperatorExpression__Group_1__0 + { + pushFollow(FOLLOW_87); + rule__XOtherOperatorExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop121; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0" + // InternalScope.g:14376:1: rule__XOtherOperatorExpression__Group_1__0 : rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ; + public final void rule__XOtherOperatorExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14380:1: ( rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ) + // InternalScope.g:14381:2: rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 + { + pushFollow(FOLLOW_76); + rule__XOtherOperatorExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0__Impl" + // InternalScope.g:14388:1: rule__XOtherOperatorExpression__Group_1__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14392:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ) + // InternalScope.g:14393:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) + { + // InternalScope.g:14393:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) + // InternalScope.g:14394:2: ( rule__XOtherOperatorExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:14395:2: ( rule__XOtherOperatorExpression__Group_1_0__0 ) + // InternalScope.g:14395:3: rule__XOtherOperatorExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1" + // InternalScope.g:14403:1: rule__XOtherOperatorExpression__Group_1__1 : rule__XOtherOperatorExpression__Group_1__1__Impl ; + public final void rule__XOtherOperatorExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14407:1: ( rule__XOtherOperatorExpression__Group_1__1__Impl ) + // InternalScope.g:14408:2: rule__XOtherOperatorExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1__Impl" + // InternalScope.g:14414:1: rule__XOtherOperatorExpression__Group_1__1__Impl : ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14418:1: ( ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ) + // InternalScope.g:14419:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) + { + // InternalScope.g:14419:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) + // InternalScope.g:14420:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalScope.g:14421:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) + // InternalScope.g:14421:3: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0" + // InternalScope.g:14430:1: rule__XOtherOperatorExpression__Group_1_0__0 : rule__XOtherOperatorExpression__Group_1_0__0__Impl ; + public final void rule__XOtherOperatorExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14434:1: ( rule__XOtherOperatorExpression__Group_1_0__0__Impl ) + // InternalScope.g:14435:2: rule__XOtherOperatorExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0__Impl" + // InternalScope.g:14441:1: rule__XOtherOperatorExpression__Group_1_0__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14445:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:14446:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:14446:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) + // InternalScope.g:14447:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:14448:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) + // InternalScope.g:14448:3: rule__XOtherOperatorExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0" + // InternalScope.g:14457:1: rule__XOtherOperatorExpression__Group_1_0_0__0 : rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14461:1: ( rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ) + // InternalScope.g:14462:2: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_86); + rule__XOtherOperatorExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl" + // InternalScope.g:14469:1: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14473:1: ( ( () ) ) + // InternalScope.g:14474:1: ( () ) + { + // InternalScope.g:14474:1: ( () ) + // InternalScope.g:14475:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalScope.g:14476:2: () + // InternalScope.g:14476:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1" + // InternalScope.g:14484:1: rule__XOtherOperatorExpression__Group_1_0_0__1 : rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14488:1: ( rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:14489:2: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl" + // InternalScope.g:14495:1: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl : ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XOtherOperatorExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14499:1: ( ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalScope.g:14500:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalScope.g:14500:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalScope.g:14501:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalScope.g:14502:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) + // InternalScope.g:14502:3: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_2__0" + // InternalScope.g:14511:1: rule__OpOther__Group_2__0 : rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ; + public final void rule__OpOther__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14515:1: ( rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ) + // InternalScope.g:14516:2: rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 + { + pushFollow(FOLLOW_88); + rule__OpOther__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__0" + + + // $ANTLR start "rule__OpOther__Group_2__0__Impl" + // InternalScope.g:14523:1: rule__OpOther__Group_2__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14527:1: ( ( '>' ) ) + // InternalScope.g:14528:1: ( '>' ) + { + // InternalScope.g:14528:1: ( '>' ) + // InternalScope.g:14529:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_2__1" + // InternalScope.g:14538:1: rule__OpOther__Group_2__1 : rule__OpOther__Group_2__1__Impl ; + public final void rule__OpOther__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14542:1: ( rule__OpOther__Group_2__1__Impl ) + // InternalScope.g:14543:2: rule__OpOther__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__1" + + + // $ANTLR start "rule__OpOther__Group_2__1__Impl" + // InternalScope.g:14549:1: rule__OpOther__Group_2__1__Impl : ( '..' ) ; + public final void rule__OpOther__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14553:1: ( ( '..' ) ) + // InternalScope.g:14554:1: ( '..' ) + { + // InternalScope.g:14554:1: ( '..' ) + // InternalScope.g:14555:2: '..' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + match(input,50,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_2__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_5__0" + // InternalScope.g:14565:1: rule__OpOther__Group_5__0 : rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ; + public final void rule__OpOther__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14569:1: ( rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ) + // InternalScope.g:14570:2: rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 + { + pushFollow(FOLLOW_89); + rule__OpOther__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__0" + + + // $ANTLR start "rule__OpOther__Group_5__0__Impl" + // InternalScope.g:14577:1: rule__OpOther__Group_5__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14581:1: ( ( '>' ) ) + // InternalScope.g:14582:1: ( '>' ) + { + // InternalScope.g:14582:1: ( '>' ) + // InternalScope.g:14583:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5__1" + // InternalScope.g:14592:1: rule__OpOther__Group_5__1 : rule__OpOther__Group_5__1__Impl ; + public final void rule__OpOther__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14596:1: ( rule__OpOther__Group_5__1__Impl ) + // InternalScope.g:14597:2: rule__OpOther__Group_5__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__1" + + + // $ANTLR start "rule__OpOther__Group_5__1__Impl" + // InternalScope.g:14603:1: rule__OpOther__Group_5__1__Impl : ( ( rule__OpOther__Alternatives_5_1 ) ) ; + public final void rule__OpOther__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14607:1: ( ( ( rule__OpOther__Alternatives_5_1 ) ) ) + // InternalScope.g:14608:1: ( ( rule__OpOther__Alternatives_5_1 ) ) + { + // InternalScope.g:14608:1: ( ( rule__OpOther__Alternatives_5_1 ) ) + // InternalScope.g:14609:2: ( rule__OpOther__Alternatives_5_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); + } + // InternalScope.g:14610:2: ( rule__OpOther__Alternatives_5_1 ) + // InternalScope.g:14610:3: rule__OpOther__Alternatives_5_1 + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives_5_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0__0" + // InternalScope.g:14619:1: rule__OpOther__Group_5_1_0__0 : rule__OpOther__Group_5_1_0__0__Impl ; + public final void rule__OpOther__Group_5_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14623:1: ( rule__OpOther__Group_5_1_0__0__Impl ) + // InternalScope.g:14624:2: rule__OpOther__Group_5_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0__0" + + + // $ANTLR start "rule__OpOther__Group_5_1_0__0__Impl" + // InternalScope.g:14630:1: rule__OpOther__Group_5_1_0__0__Impl : ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ; + public final void rule__OpOther__Group_5_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14634:1: ( ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ) + // InternalScope.g:14635:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) ) + { + // InternalScope.g:14635:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) ) + // InternalScope.g:14636:2: ( rule__OpOther__Group_5_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); + } + // InternalScope.g:14637:2: ( rule__OpOther__Group_5_1_0_0__0 ) + // InternalScope.g:14637:3: rule__OpOther__Group_5_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__0" + // InternalScope.g:14646:1: rule__OpOther__Group_5_1_0_0__0 : rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ; + public final void rule__OpOther__Group_5_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14650:1: ( rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ) + // InternalScope.g:14651:2: rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 + { + pushFollow(FOLLOW_89); + rule__OpOther__Group_5_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__0" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__0__Impl" + // InternalScope.g:14658:1: rule__OpOther__Group_5_1_0_0__0__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14662:1: ( ( '>' ) ) + // InternalScope.g:14663:1: ( '>' ) + { + // InternalScope.g:14663:1: ( '>' ) + // InternalScope.g:14664:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__1" + // InternalScope.g:14673:1: rule__OpOther__Group_5_1_0_0__1 : rule__OpOther__Group_5_1_0_0__1__Impl ; + public final void rule__OpOther__Group_5_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14677:1: ( rule__OpOther__Group_5_1_0_0__1__Impl ) + // InternalScope.g:14678:2: rule__OpOther__Group_5_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_5_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__1" + + + // $ANTLR start "rule__OpOther__Group_5_1_0_0__1__Impl" + // InternalScope.g:14684:1: rule__OpOther__Group_5_1_0_0__1__Impl : ( '>' ) ; + public final void rule__OpOther__Group_5_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14688:1: ( ( '>' ) ) + // InternalScope.g:14689:1: ( '>' ) + { + // InternalScope.g:14689:1: ( '>' ) + // InternalScope.g:14690:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_5_1_0_0__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_6__0" + // InternalScope.g:14700:1: rule__OpOther__Group_6__0 : rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ; + public final void rule__OpOther__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14704:1: ( rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ) + // InternalScope.g:14705:2: rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 + { + pushFollow(FOLLOW_90); + rule__OpOther__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__0" + + + // $ANTLR start "rule__OpOther__Group_6__0__Impl" + // InternalScope.g:14712:1: rule__OpOther__Group_6__0__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14716:1: ( ( '<' ) ) + // InternalScope.g:14717:1: ( '<' ) + { + // InternalScope.g:14717:1: ( '<' ) + // InternalScope.g:14718:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6__1" + // InternalScope.g:14727:1: rule__OpOther__Group_6__1 : rule__OpOther__Group_6__1__Impl ; + public final void rule__OpOther__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14731:1: ( rule__OpOther__Group_6__1__Impl ) + // InternalScope.g:14732:2: rule__OpOther__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__1" + + + // $ANTLR start "rule__OpOther__Group_6__1__Impl" + // InternalScope.g:14738:1: rule__OpOther__Group_6__1__Impl : ( ( rule__OpOther__Alternatives_6_1 ) ) ; + public final void rule__OpOther__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14742:1: ( ( ( rule__OpOther__Alternatives_6_1 ) ) ) + // InternalScope.g:14743:1: ( ( rule__OpOther__Alternatives_6_1 ) ) + { + // InternalScope.g:14743:1: ( ( rule__OpOther__Alternatives_6_1 ) ) + // InternalScope.g:14744:2: ( rule__OpOther__Alternatives_6_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); + } + // InternalScope.g:14745:2: ( rule__OpOther__Alternatives_6_1 ) + // InternalScope.g:14745:3: rule__OpOther__Alternatives_6_1 + { + pushFollow(FOLLOW_2); + rule__OpOther__Alternatives_6_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6__1__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0__0" + // InternalScope.g:14754:1: rule__OpOther__Group_6_1_0__0 : rule__OpOther__Group_6_1_0__0__Impl ; + public final void rule__OpOther__Group_6_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14758:1: ( rule__OpOther__Group_6_1_0__0__Impl ) + // InternalScope.g:14759:2: rule__OpOther__Group_6_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0__0" + + + // $ANTLR start "rule__OpOther__Group_6_1_0__0__Impl" + // InternalScope.g:14765:1: rule__OpOther__Group_6_1_0__0__Impl : ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ; + public final void rule__OpOther__Group_6_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14769:1: ( ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ) + // InternalScope.g:14770:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) ) + { + // InternalScope.g:14770:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) ) + // InternalScope.g:14771:2: ( rule__OpOther__Group_6_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); + } + // InternalScope.g:14772:2: ( rule__OpOther__Group_6_1_0_0__0 ) + // InternalScope.g:14772:3: rule__OpOther__Group_6_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__0" + // InternalScope.g:14781:1: rule__OpOther__Group_6_1_0_0__0 : rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ; + public final void rule__OpOther__Group_6_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14785:1: ( rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ) + // InternalScope.g:14786:2: rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 + { + pushFollow(FOLLOW_78); + rule__OpOther__Group_6_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__0" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__0__Impl" + // InternalScope.g:14793:1: rule__OpOther__Group_6_1_0_0__0__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14797:1: ( ( '<' ) ) + // InternalScope.g:14798:1: ( '<' ) + { + // InternalScope.g:14798:1: ( '<' ) + // InternalScope.g:14799:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__0__Impl" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__1" + // InternalScope.g:14808:1: rule__OpOther__Group_6_1_0_0__1 : rule__OpOther__Group_6_1_0_0__1__Impl ; + public final void rule__OpOther__Group_6_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14812:1: ( rule__OpOther__Group_6_1_0_0__1__Impl ) + // InternalScope.g:14813:2: rule__OpOther__Group_6_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__1" + + + // $ANTLR start "rule__OpOther__Group_6_1_0_0__1__Impl" + // InternalScope.g:14819:1: rule__OpOther__Group_6_1_0_0__1__Impl : ( '<' ) ; + public final void rule__OpOther__Group_6_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14823:1: ( ( '<' ) ) + // InternalScope.g:14824:1: ( '<' ) + { + // InternalScope.g:14824:1: ( '<' ) + // InternalScope.g:14825:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OpOther__Group_6_1_0_0__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group__0" + // InternalScope.g:14835:1: rule__XAdditiveExpression__Group__0 : rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ; + public final void rule__XAdditiveExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14839:1: ( rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ) + // InternalScope.g:14840:2: rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 + { + pushFollow(FOLLOW_66); + rule__XAdditiveExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group__0__Impl" + // InternalScope.g:14847:1: rule__XAdditiveExpression__Group__0__Impl : ( ruleXMultiplicativeExpression ) ; + public final void rule__XAdditiveExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14851:1: ( ( ruleXMultiplicativeExpression ) ) + // InternalScope.g:14852:1: ( ruleXMultiplicativeExpression ) + { + // InternalScope.g:14852:1: ( ruleXMultiplicativeExpression ) + // InternalScope.g:14853:2: ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group__1" + // InternalScope.g:14862:1: rule__XAdditiveExpression__Group__1 : rule__XAdditiveExpression__Group__1__Impl ; + public final void rule__XAdditiveExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14866:1: ( rule__XAdditiveExpression__Group__1__Impl ) + // InternalScope.g:14867:2: rule__XAdditiveExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group__1__Impl" + // InternalScope.g:14873:1: rule__XAdditiveExpression__Group__1__Impl : ( ( rule__XAdditiveExpression__Group_1__0 )* ) ; + public final void rule__XAdditiveExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14877:1: ( ( ( rule__XAdditiveExpression__Group_1__0 )* ) ) + // InternalScope.g:14878:1: ( ( rule__XAdditiveExpression__Group_1__0 )* ) + { + // InternalScope.g:14878:1: ( ( rule__XAdditiveExpression__Group_1__0 )* ) + // InternalScope.g:14879:2: ( rule__XAdditiveExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); + } + // InternalScope.g:14880:2: ( rule__XAdditiveExpression__Group_1__0 )* + loop122: + do { + int alt122=2; + int LA122_0 = input.LA(1); + + if ( (LA122_0==24) ) { + int LA122_2 = input.LA(2); + + if ( (synpred197_InternalScope()) ) { + alt122=1; + } + + + } + else if ( (LA122_0==23) ) { + int LA122_3 = input.LA(2); + + if ( (synpred197_InternalScope()) ) { + alt122=1; + } + + + } + + + switch (alt122) { + case 1 : + // InternalScope.g:14880:3: rule__XAdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_67); + rule__XAdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop122; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__0" + // InternalScope.g:14889:1: rule__XAdditiveExpression__Group_1__0 : rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ; + public final void rule__XAdditiveExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14893:1: ( rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ) + // InternalScope.g:14894:2: rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 + { + pushFollow(FOLLOW_76); + rule__XAdditiveExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__0__Impl" + // InternalScope.g:14901:1: rule__XAdditiveExpression__Group_1__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ; + public final void rule__XAdditiveExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14905:1: ( ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ) + // InternalScope.g:14906:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) + { + // InternalScope.g:14906:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) + // InternalScope.g:14907:2: ( rule__XAdditiveExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:14908:2: ( rule__XAdditiveExpression__Group_1_0__0 ) + // InternalScope.g:14908:3: rule__XAdditiveExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__1" + // InternalScope.g:14916:1: rule__XAdditiveExpression__Group_1__1 : rule__XAdditiveExpression__Group_1__1__Impl ; + public final void rule__XAdditiveExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14920:1: ( rule__XAdditiveExpression__Group_1__1__Impl ) + // InternalScope.g:14921:2: rule__XAdditiveExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1__1__Impl" + // InternalScope.g:14927:1: rule__XAdditiveExpression__Group_1__1__Impl : ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XAdditiveExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14931:1: ( ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ) + // InternalScope.g:14932:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) + { + // InternalScope.g:14932:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) + // InternalScope.g:14933:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalScope.g:14934:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) + // InternalScope.g:14934:3: rule__XAdditiveExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0" + // InternalScope.g:14943:1: rule__XAdditiveExpression__Group_1_0__0 : rule__XAdditiveExpression__Group_1_0__0__Impl ; + public final void rule__XAdditiveExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14947:1: ( rule__XAdditiveExpression__Group_1_0__0__Impl ) + // InternalScope.g:14948:2: rule__XAdditiveExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0__Impl" + // InternalScope.g:14954:1: rule__XAdditiveExpression__Group_1_0__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ; + public final void rule__XAdditiveExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14958:1: ( ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:14959:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:14959:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) + // InternalScope.g:14960:2: ( rule__XAdditiveExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:14961:2: ( rule__XAdditiveExpression__Group_1_0_0__0 ) + // InternalScope.g:14961:3: rule__XAdditiveExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0" + // InternalScope.g:14970:1: rule__XAdditiveExpression__Group_1_0_0__0 : rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ; + public final void rule__XAdditiveExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14974:1: ( rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ) + // InternalScope.g:14975:2: rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_66); + rule__XAdditiveExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0__Impl" + // InternalScope.g:14982:1: rule__XAdditiveExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XAdditiveExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:14986:1: ( ( () ) ) + // InternalScope.g:14987:1: ( () ) + { + // InternalScope.g:14987:1: ( () ) + // InternalScope.g:14988:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalScope.g:14989:2: () + // InternalScope.g:14989:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1" + // InternalScope.g:14997:1: rule__XAdditiveExpression__Group_1_0_0__1 : rule__XAdditiveExpression__Group_1_0_0__1__Impl ; + public final void rule__XAdditiveExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15001:1: ( rule__XAdditiveExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:15002:2: rule__XAdditiveExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1__Impl" + // InternalScope.g:15008:1: rule__XAdditiveExpression__Group_1_0_0__1__Impl : ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XAdditiveExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15012:1: ( ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalScope.g:15013:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalScope.g:15013:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalScope.g:15014:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalScope.g:15015:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) + // InternalScope.g:15015:3: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__0" + // InternalScope.g:15024:1: rule__XMultiplicativeExpression__Group__0 : rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ; + public final void rule__XMultiplicativeExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15028:1: ( rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ) + // InternalScope.g:15029:2: rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 + { + pushFollow(FOLLOW_91); + rule__XMultiplicativeExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__0__Impl" + // InternalScope.g:15036:1: rule__XMultiplicativeExpression__Group__0__Impl : ( ruleXUnaryOperation ) ; + public final void rule__XMultiplicativeExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15040:1: ( ( ruleXUnaryOperation ) ) + // InternalScope.g:15041:1: ( ruleXUnaryOperation ) + { + // InternalScope.g:15041:1: ( ruleXUnaryOperation ) + // InternalScope.g:15042:2: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__1" + // InternalScope.g:15051:1: rule__XMultiplicativeExpression__Group__1 : rule__XMultiplicativeExpression__Group__1__Impl ; + public final void rule__XMultiplicativeExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15055:1: ( rule__XMultiplicativeExpression__Group__1__Impl ) + // InternalScope.g:15056:2: rule__XMultiplicativeExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group__1__Impl" + // InternalScope.g:15062:1: rule__XMultiplicativeExpression__Group__1__Impl : ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ; + public final void rule__XMultiplicativeExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15066:1: ( ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ) + // InternalScope.g:15067:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) + { + // InternalScope.g:15067:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) + // InternalScope.g:15068:2: ( rule__XMultiplicativeExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); + } + // InternalScope.g:15069:2: ( rule__XMultiplicativeExpression__Group_1__0 )* + loop123: + do { + int alt123=2; + switch ( input.LA(1) ) { + case 25: + { + int LA123_2 = input.LA(2); + + if ( (synpred198_InternalScope()) ) { + alt123=1; + } + + + } + break; + case 54: + { + int LA123_3 = input.LA(2); + + if ( (synpred198_InternalScope()) ) { + alt123=1; + } + + + } + break; + case 26: + { + int LA123_4 = input.LA(2); + + if ( (synpred198_InternalScope()) ) { + alt123=1; + } + + + } + break; + case 55: + { + int LA123_5 = input.LA(2); + + if ( (synpred198_InternalScope()) ) { + alt123=1; + } + + + } + break; + + } + + switch (alt123) { + case 1 : + // InternalScope.g:15069:3: rule__XMultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_92); + rule__XMultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop123; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0" + // InternalScope.g:15078:1: rule__XMultiplicativeExpression__Group_1__0 : rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ; + public final void rule__XMultiplicativeExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15082:1: ( rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ) + // InternalScope.g:15083:2: rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 + { + pushFollow(FOLLOW_76); + rule__XMultiplicativeExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0__Impl" + // InternalScope.g:15090:1: rule__XMultiplicativeExpression__Group_1__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15094:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ) + // InternalScope.g:15095:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) + { + // InternalScope.g:15095:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) + // InternalScope.g:15096:2: ( rule__XMultiplicativeExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:15097:2: ( rule__XMultiplicativeExpression__Group_1_0__0 ) + // InternalScope.g:15097:3: rule__XMultiplicativeExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1" + // InternalScope.g:15105:1: rule__XMultiplicativeExpression__Group_1__1 : rule__XMultiplicativeExpression__Group_1__1__Impl ; + public final void rule__XMultiplicativeExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15109:1: ( rule__XMultiplicativeExpression__Group_1__1__Impl ) + // InternalScope.g:15110:2: rule__XMultiplicativeExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1__Impl" + // InternalScope.g:15116:1: rule__XMultiplicativeExpression__Group_1__1__Impl : ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15120:1: ( ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ) + // InternalScope.g:15121:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) + { + // InternalScope.g:15121:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) + // InternalScope.g:15122:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); + } + // InternalScope.g:15123:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) + // InternalScope.g:15123:3: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__RightOperandAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0" + // InternalScope.g:15132:1: rule__XMultiplicativeExpression__Group_1_0__0 : rule__XMultiplicativeExpression__Group_1_0__0__Impl ; + public final void rule__XMultiplicativeExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15136:1: ( rule__XMultiplicativeExpression__Group_1_0__0__Impl ) + // InternalScope.g:15137:2: rule__XMultiplicativeExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0__Impl" + // InternalScope.g:15143:1: rule__XMultiplicativeExpression__Group_1_0__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15147:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:15148:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:15148:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) + // InternalScope.g:15149:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:15150:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) + // InternalScope.g:15150:3: rule__XMultiplicativeExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0" + // InternalScope.g:15159:1: rule__XMultiplicativeExpression__Group_1_0_0__0 : rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15163:1: ( rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ) + // InternalScope.g:15164:2: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_91); + rule__XMultiplicativeExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl" + // InternalScope.g:15171:1: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15175:1: ( ( () ) ) + // InternalScope.g:15176:1: ( () ) + { + // InternalScope.g:15176:1: ( () ) + // InternalScope.g:15177:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + // InternalScope.g:15178:2: () + // InternalScope.g:15178:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1" + // InternalScope.g:15186:1: rule__XMultiplicativeExpression__Group_1_0_0__1 : rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15190:1: ( rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:15191:2: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl" + // InternalScope.g:15197:1: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl : ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ; + public final void rule__XMultiplicativeExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15201:1: ( ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ) + // InternalScope.g:15202:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) + { + // InternalScope.g:15202:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) + // InternalScope.g:15203:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + // InternalScope.g:15204:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) + // InternalScope.g:15204:3: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__0" + // InternalScope.g:15213:1: rule__XUnaryOperation__Group_0__0 : rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ; + public final void rule__XUnaryOperation__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15217:1: ( rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ) + // InternalScope.g:15218:2: rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 + { + pushFollow(FOLLOW_93); + rule__XUnaryOperation__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__0" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__0__Impl" + // InternalScope.g:15225:1: rule__XUnaryOperation__Group_0__0__Impl : ( () ) ; + public final void rule__XUnaryOperation__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15229:1: ( ( () ) ) + // InternalScope.g:15230:1: ( () ) + { + // InternalScope.g:15230:1: ( () ) + // InternalScope.g:15231:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); + } + // InternalScope.g:15232:2: () + // InternalScope.g:15232:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__0__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__1" + // InternalScope.g:15240:1: rule__XUnaryOperation__Group_0__1 : rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ; + public final void rule__XUnaryOperation__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15244:1: ( rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ) + // InternalScope.g:15245:2: rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 + { + pushFollow(FOLLOW_76); + rule__XUnaryOperation__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__1" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__1__Impl" + // InternalScope.g:15252:1: rule__XUnaryOperation__Group_0__1__Impl : ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ; + public final void rule__XUnaryOperation__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15256:1: ( ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ) + // InternalScope.g:15257:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) + { + // InternalScope.g:15257:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) + // InternalScope.g:15258:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); + } + // InternalScope.g:15259:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 ) + // InternalScope.g:15259:3: rule__XUnaryOperation__FeatureAssignment_0_1 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__FeatureAssignment_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__1__Impl" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__2" + // InternalScope.g:15267:1: rule__XUnaryOperation__Group_0__2 : rule__XUnaryOperation__Group_0__2__Impl ; + public final void rule__XUnaryOperation__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15271:1: ( rule__XUnaryOperation__Group_0__2__Impl ) + // InternalScope.g:15272:2: rule__XUnaryOperation__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__2" + + + // $ANTLR start "rule__XUnaryOperation__Group_0__2__Impl" + // InternalScope.g:15278:1: rule__XUnaryOperation__Group_0__2__Impl : ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ; + public final void rule__XUnaryOperation__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15282:1: ( ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ) + // InternalScope.g:15283:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) + { + // InternalScope.g:15283:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) + // InternalScope.g:15284:2: ( rule__XUnaryOperation__OperandAssignment_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); + } + // InternalScope.g:15285:2: ( rule__XUnaryOperation__OperandAssignment_0_2 ) + // InternalScope.g:15285:3: rule__XUnaryOperation__OperandAssignment_0_2 + { + pushFollow(FOLLOW_2); + rule__XUnaryOperation__OperandAssignment_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__Group_0__2__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group__0" + // InternalScope.g:15294:1: rule__XCastedExpression__Group__0 : rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ; + public final void rule__XCastedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15298:1: ( rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ) + // InternalScope.g:15299:2: rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 + { + pushFollow(FOLLOW_11); + rule__XCastedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__0" + + + // $ANTLR start "rule__XCastedExpression__Group__0__Impl" + // InternalScope.g:15306:1: rule__XCastedExpression__Group__0__Impl : ( ruleXPostfixOperation ) ; + public final void rule__XCastedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15310:1: ( ( ruleXPostfixOperation ) ) + // InternalScope.g:15311:1: ( ruleXPostfixOperation ) + { + // InternalScope.g:15311:1: ( ruleXPostfixOperation ) + // InternalScope.g:15312:2: ruleXPostfixOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group__1" + // InternalScope.g:15321:1: rule__XCastedExpression__Group__1 : rule__XCastedExpression__Group__1__Impl ; + public final void rule__XCastedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15325:1: ( rule__XCastedExpression__Group__1__Impl ) + // InternalScope.g:15326:2: rule__XCastedExpression__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__1" + + + // $ANTLR start "rule__XCastedExpression__Group__1__Impl" + // InternalScope.g:15332:1: rule__XCastedExpression__Group__1__Impl : ( ( rule__XCastedExpression__Group_1__0 )* ) ; + public final void rule__XCastedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15336:1: ( ( ( rule__XCastedExpression__Group_1__0 )* ) ) + // InternalScope.g:15337:1: ( ( rule__XCastedExpression__Group_1__0 )* ) + { + // InternalScope.g:15337:1: ( ( rule__XCastedExpression__Group_1__0 )* ) + // InternalScope.g:15338:2: ( rule__XCastedExpression__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); + } + // InternalScope.g:15339:2: ( rule__XCastedExpression__Group_1__0 )* + loop124: + do { + int alt124=2; + int LA124_0 = input.LA(1); + + if ( (LA124_0==69) ) { + int LA124_2 = input.LA(2); + + if ( (synpred199_InternalScope()) ) { + alt124=1; + } + + + } + + + switch (alt124) { + case 1 : + // InternalScope.g:15339:3: rule__XCastedExpression__Group_1__0 + { + pushFollow(FOLLOW_94); + rule__XCastedExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop124; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1__0" + // InternalScope.g:15348:1: rule__XCastedExpression__Group_1__0 : rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ; + public final void rule__XCastedExpression__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15352:1: ( rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ) + // InternalScope.g:15353:2: rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 + { + pushFollow(FOLLOW_84); + rule__XCastedExpression__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1__0__Impl" + // InternalScope.g:15360:1: rule__XCastedExpression__Group_1__0__Impl : ( ( rule__XCastedExpression__Group_1_0__0 ) ) ; + public final void rule__XCastedExpression__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15364:1: ( ( ( rule__XCastedExpression__Group_1_0__0 ) ) ) + // InternalScope.g:15365:1: ( ( rule__XCastedExpression__Group_1_0__0 ) ) + { + // InternalScope.g:15365:1: ( ( rule__XCastedExpression__Group_1_0__0 ) ) + // InternalScope.g:15366:2: ( rule__XCastedExpression__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); + } + // InternalScope.g:15367:2: ( rule__XCastedExpression__Group_1_0__0 ) + // InternalScope.g:15367:3: rule__XCastedExpression__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1__1" + // InternalScope.g:15375:1: rule__XCastedExpression__Group_1__1 : rule__XCastedExpression__Group_1__1__Impl ; + public final void rule__XCastedExpression__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15379:1: ( rule__XCastedExpression__Group_1__1__Impl ) + // InternalScope.g:15380:2: rule__XCastedExpression__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__1" + + + // $ANTLR start "rule__XCastedExpression__Group_1__1__Impl" + // InternalScope.g:15386:1: rule__XCastedExpression__Group_1__1__Impl : ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ; + public final void rule__XCastedExpression__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15390:1: ( ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ) + // InternalScope.g:15391:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) + { + // InternalScope.g:15391:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) + // InternalScope.g:15392:2: ( rule__XCastedExpression__TypeAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); + } + // InternalScope.g:15393:2: ( rule__XCastedExpression__TypeAssignment_1_1 ) + // InternalScope.g:15393:3: rule__XCastedExpression__TypeAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__TypeAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1__1__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0__0" + // InternalScope.g:15402:1: rule__XCastedExpression__Group_1_0__0 : rule__XCastedExpression__Group_1_0__0__Impl ; + public final void rule__XCastedExpression__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15406:1: ( rule__XCastedExpression__Group_1_0__0__Impl ) + // InternalScope.g:15407:2: rule__XCastedExpression__Group_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0__0__Impl" + // InternalScope.g:15413:1: rule__XCastedExpression__Group_1_0__0__Impl : ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ; + public final void rule__XCastedExpression__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15417:1: ( ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ) + // InternalScope.g:15418:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) + { + // InternalScope.g:15418:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) + // InternalScope.g:15419:2: ( rule__XCastedExpression__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); + } + // InternalScope.g:15420:2: ( rule__XCastedExpression__Group_1_0_0__0 ) + // InternalScope.g:15420:3: rule__XCastedExpression__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0" + // InternalScope.g:15429:1: rule__XCastedExpression__Group_1_0_0__0 : rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ; + public final void rule__XCastedExpression__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15433:1: ( rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ) + // InternalScope.g:15434:2: rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 + { + pushFollow(FOLLOW_11); + rule__XCastedExpression__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0__Impl" + // InternalScope.g:15441:1: rule__XCastedExpression__Group_1_0_0__0__Impl : ( () ) ; + public final void rule__XCastedExpression__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15445:1: ( ( () ) ) + // InternalScope.g:15446:1: ( () ) + { + // InternalScope.g:15446:1: ( () ) + // InternalScope.g:15447:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); + } + // InternalScope.g:15448:2: () + // InternalScope.g:15448:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1" + // InternalScope.g:15456:1: rule__XCastedExpression__Group_1_0_0__1 : rule__XCastedExpression__Group_1_0_0__1__Impl ; + public final void rule__XCastedExpression__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15460:1: ( rule__XCastedExpression__Group_1_0_0__1__Impl ) + // InternalScope.g:15461:2: rule__XCastedExpression__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1" + + + // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1__Impl" + // InternalScope.g:15467:1: rule__XCastedExpression__Group_1_0_0__1__Impl : ( 'as' ) ; + public final void rule__XCastedExpression__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15471:1: ( ( 'as' ) ) + // InternalScope.g:15472:1: ( 'as' ) + { + // InternalScope.g:15472:1: ( 'as' ) + // InternalScope.g:15473:2: 'as' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + match(input,69,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group__0" + // InternalScope.g:15483:1: rule__XPostfixOperation__Group__0 : rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ; + public final void rule__XPostfixOperation__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15487:1: ( rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ) + // InternalScope.g:15488:2: rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 + { + pushFollow(FOLLOW_95); + rule__XPostfixOperation__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__0" + + + // $ANTLR start "rule__XPostfixOperation__Group__0__Impl" + // InternalScope.g:15495:1: rule__XPostfixOperation__Group__0__Impl : ( ruleXMemberFeatureCall ) ; + public final void rule__XPostfixOperation__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15499:1: ( ( ruleXMemberFeatureCall ) ) + // InternalScope.g:15500:1: ( ruleXMemberFeatureCall ) + { + // InternalScope.g:15500:1: ( ruleXMemberFeatureCall ) + // InternalScope.g:15501:2: ruleXMemberFeatureCall + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group__1" + // InternalScope.g:15510:1: rule__XPostfixOperation__Group__1 : rule__XPostfixOperation__Group__1__Impl ; + public final void rule__XPostfixOperation__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15514:1: ( rule__XPostfixOperation__Group__1__Impl ) + // InternalScope.g:15515:2: rule__XPostfixOperation__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__1" + + + // $ANTLR start "rule__XPostfixOperation__Group__1__Impl" + // InternalScope.g:15521:1: rule__XPostfixOperation__Group__1__Impl : ( ( rule__XPostfixOperation__Group_1__0 )? ) ; + public final void rule__XPostfixOperation__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15525:1: ( ( ( rule__XPostfixOperation__Group_1__0 )? ) ) + // InternalScope.g:15526:1: ( ( rule__XPostfixOperation__Group_1__0 )? ) + { + // InternalScope.g:15526:1: ( ( rule__XPostfixOperation__Group_1__0 )? ) + // InternalScope.g:15527:2: ( rule__XPostfixOperation__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); + } + // InternalScope.g:15528:2: ( rule__XPostfixOperation__Group_1__0 )? + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==56) ) { + int LA125_1 = input.LA(2); + + if ( (synpred200_InternalScope()) ) { + alt125=1; + } + } + else if ( (LA125_0==57) ) { + int LA125_2 = input.LA(2); + + if ( (synpred200_InternalScope()) ) { + alt125=1; + } + } + switch (alt125) { + case 1 : + // InternalScope.g:15528:3: rule__XPostfixOperation__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group__1__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1__0" + // InternalScope.g:15537:1: rule__XPostfixOperation__Group_1__0 : rule__XPostfixOperation__Group_1__0__Impl ; + public final void rule__XPostfixOperation__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15541:1: ( rule__XPostfixOperation__Group_1__0__Impl ) + // InternalScope.g:15542:2: rule__XPostfixOperation__Group_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1__0" + + + // $ANTLR start "rule__XPostfixOperation__Group_1__0__Impl" + // InternalScope.g:15548:1: rule__XPostfixOperation__Group_1__0__Impl : ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ; + public final void rule__XPostfixOperation__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15552:1: ( ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ) + // InternalScope.g:15553:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) ) + { + // InternalScope.g:15553:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) ) + // InternalScope.g:15554:2: ( rule__XPostfixOperation__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); + } + // InternalScope.g:15555:2: ( rule__XPostfixOperation__Group_1_0__0 ) + // InternalScope.g:15555:3: rule__XPostfixOperation__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__0" + // InternalScope.g:15564:1: rule__XPostfixOperation__Group_1_0__0 : rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ; + public final void rule__XPostfixOperation__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15568:1: ( rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ) + // InternalScope.g:15569:2: rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 + { + pushFollow(FOLLOW_95); + rule__XPostfixOperation__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__0" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__0__Impl" + // InternalScope.g:15576:1: rule__XPostfixOperation__Group_1_0__0__Impl : ( () ) ; + public final void rule__XPostfixOperation__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15580:1: ( ( () ) ) + // InternalScope.g:15581:1: ( () ) + { + // InternalScope.g:15581:1: ( () ) + // InternalScope.g:15582:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); + } + // InternalScope.g:15583:2: () + // InternalScope.g:15583:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__1" + // InternalScope.g:15591:1: rule__XPostfixOperation__Group_1_0__1 : rule__XPostfixOperation__Group_1_0__1__Impl ; + public final void rule__XPostfixOperation__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15595:1: ( rule__XPostfixOperation__Group_1_0__1__Impl ) + // InternalScope.g:15596:2: rule__XPostfixOperation__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__1" + + + // $ANTLR start "rule__XPostfixOperation__Group_1_0__1__Impl" + // InternalScope.g:15602:1: rule__XPostfixOperation__Group_1_0__1__Impl : ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ; + public final void rule__XPostfixOperation__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15606:1: ( ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ) + // InternalScope.g:15607:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) + { + // InternalScope.g:15607:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) + // InternalScope.g:15608:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); + } + // InternalScope.g:15609:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) + // InternalScope.g:15609:3: rule__XPostfixOperation__FeatureAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__FeatureAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__0" + // InternalScope.g:15618:1: rule__XMemberFeatureCall__Group__0 : rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ; + public final void rule__XMemberFeatureCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15622:1: ( rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ) + // InternalScope.g:15623:2: rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 + { + pushFollow(FOLLOW_96); + rule__XMemberFeatureCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__0__Impl" + // InternalScope.g:15630:1: rule__XMemberFeatureCall__Group__0__Impl : ( ruleXPrimaryExpression ) ; + public final void rule__XMemberFeatureCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15634:1: ( ( ruleXPrimaryExpression ) ) + // InternalScope.g:15635:1: ( ruleXPrimaryExpression ) + { + // InternalScope.g:15635:1: ( ruleXPrimaryExpression ) + // InternalScope.g:15636:2: ruleXPrimaryExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__1" + // InternalScope.g:15645:1: rule__XMemberFeatureCall__Group__1 : rule__XMemberFeatureCall__Group__1__Impl ; + public final void rule__XMemberFeatureCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15649:1: ( rule__XMemberFeatureCall__Group__1__Impl ) + // InternalScope.g:15650:2: rule__XMemberFeatureCall__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group__1__Impl" + // InternalScope.g:15656:1: rule__XMemberFeatureCall__Group__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ; + public final void rule__XMemberFeatureCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15660:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ) + // InternalScope.g:15661:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) + { + // InternalScope.g:15661:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) + // InternalScope.g:15662:2: ( rule__XMemberFeatureCall__Alternatives_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); + } + // InternalScope.g:15663:2: ( rule__XMemberFeatureCall__Alternatives_1 )* + loop126: + do { + int alt126=2; + switch ( input.LA(1) ) { + case 58: + { + int LA126_2 = input.LA(2); + + if ( (synpred201_InternalScope()) ) { + alt126=1; + } + + + } + break; + case 93: + { + int LA126_3 = input.LA(2); + + if ( (synpred201_InternalScope()) ) { + alt126=1; + } + + + } + break; + case 121: + { + int LA126_4 = input.LA(2); + + if ( (synpred201_InternalScope()) ) { + alt126=1; + } + + + } + break; + + } + + switch (alt126) { + case 1 : + // InternalScope.g:15663:3: rule__XMemberFeatureCall__Alternatives_1 + { + pushFollow(FOLLOW_97); + rule__XMemberFeatureCall__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop126; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0" + // InternalScope.g:15672:1: rule__XMemberFeatureCall__Group_1_0__0 : rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15676:1: ( rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ) + // InternalScope.g:15677:2: rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 + { + pushFollow(FOLLOW_76); + rule__XMemberFeatureCall__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0__Impl" + // InternalScope.g:15684:1: rule__XMemberFeatureCall__Group_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15688:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ) + // InternalScope.g:15689:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) + { + // InternalScope.g:15689:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) + // InternalScope.g:15690:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); + } + // InternalScope.g:15691:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 ) + // InternalScope.g:15691:3: rule__XMemberFeatureCall__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1" + // InternalScope.g:15699:1: rule__XMemberFeatureCall__Group_1_0__1 : rule__XMemberFeatureCall__Group_1_0__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15703:1: ( rule__XMemberFeatureCall__Group_1_0__1__Impl ) + // InternalScope.g:15704:2: rule__XMemberFeatureCall__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1__Impl" + // InternalScope.g:15710:1: rule__XMemberFeatureCall__Group_1_0__1__Impl : ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15714:1: ( ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ) + // InternalScope.g:15715:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) + { + // InternalScope.g:15715:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) + // InternalScope.g:15716:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); + } + // InternalScope.g:15717:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) + // InternalScope.g:15717:3: rule__XMemberFeatureCall__ValueAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ValueAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0" + // InternalScope.g:15726:1: rule__XMemberFeatureCall__Group_1_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0__0__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15730:1: ( rule__XMemberFeatureCall__Group_1_0_0__0__Impl ) + // InternalScope.g:15731:2: rule__XMemberFeatureCall__Group_1_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0__Impl" + // InternalScope.g:15737:1: rule__XMemberFeatureCall__Group_1_0_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15741:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ) + // InternalScope.g:15742:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) + { + // InternalScope.g:15742:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) + // InternalScope.g:15743:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); + } + // InternalScope.g:15744:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) + // InternalScope.g:15744:3: rule__XMemberFeatureCall__Group_1_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0" + // InternalScope.g:15753:1: rule__XMemberFeatureCall__Group_1_0_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15757:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ) + // InternalScope.g:15758:2: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 + { + pushFollow(FOLLOW_98); + rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl" + // InternalScope.g:15765:1: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl : ( () ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15769:1: ( ( () ) ) + // InternalScope.g:15770:1: ( () ) + { + // InternalScope.g:15770:1: ( () ) + // InternalScope.g:15771:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); + } + // InternalScope.g:15772:2: () + // InternalScope.g:15772:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1" + // InternalScope.g:15780:1: rule__XMemberFeatureCall__Group_1_0_0_0__1 : rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15784:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ) + // InternalScope.g:15785:2: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 + { + pushFollow(FOLLOW_75); + rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl" + // InternalScope.g:15792:1: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15796:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ) + // InternalScope.g:15797:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) + { + // InternalScope.g:15797:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) + // InternalScope.g:15798:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); + } + // InternalScope.g:15799:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) + // InternalScope.g:15799:3: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_0_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2" + // InternalScope.g:15807:1: rule__XMemberFeatureCall__Group_1_0_0_0__2 : rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15811:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ) + // InternalScope.g:15812:2: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 + { + pushFollow(FOLLOW_16); + rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl" + // InternalScope.g:15819:1: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15823:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ) + // InternalScope.g:15824:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) + { + // InternalScope.g:15824:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) + // InternalScope.g:15825:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); + } + // InternalScope.g:15826:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) + // InternalScope.g:15826:3: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3" + // InternalScope.g:15834:1: rule__XMemberFeatureCall__Group_1_0_0_0__3 : rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15838:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ) + // InternalScope.g:15839:2: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl" + // InternalScope.g:15845:1: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl : ( ruleOpSingleAssign ) ; + public final void rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15849:1: ( ( ruleOpSingleAssign ) ) + // InternalScope.g:15850:1: ( ruleOpSingleAssign ) + { + // InternalScope.g:15850:1: ( ruleOpSingleAssign ) + // InternalScope.g:15851:2: ruleOpSingleAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0" + // InternalScope.g:15861:1: rule__XMemberFeatureCall__Group_1_1__0 : rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15865:1: ( rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ) + // InternalScope.g:15866:2: rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 + { + pushFollow(FOLLOW_99); + rule__XMemberFeatureCall__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0__Impl" + // InternalScope.g:15873:1: rule__XMemberFeatureCall__Group_1_1__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15877:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ) + // InternalScope.g:15878:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) + { + // InternalScope.g:15878:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) + // InternalScope.g:15879:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); + } + // InternalScope.g:15880:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 ) + // InternalScope.g:15880:3: rule__XMemberFeatureCall__Group_1_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1" + // InternalScope.g:15888:1: rule__XMemberFeatureCall__Group_1_1__1 : rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ; + public final void rule__XMemberFeatureCall__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15892:1: ( rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ) + // InternalScope.g:15893:2: rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 + { + pushFollow(FOLLOW_99); + rule__XMemberFeatureCall__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1__Impl" + // InternalScope.g:15900:1: rule__XMemberFeatureCall__Group_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15904:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ) + // InternalScope.g:15905:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) + { + // InternalScope.g:15905:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) + // InternalScope.g:15906:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); + } + // InternalScope.g:15907:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )? + int alt127=2; + int LA127_0 = input.LA(1); + + if ( (LA127_0==22) ) { + alt127=1; + } + switch (alt127) { + case 1 : + // InternalScope.g:15907:3: rule__XMemberFeatureCall__Group_1_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2" + // InternalScope.g:15915:1: rule__XMemberFeatureCall__Group_1_1__2 : rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ; + public final void rule__XMemberFeatureCall__Group_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15919:1: ( rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ) + // InternalScope.g:15920:2: rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 + { + pushFollow(FOLLOW_100); + rule__XMemberFeatureCall__Group_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2__Impl" + // InternalScope.g:15927:1: rule__XMemberFeatureCall__Group_1_1__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15931:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ) + // InternalScope.g:15932:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) + { + // InternalScope.g:15932:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) + // InternalScope.g:15933:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); + } + // InternalScope.g:15934:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) + // InternalScope.g:15934:3: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__FeatureAssignment_1_1_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3" + // InternalScope.g:15942:1: rule__XMemberFeatureCall__Group_1_1__3 : rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ; + public final void rule__XMemberFeatureCall__Group_1_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15946:1: ( rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ) + // InternalScope.g:15947:2: rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 + { + pushFollow(FOLLOW_100); + rule__XMemberFeatureCall__Group_1_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3__Impl" + // InternalScope.g:15954:1: rule__XMemberFeatureCall__Group_1_1__3__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15958:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ) + // InternalScope.g:15959:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) + { + // InternalScope.g:15959:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) + // InternalScope.g:15960:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); + } + // InternalScope.g:15961:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )? + int alt128=2; + alt128 = dfa128.predict(input); + switch (alt128) { + case 1 : + // InternalScope.g:15961:3: rule__XMemberFeatureCall__Group_1_1_3__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4" + // InternalScope.g:15969:1: rule__XMemberFeatureCall__Group_1_1__4 : rule__XMemberFeatureCall__Group_1_1__4__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15973:1: ( rule__XMemberFeatureCall__Group_1_1__4__Impl ) + // InternalScope.g:15974:2: rule__XMemberFeatureCall__Group_1_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4__Impl" + // InternalScope.g:15980:1: rule__XMemberFeatureCall__Group_1_1__4__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:15984:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ) + // InternalScope.g:15985:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) + { + // InternalScope.g:15985:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) + // InternalScope.g:15986:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); + } + // InternalScope.g:15987:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? + int alt129=2; + alt129 = dfa129.predict(input); + switch (alt129) { + case 1 : + // InternalScope.g:15987:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0" + // InternalScope.g:15996:1: rule__XMemberFeatureCall__Group_1_1_0__0 : rule__XMemberFeatureCall__Group_1_1_0__0__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16000:1: ( rule__XMemberFeatureCall__Group_1_1_0__0__Impl ) + // InternalScope.g:16001:2: rule__XMemberFeatureCall__Group_1_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0__Impl" + // InternalScope.g:16007:1: rule__XMemberFeatureCall__Group_1_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16011:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ) + // InternalScope.g:16012:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) + { + // InternalScope.g:16012:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) + // InternalScope.g:16013:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); + } + // InternalScope.g:16014:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) + // InternalScope.g:16014:3: rule__XMemberFeatureCall__Group_1_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0" + // InternalScope.g:16023:1: rule__XMemberFeatureCall__Group_1_1_0_0__0 : rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16027:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ) + // InternalScope.g:16028:2: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 + { + pushFollow(FOLLOW_96); + rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl" + // InternalScope.g:16035:1: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl : ( () ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16039:1: ( ( () ) ) + // InternalScope.g:16040:1: ( () ) + { + // InternalScope.g:16040:1: ( () ) + // InternalScope.g:16041:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); + } + // InternalScope.g:16042:2: () + // InternalScope.g:16042:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1" + // InternalScope.g:16050:1: rule__XMemberFeatureCall__Group_1_1_0_0__1 : rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16054:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ) + // InternalScope.g:16055:2: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl" + // InternalScope.g:16061:1: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16065:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ) + // InternalScope.g:16066:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) + { + // InternalScope.g:16066:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) + // InternalScope.g:16067:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); + } + // InternalScope.g:16068:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) + // InternalScope.g:16068:3: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_1_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0" + // InternalScope.g:16077:1: rule__XMemberFeatureCall__Group_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16081:1: ( rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ) + // InternalScope.g:16082:2: rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 + { + pushFollow(FOLLOW_101); + rule__XMemberFeatureCall__Group_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0__Impl" + // InternalScope.g:16089:1: rule__XMemberFeatureCall__Group_1_1_1__0__Impl : ( '<' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16093:1: ( ( '<' ) ) + // InternalScope.g:16094:1: ( '<' ) + { + // InternalScope.g:16094:1: ( '<' ) + // InternalScope.g:16095:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1" + // InternalScope.g:16104:1: rule__XMemberFeatureCall__Group_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16108:1: ( rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ) + // InternalScope.g:16109:2: rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 + { + pushFollow(FOLLOW_102); + rule__XMemberFeatureCall__Group_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1__Impl" + // InternalScope.g:16116:1: rule__XMemberFeatureCall__Group_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16120:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ) + // InternalScope.g:16121:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) + { + // InternalScope.g:16121:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) + // InternalScope.g:16122:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); + } + // InternalScope.g:16123:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) + // InternalScope.g:16123:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2" + // InternalScope.g:16131:1: rule__XMemberFeatureCall__Group_1_1_1__2 : rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ; + public final void rule__XMemberFeatureCall__Group_1_1_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16135:1: ( rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ) + // InternalScope.g:16136:2: rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 + { + pushFollow(FOLLOW_102); + rule__XMemberFeatureCall__Group_1_1_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2__Impl" + // InternalScope.g:16143:1: rule__XMemberFeatureCall__Group_1_1_1__2__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16147:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ) + // InternalScope.g:16148:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) + { + // InternalScope.g:16148:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) + // InternalScope.g:16149:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); + } + // InternalScope.g:16150:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* + loop130: + do { + int alt130=2; + int LA130_0 = input.LA(1); + + if ( (LA130_0==86) ) { + alt130=1; + } + + + switch (alt130) { + case 1 : + // InternalScope.g:16150:3: rule__XMemberFeatureCall__Group_1_1_1_2__0 + { + pushFollow(FOLLOW_39); + rule__XMemberFeatureCall__Group_1_1_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop130; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3" + // InternalScope.g:16158:1: rule__XMemberFeatureCall__Group_1_1_1__3 : rule__XMemberFeatureCall__Group_1_1_1__3__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16162:1: ( rule__XMemberFeatureCall__Group_1_1_1__3__Impl ) + // InternalScope.g:16163:2: rule__XMemberFeatureCall__Group_1_1_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3__Impl" + // InternalScope.g:16169:1: rule__XMemberFeatureCall__Group_1_1_1__3__Impl : ( '>' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16173:1: ( ( '>' ) ) + // InternalScope.g:16174:1: ( '>' ) + { + // InternalScope.g:16174:1: ( '>' ) + // InternalScope.g:16175:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0" + // InternalScope.g:16185:1: rule__XMemberFeatureCall__Group_1_1_1_2__0 : rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16189:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ) + // InternalScope.g:16190:2: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 + { + pushFollow(FOLLOW_101); + rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl" + // InternalScope.g:16197:1: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl : ( ',' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16201:1: ( ( ',' ) ) + // InternalScope.g:16202:1: ( ',' ) + { + // InternalScope.g:16202:1: ( ',' ) + // InternalScope.g:16203:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1" + // InternalScope.g:16212:1: rule__XMemberFeatureCall__Group_1_1_1_2__1 : rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16216:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ) + // InternalScope.g:16217:2: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl" + // InternalScope.g:16223:1: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16227:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ) + // InternalScope.g:16228:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) + { + // InternalScope.g:16228:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) + // InternalScope.g:16229:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); + } + // InternalScope.g:16230:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) + // InternalScope.g:16230:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0" + // InternalScope.g:16239:1: rule__XMemberFeatureCall__Group_1_1_3__0 : rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16243:1: ( rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ) + // InternalScope.g:16244:2: rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 + { + pushFollow(FOLLOW_103); + rule__XMemberFeatureCall__Group_1_1_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0__Impl" + // InternalScope.g:16251:1: rule__XMemberFeatureCall__Group_1_1_3__0__Impl : ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16255:1: ( ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ) + // InternalScope.g:16256:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) + { + // InternalScope.g:16256:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) + // InternalScope.g:16257:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); + } + // InternalScope.g:16258:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) + // InternalScope.g:16258:3: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1" + // InternalScope.g:16266:1: rule__XMemberFeatureCall__Group_1_1_3__1 : rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ; + public final void rule__XMemberFeatureCall__Group_1_1_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16270:1: ( rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ) + // InternalScope.g:16271:2: rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 + { + pushFollow(FOLLOW_103); + rule__XMemberFeatureCall__Group_1_1_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1__Impl" + // InternalScope.g:16278:1: rule__XMemberFeatureCall__Group_1_1_3__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16282:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ) + // InternalScope.g:16283:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) + { + // InternalScope.g:16283:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) + // InternalScope.g:16284:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); + } + // InternalScope.g:16285:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? + int alt131=2; + int LA131_0 = input.LA(1); + + if ( ((LA131_0>=RULE_ID && LA131_0<=RULE_STRING)||(LA131_0>=22 && LA131_0<=24)||LA131_0==27||(LA131_0>=36 && LA131_0<=37)||LA131_0==51||(LA131_0>=60 && LA131_0<=64)||LA131_0==72||LA131_0==77||LA131_0==79||LA131_0==82||LA131_0==92||LA131_0==97||LA131_0==100||LA131_0==103||(LA131_0>=105 && LA131_0<=112)||LA131_0==114) ) { + alt131=1; + } + switch (alt131) { + case 1 : + // InternalScope.g:16285:3: rule__XMemberFeatureCall__Alternatives_1_1_3_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1_1_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2" + // InternalScope.g:16293:1: rule__XMemberFeatureCall__Group_1_1_3__2 : rule__XMemberFeatureCall__Group_1_1_3__2__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16297:1: ( rule__XMemberFeatureCall__Group_1_1_3__2__Impl ) + // InternalScope.g:16298:2: rule__XMemberFeatureCall__Group_1_1_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2__Impl" + // InternalScope.g:16304:1: rule__XMemberFeatureCall__Group_1_1_3__2__Impl : ( ')' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16308:1: ( ( ')' ) ) + // InternalScope.g:16309:1: ( ')' ) + { + // InternalScope.g:16309:1: ( ')' ) + // InternalScope.g:16310:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0" + // InternalScope.g:16320:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16324:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ) + // InternalScope.g:16325:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 + { + pushFollow(FOLLOW_71); + rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl" + // InternalScope.g:16332:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16336:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ) + // InternalScope.g:16337:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) + { + // InternalScope.g:16337:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) + // InternalScope.g:16338:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); + } + // InternalScope.g:16339:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) + // InternalScope.g:16339:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1" + // InternalScope.g:16347:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16351:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ) + // InternalScope.g:16352:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl" + // InternalScope.g:16358:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16362:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ) + // InternalScope.g:16363:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) + { + // InternalScope.g:16363:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) + // InternalScope.g:16364:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); + } + // InternalScope.g:16365:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* + loop132: + do { + int alt132=2; + int LA132_0 = input.LA(1); + + if ( (LA132_0==86) ) { + alt132=1; + } + + + switch (alt132) { + case 1 : + // InternalScope.g:16365:3: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 + { + pushFollow(FOLLOW_39); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop132; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0" + // InternalScope.g:16374:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16378:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ) + // InternalScope.g:16379:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 + { + pushFollow(FOLLOW_104); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl" + // InternalScope.g:16386:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16390:1: ( ( ',' ) ) + // InternalScope.g:16391:1: ( ',' ) + { + // InternalScope.g:16391:1: ( ',' ) + // InternalScope.g:16392:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1" + // InternalScope.g:16401:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16405:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ) + // InternalScope.g:16406:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1" + + + // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl" + // InternalScope.g:16412:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ; + public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16416:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ) + // InternalScope.g:16417:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) + { + // InternalScope.g:16417:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) + // InternalScope.g:16418:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); + } + // InternalScope.g:16419:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) + // InternalScope.g:16419:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__0" + // InternalScope.g:16428:1: rule__XSetLiteral__Group__0 : rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ; + public final void rule__XSetLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16432:1: ( rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ) + // InternalScope.g:16433:2: rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 + { + pushFollow(FOLLOW_24); + rule__XSetLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__0" + + + // $ANTLR start "rule__XSetLiteral__Group__0__Impl" + // InternalScope.g:16440:1: rule__XSetLiteral__Group__0__Impl : ( () ) ; + public final void rule__XSetLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16444:1: ( ( () ) ) + // InternalScope.g:16445:1: ( () ) + { + // InternalScope.g:16445:1: ( () ) + // InternalScope.g:16446:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); + } + // InternalScope.g:16447:2: () + // InternalScope.g:16447:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__1" + // InternalScope.g:16455:1: rule__XSetLiteral__Group__1 : rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ; + public final void rule__XSetLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16459:1: ( rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ) + // InternalScope.g:16460:2: rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 + { + pushFollow(FOLLOW_13); + rule__XSetLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__1" + + + // $ANTLR start "rule__XSetLiteral__Group__1__Impl" + // InternalScope.g:16467:1: rule__XSetLiteral__Group__1__Impl : ( '#' ) ; + public final void rule__XSetLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16471:1: ( ( '#' ) ) + // InternalScope.g:16472:1: ( '#' ) + { + // InternalScope.g:16472:1: ( '#' ) + // InternalScope.g:16473:2: '#' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + match(input,79,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__2" + // InternalScope.g:16482:1: rule__XSetLiteral__Group__2 : rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ; + public final void rule__XSetLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16486:1: ( rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ) + // InternalScope.g:16487:2: rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 + { + pushFollow(FOLLOW_105); + rule__XSetLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__2" + + + // $ANTLR start "rule__XSetLiteral__Group__2__Impl" + // InternalScope.g:16494:1: rule__XSetLiteral__Group__2__Impl : ( '{' ) ; + public final void rule__XSetLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16498:1: ( ( '{' ) ) + // InternalScope.g:16499:1: ( '{' ) + { + // InternalScope.g:16499:1: ( '{' ) + // InternalScope.g:16500:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__3" + // InternalScope.g:16509:1: rule__XSetLiteral__Group__3 : rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ; + public final void rule__XSetLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16513:1: ( rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ) + // InternalScope.g:16514:2: rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 + { + pushFollow(FOLLOW_105); + rule__XSetLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__3" + + + // $ANTLR start "rule__XSetLiteral__Group__3__Impl" + // InternalScope.g:16521:1: rule__XSetLiteral__Group__3__Impl : ( ( rule__XSetLiteral__Group_3__0 )? ) ; + public final void rule__XSetLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16525:1: ( ( ( rule__XSetLiteral__Group_3__0 )? ) ) + // InternalScope.g:16526:1: ( ( rule__XSetLiteral__Group_3__0 )? ) + { + // InternalScope.g:16526:1: ( ( rule__XSetLiteral__Group_3__0 )? ) + // InternalScope.g:16527:2: ( rule__XSetLiteral__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup_3()); + } + // InternalScope.g:16528:2: ( rule__XSetLiteral__Group_3__0 )? + int alt133=2; + int LA133_0 = input.LA(1); + + if ( ((LA133_0>=RULE_ID && LA133_0<=RULE_STRING)||(LA133_0>=22 && LA133_0<=24)||LA133_0==27||(LA133_0>=36 && LA133_0<=37)||(LA133_0>=60 && LA133_0<=64)||LA133_0==72||LA133_0==77||LA133_0==79||LA133_0==82||LA133_0==97||LA133_0==100||LA133_0==103||(LA133_0>=105 && LA133_0<=112)||LA133_0==114) ) { + alt133=1; + } + switch (alt133) { + case 1 : + // InternalScope.g:16528:3: rule__XSetLiteral__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group__4" + // InternalScope.g:16536:1: rule__XSetLiteral__Group__4 : rule__XSetLiteral__Group__4__Impl ; + public final void rule__XSetLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16540:1: ( rule__XSetLiteral__Group__4__Impl ) + // InternalScope.g:16541:2: rule__XSetLiteral__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__4" + + + // $ANTLR start "rule__XSetLiteral__Group__4__Impl" + // InternalScope.g:16547:1: rule__XSetLiteral__Group__4__Impl : ( '}' ) ; + public final void rule__XSetLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16551:1: ( ( '}' ) ) + // InternalScope.g:16552:1: ( '}' ) + { + // InternalScope.g:16552:1: ( '}' ) + // InternalScope.g:16553:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3__0" + // InternalScope.g:16563:1: rule__XSetLiteral__Group_3__0 : rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ; + public final void rule__XSetLiteral__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16567:1: ( rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ) + // InternalScope.g:16568:2: rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 + { + pushFollow(FOLLOW_71); + rule__XSetLiteral__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__0" + + + // $ANTLR start "rule__XSetLiteral__Group_3__0__Impl" + // InternalScope.g:16575:1: rule__XSetLiteral__Group_3__0__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ; + public final void rule__XSetLiteral__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16579:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ) + // InternalScope.g:16580:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) + { + // InternalScope.g:16580:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) + // InternalScope.g:16581:2: ( rule__XSetLiteral__ElementsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); + } + // InternalScope.g:16582:2: ( rule__XSetLiteral__ElementsAssignment_3_0 ) + // InternalScope.g:16582:3: rule__XSetLiteral__ElementsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__ElementsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3__1" + // InternalScope.g:16590:1: rule__XSetLiteral__Group_3__1 : rule__XSetLiteral__Group_3__1__Impl ; + public final void rule__XSetLiteral__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16594:1: ( rule__XSetLiteral__Group_3__1__Impl ) + // InternalScope.g:16595:2: rule__XSetLiteral__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__1" + + + // $ANTLR start "rule__XSetLiteral__Group_3__1__Impl" + // InternalScope.g:16601:1: rule__XSetLiteral__Group_3__1__Impl : ( ( rule__XSetLiteral__Group_3_1__0 )* ) ; + public final void rule__XSetLiteral__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16605:1: ( ( ( rule__XSetLiteral__Group_3_1__0 )* ) ) + // InternalScope.g:16606:1: ( ( rule__XSetLiteral__Group_3_1__0 )* ) + { + // InternalScope.g:16606:1: ( ( rule__XSetLiteral__Group_3_1__0 )* ) + // InternalScope.g:16607:2: ( rule__XSetLiteral__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); + } + // InternalScope.g:16608:2: ( rule__XSetLiteral__Group_3_1__0 )* + loop134: + do { + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==86) ) { + alt134=1; + } + + + switch (alt134) { + case 1 : + // InternalScope.g:16608:3: rule__XSetLiteral__Group_3_1__0 + { + pushFollow(FOLLOW_39); + rule__XSetLiteral__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop134; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3__1__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__0" + // InternalScope.g:16617:1: rule__XSetLiteral__Group_3_1__0 : rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ; + public final void rule__XSetLiteral__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16621:1: ( rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ) + // InternalScope.g:16622:2: rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 + { + pushFollow(FOLLOW_104); + rule__XSetLiteral__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__0" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__0__Impl" + // InternalScope.g:16629:1: rule__XSetLiteral__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XSetLiteral__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16633:1: ( ( ',' ) ) + // InternalScope.g:16634:1: ( ',' ) + { + // InternalScope.g:16634:1: ( ',' ) + // InternalScope.g:16635:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__1" + // InternalScope.g:16644:1: rule__XSetLiteral__Group_3_1__1 : rule__XSetLiteral__Group_3_1__1__Impl ; + public final void rule__XSetLiteral__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16648:1: ( rule__XSetLiteral__Group_3_1__1__Impl ) + // InternalScope.g:16649:2: rule__XSetLiteral__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__1" + + + // $ANTLR start "rule__XSetLiteral__Group_3_1__1__Impl" + // InternalScope.g:16655:1: rule__XSetLiteral__Group_3_1__1__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ; + public final void rule__XSetLiteral__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16659:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ) + // InternalScope.g:16660:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) + { + // InternalScope.g:16660:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) + // InternalScope.g:16661:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); + } + // InternalScope.g:16662:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) + // InternalScope.g:16662:3: rule__XSetLiteral__ElementsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XSetLiteral__ElementsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__0" + // InternalScope.g:16671:1: rule__XListLiteral__Group__0 : rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ; + public final void rule__XListLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16675:1: ( rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ) + // InternalScope.g:16676:2: rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 + { + pushFollow(FOLLOW_24); + rule__XListLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__0" + + + // $ANTLR start "rule__XListLiteral__Group__0__Impl" + // InternalScope.g:16683:1: rule__XListLiteral__Group__0__Impl : ( () ) ; + public final void rule__XListLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16687:1: ( ( () ) ) + // InternalScope.g:16688:1: ( () ) + { + // InternalScope.g:16688:1: ( () ) + // InternalScope.g:16689:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); + } + // InternalScope.g:16690:2: () + // InternalScope.g:16690:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__1" + // InternalScope.g:16698:1: rule__XListLiteral__Group__1 : rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ; + public final void rule__XListLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16702:1: ( rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ) + // InternalScope.g:16703:2: rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 + { + pushFollow(FOLLOW_29); + rule__XListLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__1" + + + // $ANTLR start "rule__XListLiteral__Group__1__Impl" + // InternalScope.g:16710:1: rule__XListLiteral__Group__1__Impl : ( '#' ) ; + public final void rule__XListLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16714:1: ( ( '#' ) ) + // InternalScope.g:16715:1: ( '#' ) + { + // InternalScope.g:16715:1: ( '#' ) + // InternalScope.g:16716:2: '#' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + match(input,79,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__2" + // InternalScope.g:16725:1: rule__XListLiteral__Group__2 : rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ; + public final void rule__XListLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16729:1: ( rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ) + // InternalScope.g:16730:2: rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 + { + pushFollow(FOLLOW_106); + rule__XListLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__2" + + + // $ANTLR start "rule__XListLiteral__Group__2__Impl" + // InternalScope.g:16737:1: rule__XListLiteral__Group__2__Impl : ( '[' ) ; + public final void rule__XListLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16741:1: ( ( '[' ) ) + // InternalScope.g:16742:1: ( '[' ) + { + // InternalScope.g:16742:1: ( '[' ) + // InternalScope.g:16743:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__3" + // InternalScope.g:16752:1: rule__XListLiteral__Group__3 : rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ; + public final void rule__XListLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16756:1: ( rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ) + // InternalScope.g:16757:2: rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 + { + pushFollow(FOLLOW_106); + rule__XListLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__3" + + + // $ANTLR start "rule__XListLiteral__Group__3__Impl" + // InternalScope.g:16764:1: rule__XListLiteral__Group__3__Impl : ( ( rule__XListLiteral__Group_3__0 )? ) ; + public final void rule__XListLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16768:1: ( ( ( rule__XListLiteral__Group_3__0 )? ) ) + // InternalScope.g:16769:1: ( ( rule__XListLiteral__Group_3__0 )? ) + { + // InternalScope.g:16769:1: ( ( rule__XListLiteral__Group_3__0 )? ) + // InternalScope.g:16770:2: ( rule__XListLiteral__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup_3()); + } + // InternalScope.g:16771:2: ( rule__XListLiteral__Group_3__0 )? + int alt135=2; + int LA135_0 = input.LA(1); + + if ( ((LA135_0>=RULE_ID && LA135_0<=RULE_STRING)||(LA135_0>=22 && LA135_0<=24)||LA135_0==27||(LA135_0>=36 && LA135_0<=37)||(LA135_0>=60 && LA135_0<=64)||LA135_0==72||LA135_0==77||LA135_0==79||LA135_0==82||LA135_0==97||LA135_0==100||LA135_0==103||(LA135_0>=105 && LA135_0<=112)||LA135_0==114) ) { + alt135=1; + } + switch (alt135) { + case 1 : + // InternalScope.g:16771:3: rule__XListLiteral__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XListLiteral__Group__4" + // InternalScope.g:16779:1: rule__XListLiteral__Group__4 : rule__XListLiteral__Group__4__Impl ; + public final void rule__XListLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16783:1: ( rule__XListLiteral__Group__4__Impl ) + // InternalScope.g:16784:2: rule__XListLiteral__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__4" + + + // $ANTLR start "rule__XListLiteral__Group__4__Impl" + // InternalScope.g:16790:1: rule__XListLiteral__Group__4__Impl : ( ']' ) ; + public final void rule__XListLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16794:1: ( ( ']' ) ) + // InternalScope.g:16795:1: ( ']' ) + { + // InternalScope.g:16795:1: ( ']' ) + // InternalScope.g:16796:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3__0" + // InternalScope.g:16806:1: rule__XListLiteral__Group_3__0 : rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ; + public final void rule__XListLiteral__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16810:1: ( rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ) + // InternalScope.g:16811:2: rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 + { + pushFollow(FOLLOW_71); + rule__XListLiteral__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__0" + + + // $ANTLR start "rule__XListLiteral__Group_3__0__Impl" + // InternalScope.g:16818:1: rule__XListLiteral__Group_3__0__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ; + public final void rule__XListLiteral__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16822:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ) + // InternalScope.g:16823:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) + { + // InternalScope.g:16823:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) + // InternalScope.g:16824:2: ( rule__XListLiteral__ElementsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); + } + // InternalScope.g:16825:2: ( rule__XListLiteral__ElementsAssignment_3_0 ) + // InternalScope.g:16825:3: rule__XListLiteral__ElementsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__ElementsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3__1" + // InternalScope.g:16833:1: rule__XListLiteral__Group_3__1 : rule__XListLiteral__Group_3__1__Impl ; + public final void rule__XListLiteral__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16837:1: ( rule__XListLiteral__Group_3__1__Impl ) + // InternalScope.g:16838:2: rule__XListLiteral__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__1" + + + // $ANTLR start "rule__XListLiteral__Group_3__1__Impl" + // InternalScope.g:16844:1: rule__XListLiteral__Group_3__1__Impl : ( ( rule__XListLiteral__Group_3_1__0 )* ) ; + public final void rule__XListLiteral__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16848:1: ( ( ( rule__XListLiteral__Group_3_1__0 )* ) ) + // InternalScope.g:16849:1: ( ( rule__XListLiteral__Group_3_1__0 )* ) + { + // InternalScope.g:16849:1: ( ( rule__XListLiteral__Group_3_1__0 )* ) + // InternalScope.g:16850:2: ( rule__XListLiteral__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); + } + // InternalScope.g:16851:2: ( rule__XListLiteral__Group_3_1__0 )* + loop136: + do { + int alt136=2; + int LA136_0 = input.LA(1); + + if ( (LA136_0==86) ) { + alt136=1; + } + + + switch (alt136) { + case 1 : + // InternalScope.g:16851:3: rule__XListLiteral__Group_3_1__0 + { + pushFollow(FOLLOW_39); + rule__XListLiteral__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop136; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3__1__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__0" + // InternalScope.g:16860:1: rule__XListLiteral__Group_3_1__0 : rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ; + public final void rule__XListLiteral__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16864:1: ( rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ) + // InternalScope.g:16865:2: rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 + { + pushFollow(FOLLOW_104); + rule__XListLiteral__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__0" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__0__Impl" + // InternalScope.g:16872:1: rule__XListLiteral__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XListLiteral__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16876:1: ( ( ',' ) ) + // InternalScope.g:16877:1: ( ',' ) + { + // InternalScope.g:16877:1: ( ',' ) + // InternalScope.g:16878:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__1" + // InternalScope.g:16887:1: rule__XListLiteral__Group_3_1__1 : rule__XListLiteral__Group_3_1__1__Impl ; + public final void rule__XListLiteral__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16891:1: ( rule__XListLiteral__Group_3_1__1__Impl ) + // InternalScope.g:16892:2: rule__XListLiteral__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XListLiteral__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__1" + + + // $ANTLR start "rule__XListLiteral__Group_3_1__1__Impl" + // InternalScope.g:16898:1: rule__XListLiteral__Group_3_1__1__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ; + public final void rule__XListLiteral__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16902:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ) + // InternalScope.g:16903:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) + { + // InternalScope.g:16903:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) + // InternalScope.g:16904:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); + } + // InternalScope.g:16905:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 ) + // InternalScope.g:16905:3: rule__XListLiteral__ElementsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XListLiteral__ElementsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XClosure__Group__0" + // InternalScope.g:16914:1: rule__XClosure__Group__0 : rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ; + public final void rule__XClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16918:1: ( rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ) + // InternalScope.g:16919:2: rule__XClosure__Group__0__Impl rule__XClosure__Group__1 + { + pushFollow(FOLLOW_107); + rule__XClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__0" + + + // $ANTLR start "rule__XClosure__Group__0__Impl" + // InternalScope.g:16926:1: rule__XClosure__Group__0__Impl : ( ( rule__XClosure__Group_0__0 ) ) ; + public final void rule__XClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16930:1: ( ( ( rule__XClosure__Group_0__0 ) ) ) + // InternalScope.g:16931:1: ( ( rule__XClosure__Group_0__0 ) ) + { + // InternalScope.g:16931:1: ( ( rule__XClosure__Group_0__0 ) ) + // InternalScope.g:16932:2: ( rule__XClosure__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_0()); + } + // InternalScope.g:16933:2: ( rule__XClosure__Group_0__0 ) + // InternalScope.g:16933:3: rule__XClosure__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__0__Impl" + + + // $ANTLR start "rule__XClosure__Group__1" + // InternalScope.g:16941:1: rule__XClosure__Group__1 : rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ; + public final void rule__XClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16945:1: ( rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ) + // InternalScope.g:16946:2: rule__XClosure__Group__1__Impl rule__XClosure__Group__2 + { + pushFollow(FOLLOW_107); + rule__XClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__1" + + + // $ANTLR start "rule__XClosure__Group__1__Impl" + // InternalScope.g:16953:1: rule__XClosure__Group__1__Impl : ( ( rule__XClosure__Group_1__0 )? ) ; + public final void rule__XClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16957:1: ( ( ( rule__XClosure__Group_1__0 )? ) ) + // InternalScope.g:16958:1: ( ( rule__XClosure__Group_1__0 )? ) + { + // InternalScope.g:16958:1: ( ( rule__XClosure__Group_1__0 )? ) + // InternalScope.g:16959:2: ( rule__XClosure__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1()); + } + // InternalScope.g:16960:2: ( rule__XClosure__Group_1__0 )? + int alt137=2; + alt137 = dfa137.predict(input); + switch (alt137) { + case 1 : + // InternalScope.g:16960:3: rule__XClosure__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__1__Impl" + + + // $ANTLR start "rule__XClosure__Group__2" + // InternalScope.g:16968:1: rule__XClosure__Group__2 : rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ; + public final void rule__XClosure__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16972:1: ( rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ) + // InternalScope.g:16973:2: rule__XClosure__Group__2__Impl rule__XClosure__Group__3 + { + pushFollow(FOLLOW_30); + rule__XClosure__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__2" + + + // $ANTLR start "rule__XClosure__Group__2__Impl" + // InternalScope.g:16980:1: rule__XClosure__Group__2__Impl : ( ( rule__XClosure__ExpressionAssignment_2 ) ) ; + public final void rule__XClosure__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16984:1: ( ( ( rule__XClosure__ExpressionAssignment_2 ) ) ) + // InternalScope.g:16985:1: ( ( rule__XClosure__ExpressionAssignment_2 ) ) + { + // InternalScope.g:16985:1: ( ( rule__XClosure__ExpressionAssignment_2 ) ) + // InternalScope.g:16986:2: ( rule__XClosure__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); + } + // InternalScope.g:16987:2: ( rule__XClosure__ExpressionAssignment_2 ) + // InternalScope.g:16987:3: rule__XClosure__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XClosure__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__2__Impl" + + + // $ANTLR start "rule__XClosure__Group__3" + // InternalScope.g:16995:1: rule__XClosure__Group__3 : rule__XClosure__Group__3__Impl ; + public final void rule__XClosure__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:16999:1: ( rule__XClosure__Group__3__Impl ) + // InternalScope.g:17000:2: rule__XClosure__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__3" + + + // $ANTLR start "rule__XClosure__Group__3__Impl" + // InternalScope.g:17006:1: rule__XClosure__Group__3__Impl : ( ']' ) ; + public final void rule__XClosure__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17010:1: ( ( ']' ) ) + // InternalScope.g:17011:1: ( ']' ) + { + // InternalScope.g:17011:1: ( ']' ) + // InternalScope.g:17012:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group__3__Impl" + + + // $ANTLR start "rule__XClosure__Group_0__0" + // InternalScope.g:17022:1: rule__XClosure__Group_0__0 : rule__XClosure__Group_0__0__Impl ; + public final void rule__XClosure__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17026:1: ( rule__XClosure__Group_0__0__Impl ) + // InternalScope.g:17027:2: rule__XClosure__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0__0" + + + // $ANTLR start "rule__XClosure__Group_0__0__Impl" + // InternalScope.g:17033:1: rule__XClosure__Group_0__0__Impl : ( ( rule__XClosure__Group_0_0__0 ) ) ; + public final void rule__XClosure__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17037:1: ( ( ( rule__XClosure__Group_0_0__0 ) ) ) + // InternalScope.g:17038:1: ( ( rule__XClosure__Group_0_0__0 ) ) + { + // InternalScope.g:17038:1: ( ( rule__XClosure__Group_0_0__0 ) ) + // InternalScope.g:17039:2: ( rule__XClosure__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_0_0()); + } + // InternalScope.g:17040:2: ( rule__XClosure__Group_0_0__0 ) + // InternalScope.g:17040:3: rule__XClosure__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_0_0__0" + // InternalScope.g:17049:1: rule__XClosure__Group_0_0__0 : rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ; + public final void rule__XClosure__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17053:1: ( rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ) + // InternalScope.g:17054:2: rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 + { + pushFollow(FOLLOW_29); + rule__XClosure__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__0" + + + // $ANTLR start "rule__XClosure__Group_0_0__0__Impl" + // InternalScope.g:17061:1: rule__XClosure__Group_0_0__0__Impl : ( () ) ; + public final void rule__XClosure__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17065:1: ( ( () ) ) + // InternalScope.g:17066:1: ( () ) + { + // InternalScope.g:17066:1: ( () ) + // InternalScope.g:17067:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); + } + // InternalScope.g:17068:2: () + // InternalScope.g:17068:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_0_0__1" + // InternalScope.g:17076:1: rule__XClosure__Group_0_0__1 : rule__XClosure__Group_0_0__1__Impl ; + public final void rule__XClosure__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17080:1: ( rule__XClosure__Group_0_0__1__Impl ) + // InternalScope.g:17081:2: rule__XClosure__Group_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__1" + + + // $ANTLR start "rule__XClosure__Group_0_0__1__Impl" + // InternalScope.g:17087:1: rule__XClosure__Group_0_0__1__Impl : ( '[' ) ; + public final void rule__XClosure__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17091:1: ( ( '[' ) ) + // InternalScope.g:17092:1: ( '[' ) + { + // InternalScope.g:17092:1: ( '[' ) + // InternalScope.g:17093:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1__0" + // InternalScope.g:17103:1: rule__XClosure__Group_1__0 : rule__XClosure__Group_1__0__Impl ; + public final void rule__XClosure__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17107:1: ( rule__XClosure__Group_1__0__Impl ) + // InternalScope.g:17108:2: rule__XClosure__Group_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1__0" + + + // $ANTLR start "rule__XClosure__Group_1__0__Impl" + // InternalScope.g:17114:1: rule__XClosure__Group_1__0__Impl : ( ( rule__XClosure__Group_1_0__0 ) ) ; + public final void rule__XClosure__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17118:1: ( ( ( rule__XClosure__Group_1_0__0 ) ) ) + // InternalScope.g:17119:1: ( ( rule__XClosure__Group_1_0__0 ) ) + { + // InternalScope.g:17119:1: ( ( rule__XClosure__Group_1_0__0 ) ) + // InternalScope.g:17120:2: ( rule__XClosure__Group_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0()); + } + // InternalScope.g:17121:2: ( rule__XClosure__Group_1_0__0 ) + // InternalScope.g:17121:3: rule__XClosure__Group_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0__0" + // InternalScope.g:17130:1: rule__XClosure__Group_1_0__0 : rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ; + public final void rule__XClosure__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17134:1: ( rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ) + // InternalScope.g:17135:2: rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 + { + pushFollow(FOLLOW_108); + rule__XClosure__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__0" + + + // $ANTLR start "rule__XClosure__Group_1_0__0__Impl" + // InternalScope.g:17142:1: rule__XClosure__Group_1_0__0__Impl : ( ( rule__XClosure__Group_1_0_0__0 )? ) ; + public final void rule__XClosure__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17146:1: ( ( ( rule__XClosure__Group_1_0_0__0 )? ) ) + // InternalScope.g:17147:1: ( ( rule__XClosure__Group_1_0_0__0 )? ) + { + // InternalScope.g:17147:1: ( ( rule__XClosure__Group_1_0_0__0 )? ) + // InternalScope.g:17148:2: ( rule__XClosure__Group_1_0_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); + } + // InternalScope.g:17149:2: ( rule__XClosure__Group_1_0_0__0 )? + int alt138=2; + int LA138_0 = input.LA(1); + + if ( (LA138_0==RULE_ID||LA138_0==51||LA138_0==77) ) { + alt138=1; + } + switch (alt138) { + case 1 : + // InternalScope.g:17149:3: rule__XClosure__Group_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0__1" + // InternalScope.g:17157:1: rule__XClosure__Group_1_0__1 : rule__XClosure__Group_1_0__1__Impl ; + public final void rule__XClosure__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17161:1: ( rule__XClosure__Group_1_0__1__Impl ) + // InternalScope.g:17162:2: rule__XClosure__Group_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__1" + + + // $ANTLR start "rule__XClosure__Group_1_0__1__Impl" + // InternalScope.g:17168:1: rule__XClosure__Group_1_0__1__Impl : ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ; + public final void rule__XClosure__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17172:1: ( ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ) + // InternalScope.g:17173:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) + { + // InternalScope.g:17173:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) + // InternalScope.g:17174:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); + } + // InternalScope.g:17175:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) + // InternalScope.g:17175:3: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XClosure__ExplicitSyntaxAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__0" + // InternalScope.g:17184:1: rule__XClosure__Group_1_0_0__0 : rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ; + public final void rule__XClosure__Group_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17188:1: ( rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ) + // InternalScope.g:17189:2: rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 + { + pushFollow(FOLLOW_71); + rule__XClosure__Group_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__0" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__0__Impl" + // InternalScope.g:17196:1: rule__XClosure__Group_1_0_0__0__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ; + public final void rule__XClosure__Group_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17200:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ) + // InternalScope.g:17201:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) + { + // InternalScope.g:17201:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) + // InternalScope.g:17202:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); + } + // InternalScope.g:17203:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) + // InternalScope.g:17203:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__1" + // InternalScope.g:17211:1: rule__XClosure__Group_1_0_0__1 : rule__XClosure__Group_1_0_0__1__Impl ; + public final void rule__XClosure__Group_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17215:1: ( rule__XClosure__Group_1_0_0__1__Impl ) + // InternalScope.g:17216:2: rule__XClosure__Group_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__1" + + + // $ANTLR start "rule__XClosure__Group_1_0_0__1__Impl" + // InternalScope.g:17222:1: rule__XClosure__Group_1_0_0__1__Impl : ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ; + public final void rule__XClosure__Group_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17226:1: ( ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ) + // InternalScope.g:17227:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* ) + { + // InternalScope.g:17227:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* ) + // InternalScope.g:17228:2: ( rule__XClosure__Group_1_0_0_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); + } + // InternalScope.g:17229:2: ( rule__XClosure__Group_1_0_0_1__0 )* + loop139: + do { + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==86) ) { + alt139=1; + } + + + switch (alt139) { + case 1 : + // InternalScope.g:17229:3: rule__XClosure__Group_1_0_0_1__0 + { + pushFollow(FOLLOW_39); + rule__XClosure__Group_1_0_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop139; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0__1__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__0" + // InternalScope.g:17238:1: rule__XClosure__Group_1_0_0_1__0 : rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ; + public final void rule__XClosure__Group_1_0_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17242:1: ( rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ) + // InternalScope.g:17243:2: rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 + { + pushFollow(FOLLOW_84); + rule__XClosure__Group_1_0_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__0" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__0__Impl" + // InternalScope.g:17250:1: rule__XClosure__Group_1_0_0_1__0__Impl : ( ',' ) ; + public final void rule__XClosure__Group_1_0_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17254:1: ( ( ',' ) ) + // InternalScope.g:17255:1: ( ',' ) + { + // InternalScope.g:17255:1: ( ',' ) + // InternalScope.g:17256:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__0__Impl" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__1" + // InternalScope.g:17265:1: rule__XClosure__Group_1_0_0_1__1 : rule__XClosure__Group_1_0_0_1__1__Impl ; + public final void rule__XClosure__Group_1_0_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17269:1: ( rule__XClosure__Group_1_0_0_1__1__Impl ) + // InternalScope.g:17270:2: rule__XClosure__Group_1_0_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1_0_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__1" + + + // $ANTLR start "rule__XClosure__Group_1_0_0_1__1__Impl" + // InternalScope.g:17276:1: rule__XClosure__Group_1_0_0_1__1__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ; + public final void rule__XClosure__Group_1_0_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17280:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ) + // InternalScope.g:17281:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) + { + // InternalScope.g:17281:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) + // InternalScope.g:17282:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); + } + // InternalScope.g:17283:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) + // InternalScope.g:17283:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__Group_1_0_0_1__1__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group__0" + // InternalScope.g:17292:1: rule__XExpressionInClosure__Group__0 : rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ; + public final void rule__XExpressionInClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17296:1: ( rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ) + // InternalScope.g:17297:2: rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 + { + pushFollow(FOLLOW_107); + rule__XExpressionInClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__0" + + + // $ANTLR start "rule__XExpressionInClosure__Group__0__Impl" + // InternalScope.g:17304:1: rule__XExpressionInClosure__Group__0__Impl : ( () ) ; + public final void rule__XExpressionInClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17308:1: ( ( () ) ) + // InternalScope.g:17309:1: ( () ) + { + // InternalScope.g:17309:1: ( () ) + // InternalScope.g:17310:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); + } + // InternalScope.g:17311:2: () + // InternalScope.g:17311:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__0__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group__1" + // InternalScope.g:17319:1: rule__XExpressionInClosure__Group__1 : rule__XExpressionInClosure__Group__1__Impl ; + public final void rule__XExpressionInClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17323:1: ( rule__XExpressionInClosure__Group__1__Impl ) + // InternalScope.g:17324:2: rule__XExpressionInClosure__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__1" + + + // $ANTLR start "rule__XExpressionInClosure__Group__1__Impl" + // InternalScope.g:17330:1: rule__XExpressionInClosure__Group__1__Impl : ( ( rule__XExpressionInClosure__Group_1__0 )* ) ; + public final void rule__XExpressionInClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17334:1: ( ( ( rule__XExpressionInClosure__Group_1__0 )* ) ) + // InternalScope.g:17335:1: ( ( rule__XExpressionInClosure__Group_1__0 )* ) + { + // InternalScope.g:17335:1: ( ( rule__XExpressionInClosure__Group_1__0 )* ) + // InternalScope.g:17336:2: ( rule__XExpressionInClosure__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); + } + // InternalScope.g:17337:2: ( rule__XExpressionInClosure__Group_1__0 )* + loop140: + do { + int alt140=2; + int LA140_0 = input.LA(1); + + if ( ((LA140_0>=RULE_ID && LA140_0<=RULE_STRING)||(LA140_0>=22 && LA140_0<=24)||LA140_0==27||(LA140_0>=36 && LA140_0<=37)||(LA140_0>=59 && LA140_0<=64)||LA140_0==72||LA140_0==77||LA140_0==79||LA140_0==82||LA140_0==97||LA140_0==100||LA140_0==103||(LA140_0>=105 && LA140_0<=112)||LA140_0==114||LA140_0==122) ) { + alt140=1; + } + + + switch (alt140) { + case 1 : + // InternalScope.g:17337:3: rule__XExpressionInClosure__Group_1__0 + { + pushFollow(FOLLOW_109); + rule__XExpressionInClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop140; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group__1__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__0" + // InternalScope.g:17346:1: rule__XExpressionInClosure__Group_1__0 : rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ; + public final void rule__XExpressionInClosure__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17350:1: ( rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ) + // InternalScope.g:17351:2: rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 + { + pushFollow(FOLLOW_18); + rule__XExpressionInClosure__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__0" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__0__Impl" + // InternalScope.g:17358:1: rule__XExpressionInClosure__Group_1__0__Impl : ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ; + public final void rule__XExpressionInClosure__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17362:1: ( ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ) + // InternalScope.g:17363:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) + { + // InternalScope.g:17363:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) + // InternalScope.g:17364:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); + } + // InternalScope.g:17365:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) + // InternalScope.g:17365:3: rule__XExpressionInClosure__ExpressionsAssignment_1_0 + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__ExpressionsAssignment_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__0__Impl" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__1" + // InternalScope.g:17373:1: rule__XExpressionInClosure__Group_1__1 : rule__XExpressionInClosure__Group_1__1__Impl ; + public final void rule__XExpressionInClosure__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17377:1: ( rule__XExpressionInClosure__Group_1__1__Impl ) + // InternalScope.g:17378:2: rule__XExpressionInClosure__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XExpressionInClosure__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__1" + + + // $ANTLR start "rule__XExpressionInClosure__Group_1__1__Impl" + // InternalScope.g:17384:1: rule__XExpressionInClosure__Group_1__1__Impl : ( ( ';' )? ) ; + public final void rule__XExpressionInClosure__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17388:1: ( ( ( ';' )? ) ) + // InternalScope.g:17389:1: ( ( ';' )? ) + { + // InternalScope.g:17389:1: ( ( ';' )? ) + // InternalScope.g:17390:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + // InternalScope.g:17391:2: ( ';' )? + int alt141=2; + int LA141_0 = input.LA(1); + + if ( (LA141_0==75) ) { + alt141=1; + } + switch (alt141) { + case 1 : + // InternalScope.g:17391:3: ';' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__Group_1__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group__0" + // InternalScope.g:17400:1: rule__XShortClosure__Group__0 : rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ; + public final void rule__XShortClosure__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17404:1: ( rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ) + // InternalScope.g:17405:2: rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 + { + pushFollow(FOLLOW_104); + rule__XShortClosure__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__0" + + + // $ANTLR start "rule__XShortClosure__Group__0__Impl" + // InternalScope.g:17412:1: rule__XShortClosure__Group__0__Impl : ( ( rule__XShortClosure__Group_0__0 ) ) ; + public final void rule__XShortClosure__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17416:1: ( ( ( rule__XShortClosure__Group_0__0 ) ) ) + // InternalScope.g:17417:1: ( ( rule__XShortClosure__Group_0__0 ) ) + { + // InternalScope.g:17417:1: ( ( rule__XShortClosure__Group_0__0 ) ) + // InternalScope.g:17418:2: ( rule__XShortClosure__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0()); + } + // InternalScope.g:17419:2: ( rule__XShortClosure__Group_0__0 ) + // InternalScope.g:17419:3: rule__XShortClosure__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group__1" + // InternalScope.g:17427:1: rule__XShortClosure__Group__1 : rule__XShortClosure__Group__1__Impl ; + public final void rule__XShortClosure__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17431:1: ( rule__XShortClosure__Group__1__Impl ) + // InternalScope.g:17432:2: rule__XShortClosure__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__1" + + + // $ANTLR start "rule__XShortClosure__Group__1__Impl" + // InternalScope.g:17438:1: rule__XShortClosure__Group__1__Impl : ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ; + public final void rule__XShortClosure__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17442:1: ( ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ) + // InternalScope.g:17443:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) + { + // InternalScope.g:17443:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) + // InternalScope.g:17444:2: ( rule__XShortClosure__ExpressionAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); + } + // InternalScope.g:17445:2: ( rule__XShortClosure__ExpressionAssignment_1 ) + // InternalScope.g:17445:3: rule__XShortClosure__ExpressionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__ExpressionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0__0" + // InternalScope.g:17454:1: rule__XShortClosure__Group_0__0 : rule__XShortClosure__Group_0__0__Impl ; + public final void rule__XShortClosure__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17458:1: ( rule__XShortClosure__Group_0__0__Impl ) + // InternalScope.g:17459:2: rule__XShortClosure__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0__0" + + + // $ANTLR start "rule__XShortClosure__Group_0__0__Impl" + // InternalScope.g:17465:1: rule__XShortClosure__Group_0__0__Impl : ( ( rule__XShortClosure__Group_0_0__0 ) ) ; + public final void rule__XShortClosure__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17469:1: ( ( ( rule__XShortClosure__Group_0_0__0 ) ) ) + // InternalScope.g:17470:1: ( ( rule__XShortClosure__Group_0_0__0 ) ) + { + // InternalScope.g:17470:1: ( ( rule__XShortClosure__Group_0_0__0 ) ) + // InternalScope.g:17471:2: ( rule__XShortClosure__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); + } + // InternalScope.g:17472:2: ( rule__XShortClosure__Group_0_0__0 ) + // InternalScope.g:17472:3: rule__XShortClosure__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__0" + // InternalScope.g:17481:1: rule__XShortClosure__Group_0_0__0 : rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ; + public final void rule__XShortClosure__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17485:1: ( rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ) + // InternalScope.g:17486:2: rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 + { + pushFollow(FOLLOW_108); + rule__XShortClosure__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__0__Impl" + // InternalScope.g:17493:1: rule__XShortClosure__Group_0_0__0__Impl : ( () ) ; + public final void rule__XShortClosure__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17497:1: ( ( () ) ) + // InternalScope.g:17498:1: ( () ) + { + // InternalScope.g:17498:1: ( () ) + // InternalScope.g:17499:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); + } + // InternalScope.g:17500:2: () + // InternalScope.g:17500:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__1" + // InternalScope.g:17508:1: rule__XShortClosure__Group_0_0__1 : rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ; + public final void rule__XShortClosure__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17512:1: ( rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ) + // InternalScope.g:17513:2: rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 + { + pushFollow(FOLLOW_108); + rule__XShortClosure__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__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__XShortClosure__Group_0_0__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__1__Impl" + // InternalScope.g:17520:1: rule__XShortClosure__Group_0_0__1__Impl : ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ; + public final void rule__XShortClosure__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17524:1: ( ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ) + // InternalScope.g:17525:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? ) + { + // InternalScope.g:17525:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? ) + // InternalScope.g:17526:2: ( rule__XShortClosure__Group_0_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); + } + // InternalScope.g:17527:2: ( rule__XShortClosure__Group_0_0_1__0 )? + int alt142=2; + int LA142_0 = input.LA(1); + + if ( (LA142_0==RULE_ID||LA142_0==51||LA142_0==77) ) { + alt142=1; + } + switch (alt142) { + case 1 : + // InternalScope.g:17527:3: rule__XShortClosure__Group_0_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__2" + // InternalScope.g:17535:1: rule__XShortClosure__Group_0_0__2 : rule__XShortClosure__Group_0_0__2__Impl ; + public final void rule__XShortClosure__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17539:1: ( rule__XShortClosure__Group_0_0__2__Impl ) + // InternalScope.g:17540:2: rule__XShortClosure__Group_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__2" + + + // $ANTLR start "rule__XShortClosure__Group_0_0__2__Impl" + // InternalScope.g:17546:1: rule__XShortClosure__Group_0_0__2__Impl : ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ; + public final void rule__XShortClosure__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17550:1: ( ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ) + // InternalScope.g:17551:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) + { + // InternalScope.g:17551:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) + // InternalScope.g:17552:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); + } + // InternalScope.g:17553:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) + // InternalScope.g:17553:3: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__0" + // InternalScope.g:17562:1: rule__XShortClosure__Group_0_0_1__0 : rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ; + public final void rule__XShortClosure__Group_0_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17566:1: ( rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ) + // InternalScope.g:17567:2: rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 + { + pushFollow(FOLLOW_71); + rule__XShortClosure__Group_0_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__0__Impl" + // InternalScope.g:17574:1: rule__XShortClosure__Group_0_0_1__0__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ; + public final void rule__XShortClosure__Group_0_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17578:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ) + // InternalScope.g:17579:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) + { + // InternalScope.g:17579:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) + // InternalScope.g:17580:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); + } + // InternalScope.g:17581:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) + // InternalScope.g:17581:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__1" + // InternalScope.g:17589:1: rule__XShortClosure__Group_0_0_1__1 : rule__XShortClosure__Group_0_0_1__1__Impl ; + public final void rule__XShortClosure__Group_0_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17593:1: ( rule__XShortClosure__Group_0_0_1__1__Impl ) + // InternalScope.g:17594:2: rule__XShortClosure__Group_0_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1__1__Impl" + // InternalScope.g:17600:1: rule__XShortClosure__Group_0_0_1__1__Impl : ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ; + public final void rule__XShortClosure__Group_0_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17604:1: ( ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ) + // InternalScope.g:17605:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) + { + // InternalScope.g:17605:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) + // InternalScope.g:17606:2: ( rule__XShortClosure__Group_0_0_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); + } + // InternalScope.g:17607:2: ( rule__XShortClosure__Group_0_0_1_1__0 )* + loop143: + do { + int alt143=2; + int LA143_0 = input.LA(1); + + if ( (LA143_0==86) ) { + alt143=1; + } + + + switch (alt143) { + case 1 : + // InternalScope.g:17607:3: rule__XShortClosure__Group_0_0_1_1__0 + { + pushFollow(FOLLOW_39); + rule__XShortClosure__Group_0_0_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop143; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1__1__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0" + // InternalScope.g:17616:1: rule__XShortClosure__Group_0_0_1_1__0 : rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ; + public final void rule__XShortClosure__Group_0_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17620:1: ( rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ) + // InternalScope.g:17621:2: rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 + { + pushFollow(FOLLOW_84); + rule__XShortClosure__Group_0_0_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0__Impl" + // InternalScope.g:17628:1: rule__XShortClosure__Group_0_0_1_1__0__Impl : ( ',' ) ; + public final void rule__XShortClosure__Group_0_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17632:1: ( ( ',' ) ) + // InternalScope.g:17633:1: ( ',' ) + { + // InternalScope.g:17633:1: ( ',' ) + // InternalScope.g:17634:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0__Impl" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1" + // InternalScope.g:17643:1: rule__XShortClosure__Group_0_0_1_1__1 : rule__XShortClosure__Group_0_0_1_1__1__Impl ; + public final void rule__XShortClosure__Group_0_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17647:1: ( rule__XShortClosure__Group_0_0_1_1__1__Impl ) + // InternalScope.g:17648:2: rule__XShortClosure__Group_0_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XShortClosure__Group_0_0_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1" + + + // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1__Impl" + // InternalScope.g:17654:1: rule__XShortClosure__Group_0_0_1_1__1__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ; + public final void rule__XShortClosure__Group_0_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17658:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ) + // InternalScope.g:17659:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) + { + // InternalScope.g:17659:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) + // InternalScope.g:17660:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); + } + // InternalScope.g:17661:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) + // InternalScope.g:17661:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__0" + // InternalScope.g:17670:1: rule__XParenthesizedExpression__Group__0 : rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ; + public final void rule__XParenthesizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17674:1: ( rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ) + // InternalScope.g:17675:2: rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 + { + pushFollow(FOLLOW_104); + rule__XParenthesizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__0" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__0__Impl" + // InternalScope.g:17682:1: rule__XParenthesizedExpression__Group__0__Impl : ( '(' ) ; + public final void rule__XParenthesizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17686:1: ( ( '(' ) ) + // InternalScope.g:17687:1: ( '(' ) + { + // InternalScope.g:17687:1: ( '(' ) + // InternalScope.g:17688:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__1" + // InternalScope.g:17697:1: rule__XParenthesizedExpression__Group__1 : rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ; + public final void rule__XParenthesizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17701:1: ( rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ) + // InternalScope.g:17702:2: rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 + { + pushFollow(FOLLOW_23); + rule__XParenthesizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__1" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__1__Impl" + // InternalScope.g:17709:1: rule__XParenthesizedExpression__Group__1__Impl : ( ruleXExpression ) ; + public final void rule__XParenthesizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17713:1: ( ( ruleXExpression ) ) + // InternalScope.g:17714:1: ( ruleXExpression ) + { + // InternalScope.g:17714:1: ( ruleXExpression ) + // InternalScope.g:17715:2: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__2" + // InternalScope.g:17724:1: rule__XParenthesizedExpression__Group__2 : rule__XParenthesizedExpression__Group__2__Impl ; + public final void rule__XParenthesizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17728:1: ( rule__XParenthesizedExpression__Group__2__Impl ) + // InternalScope.g:17729:2: rule__XParenthesizedExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XParenthesizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__2" + + + // $ANTLR start "rule__XParenthesizedExpression__Group__2__Impl" + // InternalScope.g:17735:1: rule__XParenthesizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XParenthesizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17739:1: ( ( ')' ) ) + // InternalScope.g:17740:1: ( ')' ) + { + // InternalScope.g:17740:1: ( ')' ) + // InternalScope.g:17741:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XParenthesizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__0" + // InternalScope.g:17751:1: rule__XIfExpression__Group__0 : rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ; + public final void rule__XIfExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17755:1: ( rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ) + // InternalScope.g:17756:2: rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 + { + pushFollow(FOLLOW_110); + rule__XIfExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__0" + + + // $ANTLR start "rule__XIfExpression__Group__0__Impl" + // InternalScope.g:17763:1: rule__XIfExpression__Group__0__Impl : ( () ) ; + public final void rule__XIfExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17767:1: ( ( () ) ) + // InternalScope.g:17768:1: ( () ) + { + // InternalScope.g:17768:1: ( () ) + // InternalScope.g:17769:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); + } + // InternalScope.g:17770:2: () + // InternalScope.g:17770:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__0__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__1" + // InternalScope.g:17778:1: rule__XIfExpression__Group__1 : rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ; + public final void rule__XIfExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17782:1: ( rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ) + // InternalScope.g:17783:2: rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 + { + pushFollow(FOLLOW_31); + rule__XIfExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__1" + + + // $ANTLR start "rule__XIfExpression__Group__1__Impl" + // InternalScope.g:17790:1: rule__XIfExpression__Group__1__Impl : ( 'if' ) ; + public final void rule__XIfExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17794:1: ( ( 'if' ) ) + // InternalScope.g:17795:1: ( 'if' ) + { + // InternalScope.g:17795:1: ( 'if' ) + // InternalScope.g:17796:2: 'if' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + match(input,97,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__1__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__2" + // InternalScope.g:17805:1: rule__XIfExpression__Group__2 : rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ; + public final void rule__XIfExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17809:1: ( rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ) + // InternalScope.g:17810:2: rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 + { + pushFollow(FOLLOW_104); + rule__XIfExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__2" + + + // $ANTLR start "rule__XIfExpression__Group__2__Impl" + // InternalScope.g:17817:1: rule__XIfExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XIfExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17821:1: ( ( '(' ) ) + // InternalScope.g:17822:1: ( '(' ) + { + // InternalScope.g:17822:1: ( '(' ) + // InternalScope.g:17823:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__2__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__3" + // InternalScope.g:17832:1: rule__XIfExpression__Group__3 : rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ; + public final void rule__XIfExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17836:1: ( rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ) + // InternalScope.g:17837:2: rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 + { + pushFollow(FOLLOW_23); + rule__XIfExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__3" + + + // $ANTLR start "rule__XIfExpression__Group__3__Impl" + // InternalScope.g:17844:1: rule__XIfExpression__Group__3__Impl : ( ( rule__XIfExpression__IfAssignment_3 ) ) ; + public final void rule__XIfExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17848:1: ( ( ( rule__XIfExpression__IfAssignment_3 ) ) ) + // InternalScope.g:17849:1: ( ( rule__XIfExpression__IfAssignment_3 ) ) + { + // InternalScope.g:17849:1: ( ( rule__XIfExpression__IfAssignment_3 ) ) + // InternalScope.g:17850:2: ( rule__XIfExpression__IfAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); + } + // InternalScope.g:17851:2: ( rule__XIfExpression__IfAssignment_3 ) + // InternalScope.g:17851:3: rule__XIfExpression__IfAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__IfAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__3__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__4" + // InternalScope.g:17859:1: rule__XIfExpression__Group__4 : rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ; + public final void rule__XIfExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17863:1: ( rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ) + // InternalScope.g:17864:2: rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 + { + pushFollow(FOLLOW_104); + rule__XIfExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__4" + + + // $ANTLR start "rule__XIfExpression__Group__4__Impl" + // InternalScope.g:17871:1: rule__XIfExpression__Group__4__Impl : ( ')' ) ; + public final void rule__XIfExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17875:1: ( ( ')' ) ) + // InternalScope.g:17876:1: ( ')' ) + { + // InternalScope.g:17876:1: ( ')' ) + // InternalScope.g:17877:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__4__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__5" + // InternalScope.g:17886:1: rule__XIfExpression__Group__5 : rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ; + public final void rule__XIfExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17890:1: ( rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ) + // InternalScope.g:17891:2: rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 + { + pushFollow(FOLLOW_53); + rule__XIfExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__5" + + + // $ANTLR start "rule__XIfExpression__Group__5__Impl" + // InternalScope.g:17898:1: rule__XIfExpression__Group__5__Impl : ( ( rule__XIfExpression__ThenAssignment_5 ) ) ; + public final void rule__XIfExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17902:1: ( ( ( rule__XIfExpression__ThenAssignment_5 ) ) ) + // InternalScope.g:17903:1: ( ( rule__XIfExpression__ThenAssignment_5 ) ) + { + // InternalScope.g:17903:1: ( ( rule__XIfExpression__ThenAssignment_5 ) ) + // InternalScope.g:17904:2: ( rule__XIfExpression__ThenAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); + } + // InternalScope.g:17905:2: ( rule__XIfExpression__ThenAssignment_5 ) + // InternalScope.g:17905:3: rule__XIfExpression__ThenAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__ThenAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__5__Impl" + + + // $ANTLR start "rule__XIfExpression__Group__6" + // InternalScope.g:17913:1: rule__XIfExpression__Group__6 : rule__XIfExpression__Group__6__Impl ; + public final void rule__XIfExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17917:1: ( rule__XIfExpression__Group__6__Impl ) + // InternalScope.g:17918:2: rule__XIfExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__6" + + + // $ANTLR start "rule__XIfExpression__Group__6__Impl" + // InternalScope.g:17924:1: rule__XIfExpression__Group__6__Impl : ( ( rule__XIfExpression__Group_6__0 )? ) ; + public final void rule__XIfExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17928:1: ( ( ( rule__XIfExpression__Group_6__0 )? ) ) + // InternalScope.g:17929:1: ( ( rule__XIfExpression__Group_6__0 )? ) + { + // InternalScope.g:17929:1: ( ( rule__XIfExpression__Group_6__0 )? ) + // InternalScope.g:17930:2: ( rule__XIfExpression__Group_6__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getGroup_6()); + } + // InternalScope.g:17931:2: ( rule__XIfExpression__Group_6__0 )? + int alt144=2; + int LA144_0 = input.LA(1); + + if ( (LA144_0==99) ) { + int LA144_1 = input.LA(2); + + if ( (synpred219_InternalScope()) ) { + alt144=1; + } + } + switch (alt144) { + case 1 : + // InternalScope.g:17931:3: rule__XIfExpression__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getGroup_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group__6__Impl" + + + // $ANTLR start "rule__XIfExpression__Group_6__0" + // InternalScope.g:17940:1: rule__XIfExpression__Group_6__0 : rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ; + public final void rule__XIfExpression__Group_6__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17944:1: ( rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ) + // InternalScope.g:17945:2: rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 + { + pushFollow(FOLLOW_104); + rule__XIfExpression__Group_6__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__0" + + + // $ANTLR start "rule__XIfExpression__Group_6__0__Impl" + // InternalScope.g:17952:1: rule__XIfExpression__Group_6__0__Impl : ( ( 'else' ) ) ; + public final void rule__XIfExpression__Group_6__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17956:1: ( ( ( 'else' ) ) ) + // InternalScope.g:17957:1: ( ( 'else' ) ) + { + // InternalScope.g:17957:1: ( ( 'else' ) ) + // InternalScope.g:17958:2: ( 'else' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + // InternalScope.g:17959:2: ( 'else' ) + // InternalScope.g:17959:3: 'else' + { + match(input,99,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__0__Impl" + + + // $ANTLR start "rule__XIfExpression__Group_6__1" + // InternalScope.g:17967:1: rule__XIfExpression__Group_6__1 : rule__XIfExpression__Group_6__1__Impl ; + public final void rule__XIfExpression__Group_6__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17971:1: ( rule__XIfExpression__Group_6__1__Impl ) + // InternalScope.g:17972:2: rule__XIfExpression__Group_6__1__Impl + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__1" + + + // $ANTLR start "rule__XIfExpression__Group_6__1__Impl" + // InternalScope.g:17978:1: rule__XIfExpression__Group_6__1__Impl : ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ; + public final void rule__XIfExpression__Group_6__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17982:1: ( ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ) + // InternalScope.g:17983:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) + { + // InternalScope.g:17983:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) + // InternalScope.g:17984:2: ( rule__XIfExpression__ElseAssignment_6_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); + } + // InternalScope.g:17985:2: ( rule__XIfExpression__ElseAssignment_6_1 ) + // InternalScope.g:17985:3: rule__XIfExpression__ElseAssignment_6_1 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__ElseAssignment_6_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__Group_6__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__0" + // InternalScope.g:17994:1: rule__XSwitchExpression__Group__0 : rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ; + public final void rule__XSwitchExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:17998:1: ( rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ) + // InternalScope.g:17999:2: rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 + { + pushFollow(FOLLOW_111); + rule__XSwitchExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__0" + + + // $ANTLR start "rule__XSwitchExpression__Group__0__Impl" + // InternalScope.g:18006:1: rule__XSwitchExpression__Group__0__Impl : ( () ) ; + public final void rule__XSwitchExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18010:1: ( ( () ) ) + // InternalScope.g:18011:1: ( () ) + { + // InternalScope.g:18011:1: ( () ) + // InternalScope.g:18012:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); + } + // InternalScope.g:18013:2: () + // InternalScope.g:18013:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__1" + // InternalScope.g:18021:1: rule__XSwitchExpression__Group__1 : rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ; + public final void rule__XSwitchExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18025:1: ( rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ) + // InternalScope.g:18026:2: rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 + { + pushFollow(FOLLOW_104); + rule__XSwitchExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__1" + + + // $ANTLR start "rule__XSwitchExpression__Group__1__Impl" + // InternalScope.g:18033:1: rule__XSwitchExpression__Group__1__Impl : ( 'switch' ) ; + public final void rule__XSwitchExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18037:1: ( ( 'switch' ) ) + // InternalScope.g:18038:1: ( 'switch' ) + { + // InternalScope.g:18038:1: ( 'switch' ) + // InternalScope.g:18039:2: 'switch' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + match(input,100,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__2" + // InternalScope.g:18048:1: rule__XSwitchExpression__Group__2 : rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ; + public final void rule__XSwitchExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18052:1: ( rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ) + // InternalScope.g:18053:2: rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 + { + pushFollow(FOLLOW_13); + rule__XSwitchExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__2" + + + // $ANTLR start "rule__XSwitchExpression__Group__2__Impl" + // InternalScope.g:18060:1: rule__XSwitchExpression__Group__2__Impl : ( ( rule__XSwitchExpression__Alternatives_2 ) ) ; + public final void rule__XSwitchExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18064:1: ( ( ( rule__XSwitchExpression__Alternatives_2 ) ) ) + // InternalScope.g:18065:1: ( ( rule__XSwitchExpression__Alternatives_2 ) ) + { + // InternalScope.g:18065:1: ( ( rule__XSwitchExpression__Alternatives_2 ) ) + // InternalScope.g:18066:2: ( rule__XSwitchExpression__Alternatives_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); + } + // InternalScope.g:18067:2: ( rule__XSwitchExpression__Alternatives_2 ) + // InternalScope.g:18067:3: rule__XSwitchExpression__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__3" + // InternalScope.g:18075:1: rule__XSwitchExpression__Group__3 : rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ; + public final void rule__XSwitchExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18079:1: ( rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ) + // InternalScope.g:18080:2: rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 + { + pushFollow(FOLLOW_112); + rule__XSwitchExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__3" + + + // $ANTLR start "rule__XSwitchExpression__Group__3__Impl" + // InternalScope.g:18087:1: rule__XSwitchExpression__Group__3__Impl : ( '{' ) ; + public final void rule__XSwitchExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18091:1: ( ( '{' ) ) + // InternalScope.g:18092:1: ( '{' ) + { + // InternalScope.g:18092:1: ( '{' ) + // InternalScope.g:18093:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__3__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__4" + // InternalScope.g:18102:1: rule__XSwitchExpression__Group__4 : rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ; + public final void rule__XSwitchExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18106:1: ( rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ) + // InternalScope.g:18107:2: rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 + { + pushFollow(FOLLOW_112); + rule__XSwitchExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__4" + + + // $ANTLR start "rule__XSwitchExpression__Group__4__Impl" + // InternalScope.g:18114:1: rule__XSwitchExpression__Group__4__Impl : ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ; + public final void rule__XSwitchExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18118:1: ( ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ) + // InternalScope.g:18119:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) + { + // InternalScope.g:18119:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) + // InternalScope.g:18120:2: ( rule__XSwitchExpression__CasesAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); + } + // InternalScope.g:18121:2: ( rule__XSwitchExpression__CasesAssignment_4 )* + loop145: + do { + int alt145=2; + int LA145_0 = input.LA(1); + + if ( (LA145_0==RULE_ID||LA145_0==51||LA145_0==74||LA145_0==77||LA145_0==86||LA145_0==95) ) { + alt145=1; + } + + + switch (alt145) { + case 1 : + // InternalScope.g:18121:3: rule__XSwitchExpression__CasesAssignment_4 + { + pushFollow(FOLLOW_113); + rule__XSwitchExpression__CasesAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop145; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__4__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__5" + // InternalScope.g:18129:1: rule__XSwitchExpression__Group__5 : rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ; + public final void rule__XSwitchExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18133:1: ( rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ) + // InternalScope.g:18134:2: rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 + { + pushFollow(FOLLOW_112); + rule__XSwitchExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__5" + + + // $ANTLR start "rule__XSwitchExpression__Group__5__Impl" + // InternalScope.g:18141:1: rule__XSwitchExpression__Group__5__Impl : ( ( rule__XSwitchExpression__Group_5__0 )? ) ; + public final void rule__XSwitchExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18145:1: ( ( ( rule__XSwitchExpression__Group_5__0 )? ) ) + // InternalScope.g:18146:1: ( ( rule__XSwitchExpression__Group_5__0 )? ) + { + // InternalScope.g:18146:1: ( ( rule__XSwitchExpression__Group_5__0 )? ) + // InternalScope.g:18147:2: ( rule__XSwitchExpression__Group_5__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); + } + // InternalScope.g:18148:2: ( rule__XSwitchExpression__Group_5__0 )? + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==101) ) { + alt146=1; + } + switch (alt146) { + case 1 : + // InternalScope.g:18148:3: rule__XSwitchExpression__Group_5__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__5__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group__6" + // InternalScope.g:18156:1: rule__XSwitchExpression__Group__6 : rule__XSwitchExpression__Group__6__Impl ; + public final void rule__XSwitchExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18160:1: ( rule__XSwitchExpression__Group__6__Impl ) + // InternalScope.g:18161:2: rule__XSwitchExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__6" + + + // $ANTLR start "rule__XSwitchExpression__Group__6__Impl" + // InternalScope.g:18167:1: rule__XSwitchExpression__Group__6__Impl : ( '}' ) ; + public final void rule__XSwitchExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18171:1: ( ( '}' ) ) + // InternalScope.g:18172:1: ( '}' ) + { + // InternalScope.g:18172:1: ( '}' ) + // InternalScope.g:18173:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group__6__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__0" + // InternalScope.g:18183:1: rule__XSwitchExpression__Group_2_0__0 : rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ; + public final void rule__XSwitchExpression__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18187:1: ( rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ) + // InternalScope.g:18188:2: rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 + { + pushFollow(FOLLOW_104); + rule__XSwitchExpression__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__0__Impl" + // InternalScope.g:18195:1: rule__XSwitchExpression__Group_2_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18199:1: ( ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ) + // InternalScope.g:18200:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) + { + // InternalScope.g:18200:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) + // InternalScope.g:18201:2: ( rule__XSwitchExpression__Group_2_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); + } + // InternalScope.g:18202:2: ( rule__XSwitchExpression__Group_2_0_0__0 ) + // InternalScope.g:18202:3: rule__XSwitchExpression__Group_2_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__1" + // InternalScope.g:18210:1: rule__XSwitchExpression__Group_2_0__1 : rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ; + public final void rule__XSwitchExpression__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18214:1: ( rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ) + // InternalScope.g:18215:2: rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 + { + pushFollow(FOLLOW_23); + rule__XSwitchExpression__Group_2_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__1__Impl" + // InternalScope.g:18222:1: rule__XSwitchExpression__Group_2_0__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18226:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ) + // InternalScope.g:18227:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) + { + // InternalScope.g:18227:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) + // InternalScope.g:18228:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); + } + // InternalScope.g:18229:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) + // InternalScope.g:18229:3: rule__XSwitchExpression__SwitchAssignment_2_0_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__SwitchAssignment_2_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__2" + // InternalScope.g:18237:1: rule__XSwitchExpression__Group_2_0__2 : rule__XSwitchExpression__Group_2_0__2__Impl ; + public final void rule__XSwitchExpression__Group_2_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18241:1: ( rule__XSwitchExpression__Group_2_0__2__Impl ) + // InternalScope.g:18242:2: rule__XSwitchExpression__Group_2_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0__2__Impl" + // InternalScope.g:18248:1: rule__XSwitchExpression__Group_2_0__2__Impl : ( ')' ) ; + public final void rule__XSwitchExpression__Group_2_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18252:1: ( ( ')' ) ) + // InternalScope.g:18253:1: ( ')' ) + { + // InternalScope.g:18253:1: ( ')' ) + // InternalScope.g:18254:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0" + // InternalScope.g:18264:1: rule__XSwitchExpression__Group_2_0_0__0 : rule__XSwitchExpression__Group_2_0_0__0__Impl ; + public final void rule__XSwitchExpression__Group_2_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18268:1: ( rule__XSwitchExpression__Group_2_0_0__0__Impl ) + // InternalScope.g:18269:2: rule__XSwitchExpression__Group_2_0_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0__Impl" + // InternalScope.g:18275:1: rule__XSwitchExpression__Group_2_0_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18279:1: ( ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ) + // InternalScope.g:18280:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) + { + // InternalScope.g:18280:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) + // InternalScope.g:18281:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); + } + // InternalScope.g:18282:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 ) + // InternalScope.g:18282:3: rule__XSwitchExpression__Group_2_0_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0" + // InternalScope.g:18291:1: rule__XSwitchExpression__Group_2_0_0_0__0 : rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ; + public final void rule__XSwitchExpression__Group_2_0_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18295:1: ( rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ) + // InternalScope.g:18296:2: rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 + { + pushFollow(FOLLOW_84); + rule__XSwitchExpression__Group_2_0_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0__Impl" + // InternalScope.g:18303:1: rule__XSwitchExpression__Group_2_0_0_0__0__Impl : ( '(' ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18307:1: ( ( '(' ) ) + // InternalScope.g:18308:1: ( '(' ) + { + // InternalScope.g:18308:1: ( '(' ) + // InternalScope.g:18309:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1" + // InternalScope.g:18318:1: rule__XSwitchExpression__Group_2_0_0_0__1 : rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ; + public final void rule__XSwitchExpression__Group_2_0_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18322:1: ( rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ) + // InternalScope.g:18323:2: rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 + { + pushFollow(FOLLOW_47); + rule__XSwitchExpression__Group_2_0_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1__Impl" + // InternalScope.g:18330:1: rule__XSwitchExpression__Group_2_0_0_0__1__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18334:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ) + // InternalScope.g:18335:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) + { + // InternalScope.g:18335:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) + // InternalScope.g:18336:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); + } + // InternalScope.g:18337:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) + // InternalScope.g:18337:3: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2" + // InternalScope.g:18345:1: rule__XSwitchExpression__Group_2_0_0_0__2 : rule__XSwitchExpression__Group_2_0_0_0__2__Impl ; + public final void rule__XSwitchExpression__Group_2_0_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18349:1: ( rule__XSwitchExpression__Group_2_0_0_0__2__Impl ) + // InternalScope.g:18350:2: rule__XSwitchExpression__Group_2_0_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2__Impl" + // InternalScope.g:18356:1: rule__XSwitchExpression__Group_2_0_0_0__2__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_2_0_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18360:1: ( ( ':' ) ) + // InternalScope.g:18361:1: ( ':' ) + { + // InternalScope.g:18361:1: ( ':' ) + // InternalScope.g:18362:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__0" + // InternalScope.g:18372:1: rule__XSwitchExpression__Group_2_1__0 : rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ; + public final void rule__XSwitchExpression__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18376:1: ( rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ) + // InternalScope.g:18377:2: rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 + { + pushFollow(FOLLOW_104); + rule__XSwitchExpression__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__0__Impl" + // InternalScope.g:18384:1: rule__XSwitchExpression__Group_2_1__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ; + public final void rule__XSwitchExpression__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18388:1: ( ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ) + // InternalScope.g:18389:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) + { + // InternalScope.g:18389:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) + // InternalScope.g:18390:2: ( rule__XSwitchExpression__Group_2_1_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); + } + // InternalScope.g:18391:2: ( rule__XSwitchExpression__Group_2_1_0__0 )? + int alt147=2; + alt147 = dfa147.predict(input); + switch (alt147) { + case 1 : + // InternalScope.g:18391:3: rule__XSwitchExpression__Group_2_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__1" + // InternalScope.g:18399:1: rule__XSwitchExpression__Group_2_1__1 : rule__XSwitchExpression__Group_2_1__1__Impl ; + public final void rule__XSwitchExpression__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18403:1: ( rule__XSwitchExpression__Group_2_1__1__Impl ) + // InternalScope.g:18404:2: rule__XSwitchExpression__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1__1__Impl" + // InternalScope.g:18410:1: rule__XSwitchExpression__Group_2_1__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ; + public final void rule__XSwitchExpression__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18414:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ) + // InternalScope.g:18415:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) + { + // InternalScope.g:18415:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) + // InternalScope.g:18416:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); + } + // InternalScope.g:18417:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) + // InternalScope.g:18417:3: rule__XSwitchExpression__SwitchAssignment_2_1_1 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__SwitchAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0" + // InternalScope.g:18426:1: rule__XSwitchExpression__Group_2_1_0__0 : rule__XSwitchExpression__Group_2_1_0__0__Impl ; + public final void rule__XSwitchExpression__Group_2_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18430:1: ( rule__XSwitchExpression__Group_2_1_0__0__Impl ) + // InternalScope.g:18431:2: rule__XSwitchExpression__Group_2_1_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0__Impl" + // InternalScope.g:18437:1: rule__XSwitchExpression__Group_2_1_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ; + public final void rule__XSwitchExpression__Group_2_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18441:1: ( ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ) + // InternalScope.g:18442:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) + { + // InternalScope.g:18442:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) + // InternalScope.g:18443:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); + } + // InternalScope.g:18444:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 ) + // InternalScope.g:18444:3: rule__XSwitchExpression__Group_2_1_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0" + // InternalScope.g:18453:1: rule__XSwitchExpression__Group_2_1_0_0__0 : rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ; + public final void rule__XSwitchExpression__Group_2_1_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18457:1: ( rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ) + // InternalScope.g:18458:2: rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 + { + pushFollow(FOLLOW_47); + rule__XSwitchExpression__Group_2_1_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0__Impl" + // InternalScope.g:18465:1: rule__XSwitchExpression__Group_2_1_0_0__0__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ; + public final void rule__XSwitchExpression__Group_2_1_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18469:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ) + // InternalScope.g:18470:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) + { + // InternalScope.g:18470:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) + // InternalScope.g:18471:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); + } + // InternalScope.g:18472:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) + // InternalScope.g:18472:3: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1" + // InternalScope.g:18480:1: rule__XSwitchExpression__Group_2_1_0_0__1 : rule__XSwitchExpression__Group_2_1_0_0__1__Impl ; + public final void rule__XSwitchExpression__Group_2_1_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18484:1: ( rule__XSwitchExpression__Group_2_1_0_0__1__Impl ) + // InternalScope.g:18485:2: rule__XSwitchExpression__Group_2_1_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1__Impl" + // InternalScope.g:18491:1: rule__XSwitchExpression__Group_2_1_0_0__1__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_2_1_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18495:1: ( ( ':' ) ) + // InternalScope.g:18496:1: ( ':' ) + { + // InternalScope.g:18496:1: ( ':' ) + // InternalScope.g:18497:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__0" + // InternalScope.g:18507:1: rule__XSwitchExpression__Group_5__0 : rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ; + public final void rule__XSwitchExpression__Group_5__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18511:1: ( rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ) + // InternalScope.g:18512:2: rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 + { + pushFollow(FOLLOW_47); + rule__XSwitchExpression__Group_5__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__0" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__0__Impl" + // InternalScope.g:18519:1: rule__XSwitchExpression__Group_5__0__Impl : ( 'default' ) ; + public final void rule__XSwitchExpression__Group_5__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18523:1: ( ( 'default' ) ) + // InternalScope.g:18524:1: ( 'default' ) + { + // InternalScope.g:18524:1: ( 'default' ) + // InternalScope.g:18525:2: 'default' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + match(input,101,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__0__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__1" + // InternalScope.g:18534:1: rule__XSwitchExpression__Group_5__1 : rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ; + public final void rule__XSwitchExpression__Group_5__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18538:1: ( rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ) + // InternalScope.g:18539:2: rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 + { + pushFollow(FOLLOW_104); + rule__XSwitchExpression__Group_5__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__1" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__1__Impl" + // InternalScope.g:18546:1: rule__XSwitchExpression__Group_5__1__Impl : ( ':' ) ; + public final void rule__XSwitchExpression__Group_5__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18550:1: ( ( ':' ) ) + // InternalScope.g:18551:1: ( ':' ) + { + // InternalScope.g:18551:1: ( ':' ) + // InternalScope.g:18552:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__1__Impl" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__2" + // InternalScope.g:18561:1: rule__XSwitchExpression__Group_5__2 : rule__XSwitchExpression__Group_5__2__Impl ; + public final void rule__XSwitchExpression__Group_5__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18565:1: ( rule__XSwitchExpression__Group_5__2__Impl ) + // InternalScope.g:18566:2: rule__XSwitchExpression__Group_5__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_5__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__2" + + + // $ANTLR start "rule__XSwitchExpression__Group_5__2__Impl" + // InternalScope.g:18572:1: rule__XSwitchExpression__Group_5__2__Impl : ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ; + public final void rule__XSwitchExpression__Group_5__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18576:1: ( ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ) + // InternalScope.g:18577:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) + { + // InternalScope.g:18577:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) + // InternalScope.g:18578:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); + } + // InternalScope.g:18579:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 ) + // InternalScope.g:18579:3: rule__XSwitchExpression__DefaultAssignment_5_2 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__DefaultAssignment_5_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__Group_5__2__Impl" + + + // $ANTLR start "rule__XCasePart__Group__0" + // InternalScope.g:18588:1: rule__XCasePart__Group__0 : rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ; + public final void rule__XCasePart__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18592:1: ( rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ) + // InternalScope.g:18593:2: rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 + { + pushFollow(FOLLOW_114); + rule__XCasePart__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__0" + + + // $ANTLR start "rule__XCasePart__Group__0__Impl" + // InternalScope.g:18600:1: rule__XCasePart__Group__0__Impl : ( () ) ; + public final void rule__XCasePart__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18604:1: ( ( () ) ) + // InternalScope.g:18605:1: ( () ) + { + // InternalScope.g:18605:1: ( () ) + // InternalScope.g:18606:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); + } + // InternalScope.g:18607:2: () + // InternalScope.g:18607:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group__1" + // InternalScope.g:18615:1: rule__XCasePart__Group__1 : rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ; + public final void rule__XCasePart__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18619:1: ( rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ) + // InternalScope.g:18620:2: rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 + { + pushFollow(FOLLOW_114); + rule__XCasePart__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__1" + + + // $ANTLR start "rule__XCasePart__Group__1__Impl" + // InternalScope.g:18627:1: rule__XCasePart__Group__1__Impl : ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ; + public final void rule__XCasePart__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18631:1: ( ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ) + // InternalScope.g:18632:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) + { + // InternalScope.g:18632:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) + // InternalScope.g:18633:2: ( rule__XCasePart__TypeGuardAssignment_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); + } + // InternalScope.g:18634:2: ( rule__XCasePart__TypeGuardAssignment_1 )? + int alt148=2; + int LA148_0 = input.LA(1); + + if ( (LA148_0==RULE_ID||LA148_0==51||LA148_0==77) ) { + alt148=1; + } + switch (alt148) { + case 1 : + // InternalScope.g:18634:3: rule__XCasePart__TypeGuardAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__TypeGuardAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__1__Impl" + + + // $ANTLR start "rule__XCasePart__Group__2" + // InternalScope.g:18642:1: rule__XCasePart__Group__2 : rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ; + public final void rule__XCasePart__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18646:1: ( rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ) + // InternalScope.g:18647:2: rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 + { + pushFollow(FOLLOW_114); + rule__XCasePart__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__2" + + + // $ANTLR start "rule__XCasePart__Group__2__Impl" + // InternalScope.g:18654:1: rule__XCasePart__Group__2__Impl : ( ( rule__XCasePart__Group_2__0 )? ) ; + public final void rule__XCasePart__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18658:1: ( ( ( rule__XCasePart__Group_2__0 )? ) ) + // InternalScope.g:18659:1: ( ( rule__XCasePart__Group_2__0 )? ) + { + // InternalScope.g:18659:1: ( ( rule__XCasePart__Group_2__0 )? ) + // InternalScope.g:18660:2: ( rule__XCasePart__Group_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getGroup_2()); + } + // InternalScope.g:18661:2: ( rule__XCasePart__Group_2__0 )? + int alt149=2; + int LA149_0 = input.LA(1); + + if ( (LA149_0==74) ) { + alt149=1; + } + switch (alt149) { + case 1 : + // InternalScope.g:18661:3: rule__XCasePart__Group_2__0 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__2__Impl" + + + // $ANTLR start "rule__XCasePart__Group__3" + // InternalScope.g:18669:1: rule__XCasePart__Group__3 : rule__XCasePart__Group__3__Impl ; + public final void rule__XCasePart__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18673:1: ( rule__XCasePart__Group__3__Impl ) + // InternalScope.g:18674:2: rule__XCasePart__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__3" + + + // $ANTLR start "rule__XCasePart__Group__3__Impl" + // InternalScope.g:18680:1: rule__XCasePart__Group__3__Impl : ( ( rule__XCasePart__Alternatives_3 ) ) ; + public final void rule__XCasePart__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18684:1: ( ( ( rule__XCasePart__Alternatives_3 ) ) ) + // InternalScope.g:18685:1: ( ( rule__XCasePart__Alternatives_3 ) ) + { + // InternalScope.g:18685:1: ( ( rule__XCasePart__Alternatives_3 ) ) + // InternalScope.g:18686:2: ( rule__XCasePart__Alternatives_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getAlternatives_3()); + } + // InternalScope.g:18687:2: ( rule__XCasePart__Alternatives_3 ) + // InternalScope.g:18687:3: rule__XCasePart__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__XCasePart__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getAlternatives_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group__3__Impl" + + + // $ANTLR start "rule__XCasePart__Group_2__0" + // InternalScope.g:18696:1: rule__XCasePart__Group_2__0 : rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ; + public final void rule__XCasePart__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18700:1: ( rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ) + // InternalScope.g:18701:2: rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 + { + pushFollow(FOLLOW_104); + rule__XCasePart__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__0" + + + // $ANTLR start "rule__XCasePart__Group_2__0__Impl" + // InternalScope.g:18708:1: rule__XCasePart__Group_2__0__Impl : ( 'case' ) ; + public final void rule__XCasePart__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18712:1: ( ( 'case' ) ) + // InternalScope.g:18713:1: ( 'case' ) + { + // InternalScope.g:18713:1: ( 'case' ) + // InternalScope.g:18714:2: 'case' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group_2__1" + // InternalScope.g:18723:1: rule__XCasePart__Group_2__1 : rule__XCasePart__Group_2__1__Impl ; + public final void rule__XCasePart__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18727:1: ( rule__XCasePart__Group_2__1__Impl ) + // InternalScope.g:18728:2: rule__XCasePart__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__1" + + + // $ANTLR start "rule__XCasePart__Group_2__1__Impl" + // InternalScope.g:18734:1: rule__XCasePart__Group_2__1__Impl : ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ; + public final void rule__XCasePart__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18738:1: ( ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ) + // InternalScope.g:18739:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) ) + { + // InternalScope.g:18739:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) ) + // InternalScope.g:18740:2: ( rule__XCasePart__CaseAssignment_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); + } + // InternalScope.g:18741:2: ( rule__XCasePart__CaseAssignment_2_1 ) + // InternalScope.g:18741:3: rule__XCasePart__CaseAssignment_2_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__CaseAssignment_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_2__1__Impl" + + + // $ANTLR start "rule__XCasePart__Group_3_0__0" + // InternalScope.g:18750:1: rule__XCasePart__Group_3_0__0 : rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ; + public final void rule__XCasePart__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18754:1: ( rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ) + // InternalScope.g:18755:2: rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 + { + pushFollow(FOLLOW_104); + rule__XCasePart__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__0" + + + // $ANTLR start "rule__XCasePart__Group_3_0__0__Impl" + // InternalScope.g:18762:1: rule__XCasePart__Group_3_0__0__Impl : ( ':' ) ; + public final void rule__XCasePart__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18766:1: ( ( ':' ) ) + // InternalScope.g:18767:1: ( ':' ) + { + // InternalScope.g:18767:1: ( ':' ) + // InternalScope.g:18768:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__0__Impl" + + + // $ANTLR start "rule__XCasePart__Group_3_0__1" + // InternalScope.g:18777:1: rule__XCasePart__Group_3_0__1 : rule__XCasePart__Group_3_0__1__Impl ; + public final void rule__XCasePart__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18781:1: ( rule__XCasePart__Group_3_0__1__Impl ) + // InternalScope.g:18782:2: rule__XCasePart__Group_3_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XCasePart__Group_3_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__1" + + + // $ANTLR start "rule__XCasePart__Group_3_0__1__Impl" + // InternalScope.g:18788:1: rule__XCasePart__Group_3_0__1__Impl : ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ; + public final void rule__XCasePart__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18792:1: ( ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ) + // InternalScope.g:18793:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) + { + // InternalScope.g:18793:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) + // InternalScope.g:18794:2: ( rule__XCasePart__ThenAssignment_3_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); + } + // InternalScope.g:18795:2: ( rule__XCasePart__ThenAssignment_3_0_1 ) + // InternalScope.g:18795:3: rule__XCasePart__ThenAssignment_3_0_1 + { + pushFollow(FOLLOW_2); + rule__XCasePart__ThenAssignment_3_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__Group_3_0__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__0" + // InternalScope.g:18804:1: rule__XForLoopExpression__Group__0 : rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ; + public final void rule__XForLoopExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18808:1: ( rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ) + // InternalScope.g:18809:2: rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 + { + pushFollow(FOLLOW_104); + rule__XForLoopExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__0" + + + // $ANTLR start "rule__XForLoopExpression__Group__0__Impl" + // InternalScope.g:18816:1: rule__XForLoopExpression__Group__0__Impl : ( ( rule__XForLoopExpression__Group_0__0 ) ) ; + public final void rule__XForLoopExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18820:1: ( ( ( rule__XForLoopExpression__Group_0__0 ) ) ) + // InternalScope.g:18821:1: ( ( rule__XForLoopExpression__Group_0__0 ) ) + { + // InternalScope.g:18821:1: ( ( rule__XForLoopExpression__Group_0__0 ) ) + // InternalScope.g:18822:2: ( rule__XForLoopExpression__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); + } + // InternalScope.g:18823:2: ( rule__XForLoopExpression__Group_0__0 ) + // InternalScope.g:18823:3: rule__XForLoopExpression__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__1" + // InternalScope.g:18831:1: rule__XForLoopExpression__Group__1 : rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ; + public final void rule__XForLoopExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18835:1: ( rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ) + // InternalScope.g:18836:2: rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 + { + pushFollow(FOLLOW_23); + rule__XForLoopExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__1" + + + // $ANTLR start "rule__XForLoopExpression__Group__1__Impl" + // InternalScope.g:18843:1: rule__XForLoopExpression__Group__1__Impl : ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ; + public final void rule__XForLoopExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18847:1: ( ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ) + // InternalScope.g:18848:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) + { + // InternalScope.g:18848:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) + // InternalScope.g:18849:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); + } + // InternalScope.g:18850:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 ) + // InternalScope.g:18850:3: rule__XForLoopExpression__ForExpressionAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__ForExpressionAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__2" + // InternalScope.g:18858:1: rule__XForLoopExpression__Group__2 : rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ; + public final void rule__XForLoopExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18862:1: ( rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ) + // InternalScope.g:18863:2: rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 + { + pushFollow(FOLLOW_104); + rule__XForLoopExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__2" + + + // $ANTLR start "rule__XForLoopExpression__Group__2__Impl" + // InternalScope.g:18870:1: rule__XForLoopExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XForLoopExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18874:1: ( ( ')' ) ) + // InternalScope.g:18875:1: ( ')' ) + { + // InternalScope.g:18875:1: ( ')' ) + // InternalScope.g:18876:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__2__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group__3" + // InternalScope.g:18885:1: rule__XForLoopExpression__Group__3 : rule__XForLoopExpression__Group__3__Impl ; + public final void rule__XForLoopExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18889:1: ( rule__XForLoopExpression__Group__3__Impl ) + // InternalScope.g:18890:2: rule__XForLoopExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__3" + + + // $ANTLR start "rule__XForLoopExpression__Group__3__Impl" + // InternalScope.g:18896:1: rule__XForLoopExpression__Group__3__Impl : ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ; + public final void rule__XForLoopExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18900:1: ( ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ) + // InternalScope.g:18901:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) + { + // InternalScope.g:18901:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) + // InternalScope.g:18902:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); + } + // InternalScope.g:18903:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 ) + // InternalScope.g:18903:3: rule__XForLoopExpression__EachExpressionAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__EachExpressionAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group__3__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0__0" + // InternalScope.g:18912:1: rule__XForLoopExpression__Group_0__0 : rule__XForLoopExpression__Group_0__0__Impl ; + public final void rule__XForLoopExpression__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18916:1: ( rule__XForLoopExpression__Group_0__0__Impl ) + // InternalScope.g:18917:2: rule__XForLoopExpression__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0__0" + + + // $ANTLR start "rule__XForLoopExpression__Group_0__0__Impl" + // InternalScope.g:18923:1: rule__XForLoopExpression__Group_0__0__Impl : ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ; + public final void rule__XForLoopExpression__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18927:1: ( ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ) + // InternalScope.g:18928:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) ) + { + // InternalScope.g:18928:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) ) + // InternalScope.g:18929:2: ( rule__XForLoopExpression__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); + } + // InternalScope.g:18930:2: ( rule__XForLoopExpression__Group_0_0__0 ) + // InternalScope.g:18930:3: rule__XForLoopExpression__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__0" + // InternalScope.g:18939:1: rule__XForLoopExpression__Group_0_0__0 : rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ; + public final void rule__XForLoopExpression__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18943:1: ( rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ) + // InternalScope.g:18944:2: rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 + { + pushFollow(FOLLOW_115); + rule__XForLoopExpression__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__0" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__0__Impl" + // InternalScope.g:18951:1: rule__XForLoopExpression__Group_0_0__0__Impl : ( () ) ; + public final void rule__XForLoopExpression__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18955:1: ( ( () ) ) + // InternalScope.g:18956:1: ( () ) + { + // InternalScope.g:18956:1: ( () ) + // InternalScope.g:18957:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); + } + // InternalScope.g:18958:2: () + // InternalScope.g:18958:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__1" + // InternalScope.g:18966:1: rule__XForLoopExpression__Group_0_0__1 : rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ; + public final void rule__XForLoopExpression__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18970:1: ( rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ) + // InternalScope.g:18971:2: rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 + { + pushFollow(FOLLOW_31); + rule__XForLoopExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__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__XForLoopExpression__Group_0_0__1" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__1__Impl" + // InternalScope.g:18978:1: rule__XForLoopExpression__Group_0_0__1__Impl : ( 'for' ) ; + public final void rule__XForLoopExpression__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18982:1: ( ( 'for' ) ) + // InternalScope.g:18983:1: ( 'for' ) + { + // InternalScope.g:18983:1: ( 'for' ) + // InternalScope.g:18984:2: 'for' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + match(input,105,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__2" + // InternalScope.g:18993:1: rule__XForLoopExpression__Group_0_0__2 : rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ; + public final void rule__XForLoopExpression__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:18997:1: ( rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ) + // InternalScope.g:18998:2: rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 + { + pushFollow(FOLLOW_84); + rule__XForLoopExpression__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__2" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__2__Impl" + // InternalScope.g:19005:1: rule__XForLoopExpression__Group_0_0__2__Impl : ( '(' ) ; + public final void rule__XForLoopExpression__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19009:1: ( ( '(' ) ) + // InternalScope.g:19010:1: ( '(' ) + { + // InternalScope.g:19010:1: ( '(' ) + // InternalScope.g:19011:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__3" + // InternalScope.g:19020:1: rule__XForLoopExpression__Group_0_0__3 : rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ; + public final void rule__XForLoopExpression__Group_0_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19024:1: ( rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ) + // InternalScope.g:19025:2: rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 + { + pushFollow(FOLLOW_47); + rule__XForLoopExpression__Group_0_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__3" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__3__Impl" + // InternalScope.g:19032:1: rule__XForLoopExpression__Group_0_0__3__Impl : ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ; + public final void rule__XForLoopExpression__Group_0_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19036:1: ( ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ) + // InternalScope.g:19037:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) + { + // InternalScope.g:19037:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) + // InternalScope.g:19038:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); + } + // InternalScope.g:19039:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) + // InternalScope.g:19039:3: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__DeclaredParamAssignment_0_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__3__Impl" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__4" + // InternalScope.g:19047:1: rule__XForLoopExpression__Group_0_0__4 : rule__XForLoopExpression__Group_0_0__4__Impl ; + public final void rule__XForLoopExpression__Group_0_0__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19051:1: ( rule__XForLoopExpression__Group_0_0__4__Impl ) + // InternalScope.g:19052:2: rule__XForLoopExpression__Group_0_0__4__Impl + { + pushFollow(FOLLOW_2); + rule__XForLoopExpression__Group_0_0__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__4" + + + // $ANTLR start "rule__XForLoopExpression__Group_0_0__4__Impl" + // InternalScope.g:19058:1: rule__XForLoopExpression__Group_0_0__4__Impl : ( ':' ) ; + public final void rule__XForLoopExpression__Group_0_0__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19062:1: ( ( ':' ) ) + // InternalScope.g:19063:1: ( ':' ) + { + // InternalScope.g:19063:1: ( ':' ) + // InternalScope.g:19064:2: ':' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + match(input,95,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__Group_0_0__4__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__0" + // InternalScope.g:19074:1: rule__XBasicForLoopExpression__Group__0 : rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ; + public final void rule__XBasicForLoopExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19078:1: ( rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ) + // InternalScope.g:19079:2: rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 + { + pushFollow(FOLLOW_115); + rule__XBasicForLoopExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__0__Impl" + // InternalScope.g:19086:1: rule__XBasicForLoopExpression__Group__0__Impl : ( () ) ; + public final void rule__XBasicForLoopExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19090:1: ( ( () ) ) + // InternalScope.g:19091:1: ( () ) + { + // InternalScope.g:19091:1: ( () ) + // InternalScope.g:19092:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); + } + // InternalScope.g:19093:2: () + // InternalScope.g:19093:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__1" + // InternalScope.g:19101:1: rule__XBasicForLoopExpression__Group__1 : rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ; + public final void rule__XBasicForLoopExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19105:1: ( rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ) + // InternalScope.g:19106:2: rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 + { + pushFollow(FOLLOW_31); + rule__XBasicForLoopExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__1__Impl" + // InternalScope.g:19113:1: rule__XBasicForLoopExpression__Group__1__Impl : ( 'for' ) ; + public final void rule__XBasicForLoopExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19117:1: ( ( 'for' ) ) + // InternalScope.g:19118:1: ( 'for' ) + { + // InternalScope.g:19118:1: ( 'for' ) + // InternalScope.g:19119:2: 'for' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + match(input,105,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__2" + // InternalScope.g:19128:1: rule__XBasicForLoopExpression__Group__2 : rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ; + public final void rule__XBasicForLoopExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19132:1: ( rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ) + // InternalScope.g:19133:2: rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 + { + pushFollow(FOLLOW_116); + rule__XBasicForLoopExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__2" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__2__Impl" + // InternalScope.g:19140:1: rule__XBasicForLoopExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XBasicForLoopExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19144:1: ( ( '(' ) ) + // InternalScope.g:19145:1: ( '(' ) + { + // InternalScope.g:19145:1: ( '(' ) + // InternalScope.g:19146:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__2__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__3" + // InternalScope.g:19155:1: rule__XBasicForLoopExpression__Group__3 : rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ; + public final void rule__XBasicForLoopExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19159:1: ( rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ) + // InternalScope.g:19160:2: rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 + { + pushFollow(FOLLOW_116); + rule__XBasicForLoopExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__3" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__3__Impl" + // InternalScope.g:19167:1: rule__XBasicForLoopExpression__Group__3__Impl : ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ; + public final void rule__XBasicForLoopExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19171:1: ( ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ) + // InternalScope.g:19172:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) + { + // InternalScope.g:19172:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) + // InternalScope.g:19173:2: ( rule__XBasicForLoopExpression__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); + } + // InternalScope.g:19174:2: ( rule__XBasicForLoopExpression__Group_3__0 )? + int alt150=2; + int LA150_0 = input.LA(1); + + if ( ((LA150_0>=RULE_ID && LA150_0<=RULE_STRING)||(LA150_0>=22 && LA150_0<=24)||LA150_0==27||(LA150_0>=36 && LA150_0<=37)||(LA150_0>=59 && LA150_0<=64)||LA150_0==72||LA150_0==77||LA150_0==79||LA150_0==82||LA150_0==97||LA150_0==100||LA150_0==103||(LA150_0>=105 && LA150_0<=112)||LA150_0==114||LA150_0==122) ) { + alt150=1; + } + switch (alt150) { + case 1 : + // InternalScope.g:19174:3: rule__XBasicForLoopExpression__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__3__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__4" + // InternalScope.g:19182:1: rule__XBasicForLoopExpression__Group__4 : rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ; + public final void rule__XBasicForLoopExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19186:1: ( rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ) + // InternalScope.g:19187:2: rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 + { + pushFollow(FOLLOW_117); + rule__XBasicForLoopExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__4" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__4__Impl" + // InternalScope.g:19194:1: rule__XBasicForLoopExpression__Group__4__Impl : ( ';' ) ; + public final void rule__XBasicForLoopExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19198:1: ( ( ';' ) ) + // InternalScope.g:19199:1: ( ';' ) + { + // InternalScope.g:19199:1: ( ';' ) + // InternalScope.g:19200:2: ';' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + match(input,75,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__4__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__5" + // InternalScope.g:19209:1: rule__XBasicForLoopExpression__Group__5 : rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ; + public final void rule__XBasicForLoopExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19213:1: ( rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ) + // InternalScope.g:19214:2: rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 + { + pushFollow(FOLLOW_117); + rule__XBasicForLoopExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__5" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__5__Impl" + // InternalScope.g:19221:1: rule__XBasicForLoopExpression__Group__5__Impl : ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ; + public final void rule__XBasicForLoopExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19225:1: ( ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ) + // InternalScope.g:19226:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) + { + // InternalScope.g:19226:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) + // InternalScope.g:19227:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); + } + // InternalScope.g:19228:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? + int alt151=2; + int LA151_0 = input.LA(1); + + if ( ((LA151_0>=RULE_ID && LA151_0<=RULE_STRING)||(LA151_0>=22 && LA151_0<=24)||LA151_0==27||(LA151_0>=36 && LA151_0<=37)||(LA151_0>=60 && LA151_0<=64)||LA151_0==72||LA151_0==77||LA151_0==79||LA151_0==82||LA151_0==97||LA151_0==100||LA151_0==103||(LA151_0>=105 && LA151_0<=112)||LA151_0==114) ) { + alt151=1; + } + switch (alt151) { + case 1 : + // InternalScope.g:19228:3: rule__XBasicForLoopExpression__ExpressionAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__ExpressionAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__5__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__6" + // InternalScope.g:19236:1: rule__XBasicForLoopExpression__Group__6 : rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ; + public final void rule__XBasicForLoopExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19240:1: ( rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ) + // InternalScope.g:19241:2: rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 + { + pushFollow(FOLLOW_103); + rule__XBasicForLoopExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__7(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__6" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__6__Impl" + // InternalScope.g:19248:1: rule__XBasicForLoopExpression__Group__6__Impl : ( ';' ) ; + public final void rule__XBasicForLoopExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19252:1: ( ( ';' ) ) + // InternalScope.g:19253:1: ( ';' ) + { + // InternalScope.g:19253:1: ( ';' ) + // InternalScope.g:19254:2: ';' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + match(input,75,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__6__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__7" + // InternalScope.g:19263:1: rule__XBasicForLoopExpression__Group__7 : rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ; + public final void rule__XBasicForLoopExpression__Group__7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19267:1: ( rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ) + // InternalScope.g:19268:2: rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 + { + pushFollow(FOLLOW_103); + rule__XBasicForLoopExpression__Group__7__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__8(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__7" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__7__Impl" + // InternalScope.g:19275:1: rule__XBasicForLoopExpression__Group__7__Impl : ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ; + public final void rule__XBasicForLoopExpression__Group__7__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19279:1: ( ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ) + // InternalScope.g:19280:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) + { + // InternalScope.g:19280:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) + // InternalScope.g:19281:2: ( rule__XBasicForLoopExpression__Group_7__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); + } + // InternalScope.g:19282:2: ( rule__XBasicForLoopExpression__Group_7__0 )? + int alt152=2; + int LA152_0 = input.LA(1); + + if ( ((LA152_0>=RULE_ID && LA152_0<=RULE_STRING)||(LA152_0>=22 && LA152_0<=24)||LA152_0==27||(LA152_0>=36 && LA152_0<=37)||(LA152_0>=60 && LA152_0<=64)||LA152_0==72||LA152_0==77||LA152_0==79||LA152_0==82||LA152_0==97||LA152_0==100||LA152_0==103||(LA152_0>=105 && LA152_0<=112)||LA152_0==114) ) { + alt152=1; + } + switch (alt152) { + case 1 : + // InternalScope.g:19282:3: rule__XBasicForLoopExpression__Group_7__0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__7__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__8" + // InternalScope.g:19290:1: rule__XBasicForLoopExpression__Group__8 : rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ; + public final void rule__XBasicForLoopExpression__Group__8() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19294:1: ( rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ) + // InternalScope.g:19295:2: rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 + { + pushFollow(FOLLOW_104); + rule__XBasicForLoopExpression__Group__8__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__9(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__8" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__8__Impl" + // InternalScope.g:19302:1: rule__XBasicForLoopExpression__Group__8__Impl : ( ')' ) ; + public final void rule__XBasicForLoopExpression__Group__8__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19306:1: ( ( ')' ) ) + // InternalScope.g:19307:1: ( ')' ) + { + // InternalScope.g:19307:1: ( ')' ) + // InternalScope.g:19308:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__8__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__9" + // InternalScope.g:19317:1: rule__XBasicForLoopExpression__Group__9 : rule__XBasicForLoopExpression__Group__9__Impl ; + public final void rule__XBasicForLoopExpression__Group__9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19321:1: ( rule__XBasicForLoopExpression__Group__9__Impl ) + // InternalScope.g:19322:2: rule__XBasicForLoopExpression__Group__9__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group__9__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__9" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group__9__Impl" + // InternalScope.g:19328:1: rule__XBasicForLoopExpression__Group__9__Impl : ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ; + public final void rule__XBasicForLoopExpression__Group__9__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19332:1: ( ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ) + // InternalScope.g:19333:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) + { + // InternalScope.g:19333:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) + // InternalScope.g:19334:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); + } + // InternalScope.g:19335:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) + // InternalScope.g:19335:3: rule__XBasicForLoopExpression__EachExpressionAssignment_9 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__EachExpressionAssignment_9(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group__9__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0" + // InternalScope.g:19344:1: rule__XBasicForLoopExpression__Group_3__0 : rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ; + public final void rule__XBasicForLoopExpression__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19348:1: ( rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ) + // InternalScope.g:19349:2: rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 + { + pushFollow(FOLLOW_71); + rule__XBasicForLoopExpression__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0__Impl" + // InternalScope.g:19356:1: rule__XBasicForLoopExpression__Group_3__0__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ; + public final void rule__XBasicForLoopExpression__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19360:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ) + // InternalScope.g:19361:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) + { + // InternalScope.g:19361:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) + // InternalScope.g:19362:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); + } + // InternalScope.g:19363:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) + // InternalScope.g:19363:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1" + // InternalScope.g:19371:1: rule__XBasicForLoopExpression__Group_3__1 : rule__XBasicForLoopExpression__Group_3__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19375:1: ( rule__XBasicForLoopExpression__Group_3__1__Impl ) + // InternalScope.g:19376:2: rule__XBasicForLoopExpression__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1__Impl" + // InternalScope.g:19382:1: rule__XBasicForLoopExpression__Group_3__1__Impl : ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ; + public final void rule__XBasicForLoopExpression__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19386:1: ( ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ) + // InternalScope.g:19387:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) + { + // InternalScope.g:19387:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) + // InternalScope.g:19388:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); + } + // InternalScope.g:19389:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )* + loop153: + do { + int alt153=2; + int LA153_0 = input.LA(1); + + if ( (LA153_0==86) ) { + alt153=1; + } + + + switch (alt153) { + case 1 : + // InternalScope.g:19389:3: rule__XBasicForLoopExpression__Group_3_1__0 + { + pushFollow(FOLLOW_39); + rule__XBasicForLoopExpression__Group_3_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop153; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0" + // InternalScope.g:19398:1: rule__XBasicForLoopExpression__Group_3_1__0 : rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ; + public final void rule__XBasicForLoopExpression__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19402:1: ( rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ) + // InternalScope.g:19403:2: rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 + { + pushFollow(FOLLOW_107); + rule__XBasicForLoopExpression__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0__Impl" + // InternalScope.g:19410:1: rule__XBasicForLoopExpression__Group_3_1__0__Impl : ( ',' ) ; + public final void rule__XBasicForLoopExpression__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19414:1: ( ( ',' ) ) + // InternalScope.g:19415:1: ( ',' ) + { + // InternalScope.g:19415:1: ( ',' ) + // InternalScope.g:19416:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1" + // InternalScope.g:19425:1: rule__XBasicForLoopExpression__Group_3_1__1 : rule__XBasicForLoopExpression__Group_3_1__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19429:1: ( rule__XBasicForLoopExpression__Group_3_1__1__Impl ) + // InternalScope.g:19430:2: rule__XBasicForLoopExpression__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1__Impl" + // InternalScope.g:19436:1: rule__XBasicForLoopExpression__Group_3_1__1__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ; + public final void rule__XBasicForLoopExpression__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19440:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ) + // InternalScope.g:19441:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) + { + // InternalScope.g:19441:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) + // InternalScope.g:19442:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); + } + // InternalScope.g:19443:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) + // InternalScope.g:19443:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0" + // InternalScope.g:19452:1: rule__XBasicForLoopExpression__Group_7__0 : rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ; + public final void rule__XBasicForLoopExpression__Group_7__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19456:1: ( rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ) + // InternalScope.g:19457:2: rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 + { + pushFollow(FOLLOW_71); + rule__XBasicForLoopExpression__Group_7__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0__Impl" + // InternalScope.g:19464:1: rule__XBasicForLoopExpression__Group_7__0__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ; + public final void rule__XBasicForLoopExpression__Group_7__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19468:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ) + // InternalScope.g:19469:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) + { + // InternalScope.g:19469:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) + // InternalScope.g:19470:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); + } + // InternalScope.g:19471:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) + // InternalScope.g:19471:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1" + // InternalScope.g:19479:1: rule__XBasicForLoopExpression__Group_7__1 : rule__XBasicForLoopExpression__Group_7__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_7__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19483:1: ( rule__XBasicForLoopExpression__Group_7__1__Impl ) + // InternalScope.g:19484:2: rule__XBasicForLoopExpression__Group_7__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1__Impl" + // InternalScope.g:19490:1: rule__XBasicForLoopExpression__Group_7__1__Impl : ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ; + public final void rule__XBasicForLoopExpression__Group_7__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19494:1: ( ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ) + // InternalScope.g:19495:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) + { + // InternalScope.g:19495:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) + // InternalScope.g:19496:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); + } + // InternalScope.g:19497:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )* + loop154: + do { + int alt154=2; + int LA154_0 = input.LA(1); + + if ( (LA154_0==86) ) { + alt154=1; + } + + + switch (alt154) { + case 1 : + // InternalScope.g:19497:3: rule__XBasicForLoopExpression__Group_7_1__0 + { + pushFollow(FOLLOW_39); + rule__XBasicForLoopExpression__Group_7_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop154; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0" + // InternalScope.g:19506:1: rule__XBasicForLoopExpression__Group_7_1__0 : rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ; + public final void rule__XBasicForLoopExpression__Group_7_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19510:1: ( rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ) + // InternalScope.g:19511:2: rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 + { + pushFollow(FOLLOW_104); + rule__XBasicForLoopExpression__Group_7_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0__Impl" + // InternalScope.g:19518:1: rule__XBasicForLoopExpression__Group_7_1__0__Impl : ( ',' ) ; + public final void rule__XBasicForLoopExpression__Group_7_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19522:1: ( ( ',' ) ) + // InternalScope.g:19523:1: ( ',' ) + { + // InternalScope.g:19523:1: ( ',' ) + // InternalScope.g:19524:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0__Impl" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1" + // InternalScope.g:19533:1: rule__XBasicForLoopExpression__Group_7_1__1 : rule__XBasicForLoopExpression__Group_7_1__1__Impl ; + public final void rule__XBasicForLoopExpression__Group_7_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19537:1: ( rule__XBasicForLoopExpression__Group_7_1__1__Impl ) + // InternalScope.g:19538:2: rule__XBasicForLoopExpression__Group_7_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__Group_7_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1" + + + // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1__Impl" + // InternalScope.g:19544:1: rule__XBasicForLoopExpression__Group_7_1__1__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ; + public final void rule__XBasicForLoopExpression__Group_7_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19548:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ) + // InternalScope.g:19549:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) + { + // InternalScope.g:19549:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) + // InternalScope.g:19550:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); + } + // InternalScope.g:19551:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) + // InternalScope.g:19551:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 + { + pushFollow(FOLLOW_2); + rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__0" + // InternalScope.g:19560:1: rule__XWhileExpression__Group__0 : rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ; + public final void rule__XWhileExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19564:1: ( rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ) + // InternalScope.g:19565:2: rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 + { + pushFollow(FOLLOW_118); + rule__XWhileExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__0" + + + // $ANTLR start "rule__XWhileExpression__Group__0__Impl" + // InternalScope.g:19572:1: rule__XWhileExpression__Group__0__Impl : ( () ) ; + public final void rule__XWhileExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19576:1: ( ( () ) ) + // InternalScope.g:19577:1: ( () ) + { + // InternalScope.g:19577:1: ( () ) + // InternalScope.g:19578:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); + } + // InternalScope.g:19579:2: () + // InternalScope.g:19579:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__0__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__1" + // InternalScope.g:19587:1: rule__XWhileExpression__Group__1 : rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ; + public final void rule__XWhileExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19591:1: ( rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ) + // InternalScope.g:19592:2: rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 + { + pushFollow(FOLLOW_31); + rule__XWhileExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__1" + + + // $ANTLR start "rule__XWhileExpression__Group__1__Impl" + // InternalScope.g:19599:1: rule__XWhileExpression__Group__1__Impl : ( 'while' ) ; + public final void rule__XWhileExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19603:1: ( ( 'while' ) ) + // InternalScope.g:19604:1: ( 'while' ) + { + // InternalScope.g:19604:1: ( 'while' ) + // InternalScope.g:19605:2: 'while' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + match(input,106,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__1__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__2" + // InternalScope.g:19614:1: rule__XWhileExpression__Group__2 : rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ; + public final void rule__XWhileExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19618:1: ( rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ) + // InternalScope.g:19619:2: rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 + { + pushFollow(FOLLOW_104); + rule__XWhileExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__2" + + + // $ANTLR start "rule__XWhileExpression__Group__2__Impl" + // InternalScope.g:19626:1: rule__XWhileExpression__Group__2__Impl : ( '(' ) ; + public final void rule__XWhileExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19630:1: ( ( '(' ) ) + // InternalScope.g:19631:1: ( '(' ) + { + // InternalScope.g:19631:1: ( '(' ) + // InternalScope.g:19632:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__2__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__3" + // InternalScope.g:19641:1: rule__XWhileExpression__Group__3 : rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ; + public final void rule__XWhileExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19645:1: ( rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ) + // InternalScope.g:19646:2: rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 + { + pushFollow(FOLLOW_23); + rule__XWhileExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__3" + + + // $ANTLR start "rule__XWhileExpression__Group__3__Impl" + // InternalScope.g:19653:1: rule__XWhileExpression__Group__3__Impl : ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ; + public final void rule__XWhileExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19657:1: ( ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ) + // InternalScope.g:19658:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) + { + // InternalScope.g:19658:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) + // InternalScope.g:19659:2: ( rule__XWhileExpression__PredicateAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); + } + // InternalScope.g:19660:2: ( rule__XWhileExpression__PredicateAssignment_3 ) + // InternalScope.g:19660:3: rule__XWhileExpression__PredicateAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__PredicateAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__3__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__4" + // InternalScope.g:19668:1: rule__XWhileExpression__Group__4 : rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ; + public final void rule__XWhileExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19672:1: ( rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ) + // InternalScope.g:19673:2: rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 + { + pushFollow(FOLLOW_104); + rule__XWhileExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__4" + + + // $ANTLR start "rule__XWhileExpression__Group__4__Impl" + // InternalScope.g:19680:1: rule__XWhileExpression__Group__4__Impl : ( ')' ) ; + public final void rule__XWhileExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19684:1: ( ( ')' ) ) + // InternalScope.g:19685:1: ( ')' ) + { + // InternalScope.g:19685:1: ( ')' ) + // InternalScope.g:19686:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__4__Impl" + + + // $ANTLR start "rule__XWhileExpression__Group__5" + // InternalScope.g:19695:1: rule__XWhileExpression__Group__5 : rule__XWhileExpression__Group__5__Impl ; + public final void rule__XWhileExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19699:1: ( rule__XWhileExpression__Group__5__Impl ) + // InternalScope.g:19700:2: rule__XWhileExpression__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__5" + + + // $ANTLR start "rule__XWhileExpression__Group__5__Impl" + // InternalScope.g:19706:1: rule__XWhileExpression__Group__5__Impl : ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ; + public final void rule__XWhileExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19710:1: ( ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ) + // InternalScope.g:19711:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) ) + { + // InternalScope.g:19711:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) ) + // InternalScope.g:19712:2: ( rule__XWhileExpression__BodyAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); + } + // InternalScope.g:19713:2: ( rule__XWhileExpression__BodyAssignment_5 ) + // InternalScope.g:19713:3: rule__XWhileExpression__BodyAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XWhileExpression__BodyAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__Group__5__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__0" + // InternalScope.g:19722:1: rule__XDoWhileExpression__Group__0 : rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ; + public final void rule__XDoWhileExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19726:1: ( rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ) + // InternalScope.g:19727:2: rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 + { + pushFollow(FOLLOW_119); + rule__XDoWhileExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__0" + + + // $ANTLR start "rule__XDoWhileExpression__Group__0__Impl" + // InternalScope.g:19734:1: rule__XDoWhileExpression__Group__0__Impl : ( () ) ; + public final void rule__XDoWhileExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19738:1: ( ( () ) ) + // InternalScope.g:19739:1: ( () ) + { + // InternalScope.g:19739:1: ( () ) + // InternalScope.g:19740:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); + } + // InternalScope.g:19741:2: () + // InternalScope.g:19741:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__0__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__1" + // InternalScope.g:19749:1: rule__XDoWhileExpression__Group__1 : rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ; + public final void rule__XDoWhileExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19753:1: ( rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ) + // InternalScope.g:19754:2: rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 + { + pushFollow(FOLLOW_104); + rule__XDoWhileExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__1" + + + // $ANTLR start "rule__XDoWhileExpression__Group__1__Impl" + // InternalScope.g:19761:1: rule__XDoWhileExpression__Group__1__Impl : ( 'do' ) ; + public final void rule__XDoWhileExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19765:1: ( ( 'do' ) ) + // InternalScope.g:19766:1: ( 'do' ) + { + // InternalScope.g:19766:1: ( 'do' ) + // InternalScope.g:19767:2: 'do' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + match(input,107,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__1__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__2" + // InternalScope.g:19776:1: rule__XDoWhileExpression__Group__2 : rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ; + public final void rule__XDoWhileExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19780:1: ( rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ) + // InternalScope.g:19781:2: rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 + { + pushFollow(FOLLOW_118); + rule__XDoWhileExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__2" + + + // $ANTLR start "rule__XDoWhileExpression__Group__2__Impl" + // InternalScope.g:19788:1: rule__XDoWhileExpression__Group__2__Impl : ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ; + public final void rule__XDoWhileExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19792:1: ( ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ) + // InternalScope.g:19793:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) + { + // InternalScope.g:19793:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) + // InternalScope.g:19794:2: ( rule__XDoWhileExpression__BodyAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); + } + // InternalScope.g:19795:2: ( rule__XDoWhileExpression__BodyAssignment_2 ) + // InternalScope.g:19795:3: rule__XDoWhileExpression__BodyAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__BodyAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__2__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__3" + // InternalScope.g:19803:1: rule__XDoWhileExpression__Group__3 : rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ; + public final void rule__XDoWhileExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19807:1: ( rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ) + // InternalScope.g:19808:2: rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 + { + pushFollow(FOLLOW_31); + rule__XDoWhileExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__3" + + + // $ANTLR start "rule__XDoWhileExpression__Group__3__Impl" + // InternalScope.g:19815:1: rule__XDoWhileExpression__Group__3__Impl : ( 'while' ) ; + public final void rule__XDoWhileExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19819:1: ( ( 'while' ) ) + // InternalScope.g:19820:1: ( 'while' ) + { + // InternalScope.g:19820:1: ( 'while' ) + // InternalScope.g:19821:2: 'while' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + match(input,106,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__3__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__4" + // InternalScope.g:19830:1: rule__XDoWhileExpression__Group__4 : rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ; + public final void rule__XDoWhileExpression__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19834:1: ( rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ) + // InternalScope.g:19835:2: rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 + { + pushFollow(FOLLOW_104); + rule__XDoWhileExpression__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__4" + + + // $ANTLR start "rule__XDoWhileExpression__Group__4__Impl" + // InternalScope.g:19842:1: rule__XDoWhileExpression__Group__4__Impl : ( '(' ) ; + public final void rule__XDoWhileExpression__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19846:1: ( ( '(' ) ) + // InternalScope.g:19847:1: ( '(' ) + { + // InternalScope.g:19847:1: ( '(' ) + // InternalScope.g:19848:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__4__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__5" + // InternalScope.g:19857:1: rule__XDoWhileExpression__Group__5 : rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ; + public final void rule__XDoWhileExpression__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19861:1: ( rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ) + // InternalScope.g:19862:2: rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 + { + pushFollow(FOLLOW_23); + rule__XDoWhileExpression__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__6(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__5" + + + // $ANTLR start "rule__XDoWhileExpression__Group__5__Impl" + // InternalScope.g:19869:1: rule__XDoWhileExpression__Group__5__Impl : ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ; + public final void rule__XDoWhileExpression__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19873:1: ( ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ) + // InternalScope.g:19874:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) + { + // InternalScope.g:19874:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) + // InternalScope.g:19875:2: ( rule__XDoWhileExpression__PredicateAssignment_5 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); + } + // InternalScope.g:19876:2: ( rule__XDoWhileExpression__PredicateAssignment_5 ) + // InternalScope.g:19876:3: rule__XDoWhileExpression__PredicateAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__PredicateAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__5__Impl" + + + // $ANTLR start "rule__XDoWhileExpression__Group__6" + // InternalScope.g:19884:1: rule__XDoWhileExpression__Group__6 : rule__XDoWhileExpression__Group__6__Impl ; + public final void rule__XDoWhileExpression__Group__6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19888:1: ( rule__XDoWhileExpression__Group__6__Impl ) + // InternalScope.g:19889:2: rule__XDoWhileExpression__Group__6__Impl + { + pushFollow(FOLLOW_2); + rule__XDoWhileExpression__Group__6__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__6" + + + // $ANTLR start "rule__XDoWhileExpression__Group__6__Impl" + // InternalScope.g:19895:1: rule__XDoWhileExpression__Group__6__Impl : ( ')' ) ; + public final void rule__XDoWhileExpression__Group__6__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19899:1: ( ( ')' ) ) + // InternalScope.g:19900:1: ( ')' ) + { + // InternalScope.g:19900:1: ( ')' ) + // InternalScope.g:19901:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__Group__6__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__0" + // InternalScope.g:19911:1: rule__XBlockExpression__Group__0 : rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ; + public final void rule__XBlockExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19915:1: ( rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ) + // InternalScope.g:19916:2: rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 + { + pushFollow(FOLLOW_13); + rule__XBlockExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__0" + + + // $ANTLR start "rule__XBlockExpression__Group__0__Impl" + // InternalScope.g:19923:1: rule__XBlockExpression__Group__0__Impl : ( () ) ; + public final void rule__XBlockExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19927:1: ( ( () ) ) + // InternalScope.g:19928:1: ( () ) + { + // InternalScope.g:19928:1: ( () ) + // InternalScope.g:19929:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); + } + // InternalScope.g:19930:2: () + // InternalScope.g:19930:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__0__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__1" + // InternalScope.g:19938:1: rule__XBlockExpression__Group__1 : rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ; + public final void rule__XBlockExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19942:1: ( rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ) + // InternalScope.g:19943:2: rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 + { + pushFollow(FOLLOW_120); + rule__XBlockExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__1" + + + // $ANTLR start "rule__XBlockExpression__Group__1__Impl" + // InternalScope.g:19950:1: rule__XBlockExpression__Group__1__Impl : ( '{' ) ; + public final void rule__XBlockExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19954:1: ( ( '{' ) ) + // InternalScope.g:19955:1: ( '{' ) + { + // InternalScope.g:19955:1: ( '{' ) + // InternalScope.g:19956:2: '{' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + match(input,72,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__1__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__2" + // InternalScope.g:19965:1: rule__XBlockExpression__Group__2 : rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ; + public final void rule__XBlockExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19969:1: ( rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ) + // InternalScope.g:19970:2: rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 + { + pushFollow(FOLLOW_120); + rule__XBlockExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__2" + + + // $ANTLR start "rule__XBlockExpression__Group__2__Impl" + // InternalScope.g:19977:1: rule__XBlockExpression__Group__2__Impl : ( ( rule__XBlockExpression__Group_2__0 )* ) ; + public final void rule__XBlockExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19981:1: ( ( ( rule__XBlockExpression__Group_2__0 )* ) ) + // InternalScope.g:19982:1: ( ( rule__XBlockExpression__Group_2__0 )* ) + { + // InternalScope.g:19982:1: ( ( rule__XBlockExpression__Group_2__0 )* ) + // InternalScope.g:19983:2: ( rule__XBlockExpression__Group_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); + } + // InternalScope.g:19984:2: ( rule__XBlockExpression__Group_2__0 )* + loop155: + do { + int alt155=2; + int LA155_0 = input.LA(1); + + if ( ((LA155_0>=RULE_ID && LA155_0<=RULE_STRING)||(LA155_0>=22 && LA155_0<=24)||LA155_0==27||(LA155_0>=36 && LA155_0<=37)||(LA155_0>=59 && LA155_0<=64)||LA155_0==72||LA155_0==77||LA155_0==79||LA155_0==82||LA155_0==97||LA155_0==100||LA155_0==103||(LA155_0>=105 && LA155_0<=112)||LA155_0==114||LA155_0==122) ) { + alt155=1; + } + + + switch (alt155) { + case 1 : + // InternalScope.g:19984:3: rule__XBlockExpression__Group_2__0 + { + pushFollow(FOLLOW_109); + rule__XBlockExpression__Group_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop155; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__2__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group__3" + // InternalScope.g:19992:1: rule__XBlockExpression__Group__3 : rule__XBlockExpression__Group__3__Impl ; + public final void rule__XBlockExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:19996:1: ( rule__XBlockExpression__Group__3__Impl ) + // InternalScope.g:19997:2: rule__XBlockExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__3" + + + // $ANTLR start "rule__XBlockExpression__Group__3__Impl" + // InternalScope.g:20003:1: rule__XBlockExpression__Group__3__Impl : ( '}' ) ; + public final void rule__XBlockExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20007:1: ( ( '}' ) ) + // InternalScope.g:20008:1: ( '}' ) + { + // InternalScope.g:20008:1: ( '}' ) + // InternalScope.g:20009:2: '}' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + match(input,73,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group__3__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group_2__0" + // InternalScope.g:20019:1: rule__XBlockExpression__Group_2__0 : rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ; + public final void rule__XBlockExpression__Group_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20023:1: ( rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ) + // InternalScope.g:20024:2: rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 + { + pushFollow(FOLLOW_18); + rule__XBlockExpression__Group_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__0" + + + // $ANTLR start "rule__XBlockExpression__Group_2__0__Impl" + // InternalScope.g:20031:1: rule__XBlockExpression__Group_2__0__Impl : ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ; + public final void rule__XBlockExpression__Group_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20035:1: ( ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ) + // InternalScope.g:20036:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) + { + // InternalScope.g:20036:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) + // InternalScope.g:20037:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); + } + // InternalScope.g:20038:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) + // InternalScope.g:20038:3: rule__XBlockExpression__ExpressionsAssignment_2_0 + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__ExpressionsAssignment_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__0__Impl" + + + // $ANTLR start "rule__XBlockExpression__Group_2__1" + // InternalScope.g:20046:1: rule__XBlockExpression__Group_2__1 : rule__XBlockExpression__Group_2__1__Impl ; + public final void rule__XBlockExpression__Group_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20050:1: ( rule__XBlockExpression__Group_2__1__Impl ) + // InternalScope.g:20051:2: rule__XBlockExpression__Group_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBlockExpression__Group_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__1" + + + // $ANTLR start "rule__XBlockExpression__Group_2__1__Impl" + // InternalScope.g:20057:1: rule__XBlockExpression__Group_2__1__Impl : ( ( ';' )? ) ; + public final void rule__XBlockExpression__Group_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20061:1: ( ( ( ';' )? ) ) + // InternalScope.g:20062:1: ( ( ';' )? ) + { + // InternalScope.g:20062:1: ( ( ';' )? ) + // InternalScope.g:20063:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + // InternalScope.g:20064:2: ( ';' )? + int alt156=2; + int LA156_0 = input.LA(1); + + if ( (LA156_0==75) ) { + alt156=1; + } + switch (alt156) { + case 1 : + // InternalScope.g:20064:3: ';' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__Group_2__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__0" + // InternalScope.g:20073:1: rule__XVariableDeclaration__Group__0 : rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ; + public final void rule__XVariableDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20077:1: ( rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ) + // InternalScope.g:20078:2: rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 + { + pushFollow(FOLLOW_121); + rule__XVariableDeclaration__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group__0__Impl" + // InternalScope.g:20085:1: rule__XVariableDeclaration__Group__0__Impl : ( () ) ; + public final void rule__XVariableDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20089:1: ( ( () ) ) + // InternalScope.g:20090:1: ( () ) + { + // InternalScope.g:20090:1: ( () ) + // InternalScope.g:20091:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); + } + // InternalScope.g:20092:2: () + // InternalScope.g:20092:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__1" + // InternalScope.g:20100:1: rule__XVariableDeclaration__Group__1 : rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ; + public final void rule__XVariableDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20104:1: ( rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ) + // InternalScope.g:20105:2: rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 + { + pushFollow(FOLLOW_84); + rule__XVariableDeclaration__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group__1__Impl" + // InternalScope.g:20112:1: rule__XVariableDeclaration__Group__1__Impl : ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ; + public final void rule__XVariableDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20116:1: ( ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ) + // InternalScope.g:20117:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) ) + { + // InternalScope.g:20117:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) ) + // InternalScope.g:20118:2: ( rule__XVariableDeclaration__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); + } + // InternalScope.g:20119:2: ( rule__XVariableDeclaration__Alternatives_1 ) + // InternalScope.g:20119:3: rule__XVariableDeclaration__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__2" + // InternalScope.g:20127:1: rule__XVariableDeclaration__Group__2 : rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ; + public final void rule__XVariableDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20131:1: ( rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ) + // InternalScope.g:20132:2: rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 + { + pushFollow(FOLLOW_16); + rule__XVariableDeclaration__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__2" + + + // $ANTLR start "rule__XVariableDeclaration__Group__2__Impl" + // InternalScope.g:20139:1: rule__XVariableDeclaration__Group__2__Impl : ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ; + public final void rule__XVariableDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20143:1: ( ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ) + // InternalScope.g:20144:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) ) + { + // InternalScope.g:20144:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) ) + // InternalScope.g:20145:2: ( rule__XVariableDeclaration__Alternatives_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); + } + // InternalScope.g:20146:2: ( rule__XVariableDeclaration__Alternatives_2 ) + // InternalScope.g:20146:3: rule__XVariableDeclaration__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group__3" + // InternalScope.g:20154:1: rule__XVariableDeclaration__Group__3 : rule__XVariableDeclaration__Group__3__Impl ; + public final void rule__XVariableDeclaration__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20158:1: ( rule__XVariableDeclaration__Group__3__Impl ) + // InternalScope.g:20159:2: rule__XVariableDeclaration__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__3" + + + // $ANTLR start "rule__XVariableDeclaration__Group__3__Impl" + // InternalScope.g:20165:1: rule__XVariableDeclaration__Group__3__Impl : ( ( rule__XVariableDeclaration__Group_3__0 )? ) ; + public final void rule__XVariableDeclaration__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20169:1: ( ( ( rule__XVariableDeclaration__Group_3__0 )? ) ) + // InternalScope.g:20170:1: ( ( rule__XVariableDeclaration__Group_3__0 )? ) + { + // InternalScope.g:20170:1: ( ( rule__XVariableDeclaration__Group_3__0 )? ) + // InternalScope.g:20171:2: ( rule__XVariableDeclaration__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); + } + // InternalScope.g:20172:2: ( rule__XVariableDeclaration__Group_3__0 )? + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==14) ) { + alt157=1; + } + switch (alt157) { + case 1 : + // InternalScope.g:20172:3: rule__XVariableDeclaration__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group__3__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0" + // InternalScope.g:20181:1: rule__XVariableDeclaration__Group_2_0__0 : rule__XVariableDeclaration__Group_2_0__0__Impl ; + public final void rule__XVariableDeclaration__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20185:1: ( rule__XVariableDeclaration__Group_2_0__0__Impl ) + // InternalScope.g:20186:2: rule__XVariableDeclaration__Group_2_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0__Impl" + // InternalScope.g:20192:1: rule__XVariableDeclaration__Group_2_0__0__Impl : ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20196:1: ( ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ) + // InternalScope.g:20197:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) + { + // InternalScope.g:20197:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) + // InternalScope.g:20198:2: ( rule__XVariableDeclaration__Group_2_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); + } + // InternalScope.g:20199:2: ( rule__XVariableDeclaration__Group_2_0_0__0 ) + // InternalScope.g:20199:3: rule__XVariableDeclaration__Group_2_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0" + // InternalScope.g:20208:1: rule__XVariableDeclaration__Group_2_0_0__0 : rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ; + public final void rule__XVariableDeclaration__Group_2_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20212:1: ( rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ) + // InternalScope.g:20213:2: rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 + { + pushFollow(FOLLOW_4); + rule__XVariableDeclaration__Group_2_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0__Impl" + // InternalScope.g:20220:1: rule__XVariableDeclaration__Group_2_0_0__0__Impl : ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20224:1: ( ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ) + // InternalScope.g:20225:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) + { + // InternalScope.g:20225:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) + // InternalScope.g:20226:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); + } + // InternalScope.g:20227:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) + // InternalScope.g:20227:3: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__TypeAssignment_2_0_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1" + // InternalScope.g:20235:1: rule__XVariableDeclaration__Group_2_0_0__1 : rule__XVariableDeclaration__Group_2_0_0__1__Impl ; + public final void rule__XVariableDeclaration__Group_2_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20239:1: ( rule__XVariableDeclaration__Group_2_0_0__1__Impl ) + // InternalScope.g:20240:2: rule__XVariableDeclaration__Group_2_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1__Impl" + // InternalScope.g:20246:1: rule__XVariableDeclaration__Group_2_0_0__1__Impl : ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ; + public final void rule__XVariableDeclaration__Group_2_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20250:1: ( ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ) + // InternalScope.g:20251:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) + { + // InternalScope.g:20251:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) + // InternalScope.g:20252:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); + } + // InternalScope.g:20253:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) + // InternalScope.g:20253:3: rule__XVariableDeclaration__NameAssignment_2_0_0_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__NameAssignment_2_0_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__0" + // InternalScope.g:20262:1: rule__XVariableDeclaration__Group_3__0 : rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ; + public final void rule__XVariableDeclaration__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20266:1: ( rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ) + // InternalScope.g:20267:2: rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 + { + pushFollow(FOLLOW_104); + rule__XVariableDeclaration__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__0" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__0__Impl" + // InternalScope.g:20274:1: rule__XVariableDeclaration__Group_3__0__Impl : ( '=' ) ; + public final void rule__XVariableDeclaration__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20278:1: ( ( '=' ) ) + // InternalScope.g:20279:1: ( '=' ) + { + // InternalScope.g:20279:1: ( '=' ) + // InternalScope.g:20280:2: '=' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + match(input,14,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__0__Impl" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__1" + // InternalScope.g:20289:1: rule__XVariableDeclaration__Group_3__1 : rule__XVariableDeclaration__Group_3__1__Impl ; + public final void rule__XVariableDeclaration__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20293:1: ( rule__XVariableDeclaration__Group_3__1__Impl ) + // InternalScope.g:20294:2: rule__XVariableDeclaration__Group_3__1__Impl + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__1" + + + // $ANTLR start "rule__XVariableDeclaration__Group_3__1__Impl" + // InternalScope.g:20300:1: rule__XVariableDeclaration__Group_3__1__Impl : ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ; + public final void rule__XVariableDeclaration__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20304:1: ( ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ) + // InternalScope.g:20305:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) + { + // InternalScope.g:20305:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) + // InternalScope.g:20306:2: ( rule__XVariableDeclaration__RightAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); + } + // InternalScope.g:20307:2: ( rule__XVariableDeclaration__RightAssignment_3_1 ) + // InternalScope.g:20307:3: rule__XVariableDeclaration__RightAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__RightAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__Group_3__1__Impl" + + + // $ANTLR start "rule__JvmFormalParameter__Group__0" + // InternalScope.g:20316:1: rule__JvmFormalParameter__Group__0 : rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ; + public final void rule__JvmFormalParameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20320:1: ( rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ) + // InternalScope.g:20321:2: rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 + { + pushFollow(FOLLOW_84); + rule__JvmFormalParameter__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__0" + + + // $ANTLR start "rule__JvmFormalParameter__Group__0__Impl" + // InternalScope.g:20328:1: rule__JvmFormalParameter__Group__0__Impl : ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ; + public final void rule__JvmFormalParameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20332:1: ( ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ) + // InternalScope.g:20333:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) + { + // InternalScope.g:20333:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) + // InternalScope.g:20334:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + // InternalScope.g:20335:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? + int alt158=2; + int LA158_0 = input.LA(1); + + if ( (LA158_0==RULE_ID) ) { + int LA158_1 = input.LA(2); + + if ( (LA158_1==RULE_ID||LA158_1==22||LA158_1==58||LA158_1==82) ) { + alt158=1; + } + } + else if ( (LA158_0==51||LA158_0==77) ) { + alt158=1; + } + switch (alt158) { + case 1 : + // InternalScope.g:20335:3: rule__JvmFormalParameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__ParameterTypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__0__Impl" + + + // $ANTLR start "rule__JvmFormalParameter__Group__1" + // InternalScope.g:20343:1: rule__JvmFormalParameter__Group__1 : rule__JvmFormalParameter__Group__1__Impl ; + public final void rule__JvmFormalParameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20347:1: ( rule__JvmFormalParameter__Group__1__Impl ) + // InternalScope.g:20348:2: rule__JvmFormalParameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__1" + + + // $ANTLR start "rule__JvmFormalParameter__Group__1__Impl" + // InternalScope.g:20354:1: rule__JvmFormalParameter__Group__1__Impl : ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ; + public final void rule__JvmFormalParameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20358:1: ( ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ) + // InternalScope.g:20359:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) + { + // InternalScope.g:20359:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) + // InternalScope.g:20360:2: ( rule__JvmFormalParameter__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); + } + // InternalScope.g:20361:2: ( rule__JvmFormalParameter__NameAssignment_1 ) + // InternalScope.g:20361:3: rule__JvmFormalParameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmFormalParameter__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__Group__1__Impl" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__0" + // InternalScope.g:20370:1: rule__FullJvmFormalParameter__Group__0 : rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ; + public final void rule__FullJvmFormalParameter__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20374:1: ( rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ) + // InternalScope.g:20375:2: rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 + { + pushFollow(FOLLOW_4); + rule__FullJvmFormalParameter__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__0" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__0__Impl" + // InternalScope.g:20382:1: rule__FullJvmFormalParameter__Group__0__Impl : ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ; + public final void rule__FullJvmFormalParameter__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20386:1: ( ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ) + // InternalScope.g:20387:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) + { + // InternalScope.g:20387:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) + // InternalScope.g:20388:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + // InternalScope.g:20389:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) + // InternalScope.g:20389:3: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__ParameterTypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__0__Impl" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__1" + // InternalScope.g:20397:1: rule__FullJvmFormalParameter__Group__1 : rule__FullJvmFormalParameter__Group__1__Impl ; + public final void rule__FullJvmFormalParameter__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20401:1: ( rule__FullJvmFormalParameter__Group__1__Impl ) + // InternalScope.g:20402:2: rule__FullJvmFormalParameter__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__1" + + + // $ANTLR start "rule__FullJvmFormalParameter__Group__1__Impl" + // InternalScope.g:20408:1: rule__FullJvmFormalParameter__Group__1__Impl : ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ; + public final void rule__FullJvmFormalParameter__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20412:1: ( ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ) + // InternalScope.g:20413:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) + { + // InternalScope.g:20413:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) + // InternalScope.g:20414:2: ( rule__FullJvmFormalParameter__NameAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); + } + // InternalScope.g:20415:2: ( rule__FullJvmFormalParameter__NameAssignment_1 ) + // InternalScope.g:20415:3: rule__FullJvmFormalParameter__NameAssignment_1 + { + pushFollow(FOLLOW_2); + rule__FullJvmFormalParameter__NameAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__Group__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__0" + // InternalScope.g:20424:1: rule__XFeatureCall__Group__0 : rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ; + public final void rule__XFeatureCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20428:1: ( rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ) + // InternalScope.g:20429:2: rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 + { + pushFollow(FOLLOW_99); + rule__XFeatureCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__0" + + + // $ANTLR start "rule__XFeatureCall__Group__0__Impl" + // InternalScope.g:20436:1: rule__XFeatureCall__Group__0__Impl : ( () ) ; + public final void rule__XFeatureCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20440:1: ( ( () ) ) + // InternalScope.g:20441:1: ( () ) + { + // InternalScope.g:20441:1: ( () ) + // InternalScope.g:20442:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); + } + // InternalScope.g:20443:2: () + // InternalScope.g:20443:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__1" + // InternalScope.g:20451:1: rule__XFeatureCall__Group__1 : rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ; + public final void rule__XFeatureCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20455:1: ( rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ) + // InternalScope.g:20456:2: rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 + { + pushFollow(FOLLOW_99); + rule__XFeatureCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__1" + + + // $ANTLR start "rule__XFeatureCall__Group__1__Impl" + // InternalScope.g:20463:1: rule__XFeatureCall__Group__1__Impl : ( ( rule__XFeatureCall__Group_1__0 )? ) ; + public final void rule__XFeatureCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20467:1: ( ( ( rule__XFeatureCall__Group_1__0 )? ) ) + // InternalScope.g:20468:1: ( ( rule__XFeatureCall__Group_1__0 )? ) + { + // InternalScope.g:20468:1: ( ( rule__XFeatureCall__Group_1__0 )? ) + // InternalScope.g:20469:2: ( rule__XFeatureCall__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_1()); + } + // InternalScope.g:20470:2: ( rule__XFeatureCall__Group_1__0 )? + int alt159=2; + int LA159_0 = input.LA(1); + + if ( (LA159_0==22) ) { + alt159=1; + } + switch (alt159) { + case 1 : + // InternalScope.g:20470:3: rule__XFeatureCall__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__2" + // InternalScope.g:20478:1: rule__XFeatureCall__Group__2 : rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ; + public final void rule__XFeatureCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20482:1: ( rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ) + // InternalScope.g:20483:2: rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 + { + pushFollow(FOLLOW_100); + rule__XFeatureCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__2" + + + // $ANTLR start "rule__XFeatureCall__Group__2__Impl" + // InternalScope.g:20490:1: rule__XFeatureCall__Group__2__Impl : ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ; + public final void rule__XFeatureCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20494:1: ( ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ) + // InternalScope.g:20495:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) + { + // InternalScope.g:20495:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) + // InternalScope.g:20496:2: ( rule__XFeatureCall__FeatureAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); + } + // InternalScope.g:20497:2: ( rule__XFeatureCall__FeatureAssignment_2 ) + // InternalScope.g:20497:3: rule__XFeatureCall__FeatureAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__3" + // InternalScope.g:20505:1: rule__XFeatureCall__Group__3 : rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ; + public final void rule__XFeatureCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20509:1: ( rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ) + // InternalScope.g:20510:2: rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 + { + pushFollow(FOLLOW_100); + rule__XFeatureCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__3" + + + // $ANTLR start "rule__XFeatureCall__Group__3__Impl" + // InternalScope.g:20517:1: rule__XFeatureCall__Group__3__Impl : ( ( rule__XFeatureCall__Group_3__0 )? ) ; + public final void rule__XFeatureCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20521:1: ( ( ( rule__XFeatureCall__Group_3__0 )? ) ) + // InternalScope.g:20522:1: ( ( rule__XFeatureCall__Group_3__0 )? ) + { + // InternalScope.g:20522:1: ( ( rule__XFeatureCall__Group_3__0 )? ) + // InternalScope.g:20523:2: ( rule__XFeatureCall__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3()); + } + // InternalScope.g:20524:2: ( rule__XFeatureCall__Group_3__0 )? + int alt160=2; + alt160 = dfa160.predict(input); + switch (alt160) { + case 1 : + // InternalScope.g:20524:3: rule__XFeatureCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__3__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group__4" + // InternalScope.g:20532:1: rule__XFeatureCall__Group__4 : rule__XFeatureCall__Group__4__Impl ; + public final void rule__XFeatureCall__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20536:1: ( rule__XFeatureCall__Group__4__Impl ) + // InternalScope.g:20537:2: rule__XFeatureCall__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__4" + + + // $ANTLR start "rule__XFeatureCall__Group__4__Impl" + // InternalScope.g:20543:1: rule__XFeatureCall__Group__4__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ; + public final void rule__XFeatureCall__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20547:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ) + // InternalScope.g:20548:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) + { + // InternalScope.g:20548:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) + // InternalScope.g:20549:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); + } + // InternalScope.g:20550:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? + int alt161=2; + alt161 = dfa161.predict(input); + switch (alt161) { + case 1 : + // InternalScope.g:20550:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group__4__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__0" + // InternalScope.g:20559:1: rule__XFeatureCall__Group_1__0 : rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ; + public final void rule__XFeatureCall__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20563:1: ( rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ) + // InternalScope.g:20564:2: rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 + { + pushFollow(FOLLOW_101); + rule__XFeatureCall__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_1__0__Impl" + // InternalScope.g:20571:1: rule__XFeatureCall__Group_1__0__Impl : ( '<' ) ; + public final void rule__XFeatureCall__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20575:1: ( ( '<' ) ) + // InternalScope.g:20576:1: ( '<' ) + { + // InternalScope.g:20576:1: ( '<' ) + // InternalScope.g:20577:2: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__1" + // InternalScope.g:20586:1: rule__XFeatureCall__Group_1__1 : rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ; + public final void rule__XFeatureCall__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20590:1: ( rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ) + // InternalScope.g:20591:2: rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 + { + pushFollow(FOLLOW_102); + rule__XFeatureCall__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_1__1__Impl" + // InternalScope.g:20598:1: rule__XFeatureCall__Group_1__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ; + public final void rule__XFeatureCall__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20602:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ) + // InternalScope.g:20603:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) + { + // InternalScope.g:20603:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) + // InternalScope.g:20604:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); + } + // InternalScope.g:20605:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) + // InternalScope.g:20605:3: rule__XFeatureCall__TypeArgumentsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__TypeArgumentsAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__2" + // InternalScope.g:20613:1: rule__XFeatureCall__Group_1__2 : rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ; + public final void rule__XFeatureCall__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20617:1: ( rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ) + // InternalScope.g:20618:2: rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 + { + pushFollow(FOLLOW_102); + rule__XFeatureCall__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__2" + + + // $ANTLR start "rule__XFeatureCall__Group_1__2__Impl" + // InternalScope.g:20625:1: rule__XFeatureCall__Group_1__2__Impl : ( ( rule__XFeatureCall__Group_1_2__0 )* ) ; + public final void rule__XFeatureCall__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20629:1: ( ( ( rule__XFeatureCall__Group_1_2__0 )* ) ) + // InternalScope.g:20630:1: ( ( rule__XFeatureCall__Group_1_2__0 )* ) + { + // InternalScope.g:20630:1: ( ( rule__XFeatureCall__Group_1_2__0 )* ) + // InternalScope.g:20631:2: ( rule__XFeatureCall__Group_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); + } + // InternalScope.g:20632:2: ( rule__XFeatureCall__Group_1_2__0 )* + loop162: + do { + int alt162=2; + int LA162_0 = input.LA(1); + + if ( (LA162_0==86) ) { + alt162=1; + } + + + switch (alt162) { + case 1 : + // InternalScope.g:20632:3: rule__XFeatureCall__Group_1_2__0 + { + pushFollow(FOLLOW_39); + rule__XFeatureCall__Group_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop162; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1__3" + // InternalScope.g:20640:1: rule__XFeatureCall__Group_1__3 : rule__XFeatureCall__Group_1__3__Impl ; + public final void rule__XFeatureCall__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20644:1: ( rule__XFeatureCall__Group_1__3__Impl ) + // InternalScope.g:20645:2: rule__XFeatureCall__Group_1__3__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__3" + + + // $ANTLR start "rule__XFeatureCall__Group_1__3__Impl" + // InternalScope.g:20651:1: rule__XFeatureCall__Group_1__3__Impl : ( '>' ) ; + public final void rule__XFeatureCall__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20655:1: ( ( '>' ) ) + // InternalScope.g:20656:1: ( '>' ) + { + // InternalScope.g:20656:1: ( '>' ) + // InternalScope.g:20657:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1__3__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__0" + // InternalScope.g:20667:1: rule__XFeatureCall__Group_1_2__0 : rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ; + public final void rule__XFeatureCall__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20671:1: ( rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ) + // InternalScope.g:20672:2: rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 + { + pushFollow(FOLLOW_101); + rule__XFeatureCall__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__0" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__0__Impl" + // InternalScope.g:20679:1: rule__XFeatureCall__Group_1_2__0__Impl : ( ',' ) ; + public final void rule__XFeatureCall__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20683:1: ( ( ',' ) ) + // InternalScope.g:20684:1: ( ',' ) + { + // InternalScope.g:20684:1: ( ',' ) + // InternalScope.g:20685:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__1" + // InternalScope.g:20694:1: rule__XFeatureCall__Group_1_2__1 : rule__XFeatureCall__Group_1_2__1__Impl ; + public final void rule__XFeatureCall__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20698:1: ( rule__XFeatureCall__Group_1_2__1__Impl ) + // InternalScope.g:20699:2: rule__XFeatureCall__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__1" + + + // $ANTLR start "rule__XFeatureCall__Group_1_2__1__Impl" + // InternalScope.g:20705:1: rule__XFeatureCall__Group_1_2__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ; + public final void rule__XFeatureCall__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20709:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ) + // InternalScope.g:20710:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) + { + // InternalScope.g:20710:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) + // InternalScope.g:20711:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); + } + // InternalScope.g:20712:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) + // InternalScope.g:20712:3: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__TypeArgumentsAssignment_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_1_2__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__0" + // InternalScope.g:20721:1: rule__XFeatureCall__Group_3__0 : rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ; + public final void rule__XFeatureCall__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20725:1: ( rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ) + // InternalScope.g:20726:2: rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 + { + pushFollow(FOLLOW_103); + rule__XFeatureCall__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3__0__Impl" + // InternalScope.g:20733:1: rule__XFeatureCall__Group_3__0__Impl : ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ; + public final void rule__XFeatureCall__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20737:1: ( ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ) + // InternalScope.g:20738:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) + { + // InternalScope.g:20738:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) + // InternalScope.g:20739:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); + } + // InternalScope.g:20740:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) + // InternalScope.g:20740:3: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__ExplicitOperationCallAssignment_3_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__1" + // InternalScope.g:20748:1: rule__XFeatureCall__Group_3__1 : rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ; + public final void rule__XFeatureCall__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20752:1: ( rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ) + // InternalScope.g:20753:2: rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 + { + pushFollow(FOLLOW_103); + rule__XFeatureCall__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3__1__Impl" + // InternalScope.g:20760:1: rule__XFeatureCall__Group_3__1__Impl : ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ; + public final void rule__XFeatureCall__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20764:1: ( ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ) + // InternalScope.g:20765:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? ) + { + // InternalScope.g:20765:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? ) + // InternalScope.g:20766:2: ( rule__XFeatureCall__Alternatives_3_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); + } + // InternalScope.g:20767:2: ( rule__XFeatureCall__Alternatives_3_1 )? + int alt163=2; + int LA163_0 = input.LA(1); + + if ( ((LA163_0>=RULE_ID && LA163_0<=RULE_STRING)||(LA163_0>=22 && LA163_0<=24)||LA163_0==27||(LA163_0>=36 && LA163_0<=37)||LA163_0==51||(LA163_0>=60 && LA163_0<=64)||LA163_0==72||LA163_0==77||LA163_0==79||LA163_0==82||LA163_0==92||LA163_0==97||LA163_0==100||LA163_0==103||(LA163_0>=105 && LA163_0<=112)||LA163_0==114) ) { + alt163=1; + } + switch (alt163) { + case 1 : + // InternalScope.g:20767:3: rule__XFeatureCall__Alternatives_3_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Alternatives_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3__2" + // InternalScope.g:20775:1: rule__XFeatureCall__Group_3__2 : rule__XFeatureCall__Group_3__2__Impl ; + public final void rule__XFeatureCall__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20779:1: ( rule__XFeatureCall__Group_3__2__Impl ) + // InternalScope.g:20780:2: rule__XFeatureCall__Group_3__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__2" + + + // $ANTLR start "rule__XFeatureCall__Group_3__2__Impl" + // InternalScope.g:20786:1: rule__XFeatureCall__Group_3__2__Impl : ( ')' ) ; + public final void rule__XFeatureCall__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20790:1: ( ( ')' ) ) + // InternalScope.g:20791:1: ( ')' ) + { + // InternalScope.g:20791:1: ( ')' ) + // InternalScope.g:20792:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3__2__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0" + // InternalScope.g:20802:1: rule__XFeatureCall__Group_3_1_1__0 : rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ; + public final void rule__XFeatureCall__Group_3_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20806:1: ( rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ) + // InternalScope.g:20807:2: rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 + { + pushFollow(FOLLOW_71); + rule__XFeatureCall__Group_3_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0__Impl" + // InternalScope.g:20814:1: rule__XFeatureCall__Group_3_1_1__0__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ; + public final void rule__XFeatureCall__Group_3_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20818:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ) + // InternalScope.g:20819:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) + { + // InternalScope.g:20819:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) + // InternalScope.g:20820:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); + } + // InternalScope.g:20821:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) + // InternalScope.g:20821:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1" + // InternalScope.g:20829:1: rule__XFeatureCall__Group_3_1_1__1 : rule__XFeatureCall__Group_3_1_1__1__Impl ; + public final void rule__XFeatureCall__Group_3_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20833:1: ( rule__XFeatureCall__Group_3_1_1__1__Impl ) + // InternalScope.g:20834:2: rule__XFeatureCall__Group_3_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1__Impl" + // InternalScope.g:20840:1: rule__XFeatureCall__Group_3_1_1__1__Impl : ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ; + public final void rule__XFeatureCall__Group_3_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20844:1: ( ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ) + // InternalScope.g:20845:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) + { + // InternalScope.g:20845:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) + // InternalScope.g:20846:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); + } + // InternalScope.g:20847:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )* + loop164: + do { + int alt164=2; + int LA164_0 = input.LA(1); + + if ( (LA164_0==86) ) { + alt164=1; + } + + + switch (alt164) { + case 1 : + // InternalScope.g:20847:3: rule__XFeatureCall__Group_3_1_1_1__0 + { + pushFollow(FOLLOW_39); + rule__XFeatureCall__Group_3_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop164; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0" + // InternalScope.g:20856:1: rule__XFeatureCall__Group_3_1_1_1__0 : rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ; + public final void rule__XFeatureCall__Group_3_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20860:1: ( rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ) + // InternalScope.g:20861:2: rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 + { + pushFollow(FOLLOW_104); + rule__XFeatureCall__Group_3_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0__Impl" + // InternalScope.g:20868:1: rule__XFeatureCall__Group_3_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XFeatureCall__Group_3_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20872:1: ( ( ',' ) ) + // InternalScope.g:20873:1: ( ',' ) + { + // InternalScope.g:20873:1: ( ',' ) + // InternalScope.g:20874:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0__Impl" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1" + // InternalScope.g:20883:1: rule__XFeatureCall__Group_3_1_1_1__1 : rule__XFeatureCall__Group_3_1_1_1__1__Impl ; + public final void rule__XFeatureCall__Group_3_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20887:1: ( rule__XFeatureCall__Group_3_1_1_1__1__Impl ) + // InternalScope.g:20888:2: rule__XFeatureCall__Group_3_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1" + + + // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1__Impl" + // InternalScope.g:20894:1: rule__XFeatureCall__Group_3_1_1_1__1__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ; + public final void rule__XFeatureCall__Group_3_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20898:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ) + // InternalScope.g:20899:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) + { + // InternalScope.g:20899:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) + // InternalScope.g:20900:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); + } + // InternalScope.g:20901:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) + // InternalScope.g:20901:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__0" + // InternalScope.g:20910:1: rule__XConstructorCall__Group__0 : rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ; + public final void rule__XConstructorCall__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20914:1: ( rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ) + // InternalScope.g:20915:2: rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 + { + pushFollow(FOLLOW_122); + rule__XConstructorCall__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__0" + + + // $ANTLR start "rule__XConstructorCall__Group__0__Impl" + // InternalScope.g:20922:1: rule__XConstructorCall__Group__0__Impl : ( () ) ; + public final void rule__XConstructorCall__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20926:1: ( ( () ) ) + // InternalScope.g:20927:1: ( () ) + { + // InternalScope.g:20927:1: ( () ) + // InternalScope.g:20928:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); + } + // InternalScope.g:20929:2: () + // InternalScope.g:20929:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__1" + // InternalScope.g:20937:1: rule__XConstructorCall__Group__1 : rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ; + public final void rule__XConstructorCall__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20941:1: ( rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ) + // InternalScope.g:20942:2: rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 + { + pushFollow(FOLLOW_4); + rule__XConstructorCall__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__1" + + + // $ANTLR start "rule__XConstructorCall__Group__1__Impl" + // InternalScope.g:20949:1: rule__XConstructorCall__Group__1__Impl : ( 'new' ) ; + public final void rule__XConstructorCall__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20953:1: ( ( 'new' ) ) + // InternalScope.g:20954:1: ( 'new' ) + { + // InternalScope.g:20954:1: ( 'new' ) + // InternalScope.g:20955:2: 'new' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + match(input,103,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__2" + // InternalScope.g:20964:1: rule__XConstructorCall__Group__2 : rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ; + public final void rule__XConstructorCall__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20968:1: ( rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ) + // InternalScope.g:20969:2: rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 + { + pushFollow(FOLLOW_123); + rule__XConstructorCall__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__2" + + + // $ANTLR start "rule__XConstructorCall__Group__2__Impl" + // InternalScope.g:20976:1: rule__XConstructorCall__Group__2__Impl : ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ; + public final void rule__XConstructorCall__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20980:1: ( ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ) + // InternalScope.g:20981:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) + { + // InternalScope.g:20981:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) + // InternalScope.g:20982:2: ( rule__XConstructorCall__ConstructorAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); + } + // InternalScope.g:20983:2: ( rule__XConstructorCall__ConstructorAssignment_2 ) + // InternalScope.g:20983:3: rule__XConstructorCall__ConstructorAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ConstructorAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__3" + // InternalScope.g:20991:1: rule__XConstructorCall__Group__3 : rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ; + public final void rule__XConstructorCall__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:20995:1: ( rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ) + // InternalScope.g:20996:2: rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 + { + pushFollow(FOLLOW_123); + rule__XConstructorCall__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__3" + + + // $ANTLR start "rule__XConstructorCall__Group__3__Impl" + // InternalScope.g:21003:1: rule__XConstructorCall__Group__3__Impl : ( ( rule__XConstructorCall__Group_3__0 )? ) ; + public final void rule__XConstructorCall__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21007:1: ( ( ( rule__XConstructorCall__Group_3__0 )? ) ) + // InternalScope.g:21008:1: ( ( rule__XConstructorCall__Group_3__0 )? ) + { + // InternalScope.g:21008:1: ( ( rule__XConstructorCall__Group_3__0 )? ) + // InternalScope.g:21009:2: ( rule__XConstructorCall__Group_3__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_3()); + } + // InternalScope.g:21010:2: ( rule__XConstructorCall__Group_3__0 )? + int alt165=2; + alt165 = dfa165.predict(input); + switch (alt165) { + case 1 : + // InternalScope.g:21010:3: rule__XConstructorCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__3__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__4" + // InternalScope.g:21018:1: rule__XConstructorCall__Group__4 : rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ; + public final void rule__XConstructorCall__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21022:1: ( rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ) + // InternalScope.g:21023:2: rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 + { + pushFollow(FOLLOW_123); + rule__XConstructorCall__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__4" + + + // $ANTLR start "rule__XConstructorCall__Group__4__Impl" + // InternalScope.g:21030:1: rule__XConstructorCall__Group__4__Impl : ( ( rule__XConstructorCall__Group_4__0 )? ) ; + public final void rule__XConstructorCall__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21034:1: ( ( ( rule__XConstructorCall__Group_4__0 )? ) ) + // InternalScope.g:21035:1: ( ( rule__XConstructorCall__Group_4__0 )? ) + { + // InternalScope.g:21035:1: ( ( rule__XConstructorCall__Group_4__0 )? ) + // InternalScope.g:21036:2: ( rule__XConstructorCall__Group_4__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4()); + } + // InternalScope.g:21037:2: ( rule__XConstructorCall__Group_4__0 )? + int alt166=2; + alt166 = dfa166.predict(input); + switch (alt166) { + case 1 : + // InternalScope.g:21037:3: rule__XConstructorCall__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__4__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group__5" + // InternalScope.g:21045:1: rule__XConstructorCall__Group__5 : rule__XConstructorCall__Group__5__Impl ; + public final void rule__XConstructorCall__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21049:1: ( rule__XConstructorCall__Group__5__Impl ) + // InternalScope.g:21050:2: rule__XConstructorCall__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__5" + + + // $ANTLR start "rule__XConstructorCall__Group__5__Impl" + // InternalScope.g:21056:1: rule__XConstructorCall__Group__5__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ; + public final void rule__XConstructorCall__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21060:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ) + // InternalScope.g:21061:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) + { + // InternalScope.g:21061:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) + // InternalScope.g:21062:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); + } + // InternalScope.g:21063:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )? + int alt167=2; + alt167 = dfa167.predict(input); + switch (alt167) { + case 1 : + // InternalScope.g:21063:3: rule__XConstructorCall__ArgumentsAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group__5__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__0" + // InternalScope.g:21072:1: rule__XConstructorCall__Group_3__0 : rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ; + public final void rule__XConstructorCall__Group_3__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21076:1: ( rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ) + // InternalScope.g:21077:2: rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 + { + pushFollow(FOLLOW_101); + rule__XConstructorCall__Group_3__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__0" + + + // $ANTLR start "rule__XConstructorCall__Group_3__0__Impl" + // InternalScope.g:21084:1: rule__XConstructorCall__Group_3__0__Impl : ( ( '<' ) ) ; + public final void rule__XConstructorCall__Group_3__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21088:1: ( ( ( '<' ) ) ) + // InternalScope.g:21089:1: ( ( '<' ) ) + { + // InternalScope.g:21089:1: ( ( '<' ) ) + // InternalScope.g:21090:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + // InternalScope.g:21091:2: ( '<' ) + // InternalScope.g:21091:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__1" + // InternalScope.g:21099:1: rule__XConstructorCall__Group_3__1 : rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ; + public final void rule__XConstructorCall__Group_3__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21103:1: ( rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ) + // InternalScope.g:21104:2: rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 + { + pushFollow(FOLLOW_102); + rule__XConstructorCall__Group_3__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__1" + + + // $ANTLR start "rule__XConstructorCall__Group_3__1__Impl" + // InternalScope.g:21111:1: rule__XConstructorCall__Group_3__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ; + public final void rule__XConstructorCall__Group_3__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21115:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ) + // InternalScope.g:21116:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) + { + // InternalScope.g:21116:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) + // InternalScope.g:21117:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); + } + // InternalScope.g:21118:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) + // InternalScope.g:21118:3: rule__XConstructorCall__TypeArgumentsAssignment_3_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__TypeArgumentsAssignment_3_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__2" + // InternalScope.g:21126:1: rule__XConstructorCall__Group_3__2 : rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ; + public final void rule__XConstructorCall__Group_3__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21130:1: ( rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ) + // InternalScope.g:21131:2: rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 + { + pushFollow(FOLLOW_102); + rule__XConstructorCall__Group_3__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__2" + + + // $ANTLR start "rule__XConstructorCall__Group_3__2__Impl" + // InternalScope.g:21138:1: rule__XConstructorCall__Group_3__2__Impl : ( ( rule__XConstructorCall__Group_3_2__0 )* ) ; + public final void rule__XConstructorCall__Group_3__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21142:1: ( ( ( rule__XConstructorCall__Group_3_2__0 )* ) ) + // InternalScope.g:21143:1: ( ( rule__XConstructorCall__Group_3_2__0 )* ) + { + // InternalScope.g:21143:1: ( ( rule__XConstructorCall__Group_3_2__0 )* ) + // InternalScope.g:21144:2: ( rule__XConstructorCall__Group_3_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); + } + // InternalScope.g:21145:2: ( rule__XConstructorCall__Group_3_2__0 )* + loop168: + do { + int alt168=2; + int LA168_0 = input.LA(1); + + if ( (LA168_0==86) ) { + alt168=1; + } + + + switch (alt168) { + case 1 : + // InternalScope.g:21145:3: rule__XConstructorCall__Group_3_2__0 + { + pushFollow(FOLLOW_39); + rule__XConstructorCall__Group_3_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop168; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3__3" + // InternalScope.g:21153:1: rule__XConstructorCall__Group_3__3 : rule__XConstructorCall__Group_3__3__Impl ; + public final void rule__XConstructorCall__Group_3__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21157:1: ( rule__XConstructorCall__Group_3__3__Impl ) + // InternalScope.g:21158:2: rule__XConstructorCall__Group_3__3__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__3" + + + // $ANTLR start "rule__XConstructorCall__Group_3__3__Impl" + // InternalScope.g:21164:1: rule__XConstructorCall__Group_3__3__Impl : ( '>' ) ; + public final void rule__XConstructorCall__Group_3__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21168:1: ( ( '>' ) ) + // InternalScope.g:21169:1: ( '>' ) + { + // InternalScope.g:21169:1: ( '>' ) + // InternalScope.g:21170:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3__3__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__0" + // InternalScope.g:21180:1: rule__XConstructorCall__Group_3_2__0 : rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ; + public final void rule__XConstructorCall__Group_3_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21184:1: ( rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ) + // InternalScope.g:21185:2: rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 + { + pushFollow(FOLLOW_101); + rule__XConstructorCall__Group_3_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__0" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__0__Impl" + // InternalScope.g:21192:1: rule__XConstructorCall__Group_3_2__0__Impl : ( ',' ) ; + public final void rule__XConstructorCall__Group_3_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21196:1: ( ( ',' ) ) + // InternalScope.g:21197:1: ( ',' ) + { + // InternalScope.g:21197:1: ( ',' ) + // InternalScope.g:21198:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__1" + // InternalScope.g:21207:1: rule__XConstructorCall__Group_3_2__1 : rule__XConstructorCall__Group_3_2__1__Impl ; + public final void rule__XConstructorCall__Group_3_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21211:1: ( rule__XConstructorCall__Group_3_2__1__Impl ) + // InternalScope.g:21212:2: rule__XConstructorCall__Group_3_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__1" + + + // $ANTLR start "rule__XConstructorCall__Group_3_2__1__Impl" + // InternalScope.g:21218:1: rule__XConstructorCall__Group_3_2__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ; + public final void rule__XConstructorCall__Group_3_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21222:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ) + // InternalScope.g:21223:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) + { + // InternalScope.g:21223:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) + // InternalScope.g:21224:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); + } + // InternalScope.g:21225:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) + // InternalScope.g:21225:3: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__TypeArgumentsAssignment_3_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_3_2__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__0" + // InternalScope.g:21234:1: rule__XConstructorCall__Group_4__0 : rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ; + public final void rule__XConstructorCall__Group_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21238:1: ( rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ) + // InternalScope.g:21239:2: rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 + { + pushFollow(FOLLOW_103); + rule__XConstructorCall__Group_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4__0__Impl" + // InternalScope.g:21246:1: rule__XConstructorCall__Group_4__0__Impl : ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ; + public final void rule__XConstructorCall__Group_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21250:1: ( ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ) + // InternalScope.g:21251:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) + { + // InternalScope.g:21251:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) + // InternalScope.g:21252:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); + } + // InternalScope.g:21253:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) + // InternalScope.g:21253:3: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__1" + // InternalScope.g:21261:1: rule__XConstructorCall__Group_4__1 : rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ; + public final void rule__XConstructorCall__Group_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21265:1: ( rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ) + // InternalScope.g:21266:2: rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 + { + pushFollow(FOLLOW_103); + rule__XConstructorCall__Group_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4__1__Impl" + // InternalScope.g:21273:1: rule__XConstructorCall__Group_4__1__Impl : ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ; + public final void rule__XConstructorCall__Group_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21277:1: ( ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ) + // InternalScope.g:21278:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? ) + { + // InternalScope.g:21278:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? ) + // InternalScope.g:21279:2: ( rule__XConstructorCall__Alternatives_4_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); + } + // InternalScope.g:21280:2: ( rule__XConstructorCall__Alternatives_4_1 )? + int alt169=2; + int LA169_0 = input.LA(1); + + if ( ((LA169_0>=RULE_ID && LA169_0<=RULE_STRING)||(LA169_0>=22 && LA169_0<=24)||LA169_0==27||(LA169_0>=36 && LA169_0<=37)||LA169_0==51||(LA169_0>=60 && LA169_0<=64)||LA169_0==72||LA169_0==77||LA169_0==79||LA169_0==82||LA169_0==92||LA169_0==97||LA169_0==100||LA169_0==103||(LA169_0>=105 && LA169_0<=112)||LA169_0==114) ) { + alt169=1; + } + switch (alt169) { + case 1 : + // InternalScope.g:21280:3: rule__XConstructorCall__Alternatives_4_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Alternatives_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4__2" + // InternalScope.g:21288:1: rule__XConstructorCall__Group_4__2 : rule__XConstructorCall__Group_4__2__Impl ; + public final void rule__XConstructorCall__Group_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21292:1: ( rule__XConstructorCall__Group_4__2__Impl ) + // InternalScope.g:21293:2: rule__XConstructorCall__Group_4__2__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__2" + + + // $ANTLR start "rule__XConstructorCall__Group_4__2__Impl" + // InternalScope.g:21299:1: rule__XConstructorCall__Group_4__2__Impl : ( ')' ) ; + public final void rule__XConstructorCall__Group_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21303:1: ( ( ')' ) ) + // InternalScope.g:21304:1: ( ')' ) + { + // InternalScope.g:21304:1: ( ')' ) + // InternalScope.g:21305:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4__2__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0" + // InternalScope.g:21315:1: rule__XConstructorCall__Group_4_1_1__0 : rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ; + public final void rule__XConstructorCall__Group_4_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21319:1: ( rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ) + // InternalScope.g:21320:2: rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 + { + pushFollow(FOLLOW_71); + rule__XConstructorCall__Group_4_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0__Impl" + // InternalScope.g:21327:1: rule__XConstructorCall__Group_4_1_1__0__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ; + public final void rule__XConstructorCall__Group_4_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21331:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ) + // InternalScope.g:21332:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) + { + // InternalScope.g:21332:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) + // InternalScope.g:21333:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); + } + // InternalScope.g:21334:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) + // InternalScope.g:21334:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1" + // InternalScope.g:21342:1: rule__XConstructorCall__Group_4_1_1__1 : rule__XConstructorCall__Group_4_1_1__1__Impl ; + public final void rule__XConstructorCall__Group_4_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21346:1: ( rule__XConstructorCall__Group_4_1_1__1__Impl ) + // InternalScope.g:21347:2: rule__XConstructorCall__Group_4_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1__Impl" + // InternalScope.g:21353:1: rule__XConstructorCall__Group_4_1_1__1__Impl : ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ; + public final void rule__XConstructorCall__Group_4_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21357:1: ( ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ) + // InternalScope.g:21358:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) + { + // InternalScope.g:21358:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) + // InternalScope.g:21359:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); + } + // InternalScope.g:21360:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )* + loop170: + do { + int alt170=2; + int LA170_0 = input.LA(1); + + if ( (LA170_0==86) ) { + alt170=1; + } + + + switch (alt170) { + case 1 : + // InternalScope.g:21360:3: rule__XConstructorCall__Group_4_1_1_1__0 + { + pushFollow(FOLLOW_39); + rule__XConstructorCall__Group_4_1_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop170; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0" + // InternalScope.g:21369:1: rule__XConstructorCall__Group_4_1_1_1__0 : rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ; + public final void rule__XConstructorCall__Group_4_1_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21373:1: ( rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ) + // InternalScope.g:21374:2: rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 + { + pushFollow(FOLLOW_104); + rule__XConstructorCall__Group_4_1_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0__Impl" + // InternalScope.g:21381:1: rule__XConstructorCall__Group_4_1_1_1__0__Impl : ( ',' ) ; + public final void rule__XConstructorCall__Group_4_1_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21385:1: ( ( ',' ) ) + // InternalScope.g:21386:1: ( ',' ) + { + // InternalScope.g:21386:1: ( ',' ) + // InternalScope.g:21387:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0__Impl" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1" + // InternalScope.g:21396:1: rule__XConstructorCall__Group_4_1_1_1__1 : rule__XConstructorCall__Group_4_1_1_1__1__Impl ; + public final void rule__XConstructorCall__Group_4_1_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21400:1: ( rule__XConstructorCall__Group_4_1_1_1__1__Impl ) + // InternalScope.g:21401:2: rule__XConstructorCall__Group_4_1_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4_1_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1" + + + // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1__Impl" + // InternalScope.g:21407:1: rule__XConstructorCall__Group_4_1_1_1__1__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ; + public final void rule__XConstructorCall__Group_4_1_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21411:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ) + // InternalScope.g:21412:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) + { + // InternalScope.g:21412:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) + // InternalScope.g:21413:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); + } + // InternalScope.g:21414:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) + // InternalScope.g:21414:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1__Impl" + + + // $ANTLR start "rule__XBooleanLiteral__Group__0" + // InternalScope.g:21423:1: rule__XBooleanLiteral__Group__0 : rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ; + public final void rule__XBooleanLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21427:1: ( rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ) + // InternalScope.g:21428:2: rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 + { + pushFollow(FOLLOW_124); + rule__XBooleanLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__0" + + + // $ANTLR start "rule__XBooleanLiteral__Group__0__Impl" + // InternalScope.g:21435:1: rule__XBooleanLiteral__Group__0__Impl : ( () ) ; + public final void rule__XBooleanLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21439:1: ( ( () ) ) + // InternalScope.g:21440:1: ( () ) + { + // InternalScope.g:21440:1: ( () ) + // InternalScope.g:21441:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); + } + // InternalScope.g:21442:2: () + // InternalScope.g:21442:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XBooleanLiteral__Group__1" + // InternalScope.g:21450:1: rule__XBooleanLiteral__Group__1 : rule__XBooleanLiteral__Group__1__Impl ; + public final void rule__XBooleanLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21454:1: ( rule__XBooleanLiteral__Group__1__Impl ) + // InternalScope.g:21455:2: rule__XBooleanLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__1" + + + // $ANTLR start "rule__XBooleanLiteral__Group__1__Impl" + // InternalScope.g:21461:1: rule__XBooleanLiteral__Group__1__Impl : ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ; + public final void rule__XBooleanLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21465:1: ( ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ) + // InternalScope.g:21466:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) ) + { + // InternalScope.g:21466:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) ) + // InternalScope.g:21467:2: ( rule__XBooleanLiteral__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); + } + // InternalScope.g:21468:2: ( rule__XBooleanLiteral__Alternatives_1 ) + // InternalScope.g:21468:3: rule__XBooleanLiteral__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XBooleanLiteral__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XNullLiteral__Group__0" + // InternalScope.g:21477:1: rule__XNullLiteral__Group__0 : rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ; + public final void rule__XNullLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21481:1: ( rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ) + // InternalScope.g:21482:2: rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 + { + pushFollow(FOLLOW_125); + rule__XNullLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__0" + + + // $ANTLR start "rule__XNullLiteral__Group__0__Impl" + // InternalScope.g:21489:1: rule__XNullLiteral__Group__0__Impl : ( () ) ; + public final void rule__XNullLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21493:1: ( ( () ) ) + // InternalScope.g:21494:1: ( () ) + { + // InternalScope.g:21494:1: ( () ) + // InternalScope.g:21495:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); + } + // InternalScope.g:21496:2: () + // InternalScope.g:21496:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XNullLiteral__Group__1" + // InternalScope.g:21504:1: rule__XNullLiteral__Group__1 : rule__XNullLiteral__Group__1__Impl ; + public final void rule__XNullLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21508:1: ( rule__XNullLiteral__Group__1__Impl ) + // InternalScope.g:21509:2: rule__XNullLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XNullLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__1" + + + // $ANTLR start "rule__XNullLiteral__Group__1__Impl" + // InternalScope.g:21515:1: rule__XNullLiteral__Group__1__Impl : ( 'null' ) ; + public final void rule__XNullLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21519:1: ( ( 'null' ) ) + // InternalScope.g:21520:1: ( 'null' ) + { + // InternalScope.g:21520:1: ( 'null' ) + // InternalScope.g:21521:2: 'null' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + match(input,108,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNullLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XNumberLiteral__Group__0" + // InternalScope.g:21531:1: rule__XNumberLiteral__Group__0 : rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ; + public final void rule__XNumberLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21535:1: ( rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ) + // InternalScope.g:21536:2: rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 + { + pushFollow(FOLLOW_126); + rule__XNumberLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__0" + + + // $ANTLR start "rule__XNumberLiteral__Group__0__Impl" + // InternalScope.g:21543:1: rule__XNumberLiteral__Group__0__Impl : ( () ) ; + public final void rule__XNumberLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21547:1: ( ( () ) ) + // InternalScope.g:21548:1: ( () ) + { + // InternalScope.g:21548:1: ( () ) + // InternalScope.g:21549:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); + } + // InternalScope.g:21550:2: () + // InternalScope.g:21550:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XNumberLiteral__Group__1" + // InternalScope.g:21558:1: rule__XNumberLiteral__Group__1 : rule__XNumberLiteral__Group__1__Impl ; + public final void rule__XNumberLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21562:1: ( rule__XNumberLiteral__Group__1__Impl ) + // InternalScope.g:21563:2: rule__XNumberLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__1" + + + // $ANTLR start "rule__XNumberLiteral__Group__1__Impl" + // InternalScope.g:21569:1: rule__XNumberLiteral__Group__1__Impl : ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ; + public final void rule__XNumberLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21573:1: ( ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ) + // InternalScope.g:21574:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) + { + // InternalScope.g:21574:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) + // InternalScope.g:21575:2: ( rule__XNumberLiteral__ValueAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); + } + // InternalScope.g:21576:2: ( rule__XNumberLiteral__ValueAssignment_1 ) + // InternalScope.g:21576:3: rule__XNumberLiteral__ValueAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XNumberLiteral__ValueAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XStringLiteral__Group__0" + // InternalScope.g:21585:1: rule__XStringLiteral__Group__0 : rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ; + public final void rule__XStringLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21589:1: ( rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ) + // InternalScope.g:21590:2: rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 + { + pushFollow(FOLLOW_10); + rule__XStringLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__0" + + + // $ANTLR start "rule__XStringLiteral__Group__0__Impl" + // InternalScope.g:21597:1: rule__XStringLiteral__Group__0__Impl : ( () ) ; + public final void rule__XStringLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21601:1: ( ( () ) ) + // InternalScope.g:21602:1: ( () ) + { + // InternalScope.g:21602:1: ( () ) + // InternalScope.g:21603:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); + } + // InternalScope.g:21604:2: () + // InternalScope.g:21604:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XStringLiteral__Group__1" + // InternalScope.g:21612:1: rule__XStringLiteral__Group__1 : rule__XStringLiteral__Group__1__Impl ; + public final void rule__XStringLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21616:1: ( rule__XStringLiteral__Group__1__Impl ) + // InternalScope.g:21617:2: rule__XStringLiteral__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__1" + + + // $ANTLR start "rule__XStringLiteral__Group__1__Impl" + // InternalScope.g:21623:1: rule__XStringLiteral__Group__1__Impl : ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ; + public final void rule__XStringLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21627:1: ( ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ) + // InternalScope.g:21628:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) ) + { + // InternalScope.g:21628:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) ) + // InternalScope.g:21629:2: ( rule__XStringLiteral__ValueAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); + } + // InternalScope.g:21630:2: ( rule__XStringLiteral__ValueAssignment_1 ) + // InternalScope.g:21630:3: rule__XStringLiteral__ValueAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XStringLiteral__ValueAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__0" + // InternalScope.g:21639:1: rule__XTypeLiteral__Group__0 : rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ; + public final void rule__XTypeLiteral__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21643:1: ( rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ) + // InternalScope.g:21644:2: rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 + { + pushFollow(FOLLOW_127); + rule__XTypeLiteral__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__0" + + + // $ANTLR start "rule__XTypeLiteral__Group__0__Impl" + // InternalScope.g:21651:1: rule__XTypeLiteral__Group__0__Impl : ( () ) ; + public final void rule__XTypeLiteral__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21655:1: ( ( () ) ) + // InternalScope.g:21656:1: ( () ) + { + // InternalScope.g:21656:1: ( () ) + // InternalScope.g:21657:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); + } + // InternalScope.g:21658:2: () + // InternalScope.g:21658:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__0__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__1" + // InternalScope.g:21666:1: rule__XTypeLiteral__Group__1 : rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ; + public final void rule__XTypeLiteral__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21670:1: ( rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ) + // InternalScope.g:21671:2: rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 + { + pushFollow(FOLLOW_31); + rule__XTypeLiteral__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__1" + + + // $ANTLR start "rule__XTypeLiteral__Group__1__Impl" + // InternalScope.g:21678:1: rule__XTypeLiteral__Group__1__Impl : ( 'typeof' ) ; + public final void rule__XTypeLiteral__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21682:1: ( ( 'typeof' ) ) + // InternalScope.g:21683:1: ( 'typeof' ) + { + // InternalScope.g:21683:1: ( 'typeof' ) + // InternalScope.g:21684:2: 'typeof' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + match(input,109,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__1__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__2" + // InternalScope.g:21693:1: rule__XTypeLiteral__Group__2 : rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ; + public final void rule__XTypeLiteral__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21697:1: ( rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ) + // InternalScope.g:21698:2: rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 + { + pushFollow(FOLLOW_4); + rule__XTypeLiteral__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__2" + + + // $ANTLR start "rule__XTypeLiteral__Group__2__Impl" + // InternalScope.g:21705:1: rule__XTypeLiteral__Group__2__Impl : ( '(' ) ; + public final void rule__XTypeLiteral__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21709:1: ( ( '(' ) ) + // InternalScope.g:21710:1: ( '(' ) + { + // InternalScope.g:21710:1: ( '(' ) + // InternalScope.g:21711:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__2__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__3" + // InternalScope.g:21720:1: rule__XTypeLiteral__Group__3 : rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ; + public final void rule__XTypeLiteral__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21724:1: ( rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ) + // InternalScope.g:21725:2: rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 + { + pushFollow(FOLLOW_128); + rule__XTypeLiteral__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__3" + + + // $ANTLR start "rule__XTypeLiteral__Group__3__Impl" + // InternalScope.g:21732:1: rule__XTypeLiteral__Group__3__Impl : ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ; + public final void rule__XTypeLiteral__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21736:1: ( ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ) + // InternalScope.g:21737:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) + { + // InternalScope.g:21737:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) + // InternalScope.g:21738:2: ( rule__XTypeLiteral__TypeAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); + } + // InternalScope.g:21739:2: ( rule__XTypeLiteral__TypeAssignment_3 ) + // InternalScope.g:21739:3: rule__XTypeLiteral__TypeAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__TypeAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__3__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__4" + // InternalScope.g:21747:1: rule__XTypeLiteral__Group__4 : rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ; + public final void rule__XTypeLiteral__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21751:1: ( rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ) + // InternalScope.g:21752:2: rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 + { + pushFollow(FOLLOW_128); + rule__XTypeLiteral__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__5(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__4" + + + // $ANTLR start "rule__XTypeLiteral__Group__4__Impl" + // InternalScope.g:21759:1: rule__XTypeLiteral__Group__4__Impl : ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ; + public final void rule__XTypeLiteral__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21763:1: ( ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ) + // InternalScope.g:21764:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) + { + // InternalScope.g:21764:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) + // InternalScope.g:21765:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); + } + // InternalScope.g:21766:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* + loop171: + do { + int alt171=2; + int LA171_0 = input.LA(1); + + if ( (LA171_0==82) ) { + alt171=1; + } + + + switch (alt171) { + case 1 : + // InternalScope.g:21766:3: rule__XTypeLiteral__ArrayDimensionsAssignment_4 + { + pushFollow(FOLLOW_129); + rule__XTypeLiteral__ArrayDimensionsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop171; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__4__Impl" + + + // $ANTLR start "rule__XTypeLiteral__Group__5" + // InternalScope.g:21774:1: rule__XTypeLiteral__Group__5 : rule__XTypeLiteral__Group__5__Impl ; + public final void rule__XTypeLiteral__Group__5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21778:1: ( rule__XTypeLiteral__Group__5__Impl ) + // InternalScope.g:21779:2: rule__XTypeLiteral__Group__5__Impl + { + pushFollow(FOLLOW_2); + rule__XTypeLiteral__Group__5__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__5" + + + // $ANTLR start "rule__XTypeLiteral__Group__5__Impl" + // InternalScope.g:21785:1: rule__XTypeLiteral__Group__5__Impl : ( ')' ) ; + public final void rule__XTypeLiteral__Group__5__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21789:1: ( ( ')' ) ) + // InternalScope.g:21790:1: ( ')' ) + { + // InternalScope.g:21790:1: ( ')' ) + // InternalScope.g:21791:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__Group__5__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__0" + // InternalScope.g:21801:1: rule__XThrowExpression__Group__0 : rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ; + public final void rule__XThrowExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21805:1: ( rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ) + // InternalScope.g:21806:2: rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 + { + pushFollow(FOLLOW_130); + rule__XThrowExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__0" + + + // $ANTLR start "rule__XThrowExpression__Group__0__Impl" + // InternalScope.g:21813:1: rule__XThrowExpression__Group__0__Impl : ( () ) ; + public final void rule__XThrowExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21817:1: ( ( () ) ) + // InternalScope.g:21818:1: ( () ) + { + // InternalScope.g:21818:1: ( () ) + // InternalScope.g:21819:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); + } + // InternalScope.g:21820:2: () + // InternalScope.g:21820:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__0__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__1" + // InternalScope.g:21828:1: rule__XThrowExpression__Group__1 : rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ; + public final void rule__XThrowExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21832:1: ( rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ) + // InternalScope.g:21833:2: rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 + { + pushFollow(FOLLOW_104); + rule__XThrowExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__1" + + + // $ANTLR start "rule__XThrowExpression__Group__1__Impl" + // InternalScope.g:21840:1: rule__XThrowExpression__Group__1__Impl : ( 'throw' ) ; + public final void rule__XThrowExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21844:1: ( ( 'throw' ) ) + // InternalScope.g:21845:1: ( 'throw' ) + { + // InternalScope.g:21845:1: ( 'throw' ) + // InternalScope.g:21846:2: 'throw' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + match(input,110,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__1__Impl" + + + // $ANTLR start "rule__XThrowExpression__Group__2" + // InternalScope.g:21855:1: rule__XThrowExpression__Group__2 : rule__XThrowExpression__Group__2__Impl ; + public final void rule__XThrowExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21859:1: ( rule__XThrowExpression__Group__2__Impl ) + // InternalScope.g:21860:2: rule__XThrowExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__2" + + + // $ANTLR start "rule__XThrowExpression__Group__2__Impl" + // InternalScope.g:21866:1: rule__XThrowExpression__Group__2__Impl : ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ; + public final void rule__XThrowExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21870:1: ( ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ) + // InternalScope.g:21871:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) + { + // InternalScope.g:21871:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) + // InternalScope.g:21872:2: ( rule__XThrowExpression__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); + } + // InternalScope.g:21873:2: ( rule__XThrowExpression__ExpressionAssignment_2 ) + // InternalScope.g:21873:3: rule__XThrowExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XThrowExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__Group__2__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__0" + // InternalScope.g:21882:1: rule__XReturnExpression__Group__0 : rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ; + public final void rule__XReturnExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21886:1: ( rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ) + // InternalScope.g:21887:2: rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 + { + pushFollow(FOLLOW_131); + rule__XReturnExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__0" + + + // $ANTLR start "rule__XReturnExpression__Group__0__Impl" + // InternalScope.g:21894:1: rule__XReturnExpression__Group__0__Impl : ( () ) ; + public final void rule__XReturnExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21898:1: ( ( () ) ) + // InternalScope.g:21899:1: ( () ) + { + // InternalScope.g:21899:1: ( () ) + // InternalScope.g:21900:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); + } + // InternalScope.g:21901:2: () + // InternalScope.g:21901:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__0__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__1" + // InternalScope.g:21909:1: rule__XReturnExpression__Group__1 : rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ; + public final void rule__XReturnExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21913:1: ( rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ) + // InternalScope.g:21914:2: rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 + { + pushFollow(FOLLOW_104); + rule__XReturnExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__1" + + + // $ANTLR start "rule__XReturnExpression__Group__1__Impl" + // InternalScope.g:21921:1: rule__XReturnExpression__Group__1__Impl : ( 'return' ) ; + public final void rule__XReturnExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21925:1: ( ( 'return' ) ) + // InternalScope.g:21926:1: ( 'return' ) + { + // InternalScope.g:21926:1: ( 'return' ) + // InternalScope.g:21927:2: 'return' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + match(input,111,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__1__Impl" + + + // $ANTLR start "rule__XReturnExpression__Group__2" + // InternalScope.g:21936:1: rule__XReturnExpression__Group__2 : rule__XReturnExpression__Group__2__Impl ; + public final void rule__XReturnExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21940:1: ( rule__XReturnExpression__Group__2__Impl ) + // InternalScope.g:21941:2: rule__XReturnExpression__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__2" + + + // $ANTLR start "rule__XReturnExpression__Group__2__Impl" + // InternalScope.g:21947:1: rule__XReturnExpression__Group__2__Impl : ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ; + public final void rule__XReturnExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21951:1: ( ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ) + // InternalScope.g:21952:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) + { + // InternalScope.g:21952:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) + // InternalScope.g:21953:2: ( rule__XReturnExpression__ExpressionAssignment_2 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); + } + // InternalScope.g:21954:2: ( rule__XReturnExpression__ExpressionAssignment_2 )? + int alt172=2; + alt172 = dfa172.predict(input); + switch (alt172) { + case 1 : + // InternalScope.g:21954:3: rule__XReturnExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__Group__2__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0" + // InternalScope.g:21963:1: rule__XTryCatchFinallyExpression__Group__0 : rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ; + public final void rule__XTryCatchFinallyExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21967:1: ( rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ) + // InternalScope.g:21968:2: rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 + { + pushFollow(FOLLOW_132); + rule__XTryCatchFinallyExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0__Impl" + // InternalScope.g:21975:1: rule__XTryCatchFinallyExpression__Group__0__Impl : ( () ) ; + public final void rule__XTryCatchFinallyExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21979:1: ( ( () ) ) + // InternalScope.g:21980:1: ( () ) + { + // InternalScope.g:21980:1: ( () ) + // InternalScope.g:21981:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); + } + // InternalScope.g:21982:2: () + // InternalScope.g:21982:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1" + // InternalScope.g:21990:1: rule__XTryCatchFinallyExpression__Group__1 : rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ; + public final void rule__XTryCatchFinallyExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:21994:1: ( rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ) + // InternalScope.g:21995:2: rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 + { + pushFollow(FOLLOW_104); + rule__XTryCatchFinallyExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1__Impl" + // InternalScope.g:22002:1: rule__XTryCatchFinallyExpression__Group__1__Impl : ( 'try' ) ; + public final void rule__XTryCatchFinallyExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22006:1: ( ( 'try' ) ) + // InternalScope.g:22007:1: ( 'try' ) + { + // InternalScope.g:22007:1: ( 'try' ) + // InternalScope.g:22008:2: 'try' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + match(input,112,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2" + // InternalScope.g:22017:1: rule__XTryCatchFinallyExpression__Group__2 : rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ; + public final void rule__XTryCatchFinallyExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22021:1: ( rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ) + // InternalScope.g:22022:2: rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 + { + pushFollow(FOLLOW_133); + rule__XTryCatchFinallyExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2__Impl" + // InternalScope.g:22029:1: rule__XTryCatchFinallyExpression__Group__2__Impl : ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22033:1: ( ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ) + // InternalScope.g:22034:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) + { + // InternalScope.g:22034:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) + // InternalScope.g:22035:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); + } + // InternalScope.g:22036:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) + // InternalScope.g:22036:3: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3" + // InternalScope.g:22044:1: rule__XTryCatchFinallyExpression__Group__3 : rule__XTryCatchFinallyExpression__Group__3__Impl ; + public final void rule__XTryCatchFinallyExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22048:1: ( rule__XTryCatchFinallyExpression__Group__3__Impl ) + // InternalScope.g:22049:2: rule__XTryCatchFinallyExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3__Impl" + // InternalScope.g:22055:1: rule__XTryCatchFinallyExpression__Group__3__Impl : ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22059:1: ( ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ) + // InternalScope.g:22060:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) + { + // InternalScope.g:22060:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) + // InternalScope.g:22061:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); + } + // InternalScope.g:22062:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 ) + // InternalScope.g:22062:3: rule__XTryCatchFinallyExpression__Alternatives_3 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Alternatives_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0" + // InternalScope.g:22071:1: rule__XTryCatchFinallyExpression__Group_3_0__0 : rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22075:1: ( rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ) + // InternalScope.g:22076:2: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 + { + pushFollow(FOLLOW_134); + rule__XTryCatchFinallyExpression__Group_3_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl" + // InternalScope.g:22083:1: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl : ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22087:1: ( ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ) + // InternalScope.g:22088:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) + { + // InternalScope.g:22088:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) + // InternalScope.g:22089:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) + { + // InternalScope.g:22089:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) + // InternalScope.g:22090:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + // InternalScope.g:22091:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + // InternalScope.g:22091:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_135); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + + } + + // InternalScope.g:22094:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) + // InternalScope.g:22095:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + // InternalScope.g:22096:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* + loop173: + do { + int alt173=2; + int LA173_0 = input.LA(1); + + if ( (LA173_0==115) ) { + int LA173_2 = input.LA(2); + + if ( (synpred248_InternalScope()) ) { + alt173=1; + } + + + } + + + switch (alt173) { + case 1 : + // InternalScope.g:22096:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_135); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop173; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); + } + + } + + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1" + // InternalScope.g:22105:1: rule__XTryCatchFinallyExpression__Group_3_0__1 : rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22109:1: ( rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ) + // InternalScope.g:22110:2: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl" + // InternalScope.g:22116:1: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl : ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22120:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ) + // InternalScope.g:22121:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) + { + // InternalScope.g:22121:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) + // InternalScope.g:22122:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); + } + // InternalScope.g:22123:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? + int alt174=2; + int LA174_0 = input.LA(1); + + if ( (LA174_0==113) ) { + int LA174_1 = input.LA(2); + + if ( (synpred249_InternalScope()) ) { + alt174=1; + } + } + switch (alt174) { + case 1 : + // InternalScope.g:22123:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0" + // InternalScope.g:22132:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0 : rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22136:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ) + // InternalScope.g:22137:2: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 + { + pushFollow(FOLLOW_104); + rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl" + // InternalScope.g:22144:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl : ( ( 'finally' ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22148:1: ( ( ( 'finally' ) ) ) + // InternalScope.g:22149:1: ( ( 'finally' ) ) + { + // InternalScope.g:22149:1: ( ( 'finally' ) ) + // InternalScope.g:22150:2: ( 'finally' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + // InternalScope.g:22151:2: ( 'finally' ) + // InternalScope.g:22151:3: 'finally' + { + match(input,113,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1" + // InternalScope.g:22159:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1 : rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22163:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ) + // InternalScope.g:22164:2: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl" + // InternalScope.g:22170:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22174:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ) + // InternalScope.g:22175:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) + { + // InternalScope.g:22175:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) + // InternalScope.g:22176:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); + } + // InternalScope.g:22177:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) + // InternalScope.g:22177:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0" + // InternalScope.g:22186:1: rule__XTryCatchFinallyExpression__Group_3_1__0 : rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22190:1: ( rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ) + // InternalScope.g:22191:2: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 + { + pushFollow(FOLLOW_104); + rule__XTryCatchFinallyExpression__Group_3_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl" + // InternalScope.g:22198:1: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl : ( 'finally' ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22202:1: ( ( 'finally' ) ) + // InternalScope.g:22203:1: ( 'finally' ) + { + // InternalScope.g:22203:1: ( 'finally' ) + // InternalScope.g:22204:2: 'finally' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + match(input,113,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1" + // InternalScope.g:22213:1: rule__XTryCatchFinallyExpression__Group_3_1__1 : rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22217:1: ( rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ) + // InternalScope.g:22218:2: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl" + // InternalScope.g:22224:1: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ; + public final void rule__XTryCatchFinallyExpression__Group_3_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22228:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ) + // InternalScope.g:22229:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) + { + // InternalScope.g:22229:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) + // InternalScope.g:22230:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); + } + // InternalScope.g:22231:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) + // InternalScope.g:22231:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__0" + // InternalScope.g:22240:1: rule__XSynchronizedExpression__Group__0 : rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ; + public final void rule__XSynchronizedExpression__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22244:1: ( rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ) + // InternalScope.g:22245:2: rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 + { + pushFollow(FOLLOW_104); + rule__XSynchronizedExpression__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__0__Impl" + // InternalScope.g:22252:1: rule__XSynchronizedExpression__Group__0__Impl : ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ; + public final void rule__XSynchronizedExpression__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22256:1: ( ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ) + // InternalScope.g:22257:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) ) + { + // InternalScope.g:22257:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) ) + // InternalScope.g:22258:2: ( rule__XSynchronizedExpression__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); + } + // InternalScope.g:22259:2: ( rule__XSynchronizedExpression__Group_0__0 ) + // InternalScope.g:22259:3: rule__XSynchronizedExpression__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__1" + // InternalScope.g:22267:1: rule__XSynchronizedExpression__Group__1 : rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ; + public final void rule__XSynchronizedExpression__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22271:1: ( rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ) + // InternalScope.g:22272:2: rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 + { + pushFollow(FOLLOW_23); + rule__XSynchronizedExpression__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__1" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__1__Impl" + // InternalScope.g:22279:1: rule__XSynchronizedExpression__Group__1__Impl : ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ; + public final void rule__XSynchronizedExpression__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22283:1: ( ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ) + // InternalScope.g:22284:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) + { + // InternalScope.g:22284:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) + // InternalScope.g:22285:2: ( rule__XSynchronizedExpression__ParamAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); + } + // InternalScope.g:22286:2: ( rule__XSynchronizedExpression__ParamAssignment_1 ) + // InternalScope.g:22286:3: rule__XSynchronizedExpression__ParamAssignment_1 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__ParamAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__2" + // InternalScope.g:22294:1: rule__XSynchronizedExpression__Group__2 : rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ; + public final void rule__XSynchronizedExpression__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22298:1: ( rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ) + // InternalScope.g:22299:2: rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 + { + pushFollow(FOLLOW_104); + rule__XSynchronizedExpression__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__2" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__2__Impl" + // InternalScope.g:22306:1: rule__XSynchronizedExpression__Group__2__Impl : ( ')' ) ; + public final void rule__XSynchronizedExpression__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22310:1: ( ( ')' ) ) + // InternalScope.g:22311:1: ( ')' ) + { + // InternalScope.g:22311:1: ( ')' ) + // InternalScope.g:22312:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__2__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__3" + // InternalScope.g:22321:1: rule__XSynchronizedExpression__Group__3 : rule__XSynchronizedExpression__Group__3__Impl ; + public final void rule__XSynchronizedExpression__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22325:1: ( rule__XSynchronizedExpression__Group__3__Impl ) + // InternalScope.g:22326:2: rule__XSynchronizedExpression__Group__3__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__3" + + + // $ANTLR start "rule__XSynchronizedExpression__Group__3__Impl" + // InternalScope.g:22332:1: rule__XSynchronizedExpression__Group__3__Impl : ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ; + public final void rule__XSynchronizedExpression__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22336:1: ( ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ) + // InternalScope.g:22337:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) + { + // InternalScope.g:22337:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) + // InternalScope.g:22338:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); + } + // InternalScope.g:22339:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) + // InternalScope.g:22339:3: rule__XSynchronizedExpression__ExpressionAssignment_3 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__ExpressionAssignment_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group__3__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0__0" + // InternalScope.g:22348:1: rule__XSynchronizedExpression__Group_0__0 : rule__XSynchronizedExpression__Group_0__0__Impl ; + public final void rule__XSynchronizedExpression__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22352:1: ( rule__XSynchronizedExpression__Group_0__0__Impl ) + // InternalScope.g:22353:2: rule__XSynchronizedExpression__Group_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0__0__Impl" + // InternalScope.g:22359:1: rule__XSynchronizedExpression__Group_0__0__Impl : ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ; + public final void rule__XSynchronizedExpression__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22363:1: ( ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ) + // InternalScope.g:22364:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) + { + // InternalScope.g:22364:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) + // InternalScope.g:22365:2: ( rule__XSynchronizedExpression__Group_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); + } + // InternalScope.g:22366:2: ( rule__XSynchronizedExpression__Group_0_0__0 ) + // InternalScope.g:22366:3: rule__XSynchronizedExpression__Group_0_0__0 + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0" + // InternalScope.g:22375:1: rule__XSynchronizedExpression__Group_0_0__0 : rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ; + public final void rule__XSynchronizedExpression__Group_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22379:1: ( rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ) + // InternalScope.g:22380:2: rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 + { + pushFollow(FOLLOW_136); + rule__XSynchronizedExpression__Group_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0__Impl" + // InternalScope.g:22387:1: rule__XSynchronizedExpression__Group_0_0__0__Impl : ( () ) ; + public final void rule__XSynchronizedExpression__Group_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22391:1: ( ( () ) ) + // InternalScope.g:22392:1: ( () ) + { + // InternalScope.g:22392:1: ( () ) + // InternalScope.g:22393:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); + } + // InternalScope.g:22394:2: () + // InternalScope.g:22394:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1" + // InternalScope.g:22402:1: rule__XSynchronizedExpression__Group_0_0__1 : rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ; + public final void rule__XSynchronizedExpression__Group_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22406:1: ( rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ) + // InternalScope.g:22407:2: rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 + { + pushFollow(FOLLOW_31); + rule__XSynchronizedExpression__Group_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__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__XSynchronizedExpression__Group_0_0__1" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1__Impl" + // InternalScope.g:22414:1: rule__XSynchronizedExpression__Group_0_0__1__Impl : ( 'synchronized' ) ; + public final void rule__XSynchronizedExpression__Group_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22418:1: ( ( 'synchronized' ) ) + // InternalScope.g:22419:1: ( 'synchronized' ) + { + // InternalScope.g:22419:1: ( 'synchronized' ) + // InternalScope.g:22420:2: 'synchronized' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + match(input,114,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1__Impl" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2" + // InternalScope.g:22429:1: rule__XSynchronizedExpression__Group_0_0__2 : rule__XSynchronizedExpression__Group_0_0__2__Impl ; + public final void rule__XSynchronizedExpression__Group_0_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22433:1: ( rule__XSynchronizedExpression__Group_0_0__2__Impl ) + // InternalScope.g:22434:2: rule__XSynchronizedExpression__Group_0_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XSynchronizedExpression__Group_0_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2" + + + // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2__Impl" + // InternalScope.g:22440:1: rule__XSynchronizedExpression__Group_0_0__2__Impl : ( '(' ) ; + public final void rule__XSynchronizedExpression__Group_0_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22444:1: ( ( '(' ) ) + // InternalScope.g:22445:1: ( '(' ) + { + // InternalScope.g:22445:1: ( '(' ) + // InternalScope.g:22446:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__0" + // InternalScope.g:22456:1: rule__XCatchClause__Group__0 : rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ; + public final void rule__XCatchClause__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22460:1: ( rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ) + // InternalScope.g:22461:2: rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 + { + pushFollow(FOLLOW_31); + rule__XCatchClause__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__0" + + + // $ANTLR start "rule__XCatchClause__Group__0__Impl" + // InternalScope.g:22468:1: rule__XCatchClause__Group__0__Impl : ( ( 'catch' ) ) ; + public final void rule__XCatchClause__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22472:1: ( ( ( 'catch' ) ) ) + // InternalScope.g:22473:1: ( ( 'catch' ) ) + { + // InternalScope.g:22473:1: ( ( 'catch' ) ) + // InternalScope.g:22474:2: ( 'catch' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + // InternalScope.g:22475:2: ( 'catch' ) + // InternalScope.g:22475:3: 'catch' + { + match(input,115,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__0__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__1" + // InternalScope.g:22483:1: rule__XCatchClause__Group__1 : rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ; + public final void rule__XCatchClause__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22487:1: ( rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ) + // InternalScope.g:22488:2: rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 + { + pushFollow(FOLLOW_84); + rule__XCatchClause__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__1" + + + // $ANTLR start "rule__XCatchClause__Group__1__Impl" + // InternalScope.g:22495:1: rule__XCatchClause__Group__1__Impl : ( '(' ) ; + public final void rule__XCatchClause__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22499:1: ( ( '(' ) ) + // InternalScope.g:22500:1: ( '(' ) + { + // InternalScope.g:22500:1: ( '(' ) + // InternalScope.g:22501:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__1__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__2" + // InternalScope.g:22510:1: rule__XCatchClause__Group__2 : rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ; + public final void rule__XCatchClause__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22514:1: ( rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ) + // InternalScope.g:22515:2: rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 + { + pushFollow(FOLLOW_23); + rule__XCatchClause__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__2" + + + // $ANTLR start "rule__XCatchClause__Group__2__Impl" + // InternalScope.g:22522:1: rule__XCatchClause__Group__2__Impl : ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ; + public final void rule__XCatchClause__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22526:1: ( ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ) + // InternalScope.g:22527:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) + { + // InternalScope.g:22527:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) + // InternalScope.g:22528:2: ( rule__XCatchClause__DeclaredParamAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); + } + // InternalScope.g:22529:2: ( rule__XCatchClause__DeclaredParamAssignment_2 ) + // InternalScope.g:22529:3: rule__XCatchClause__DeclaredParamAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__DeclaredParamAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__2__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__3" + // InternalScope.g:22537:1: rule__XCatchClause__Group__3 : rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ; + public final void rule__XCatchClause__Group__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22541:1: ( rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ) + // InternalScope.g:22542:2: rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 + { + pushFollow(FOLLOW_104); + rule__XCatchClause__Group__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__3" + + + // $ANTLR start "rule__XCatchClause__Group__3__Impl" + // InternalScope.g:22549:1: rule__XCatchClause__Group__3__Impl : ( ')' ) ; + public final void rule__XCatchClause__Group__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22553:1: ( ( ')' ) ) + // InternalScope.g:22554:1: ( ')' ) + { + // InternalScope.g:22554:1: ( ')' ) + // InternalScope.g:22555:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__3__Impl" + + + // $ANTLR start "rule__XCatchClause__Group__4" + // InternalScope.g:22564:1: rule__XCatchClause__Group__4 : rule__XCatchClause__Group__4__Impl ; + public final void rule__XCatchClause__Group__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22568:1: ( rule__XCatchClause__Group__4__Impl ) + // InternalScope.g:22569:2: rule__XCatchClause__Group__4__Impl + { + pushFollow(FOLLOW_2); + rule__XCatchClause__Group__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__4" + + + // $ANTLR start "rule__XCatchClause__Group__4__Impl" + // InternalScope.g:22575:1: rule__XCatchClause__Group__4__Impl : ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ; + public final void rule__XCatchClause__Group__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22579:1: ( ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ) + // InternalScope.g:22580:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) + { + // InternalScope.g:22580:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) + // InternalScope.g:22581:2: ( rule__XCatchClause__ExpressionAssignment_4 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); + } + // InternalScope.g:22582:2: ( rule__XCatchClause__ExpressionAssignment_4 ) + // InternalScope.g:22582:3: rule__XCatchClause__ExpressionAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XCatchClause__ExpressionAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__Group__4__Impl" + + + // $ANTLR start "rule__QualifiedName__Group__0" + // InternalScope.g:22591: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 { + // InternalScope.g:22595:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ) + // InternalScope.g:22596:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 + { + pushFollow(FOLLOW_45); + rule__QualifiedName__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__0" + + + // $ANTLR start "rule__QualifiedName__Group__0__Impl" + // InternalScope.g:22603:1: rule__QualifiedName__Group__0__Impl : ( ruleValidID ) ; + public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22607:1: ( ( ruleValidID ) ) + // InternalScope.g:22608:1: ( ruleValidID ) + { + // InternalScope.g:22608:1: ( ruleValidID ) + // InternalScope.g:22609:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group__1" + // InternalScope.g:22618:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ; + public final void rule__QualifiedName__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22622:1: ( rule__QualifiedName__Group__1__Impl ) + // InternalScope.g:22623:2: rule__QualifiedName__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__1" + + + // $ANTLR start "rule__QualifiedName__Group__1__Impl" + // InternalScope.g:22629: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 { + // InternalScope.g:22633:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) ) + // InternalScope.g:22634:1: ( ( rule__QualifiedName__Group_1__0 )* ) + { + // InternalScope.g:22634:1: ( ( rule__QualifiedName__Group_1__0 )* ) + // InternalScope.g:22635:2: ( rule__QualifiedName__Group_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getGroup_1()); + } + // InternalScope.g:22636:2: ( rule__QualifiedName__Group_1__0 )* + loop175: + do { + int alt175=2; + int LA175_0 = input.LA(1); + + if ( (LA175_0==58) ) { + int LA175_2 = input.LA(2); + + if ( (LA175_2==RULE_ID) ) { + int LA175_3 = input.LA(3); + + if ( (synpred250_InternalScope()) ) { + alt175=1; + } + + + } + + + } + + + switch (alt175) { + case 1 : + // InternalScope.g:22636:3: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_46); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop175; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__0" + // InternalScope.g:22645: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 { + // InternalScope.g:22649:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ) + // InternalScope.g:22650:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 + { + pushFollow(FOLLOW_4); + rule__QualifiedName__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0" + + + // $ANTLR start "rule__QualifiedName__Group_1__0__Impl" + // InternalScope.g:22657:1: rule__QualifiedName__Group_1__0__Impl : ( ( '.' ) ) ; + public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22661:1: ( ( ( '.' ) ) ) + // InternalScope.g:22662:1: ( ( '.' ) ) + { + // InternalScope.g:22662:1: ( ( '.' ) ) + // InternalScope.g:22663:2: ( '.' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + // InternalScope.g:22664:2: ( '.' ) + // InternalScope.g:22664:3: '.' + { + match(input,58,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__0__Impl" + + + // $ANTLR start "rule__QualifiedName__Group_1__1" + // InternalScope.g:22672: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 { + // InternalScope.g:22676:1: ( rule__QualifiedName__Group_1__1__Impl ) + // InternalScope.g:22677:2: rule__QualifiedName__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1" + + + // $ANTLR start "rule__QualifiedName__Group_1__1__Impl" + // InternalScope.g:22683:1: rule__QualifiedName__Group_1__1__Impl : ( ruleValidID ) ; + public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22687:1: ( ( ruleValidID ) ) + // InternalScope.g:22688:1: ( ruleValidID ) + { + // InternalScope.g:22688:1: ( ruleValidID ) + // InternalScope.g:22689:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedName__Group_1__1__Impl" + + + // $ANTLR start "rule__Number__Group_1__0" + // InternalScope.g:22699:1: rule__Number__Group_1__0 : rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ; + public final void rule__Number__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22703:1: ( rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ) + // InternalScope.g:22704:2: rule__Number__Group_1__0__Impl rule__Number__Group_1__1 + { + pushFollow(FOLLOW_45); + rule__Number__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Number__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__0" + + + // $ANTLR start "rule__Number__Group_1__0__Impl" + // InternalScope.g:22711:1: rule__Number__Group_1__0__Impl : ( ( rule__Number__Alternatives_1_0 ) ) ; + public final void rule__Number__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22715:1: ( ( ( rule__Number__Alternatives_1_0 ) ) ) + // InternalScope.g:22716:1: ( ( rule__Number__Alternatives_1_0 ) ) + { + // InternalScope.g:22716:1: ( ( rule__Number__Alternatives_1_0 ) ) + // InternalScope.g:22717:2: ( rule__Number__Alternatives_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives_1_0()); + } + // InternalScope.g:22718:2: ( rule__Number__Alternatives_1_0 ) + // InternalScope.g:22718:3: rule__Number__Alternatives_1_0 + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getAlternatives_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__0__Impl" + + + // $ANTLR start "rule__Number__Group_1__1" + // InternalScope.g:22726:1: rule__Number__Group_1__1 : rule__Number__Group_1__1__Impl ; + public final void rule__Number__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22730:1: ( rule__Number__Group_1__1__Impl ) + // InternalScope.g:22731:2: rule__Number__Group_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Number__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__1" + + + // $ANTLR start "rule__Number__Group_1__1__Impl" + // InternalScope.g:22737:1: rule__Number__Group_1__1__Impl : ( ( rule__Number__Group_1_1__0 )? ) ; + public final void rule__Number__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22741:1: ( ( ( rule__Number__Group_1_1__0 )? ) ) + // InternalScope.g:22742:1: ( ( rule__Number__Group_1_1__0 )? ) + { + // InternalScope.g:22742:1: ( ( rule__Number__Group_1_1__0 )? ) + // InternalScope.g:22743:2: ( rule__Number__Group_1_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getGroup_1_1()); + } + // InternalScope.g:22744:2: ( rule__Number__Group_1_1__0 )? + int alt176=2; + int LA176_0 = input.LA(1); + + if ( (LA176_0==58) ) { + int LA176_1 = input.LA(2); + + if ( ((LA176_1>=RULE_INT && LA176_1<=RULE_DECIMAL)) ) { + alt176=1; + } + } + switch (alt176) { + case 1 : + // InternalScope.g:22744:3: rule__Number__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getGroup_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1__1__Impl" + + + // $ANTLR start "rule__Number__Group_1_1__0" + // InternalScope.g:22753:1: rule__Number__Group_1_1__0 : rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ; + public final void rule__Number__Group_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22757:1: ( rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ) + // InternalScope.g:22758:2: rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 + { + pushFollow(FOLLOW_137); + rule__Number__Group_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__0" + + + // $ANTLR start "rule__Number__Group_1_1__0__Impl" + // InternalScope.g:22765:1: rule__Number__Group_1_1__0__Impl : ( '.' ) ; + public final void rule__Number__Group_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22769:1: ( ( '.' ) ) + // InternalScope.g:22770:1: ( '.' ) + { + // InternalScope.g:22770:1: ( '.' ) + // InternalScope.g:22771:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__0__Impl" + + + // $ANTLR start "rule__Number__Group_1_1__1" + // InternalScope.g:22780:1: rule__Number__Group_1_1__1 : rule__Number__Group_1_1__1__Impl ; + public final void rule__Number__Group_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22784:1: ( rule__Number__Group_1_1__1__Impl ) + // InternalScope.g:22785:2: rule__Number__Group_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__Number__Group_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__1" + + + // $ANTLR start "rule__Number__Group_1_1__1__Impl" + // InternalScope.g:22791:1: rule__Number__Group_1_1__1__Impl : ( ( rule__Number__Alternatives_1_1_1 ) ) ; + public final void rule__Number__Group_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22795:1: ( ( ( rule__Number__Alternatives_1_1_1 ) ) ) + // InternalScope.g:22796:1: ( ( rule__Number__Alternatives_1_1_1 ) ) + { + // InternalScope.g:22796:1: ( ( rule__Number__Alternatives_1_1_1 ) ) + // InternalScope.g:22797:2: ( rule__Number__Alternatives_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); + } + // InternalScope.g:22798:2: ( rule__Number__Alternatives_1_1_1 ) + // InternalScope.g:22798:3: rule__Number__Alternatives_1_1_1 + { + pushFollow(FOLLOW_2); + rule__Number__Alternatives_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Number__Group_1_1__1__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__0" + // InternalScope.g:22807:1: rule__JvmTypeReference__Group_0__0 : rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ; + public final void rule__JvmTypeReference__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22811:1: ( rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ) + // InternalScope.g:22812:2: rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 + { + pushFollow(FOLLOW_29); + rule__JvmTypeReference__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__0__Impl" + // InternalScope.g:22819:1: rule__JvmTypeReference__Group_0__0__Impl : ( ruleJvmParameterizedTypeReference ) ; + public final void rule__JvmTypeReference__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22823:1: ( ( ruleJvmParameterizedTypeReference ) ) + // InternalScope.g:22824:1: ( ruleJvmParameterizedTypeReference ) + { + // InternalScope.g:22824:1: ( ruleJvmParameterizedTypeReference ) + // InternalScope.g:22825:2: ruleJvmParameterizedTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__1" + // InternalScope.g:22834:1: rule__JvmTypeReference__Group_0__1 : rule__JvmTypeReference__Group_0__1__Impl ; + public final void rule__JvmTypeReference__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22838:1: ( rule__JvmTypeReference__Group_0__1__Impl ) + // InternalScope.g:22839:2: rule__JvmTypeReference__Group_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__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__JvmTypeReference__Group_0__1" + + + // $ANTLR start "rule__JvmTypeReference__Group_0__1__Impl" + // InternalScope.g:22845:1: rule__JvmTypeReference__Group_0__1__Impl : ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ; + public final void rule__JvmTypeReference__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22849:1: ( ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ) + // InternalScope.g:22850:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) + { + // InternalScope.g:22850:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* ) + // InternalScope.g:22851:2: ( rule__JvmTypeReference__Group_0_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); + } + // InternalScope.g:22852:2: ( rule__JvmTypeReference__Group_0_1__0 )* + loop177: + do { + int alt177=2; + int LA177_0 = input.LA(1); + + if ( (LA177_0==82) ) { + int LA177_2 = input.LA(2); + + if ( (LA177_2==83) ) { + int LA177_3 = input.LA(3); + + if ( (synpred252_InternalScope()) ) { + alt177=1; + } + + + } + + + } + + + switch (alt177) { + case 1 : + // InternalScope.g:22852:3: rule__JvmTypeReference__Group_0_1__0 + { + pushFollow(FOLLOW_129); + rule__JvmTypeReference__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop177; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0__1__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1__0" + // InternalScope.g:22861:1: rule__JvmTypeReference__Group_0_1__0 : rule__JvmTypeReference__Group_0_1__0__Impl ; + public final void rule__JvmTypeReference__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22865:1: ( rule__JvmTypeReference__Group_0_1__0__Impl ) + // InternalScope.g:22866:2: rule__JvmTypeReference__Group_0_1__0__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1__0__Impl" + // InternalScope.g:22872:1: rule__JvmTypeReference__Group_0_1__0__Impl : ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ; + public final void rule__JvmTypeReference__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22876:1: ( ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ) + // InternalScope.g:22877:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) + { + // InternalScope.g:22877:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) + // InternalScope.g:22878:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); + } + // InternalScope.g:22879:2: ( rule__JvmTypeReference__Group_0_1_0__0 ) + // InternalScope.g:22879:3: rule__JvmTypeReference__Group_0_1_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0" + // InternalScope.g:22888:1: rule__JvmTypeReference__Group_0_1_0__0 : rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ; + public final void rule__JvmTypeReference__Group_0_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22892:1: ( rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ) + // InternalScope.g:22893:2: rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 + { + pushFollow(FOLLOW_29); + rule__JvmTypeReference__Group_0_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0__Impl" + // InternalScope.g:22900:1: rule__JvmTypeReference__Group_0_1_0__0__Impl : ( () ) ; + public final void rule__JvmTypeReference__Group_0_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22904:1: ( ( () ) ) + // InternalScope.g:22905:1: ( () ) + { + // InternalScope.g:22905:1: ( () ) + // InternalScope.g:22906:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); + } + // InternalScope.g:22907:2: () + // InternalScope.g:22907:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0__Impl" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1" + // InternalScope.g:22915:1: rule__JvmTypeReference__Group_0_1_0__1 : rule__JvmTypeReference__Group_0_1_0__1__Impl ; + public final void rule__JvmTypeReference__Group_0_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22919:1: ( rule__JvmTypeReference__Group_0_1_0__1__Impl ) + // InternalScope.g:22920:2: rule__JvmTypeReference__Group_0_1_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1" + + + // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1__Impl" + // InternalScope.g:22926:1: rule__JvmTypeReference__Group_0_1_0__1__Impl : ( ruleArrayBrackets ) ; + public final void rule__JvmTypeReference__Group_0_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22930:1: ( ( ruleArrayBrackets ) ) + // InternalScope.g:22931:1: ( ruleArrayBrackets ) + { + // InternalScope.g:22931:1: ( ruleArrayBrackets ) + // InternalScope.g:22932:2: ruleArrayBrackets + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1__Impl" + + + // $ANTLR start "rule__ArrayBrackets__Group__0" + // InternalScope.g:22942:1: rule__ArrayBrackets__Group__0 : rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ; + public final void rule__ArrayBrackets__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22946:1: ( rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ) + // InternalScope.g:22947:2: rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 + { + pushFollow(FOLLOW_30); + rule__ArrayBrackets__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__0" + + + // $ANTLR start "rule__ArrayBrackets__Group__0__Impl" + // InternalScope.g:22954:1: rule__ArrayBrackets__Group__0__Impl : ( '[' ) ; + public final void rule__ArrayBrackets__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22958:1: ( ( '[' ) ) + // InternalScope.g:22959:1: ( '[' ) + { + // InternalScope.g:22959:1: ( '[' ) + // InternalScope.g:22960:2: '[' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + match(input,82,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__0__Impl" + + + // $ANTLR start "rule__ArrayBrackets__Group__1" + // InternalScope.g:22969:1: rule__ArrayBrackets__Group__1 : rule__ArrayBrackets__Group__1__Impl ; + public final void rule__ArrayBrackets__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22973:1: ( rule__ArrayBrackets__Group__1__Impl ) + // InternalScope.g:22974:2: rule__ArrayBrackets__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__ArrayBrackets__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__1" + + + // $ANTLR start "rule__ArrayBrackets__Group__1__Impl" + // InternalScope.g:22980:1: rule__ArrayBrackets__Group__1__Impl : ( ']' ) ; + public final void rule__ArrayBrackets__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:22984:1: ( ( ']' ) ) + // InternalScope.g:22985:1: ( ']' ) + { + // InternalScope.g:22985:1: ( ']' ) + // InternalScope.g:22986:2: ']' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + match(input,83,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ArrayBrackets__Group__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__0" + // InternalScope.g:22996:1: rule__XFunctionTypeRef__Group__0 : rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ; + public final void rule__XFunctionTypeRef__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23000:1: ( rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ) + // InternalScope.g:23001:2: rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 + { + pushFollow(FOLLOW_84); + rule__XFunctionTypeRef__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__0__Impl" + // InternalScope.g:23008:1: rule__XFunctionTypeRef__Group__0__Impl : ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ; + public final void rule__XFunctionTypeRef__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23012:1: ( ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ) + // InternalScope.g:23013:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) + { + // InternalScope.g:23013:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? ) + // InternalScope.g:23014:2: ( rule__XFunctionTypeRef__Group_0__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); + } + // InternalScope.g:23015:2: ( rule__XFunctionTypeRef__Group_0__0 )? + int alt178=2; + int LA178_0 = input.LA(1); + + if ( (LA178_0==77) ) { + alt178=1; + } + switch (alt178) { + case 1 : + // InternalScope.g:23015:3: rule__XFunctionTypeRef__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__1" + // InternalScope.g:23023:1: rule__XFunctionTypeRef__Group__1 : rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ; + public final void rule__XFunctionTypeRef__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23027:1: ( rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ) + // InternalScope.g:23028:2: rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 + { + pushFollow(FOLLOW_84); + rule__XFunctionTypeRef__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__1__Impl" + // InternalScope.g:23035:1: rule__XFunctionTypeRef__Group__1__Impl : ( '=>' ) ; + public final void rule__XFunctionTypeRef__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23039:1: ( ( '=>' ) ) + // InternalScope.g:23040:1: ( '=>' ) + { + // InternalScope.g:23040:1: ( '=>' ) + // InternalScope.g:23041:2: '=>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + match(input,51,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__2" + // InternalScope.g:23050:1: rule__XFunctionTypeRef__Group__2 : rule__XFunctionTypeRef__Group__2__Impl ; + public final void rule__XFunctionTypeRef__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23054:1: ( rule__XFunctionTypeRef__Group__2__Impl ) + // InternalScope.g:23055:2: rule__XFunctionTypeRef__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__2" + + + // $ANTLR start "rule__XFunctionTypeRef__Group__2__Impl" + // InternalScope.g:23061:1: rule__XFunctionTypeRef__Group__2__Impl : ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ; + public final void rule__XFunctionTypeRef__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23065:1: ( ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ) + // InternalScope.g:23066:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) + { + // InternalScope.g:23066:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) + // InternalScope.g:23067:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); + } + // InternalScope.g:23068:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) + // InternalScope.g:23068:3: rule__XFunctionTypeRef__ReturnTypeAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ReturnTypeAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group__2__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__0" + // InternalScope.g:23077:1: rule__XFunctionTypeRef__Group_0__0 : rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ; + public final void rule__XFunctionTypeRef__Group_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23081:1: ( rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ) + // InternalScope.g:23082:2: rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 + { + pushFollow(FOLLOW_138); + rule__XFunctionTypeRef__Group_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__0__Impl" + // InternalScope.g:23089:1: rule__XFunctionTypeRef__Group_0__0__Impl : ( '(' ) ; + public final void rule__XFunctionTypeRef__Group_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23093:1: ( ( '(' ) ) + // InternalScope.g:23094:1: ( '(' ) + { + // InternalScope.g:23094:1: ( '(' ) + // InternalScope.g:23095:2: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__1" + // InternalScope.g:23104:1: rule__XFunctionTypeRef__Group_0__1 : rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ; + public final void rule__XFunctionTypeRef__Group_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23108:1: ( rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ) + // InternalScope.g:23109:2: rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 + { + pushFollow(FOLLOW_138); + rule__XFunctionTypeRef__Group_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__1__Impl" + // InternalScope.g:23116:1: rule__XFunctionTypeRef__Group_0__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ; + public final void rule__XFunctionTypeRef__Group_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23120:1: ( ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ) + // InternalScope.g:23121:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) + { + // InternalScope.g:23121:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) + // InternalScope.g:23122:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); + } + // InternalScope.g:23123:2: ( rule__XFunctionTypeRef__Group_0_1__0 )? + int alt179=2; + int LA179_0 = input.LA(1); + + if ( (LA179_0==RULE_ID||LA179_0==51||LA179_0==77) ) { + alt179=1; + } + switch (alt179) { + case 1 : + // InternalScope.g:23123:3: rule__XFunctionTypeRef__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__2" + // InternalScope.g:23131:1: rule__XFunctionTypeRef__Group_0__2 : rule__XFunctionTypeRef__Group_0__2__Impl ; + public final void rule__XFunctionTypeRef__Group_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23135:1: ( rule__XFunctionTypeRef__Group_0__2__Impl ) + // InternalScope.g:23136:2: rule__XFunctionTypeRef__Group_0__2__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__2" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0__2__Impl" + // InternalScope.g:23142:1: rule__XFunctionTypeRef__Group_0__2__Impl : ( ')' ) ; + public final void rule__XFunctionTypeRef__Group_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23146:1: ( ( ')' ) ) + // InternalScope.g:23147:1: ( ')' ) + { + // InternalScope.g:23147:1: ( ')' ) + // InternalScope.g:23148:2: ')' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + match(input,78,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0__2__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0" + // InternalScope.g:23158:1: rule__XFunctionTypeRef__Group_0_1__0 : rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ; + public final void rule__XFunctionTypeRef__Group_0_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23162:1: ( rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ) + // InternalScope.g:23163:2: rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 + { + pushFollow(FOLLOW_71); + rule__XFunctionTypeRef__Group_0_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0__Impl" + // InternalScope.g:23170:1: rule__XFunctionTypeRef__Group_0_1__0__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ; + public final void rule__XFunctionTypeRef__Group_0_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23174:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ) + // InternalScope.g:23175:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) + { + // InternalScope.g:23175:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) + // InternalScope.g:23176:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); + } + // InternalScope.g:23177:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) + // InternalScope.g:23177:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1" + // InternalScope.g:23185:1: rule__XFunctionTypeRef__Group_0_1__1 : rule__XFunctionTypeRef__Group_0_1__1__Impl ; + public final void rule__XFunctionTypeRef__Group_0_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23189:1: ( rule__XFunctionTypeRef__Group_0_1__1__Impl ) + // InternalScope.g:23190:2: rule__XFunctionTypeRef__Group_0_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1__Impl" + // InternalScope.g:23196:1: rule__XFunctionTypeRef__Group_0_1__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ; + public final void rule__XFunctionTypeRef__Group_0_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23200:1: ( ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ) + // InternalScope.g:23201:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) + { + // InternalScope.g:23201:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) + // InternalScope.g:23202:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); + } + // InternalScope.g:23203:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )* + loop180: + do { + int alt180=2; + int LA180_0 = input.LA(1); + + if ( (LA180_0==86) ) { + alt180=1; + } + + + switch (alt180) { + case 1 : + // InternalScope.g:23203:3: rule__XFunctionTypeRef__Group_0_1_1__0 + { + pushFollow(FOLLOW_39); + rule__XFunctionTypeRef__Group_0_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop180; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0" + // InternalScope.g:23212:1: rule__XFunctionTypeRef__Group_0_1_1__0 : rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ; + public final void rule__XFunctionTypeRef__Group_0_1_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23216:1: ( rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ) + // InternalScope.g:23217:2: rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 + { + pushFollow(FOLLOW_84); + rule__XFunctionTypeRef__Group_0_1_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" + // InternalScope.g:23224:1: rule__XFunctionTypeRef__Group_0_1_1__0__Impl : ( ',' ) ; + public final void rule__XFunctionTypeRef__Group_0_1_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23228:1: ( ( ',' ) ) + // InternalScope.g:23229:1: ( ',' ) + { + // InternalScope.g:23229:1: ( ',' ) + // InternalScope.g:23230:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0__Impl" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1" + // InternalScope.g:23239:1: rule__XFunctionTypeRef__Group_0_1_1__1 : rule__XFunctionTypeRef__Group_0_1_1__1__Impl ; + public final void rule__XFunctionTypeRef__Group_0_1_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23243:1: ( rule__XFunctionTypeRef__Group_0_1_1__1__Impl ) + // InternalScope.g:23244:2: rule__XFunctionTypeRef__Group_0_1_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__Group_0_1_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1" + + + // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" + // InternalScope.g:23250:1: rule__XFunctionTypeRef__Group_0_1_1__1__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ; + public final void rule__XFunctionTypeRef__Group_0_1_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23254:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ) + // InternalScope.g:23255:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) + { + // InternalScope.g:23255:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) + // InternalScope.g:23256:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); + } + // InternalScope.g:23257:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) + // InternalScope.g:23257:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 + { + pushFollow(FOLLOW_2); + rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0" + // InternalScope.g:23266:1: rule__JvmParameterizedTypeReference__Group__0 : rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ; + public final void rule__JvmParameterizedTypeReference__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23270:1: ( rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ) + // InternalScope.g:23271:2: rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 + { + pushFollow(FOLLOW_78); + rule__JvmParameterizedTypeReference__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0__Impl" + // InternalScope.g:23278:1: rule__JvmParameterizedTypeReference__Group__0__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23282:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ) + // InternalScope.g:23283:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) + { + // InternalScope.g:23283:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) + // InternalScope.g:23284:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); + } + // InternalScope.g:23285:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) + // InternalScope.g:23285:3: rule__JvmParameterizedTypeReference__TypeAssignment_0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__TypeAssignment_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1" + // InternalScope.g:23293:1: rule__JvmParameterizedTypeReference__Group__1 : rule__JvmParameterizedTypeReference__Group__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23297:1: ( rule__JvmParameterizedTypeReference__Group__1__Impl ) + // InternalScope.g:23298:2: rule__JvmParameterizedTypeReference__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1__Impl" + // InternalScope.g:23304:1: rule__JvmParameterizedTypeReference__Group__1__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ; + public final void rule__JvmParameterizedTypeReference__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23308:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ) + // InternalScope.g:23309:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) + { + // InternalScope.g:23309:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) + // InternalScope.g:23310:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); + } + // InternalScope.g:23311:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )? + int alt181=2; + alt181 = dfa181.predict(input); + switch (alt181) { + case 1 : + // InternalScope.g:23311:3: rule__JvmParameterizedTypeReference__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0" + // InternalScope.g:23320:1: rule__JvmParameterizedTypeReference__Group_1__0 : rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23324:1: ( rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ) + // InternalScope.g:23325:2: rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 + { + pushFollow(FOLLOW_101); + rule__JvmParameterizedTypeReference__Group_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0__Impl" + // InternalScope.g:23332:1: rule__JvmParameterizedTypeReference__Group_1__0__Impl : ( ( '<' ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23336:1: ( ( ( '<' ) ) ) + // InternalScope.g:23337:1: ( ( '<' ) ) + { + // InternalScope.g:23337:1: ( ( '<' ) ) + // InternalScope.g:23338:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + // InternalScope.g:23339:2: ( '<' ) + // InternalScope.g:23339:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1" + // InternalScope.g:23347:1: rule__JvmParameterizedTypeReference__Group_1__1 : rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23351:1: ( rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ) + // InternalScope.g:23352:2: rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 + { + pushFollow(FOLLOW_102); + rule__JvmParameterizedTypeReference__Group_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1__Impl" + // InternalScope.g:23359:1: rule__JvmParameterizedTypeReference__Group_1__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23363:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ) + // InternalScope.g:23364:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) + { + // InternalScope.g:23364:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) + // InternalScope.g:23365:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); + } + // InternalScope.g:23366:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) + // InternalScope.g:23366:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2" + // InternalScope.g:23374:1: rule__JvmParameterizedTypeReference__Group_1__2 : rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ; + public final void rule__JvmParameterizedTypeReference__Group_1__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23378:1: ( rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ) + // InternalScope.g:23379:2: rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 + { + pushFollow(FOLLOW_102); + rule__JvmParameterizedTypeReference__Group_1__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2__Impl" + // InternalScope.g:23386:1: rule__JvmParameterizedTypeReference__Group_1__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23390:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ) + // InternalScope.g:23391:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) + { + // InternalScope.g:23391:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) + // InternalScope.g:23392:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); + } + // InternalScope.g:23393:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* + loop182: + do { + int alt182=2; + int LA182_0 = input.LA(1); + + if ( (LA182_0==86) ) { + alt182=1; + } + + + switch (alt182) { + case 1 : + // InternalScope.g:23393:3: rule__JvmParameterizedTypeReference__Group_1_2__0 + { + pushFollow(FOLLOW_39); + rule__JvmParameterizedTypeReference__Group_1_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop182; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3" + // InternalScope.g:23401:1: rule__JvmParameterizedTypeReference__Group_1__3 : rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ; + public final void rule__JvmParameterizedTypeReference__Group_1__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23405:1: ( rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ) + // InternalScope.g:23406:2: rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 + { + pushFollow(FOLLOW_45); + rule__JvmParameterizedTypeReference__Group_1__3__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__4(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3__Impl" + // InternalScope.g:23413:1: rule__JvmParameterizedTypeReference__Group_1__3__Impl : ( '>' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23417:1: ( ( '>' ) ) + // InternalScope.g:23418:1: ( '>' ) + { + // InternalScope.g:23418:1: ( '>' ) + // InternalScope.g:23419:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4" + // InternalScope.g:23428:1: rule__JvmParameterizedTypeReference__Group_1__4 : rule__JvmParameterizedTypeReference__Group_1__4__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1__4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23432:1: ( rule__JvmParameterizedTypeReference__Group_1__4__Impl ) + // InternalScope.g:23433:2: rule__JvmParameterizedTypeReference__Group_1__4__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__4__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4__Impl" + // InternalScope.g:23439:1: rule__JvmParameterizedTypeReference__Group_1__4__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1__4__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23443:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ) + // InternalScope.g:23444:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) + { + // InternalScope.g:23444:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) + // InternalScope.g:23445:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); + } + // InternalScope.g:23446:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* + loop183: + do { + int alt183=2; + int LA183_0 = input.LA(1); + + if ( (LA183_0==58) ) { + int LA183_2 = input.LA(2); + + if ( (LA183_2==RULE_ID) ) { + int LA183_3 = input.LA(3); + + if ( (synpred258_InternalScope()) ) { + alt183=1; + } + + + } + + + } + + + switch (alt183) { + case 1 : + // InternalScope.g:23446:3: rule__JvmParameterizedTypeReference__Group_1_4__0 + { + pushFollow(FOLLOW_46); + rule__JvmParameterizedTypeReference__Group_1_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop183; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0" + // InternalScope.g:23455:1: rule__JvmParameterizedTypeReference__Group_1_2__0 : rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23459:1: ( rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ) + // InternalScope.g:23460:2: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 + { + pushFollow(FOLLOW_101); + rule__JvmParameterizedTypeReference__Group_1_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" + // InternalScope.g:23467:1: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl : ( ',' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23471:1: ( ( ',' ) ) + // InternalScope.g:23472:1: ( ',' ) + { + // InternalScope.g:23472:1: ( ',' ) + // InternalScope.g:23473:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1" + // InternalScope.g:23482:1: rule__JvmParameterizedTypeReference__Group_1_2__1 : rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23486:1: ( rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ) + // InternalScope.g:23487:2: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" + // InternalScope.g:23493:1: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23497:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ) + // InternalScope.g:23498:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) + { + // InternalScope.g:23498:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) + // InternalScope.g:23499:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); + } + // InternalScope.g:23500:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) + // InternalScope.g:23500:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0" + // InternalScope.g:23509:1: rule__JvmParameterizedTypeReference__Group_1_4__0 : rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23513:1: ( rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ) + // InternalScope.g:23514:2: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 + { + pushFollow(FOLLOW_4); + rule__JvmParameterizedTypeReference__Group_1_4__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" + // InternalScope.g:23521:1: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23525:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ) + // InternalScope.g:23526:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) + { + // InternalScope.g:23526:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) + // InternalScope.g:23527:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); + } + // InternalScope.g:23528:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) + // InternalScope.g:23528:3: rule__JvmParameterizedTypeReference__Group_1_4_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1" + // InternalScope.g:23536:1: rule__JvmParameterizedTypeReference__Group_1_4__1 : rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23540:1: ( rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ) + // InternalScope.g:23541:2: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 + { + pushFollow(FOLLOW_78); + rule__JvmParameterizedTypeReference__Group_1_4__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" + // InternalScope.g:23548:1: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23552:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ) + // InternalScope.g:23553:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) + { + // InternalScope.g:23553:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) + // InternalScope.g:23554:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); + } + // InternalScope.g:23555:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) + // InternalScope.g:23555:3: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2" + // InternalScope.g:23563:1: rule__JvmParameterizedTypeReference__Group_1_4__2 : rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23567:1: ( rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ) + // InternalScope.g:23568:2: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" + // InternalScope.g:23574:1: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23578:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ) + // InternalScope.g:23579:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) + { + // InternalScope.g:23579:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) + // InternalScope.g:23580:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); + } + // InternalScope.g:23581:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? + int alt184=2; + alt184 = dfa184.predict(input); + switch (alt184) { + case 1 : + // InternalScope.g:23581:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0" + // InternalScope.g:23590:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23594:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ) + // InternalScope.g:23595:2: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" + // InternalScope.g:23601:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23605:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ) + // InternalScope.g:23606:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) + { + // InternalScope.g:23606:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) + // InternalScope.g:23607:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); + } + // InternalScope.g:23608:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) + // InternalScope.g:23608:3: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" + // InternalScope.g:23617:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23621:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ) + // InternalScope.g:23622:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 + { + pushFollow(FOLLOW_45); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" + // InternalScope.g:23629:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl : ( () ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23633:1: ( ( () ) ) + // InternalScope.g:23634:1: ( () ) + { + // InternalScope.g:23634:1: ( () ) + // InternalScope.g:23635:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); + } + // InternalScope.g:23636:2: () + // InternalScope.g:23636:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" + // InternalScope.g:23644:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23648:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ) + // InternalScope.g:23649:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" + // InternalScope.g:23655:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl : ( '.' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23659:1: ( ( '.' ) ) + // InternalScope.g:23660:1: ( '.' ) + { + // InternalScope.g:23660:1: ( '.' ) + // InternalScope.g:23661:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0" + // InternalScope.g:23671:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23675:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ) + // InternalScope.g:23676:2: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 + { + pushFollow(FOLLOW_101); + rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" + // InternalScope.g:23683:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl : ( ( '<' ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23687:1: ( ( ( '<' ) ) ) + // InternalScope.g:23688:1: ( ( '<' ) ) + { + // InternalScope.g:23688:1: ( ( '<' ) ) + // InternalScope.g:23689:2: ( '<' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + // InternalScope.g:23690:2: ( '<' ) + // InternalScope.g:23690:3: '<' + { + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1" + // InternalScope.g:23698:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23702:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ) + // InternalScope.g:23703:2: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 + { + pushFollow(FOLLOW_102); + rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" + // InternalScope.g:23710:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23714:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ) + // InternalScope.g:23715:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) + { + // InternalScope.g:23715:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) + // InternalScope.g:23716:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); + } + // InternalScope.g:23717:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) + // InternalScope.g:23717:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2" + // InternalScope.g:23725:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2 : rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23729:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ) + // InternalScope.g:23730:2: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 + { + pushFollow(FOLLOW_102); + rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" + // InternalScope.g:23737:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23741:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ) + // InternalScope.g:23742:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) + { + // InternalScope.g:23742:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) + // InternalScope.g:23743:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); + } + // InternalScope.g:23744:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* + loop185: + do { + int alt185=2; + int LA185_0 = input.LA(1); + + if ( (LA185_0==86) ) { + alt185=1; + } + + + switch (alt185) { + case 1 : + // InternalScope.g:23744:3: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 + { + pushFollow(FOLLOW_39); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop185; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3" + // InternalScope.g:23752:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3 : rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23756:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ) + // InternalScope.g:23757:2: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" + // InternalScope.g:23763:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl : ( '>' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23767:1: ( ( '>' ) ) + // InternalScope.g:23768:1: ( '>' ) + { + // InternalScope.g:23768:1: ( '>' ) + // InternalScope.g:23769:2: '>' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + match(input,21,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" + // InternalScope.g:23779:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23783:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ) + // InternalScope.g:23784:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 + { + pushFollow(FOLLOW_101); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" + // InternalScope.g:23791:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl : ( ',' ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23795:1: ( ( ',' ) ) + // InternalScope.g:23796:1: ( ',' ) + { + // InternalScope.g:23796:1: ( ',' ) + // InternalScope.g:23797:2: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" + // InternalScope.g:23806:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23810:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ) + // InternalScope.g:23811:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" + // InternalScope.g:23817:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ; + public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23821:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ) + // InternalScope.g:23822:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) + { + // InternalScope.g:23822:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) + // InternalScope.g:23823:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); + } + // InternalScope.g:23824:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) + // InternalScope.g:23824:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__0" + // InternalScope.g:23833:1: rule__JvmWildcardTypeReference__Group__0 : rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ; + public final void rule__JvmWildcardTypeReference__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23837:1: ( rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ) + // InternalScope.g:23838:2: rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 + { + pushFollow(FOLLOW_101); + rule__JvmWildcardTypeReference__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__0__Impl" + // InternalScope.g:23845:1: rule__JvmWildcardTypeReference__Group__0__Impl : ( () ) ; + public final void rule__JvmWildcardTypeReference__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23849:1: ( ( () ) ) + // InternalScope.g:23850:1: ( () ) + { + // InternalScope.g:23850:1: ( () ) + // InternalScope.g:23851:2: () + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); + } + // InternalScope.g:23852:2: () + // InternalScope.g:23852:3: + { + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); + } + + } + + + } + + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__1" + // InternalScope.g:23860:1: rule__JvmWildcardTypeReference__Group__1 : rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ; + public final void rule__JvmWildcardTypeReference__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23864:1: ( rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ) + // InternalScope.g:23865:2: rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 + { + pushFollow(FOLLOW_139); + rule__JvmWildcardTypeReference__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__1__Impl" + // InternalScope.g:23872:1: rule__JvmWildcardTypeReference__Group__1__Impl : ( '?' ) ; + public final void rule__JvmWildcardTypeReference__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23876:1: ( ( '?' ) ) + // InternalScope.g:23877:1: ( '?' ) + { + // InternalScope.g:23877:1: ( '?' ) + // InternalScope.g:23878:2: '?' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + match(input,96,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__2" + // InternalScope.g:23887:1: rule__JvmWildcardTypeReference__Group__2 : rule__JvmWildcardTypeReference__Group__2__Impl ; + public final void rule__JvmWildcardTypeReference__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23891:1: ( rule__JvmWildcardTypeReference__Group__2__Impl ) + // InternalScope.g:23892:2: rule__JvmWildcardTypeReference__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__2" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group__2__Impl" + // InternalScope.g:23898:1: rule__JvmWildcardTypeReference__Group__2__Impl : ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ; + public final void rule__JvmWildcardTypeReference__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23902:1: ( ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ) + // InternalScope.g:23903:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) + { + // InternalScope.g:23903:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) + // InternalScope.g:23904:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); + } + // InternalScope.g:23905:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )? + int alt186=2; + int LA186_0 = input.LA(1); + + if ( (LA186_0==60||LA186_0==64) ) { + alt186=1; + } + switch (alt186) { + case 1 : + // InternalScope.g:23905:3: rule__JvmWildcardTypeReference__Alternatives_2 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Alternatives_2(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group__2__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0" + // InternalScope.g:23914:1: rule__JvmWildcardTypeReference__Group_2_0__0 : rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ; + public final void rule__JvmWildcardTypeReference__Group_2_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23918:1: ( rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ) + // InternalScope.g:23919:2: rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 + { + pushFollow(FOLLOW_140); + rule__JvmWildcardTypeReference__Group_2_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" + // InternalScope.g:23926:1: rule__JvmWildcardTypeReference__Group_2_0__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ; + public final void rule__JvmWildcardTypeReference__Group_2_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23930:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ) + // InternalScope.g:23931:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) + { + // InternalScope.g:23931:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) + // InternalScope.g:23932:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); + } + // InternalScope.g:23933:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) + // InternalScope.g:23933:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1" + // InternalScope.g:23941:1: rule__JvmWildcardTypeReference__Group_2_0__1 : rule__JvmWildcardTypeReference__Group_2_0__1__Impl ; + public final void rule__JvmWildcardTypeReference__Group_2_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23945:1: ( rule__JvmWildcardTypeReference__Group_2_0__1__Impl ) + // InternalScope.g:23946:2: rule__JvmWildcardTypeReference__Group_2_0__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" + // InternalScope.g:23952:1: rule__JvmWildcardTypeReference__Group_2_0__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ; + public final void rule__JvmWildcardTypeReference__Group_2_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23956:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ) + // InternalScope.g:23957:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) + { + // InternalScope.g:23957:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) + // InternalScope.g:23958:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); + } + // InternalScope.g:23959:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* + loop187: + do { + int alt187=2; + int LA187_0 = input.LA(1); + + if ( (LA187_0==116) ) { + alt187=1; + } + + + switch (alt187) { + case 1 : + // InternalScope.g:23959:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 + { + pushFollow(FOLLOW_141); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop187; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0" + // InternalScope.g:23968:1: rule__JvmWildcardTypeReference__Group_2_1__0 : rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ; + public final void rule__JvmWildcardTypeReference__Group_2_1__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23972:1: ( rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ) + // InternalScope.g:23973:2: rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 + { + pushFollow(FOLLOW_140); + rule__JvmWildcardTypeReference__Group_2_1__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" + // InternalScope.g:23980:1: rule__JvmWildcardTypeReference__Group_2_1__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ; + public final void rule__JvmWildcardTypeReference__Group_2_1__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23984:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ) + // InternalScope.g:23985:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) + { + // InternalScope.g:23985:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) + // InternalScope.g:23986:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); + } + // InternalScope.g:23987:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) + // InternalScope.g:23987:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0__Impl" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1" + // InternalScope.g:23995:1: rule__JvmWildcardTypeReference__Group_2_1__1 : rule__JvmWildcardTypeReference__Group_2_1__1__Impl ; + public final void rule__JvmWildcardTypeReference__Group_2_1__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:23999:1: ( rule__JvmWildcardTypeReference__Group_2_1__1__Impl ) + // InternalScope.g:24000:2: rule__JvmWildcardTypeReference__Group_2_1__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmWildcardTypeReference__Group_2_1__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" + // InternalScope.g:24006:1: rule__JvmWildcardTypeReference__Group_2_1__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ; + public final void rule__JvmWildcardTypeReference__Group_2_1__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24010:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ) + // InternalScope.g:24011:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) + { + // InternalScope.g:24011:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) + // InternalScope.g:24012:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); + } + // InternalScope.g:24013:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* + loop188: + do { + int alt188=2; + int LA188_0 = input.LA(1); + + if ( (LA188_0==116) ) { + alt188=1; + } + + + switch (alt188) { + case 1 : + // InternalScope.g:24013:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 + { + pushFollow(FOLLOW_141); + rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + default : + break loop188; + } + } while (true); + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1__Impl" + + + // $ANTLR start "rule__JvmUpperBound__Group__0" + // InternalScope.g:24022:1: rule__JvmUpperBound__Group__0 : rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ; + public final void rule__JvmUpperBound__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24026:1: ( rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ) + // InternalScope.g:24027:2: rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 + { + pushFollow(FOLLOW_84); + rule__JvmUpperBound__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__0" + + + // $ANTLR start "rule__JvmUpperBound__Group__0__Impl" + // InternalScope.g:24034:1: rule__JvmUpperBound__Group__0__Impl : ( 'extends' ) ; + public final void rule__JvmUpperBound__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24038:1: ( ( 'extends' ) ) + // InternalScope.g:24039:1: ( 'extends' ) + { + // InternalScope.g:24039:1: ( 'extends' ) + // InternalScope.g:24040:2: 'extends' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + match(input,60,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__0__Impl" + + + // $ANTLR start "rule__JvmUpperBound__Group__1" + // InternalScope.g:24049:1: rule__JvmUpperBound__Group__1 : rule__JvmUpperBound__Group__1__Impl ; + public final void rule__JvmUpperBound__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24053:1: ( rule__JvmUpperBound__Group__1__Impl ) + // InternalScope.g:24054:2: rule__JvmUpperBound__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__1" + + + // $ANTLR start "rule__JvmUpperBound__Group__1__Impl" + // InternalScope.g:24060:1: rule__JvmUpperBound__Group__1__Impl : ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmUpperBound__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24064:1: ( ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ) + // InternalScope.g:24065:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) + { + // InternalScope.g:24065:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) + // InternalScope.g:24066:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); + } + // InternalScope.g:24067:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) + // InternalScope.g:24067:3: rule__JvmUpperBound__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBound__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__Group__1__Impl" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__0" + // InternalScope.g:24076:1: rule__JvmUpperBoundAnded__Group__0 : rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ; + public final void rule__JvmUpperBoundAnded__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24080:1: ( rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ) + // InternalScope.g:24081:2: rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 + { + pushFollow(FOLLOW_84); + rule__JvmUpperBoundAnded__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__0" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__0__Impl" + // InternalScope.g:24088:1: rule__JvmUpperBoundAnded__Group__0__Impl : ( '&' ) ; + public final void rule__JvmUpperBoundAnded__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24092:1: ( ( '&' ) ) + // InternalScope.g:24093:1: ( '&' ) + { + // InternalScope.g:24093:1: ( '&' ) + // InternalScope.g:24094:2: '&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + match(input,116,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__0__Impl" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__1" + // InternalScope.g:24103:1: rule__JvmUpperBoundAnded__Group__1 : rule__JvmUpperBoundAnded__Group__1__Impl ; + public final void rule__JvmUpperBoundAnded__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24107:1: ( rule__JvmUpperBoundAnded__Group__1__Impl ) + // InternalScope.g:24108:2: rule__JvmUpperBoundAnded__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__1" + + + // $ANTLR start "rule__JvmUpperBoundAnded__Group__1__Impl" + // InternalScope.g:24114:1: rule__JvmUpperBoundAnded__Group__1__Impl : ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmUpperBoundAnded__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24118:1: ( ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ) + // InternalScope.g:24119:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) + { + // InternalScope.g:24119:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) + // InternalScope.g:24120:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); + } + // InternalScope.g:24121:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) + // InternalScope.g:24121:3: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmUpperBoundAnded__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__Group__1__Impl" + + + // $ANTLR start "rule__JvmLowerBound__Group__0" + // InternalScope.g:24130:1: rule__JvmLowerBound__Group__0 : rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ; + public final void rule__JvmLowerBound__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24134:1: ( rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ) + // InternalScope.g:24135:2: rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 + { + pushFollow(FOLLOW_84); + rule__JvmLowerBound__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__0" + + + // $ANTLR start "rule__JvmLowerBound__Group__0__Impl" + // InternalScope.g:24142:1: rule__JvmLowerBound__Group__0__Impl : ( 'super' ) ; + public final void rule__JvmLowerBound__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24146:1: ( ( 'super' ) ) + // InternalScope.g:24147:1: ( 'super' ) + { + // InternalScope.g:24147:1: ( 'super' ) + // InternalScope.g:24148:2: 'super' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + match(input,64,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__0__Impl" + + + // $ANTLR start "rule__JvmLowerBound__Group__1" + // InternalScope.g:24157:1: rule__JvmLowerBound__Group__1 : rule__JvmLowerBound__Group__1__Impl ; + public final void rule__JvmLowerBound__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24161:1: ( rule__JvmLowerBound__Group__1__Impl ) + // InternalScope.g:24162:2: rule__JvmLowerBound__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__1" + + + // $ANTLR start "rule__JvmLowerBound__Group__1__Impl" + // InternalScope.g:24168:1: rule__JvmLowerBound__Group__1__Impl : ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmLowerBound__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24172:1: ( ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ) + // InternalScope.g:24173:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) + { + // InternalScope.g:24173:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) + // InternalScope.g:24174:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); + } + // InternalScope.g:24175:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) + // InternalScope.g:24175:3: rule__JvmLowerBound__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBound__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__Group__1__Impl" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__0" + // InternalScope.g:24184:1: rule__JvmLowerBoundAnded__Group__0 : rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ; + public final void rule__JvmLowerBoundAnded__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24188:1: ( rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ) + // InternalScope.g:24189:2: rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 + { + pushFollow(FOLLOW_84); + rule__JvmLowerBoundAnded__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__0" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__0__Impl" + // InternalScope.g:24196:1: rule__JvmLowerBoundAnded__Group__0__Impl : ( '&' ) ; + public final void rule__JvmLowerBoundAnded__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24200:1: ( ( '&' ) ) + // InternalScope.g:24201:1: ( '&' ) + { + // InternalScope.g:24201:1: ( '&' ) + // InternalScope.g:24202:2: '&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + match(input,116,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__0__Impl" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__1" + // InternalScope.g:24211:1: rule__JvmLowerBoundAnded__Group__1 : rule__JvmLowerBoundAnded__Group__1__Impl ; + public final void rule__JvmLowerBoundAnded__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24215:1: ( rule__JvmLowerBoundAnded__Group__1__Impl ) + // InternalScope.g:24216:2: rule__JvmLowerBoundAnded__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__1" + + + // $ANTLR start "rule__JvmLowerBoundAnded__Group__1__Impl" + // InternalScope.g:24222:1: rule__JvmLowerBoundAnded__Group__1__Impl : ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ; + public final void rule__JvmLowerBoundAnded__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24226:1: ( ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ) + // InternalScope.g:24227:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) + { + // InternalScope.g:24227:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) + // InternalScope.g:24228:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); + } + // InternalScope.g:24229:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) + // InternalScope.g:24229:3: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 + { + pushFollow(FOLLOW_2); + rule__JvmLowerBoundAnded__TypeReferenceAssignment_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0" + // InternalScope.g:24238:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ; + public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24242:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ) + // InternalScope.g:24243:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 + { + pushFollow(FOLLOW_45); + rule__QualifiedNameWithWildcard__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl" + // InternalScope.g:24250:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ; + public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24254:1: ( ( ruleQualifiedName ) ) + // InternalScope.g:24255:1: ( ruleQualifiedName ) + { + // InternalScope.g:24255:1: ( ruleQualifiedName ) + // InternalScope.g:24256:2: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1" + // InternalScope.g:24265:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ; + public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24269:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ) + // InternalScope.g:24270:2: rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 + { + pushFollow(FOLLOW_142); + rule__QualifiedNameWithWildcard__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl" + // InternalScope.g:24277:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( '.' ) ; + public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24281:1: ( ( '.' ) ) + // InternalScope.g:24282:1: ( '.' ) + { + // InternalScope.g:24282:1: ( '.' ) + // InternalScope.g:24283:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2" + // InternalScope.g:24292:1: rule__QualifiedNameWithWildcard__Group__2 : rule__QualifiedNameWithWildcard__Group__2__Impl ; + public final void rule__QualifiedNameWithWildcard__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24296:1: ( rule__QualifiedNameWithWildcard__Group__2__Impl ) + // InternalScope.g:24297:2: rule__QualifiedNameWithWildcard__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedNameWithWildcard__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2" + + + // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2__Impl" + // InternalScope.g:24303:1: rule__QualifiedNameWithWildcard__Group__2__Impl : ( '*' ) ; + public final void rule__QualifiedNameWithWildcard__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24307:1: ( ( '*' ) ) + // InternalScope.g:24308:1: ( '*' ) + { + // InternalScope.g:24308:1: ( '*' ) + // InternalScope.g:24309:2: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__0" + // InternalScope.g:24319:1: rule__XImportDeclaration__Group__0 : rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ; + public final void rule__XImportDeclaration__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24323:1: ( rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ) + // InternalScope.g:24324:2: rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 + { + pushFollow(FOLLOW_143); + rule__XImportDeclaration__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__0" + + + // $ANTLR start "rule__XImportDeclaration__Group__0__Impl" + // InternalScope.g:24331:1: rule__XImportDeclaration__Group__0__Impl : ( 'import' ) ; + public final void rule__XImportDeclaration__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24335:1: ( ( 'import' ) ) + // InternalScope.g:24336:1: ( 'import' ) + { + // InternalScope.g:24336:1: ( 'import' ) + // InternalScope.g:24337:2: 'import' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + match(input,62,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__0__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__1" + // InternalScope.g:24346:1: rule__XImportDeclaration__Group__1 : rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ; + public final void rule__XImportDeclaration__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24350:1: ( rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ) + // InternalScope.g:24351:2: rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 + { + pushFollow(FOLLOW_18); + rule__XImportDeclaration__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__1" + + + // $ANTLR start "rule__XImportDeclaration__Group__1__Impl" + // InternalScope.g:24358:1: rule__XImportDeclaration__Group__1__Impl : ( ( rule__XImportDeclaration__Alternatives_1 ) ) ; + public final void rule__XImportDeclaration__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24362:1: ( ( ( rule__XImportDeclaration__Alternatives_1 ) ) ) + // InternalScope.g:24363:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) + { + // InternalScope.g:24363:1: ( ( rule__XImportDeclaration__Alternatives_1 ) ) + // InternalScope.g:24364:2: ( rule__XImportDeclaration__Alternatives_1 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); + } + // InternalScope.g:24365:2: ( rule__XImportDeclaration__Alternatives_1 ) + // InternalScope.g:24365:3: rule__XImportDeclaration__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__1__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group__2" + // InternalScope.g:24373:1: rule__XImportDeclaration__Group__2 : rule__XImportDeclaration__Group__2__Impl ; + public final void rule__XImportDeclaration__Group__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24377:1: ( rule__XImportDeclaration__Group__2__Impl ) + // InternalScope.g:24378:2: rule__XImportDeclaration__Group__2__Impl + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group__2__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__2" + + + // $ANTLR start "rule__XImportDeclaration__Group__2__Impl" + // InternalScope.g:24384:1: rule__XImportDeclaration__Group__2__Impl : ( ( ';' )? ) ; + public final void rule__XImportDeclaration__Group__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24388:1: ( ( ( ';' )? ) ) + // InternalScope.g:24389:1: ( ( ';' )? ) + { + // InternalScope.g:24389:1: ( ( ';' )? ) + // InternalScope.g:24390:2: ( ';' )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + // InternalScope.g:24391:2: ( ';' )? + int alt189=2; + int LA189_0 = input.LA(1); + + if ( (LA189_0==75) ) { + alt189=1; + } + switch (alt189) { + case 1 : + // InternalScope.g:24391:3: ';' + { + match(input,75,FOLLOW_2); if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__0" + // InternalScope.g:24400:1: rule__XImportDeclaration__Group_1_0__0 : rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ; + public final void rule__XImportDeclaration__Group_1_0__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24404:1: ( rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 ) + // InternalScope.g:24405:2: rule__XImportDeclaration__Group_1_0__0__Impl rule__XImportDeclaration__Group_1_0__1 + { + pushFollow(FOLLOW_144); + rule__XImportDeclaration__Group_1_0__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__0" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__0__Impl" + // InternalScope.g:24412:1: rule__XImportDeclaration__Group_1_0__0__Impl : ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24416:1: ( ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) ) + // InternalScope.g:24417:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) + { + // InternalScope.g:24417:1: ( ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) ) + // InternalScope.g:24418:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); + } + // InternalScope.g:24419:2: ( rule__XImportDeclaration__StaticAssignment_1_0_0 ) + // InternalScope.g:24419:3: rule__XImportDeclaration__StaticAssignment_1_0_0 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__StaticAssignment_1_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__0__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__1" + // InternalScope.g:24427:1: rule__XImportDeclaration__Group_1_0__1 : rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ; + public final void rule__XImportDeclaration__Group_1_0__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24431:1: ( rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 ) + // InternalScope.g:24432:2: rule__XImportDeclaration__Group_1_0__1__Impl rule__XImportDeclaration__Group_1_0__2 + { + pushFollow(FOLLOW_144); + rule__XImportDeclaration__Group_1_0__1__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__2(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__1" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__1__Impl" + // InternalScope.g:24439:1: rule__XImportDeclaration__Group_1_0__1__Impl : ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ; + public final void rule__XImportDeclaration__Group_1_0__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24443:1: ( ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) ) + // InternalScope.g:24444:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) + { + // InternalScope.g:24444:1: ( ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? ) + // InternalScope.g:24445:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); + } + // InternalScope.g:24446:2: ( rule__XImportDeclaration__ExtensionAssignment_1_0_1 )? + int alt190=2; + int LA190_0 = input.LA(1); + + if ( (LA190_0==63) ) { + alt190=1; + } + switch (alt190) { + case 1 : + // InternalScope.g:24446:3: rule__XImportDeclaration__ExtensionAssignment_1_0_1 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ExtensionAssignment_1_0_1(); + + state._fsp--; + if (state.failed) return ; + + } + break; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_1_0_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__1__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__2" + // InternalScope.g:24454:1: rule__XImportDeclaration__Group_1_0__2 : rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ; + public final void rule__XImportDeclaration__Group_1_0__2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24458:1: ( rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 ) + // InternalScope.g:24459:2: rule__XImportDeclaration__Group_1_0__2__Impl rule__XImportDeclaration__Group_1_0__3 + { + pushFollow(FOLLOW_25); + rule__XImportDeclaration__Group_1_0__2__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__3(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__2" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__2__Impl" + // InternalScope.g:24466:1: rule__XImportDeclaration__Group_1_0__2__Impl : ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__2__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24470:1: ( ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) ) + // InternalScope.g:24471:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) + { + // InternalScope.g:24471:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) ) + // InternalScope.g:24472:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); + } + // InternalScope.g:24473:2: ( rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 ) + // InternalScope.g:24473:3: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__ImportedTypeAssignment_1_0_2(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_0_2()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__2__Impl" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__3" + // InternalScope.g:24481:1: rule__XImportDeclaration__Group_1_0__3 : rule__XImportDeclaration__Group_1_0__3__Impl ; + public final void rule__XImportDeclaration__Group_1_0__3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24485:1: ( rule__XImportDeclaration__Group_1_0__3__Impl ) + // InternalScope.g:24486:2: rule__XImportDeclaration__Group_1_0__3__Impl + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Group_1_0__3__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__3" + + + // $ANTLR start "rule__XImportDeclaration__Group_1_0__3__Impl" + // InternalScope.g:24492:1: rule__XImportDeclaration__Group_1_0__3__Impl : ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ; + public final void rule__XImportDeclaration__Group_1_0__3__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24496:1: ( ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) ) + // InternalScope.g:24497:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) + { + // InternalScope.g:24497:1: ( ( rule__XImportDeclaration__Alternatives_1_0_3 ) ) + // InternalScope.g:24498:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); + } + // InternalScope.g:24499:2: ( rule__XImportDeclaration__Alternatives_1_0_3 ) + // InternalScope.g:24499:3: rule__XImportDeclaration__Alternatives_1_0_3 + { + pushFollow(FOLLOW_2); + rule__XImportDeclaration__Alternatives_1_0_3(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getAlternatives_1_0_3()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__Group_1_0__3__Impl" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0" + // InternalScope.g:24508:1: rule__QualifiedNameInStaticImport__Group__0 : rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ; + public final void rule__QualifiedNameInStaticImport__Group__0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24512:1: ( rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ) + // InternalScope.g:24513:2: rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 + { + pushFollow(FOLLOW_45); + rule__QualifiedNameInStaticImport__Group__0__Impl(); + + state._fsp--; + if (state.failed) return ; + pushFollow(FOLLOW_2); + rule__QualifiedNameInStaticImport__Group__1(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0__Impl" + // InternalScope.g:24520:1: rule__QualifiedNameInStaticImport__Group__0__Impl : ( ruleValidID ) ; + public final void rule__QualifiedNameInStaticImport__Group__0__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24524:1: ( ( ruleValidID ) ) + // InternalScope.g:24525:1: ( ruleValidID ) + { + // InternalScope.g:24525:1: ( ruleValidID ) + // InternalScope.g:24526:2: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0__Impl" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1" + // InternalScope.g:24535:1: rule__QualifiedNameInStaticImport__Group__1 : rule__QualifiedNameInStaticImport__Group__1__Impl ; + public final void rule__QualifiedNameInStaticImport__Group__1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24539:1: ( rule__QualifiedNameInStaticImport__Group__1__Impl ) + // InternalScope.g:24540:2: rule__QualifiedNameInStaticImport__Group__1__Impl + { + pushFollow(FOLLOW_2); + rule__QualifiedNameInStaticImport__Group__1__Impl(); + + state._fsp--; + if (state.failed) return ; + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1" + + + // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1__Impl" + // InternalScope.g:24546:1: rule__QualifiedNameInStaticImport__Group__1__Impl : ( '.' ) ; + public final void rule__QualifiedNameInStaticImport__Group__1__Impl() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24550:1: ( ( '.' ) ) + // InternalScope.g:24551:1: ( '.' ) + { + // InternalScope.g:24551:1: ( '.' ) + // InternalScope.g:24552:2: '.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + match(input,58,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1__Impl" + + + // $ANTLR start "rule__ScopeModel__NameAssignment_1" + // InternalScope.g:24562:1: rule__ScopeModel__NameAssignment_1 : ( ruleDottedID ) ; + public final void rule__ScopeModel__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24566:1: ( ( ruleDottedID ) ) + // InternalScope.g:24567:2: ( ruleDottedID ) + { + // InternalScope.g:24567:2: ( ruleDottedID ) + // InternalScope.g:24568:3: ruleDottedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleDottedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getNameDottedIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__NameAssignment_1" + + + // $ANTLR start "rule__ScopeModel__IncludedScopesAssignment_2_1" + // InternalScope.g:24577:1: rule__ScopeModel__IncludedScopesAssignment_2_1 : ( ( ruleDottedID ) ) ; + public final void rule__ScopeModel__IncludedScopesAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24581:1: ( ( ( ruleDottedID ) ) ) + // InternalScope.g:24582:2: ( ( ruleDottedID ) ) + { + // InternalScope.g:24582:2: ( ( ruleDottedID ) ) + // InternalScope.g:24583:3: ( ruleDottedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); + } + // InternalScope.g:24584:3: ( ruleDottedID ) + // InternalScope.g:24585:4: ruleDottedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleDottedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelDottedIDParserRuleCall_2_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getIncludedScopesScopeModelCrossReference_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__IncludedScopesAssignment_2_1" + + + // $ANTLR start "rule__ScopeModel__ImportsAssignment_3" + // InternalScope.g:24596:1: rule__ScopeModel__ImportsAssignment_3 : ( ruleImport ) ; + public final void rule__ScopeModel__ImportsAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24600:1: ( ( ruleImport ) ) + // InternalScope.g:24601:2: ( ruleImport ) + { + // InternalScope.g:24601:2: ( ruleImport ) + // InternalScope.g:24602:3: ruleImport + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getImportsImportParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__ImportsAssignment_3" + + + // $ANTLR start "rule__ScopeModel__ExtensionsAssignment_4" + // InternalScope.g:24611:1: rule__ScopeModel__ExtensionsAssignment_4 : ( ruleExtension ) ; + public final void rule__ScopeModel__ExtensionsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24615:1: ( ( ruleExtension ) ) + // InternalScope.g:24616:2: ( ruleExtension ) + { + // InternalScope.g:24616:2: ( ruleExtension ) + // InternalScope.g:24617:3: ruleExtension + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleExtension(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getExtensionsExtensionParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__ExtensionsAssignment_4" + + + // $ANTLR start "rule__ScopeModel__InjectionsAssignment_5" + // InternalScope.g:24626:1: rule__ScopeModel__InjectionsAssignment_5 : ( ruleInjection ) ; + public final void rule__ScopeModel__InjectionsAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24630:1: ( ( ruleInjection ) ) + // InternalScope.g:24631:2: ( ruleInjection ) + { + // InternalScope.g:24631:2: ( ruleInjection ) + // InternalScope.g:24632:3: ruleInjection + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleInjection(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getInjectionsInjectionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__InjectionsAssignment_5" + + + // $ANTLR start "rule__ScopeModel__NamingAssignment_6" + // InternalScope.g:24641:1: rule__ScopeModel__NamingAssignment_6 : ( ruleNamingSection ) ; + public final void rule__ScopeModel__NamingAssignment_6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24645:1: ( ( ruleNamingSection ) ) + // InternalScope.g:24646:2: ( ruleNamingSection ) + { + // InternalScope.g:24646:2: ( ruleNamingSection ) + // InternalScope.g:24647:3: ruleNamingSection + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); + } + pushFollow(FOLLOW_2); + ruleNamingSection(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getNamingNamingSectionParserRuleCall_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__NamingAssignment_6" + + + // $ANTLR start "rule__ScopeModel__ScopesAssignment_7" + // InternalScope.g:24656:1: rule__ScopeModel__ScopesAssignment_7 : ( ruleScopeDefinition ) ; + public final void rule__ScopeModel__ScopesAssignment_7() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24660:1: ( ( ruleScopeDefinition ) ) + // InternalScope.g:24661:2: ( ruleScopeDefinition ) + { + // InternalScope.g:24661:2: ( ruleScopeDefinition ) + // InternalScope.g:24662:3: ruleScopeDefinition + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); + } + pushFollow(FOLLOW_2); + ruleScopeDefinition(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeModelAccess().getScopesScopeDefinitionParserRuleCall_7_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeModel__ScopesAssignment_7" + + + // $ANTLR start "rule__Import__PackageAssignment_1" + // InternalScope.g:24671:1: rule__Import__PackageAssignment_1 : ( ( RULE_STRING ) ) ; + public final void rule__Import__PackageAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24675:1: ( ( ( RULE_STRING ) ) ) + // InternalScope.g:24676:2: ( ( RULE_STRING ) ) + { + // InternalScope.g:24676:2: ( ( RULE_STRING ) ) + // InternalScope.g:24677:3: ( RULE_STRING ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); + } + // InternalScope.g:24678:3: ( RULE_STRING ) + // InternalScope.g:24679:4: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImportAccess().getPackageEPackageSTRINGTerminalRuleCall_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getImportAccess().getPackageEPackageCrossReference_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Import__PackageAssignment_1" + + + // $ANTLR start "rule__Import__NameAssignment_2_1" + // InternalScope.g:24690:1: rule__Import__NameAssignment_2_1 : ( ruleIdentifier ) ; + public final void rule__Import__NameAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24694:1: ( ( ruleIdentifier ) ) + // InternalScope.g:24695:2: ( ruleIdentifier ) + { + // InternalScope.g:24695:2: ( ruleIdentifier ) + // InternalScope.g:24696:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImportAccess().getNameIdentifierParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Import__NameAssignment_2_1" + + + // $ANTLR start "rule__Extension__ExtensionAssignment_1" + // InternalScope.g:24705:1: rule__Extension__ExtensionAssignment_1 : ( ruleQualifiedID ) ; + public final void rule__Extension__ExtensionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24709:1: ( ( ruleQualifiedID ) ) + // InternalScope.g:24710:2: ( ruleQualifiedID ) + { + // InternalScope.g:24710:2: ( ruleQualifiedID ) + // InternalScope.g:24711:3: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getExtensionAccess().getExtensionQualifiedIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Extension__ExtensionAssignment_1" + + + // $ANTLR start "rule__Injection__TypeAssignment_1" + // InternalScope.g:24720:1: rule__Injection__TypeAssignment_1 : ( ruleDottedID ) ; + public final void rule__Injection__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24724:1: ( ( ruleDottedID ) ) + // InternalScope.g:24725:2: ( ruleDottedID ) + { + // InternalScope.g:24725:2: ( ruleDottedID ) + // InternalScope.g:24726:3: ruleDottedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleDottedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInjectionAccess().getTypeDottedIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Injection__TypeAssignment_1" + + + // $ANTLR start "rule__Injection__NameAssignment_3" + // InternalScope.g:24735:1: rule__Injection__NameAssignment_3 : ( ruleIdentifier ) ; + public final void rule__Injection__NameAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24739:1: ( ( ruleIdentifier ) ) + // InternalScope.g:24740:2: ( ruleIdentifier ) + { + // InternalScope.g:24740:2: ( ruleIdentifier ) + // InternalScope.g:24741:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInjectionAccess().getNameIdentifierParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Injection__NameAssignment_3" + + + // $ANTLR start "rule__NamingSection__CasingAssignment_1_1" + // InternalScope.g:24750:1: rule__NamingSection__CasingAssignment_1_1 : ( ruleCasing ) ; + public final void rule__NamingSection__CasingAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24754:1: ( ( ruleCasing ) ) + // InternalScope.g:24755:2: ( ruleCasing ) + { + // InternalScope.g:24755:2: ( ruleCasing ) + // InternalScope.g:24756:3: ruleCasing + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleCasing(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingSectionAccess().getCasingCasingEnumRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingSection__CasingAssignment_1_1" + + + // $ANTLR start "rule__NamingSection__NamingsAssignment_4" + // InternalScope.g:24765:1: rule__NamingSection__NamingsAssignment_4 : ( ruleNamingDefinition ) ; + public final void rule__NamingSection__NamingsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24769:1: ( ( ruleNamingDefinition ) ) + // InternalScope.g:24770:2: ( ruleNamingDefinition ) + { + // InternalScope.g:24770:2: ( ruleNamingDefinition ) + // InternalScope.g:24771:3: ruleNamingDefinition + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleNamingDefinition(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingSectionAccess().getNamingsNamingDefinitionParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingSection__NamingsAssignment_4" + + + // $ANTLR start "rule__NamingDefinition__TypeAssignment_0" + // InternalScope.g:24780:1: rule__NamingDefinition__TypeAssignment_0 : ( ( ruleQualifiedID ) ) ; + public final void rule__NamingDefinition__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24784:1: ( ( ( ruleQualifiedID ) ) ) + // InternalScope.g:24785:2: ( ( ruleQualifiedID ) ) + { + // InternalScope.g:24785:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:24786:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); + } + // InternalScope.g:24787:3: ( ruleQualifiedID ) + // InternalScope.g:24788:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingDefinitionAccess().getTypeEClassQualifiedIDParserRuleCall_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingDefinitionAccess().getTypeEClassCrossReference_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingDefinition__TypeAssignment_0" + + + // $ANTLR start "rule__NamingDefinition__NamingAssignment_2" + // InternalScope.g:24799:1: rule__NamingDefinition__NamingAssignment_2 : ( ruleNaming ) ; + public final void rule__NamingDefinition__NamingAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24803:1: ( ( ruleNaming ) ) + // InternalScope.g:24804:2: ( ruleNaming ) + { + // InternalScope.g:24804:2: ( ruleNaming ) + // InternalScope.g:24805:3: ruleNaming + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleNaming(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingDefinitionAccess().getNamingNamingParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingDefinition__NamingAssignment_2" + + + // $ANTLR start "rule__ScopeDefinition__NameAssignment_1_1" + // InternalScope.g:24814:1: rule__ScopeDefinition__NameAssignment_1_1 : ( ruleIdentifier ) ; + public final void rule__ScopeDefinition__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24818:1: ( ( ruleIdentifier ) ) + // InternalScope.g:24819:2: ( ruleIdentifier ) + { + // InternalScope.g:24819:2: ( ruleIdentifier ) + // InternalScope.g:24820:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getNameIdentifierParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDefinition__NameAssignment_1_1" + + + // $ANTLR start "rule__ScopeDefinition__TargetTypeAssignment_2_0" + // InternalScope.g:24829:1: rule__ScopeDefinition__TargetTypeAssignment_2_0 : ( ( ruleQualifiedID ) ) ; + public final void rule__ScopeDefinition__TargetTypeAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24833:1: ( ( ( ruleQualifiedID ) ) ) + // InternalScope.g:24834:2: ( ( ruleQualifiedID ) ) + { + // InternalScope.g:24834:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:24835:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); + } + // InternalScope.g:24836:3: ( ruleQualifiedID ) + // InternalScope.g:24837:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassQualifiedIDParserRuleCall_2_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getTargetTypeEClassCrossReference_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDefinition__TargetTypeAssignment_2_0" + + + // $ANTLR start "rule__ScopeDefinition__ContextTypeAssignment_2_1_0" + // InternalScope.g:24848:1: rule__ScopeDefinition__ContextTypeAssignment_2_1_0 : ( ( ruleQualifiedID ) ) ; + public final void rule__ScopeDefinition__ContextTypeAssignment_2_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24852:1: ( ( ( ruleQualifiedID ) ) ) + // InternalScope.g:24853:2: ( ( ruleQualifiedID ) ) + { + // InternalScope.g:24853:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:24854:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); + } + // InternalScope.g:24855:3: ( ruleQualifiedID ) + // InternalScope.g:24856:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassQualifiedIDParserRuleCall_2_1_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getContextTypeEClassCrossReference_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDefinition__ContextTypeAssignment_2_1_0" + + + // $ANTLR start "rule__ScopeDefinition__ReferenceAssignment_2_1_2" + // InternalScope.g:24867:1: rule__ScopeDefinition__ReferenceAssignment_2_1_2 : ( ( ruleIdentifier ) ) ; + public final void rule__ScopeDefinition__ReferenceAssignment_2_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24871:1: ( ( ( ruleIdentifier ) ) ) + // InternalScope.g:24872:2: ( ( ruleIdentifier ) ) + { + // InternalScope.g:24872:2: ( ( ruleIdentifier ) ) + // InternalScope.g:24873:3: ( ruleIdentifier ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); + } + // InternalScope.g:24874:3: ( ruleIdentifier ) + // InternalScope.g:24875:4: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceIdentifierParserRuleCall_2_1_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getReferenceEReferenceCrossReference_2_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDefinition__ReferenceAssignment_2_1_2" + + + // $ANTLR start "rule__ScopeDefinition__RulesAssignment_4" + // InternalScope.g:24886:1: rule__ScopeDefinition__RulesAssignment_4 : ( ruleScopeRule ) ; + public final void rule__ScopeDefinition__RulesAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24890:1: ( ( ruleScopeRule ) ) + // InternalScope.g:24891:2: ( ruleScopeRule ) + { + // InternalScope.g:24891:2: ( ruleScopeRule ) + // InternalScope.g:24892:3: ruleScopeRule + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleScopeRule(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDefinitionAccess().getRulesScopeRuleParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDefinition__RulesAssignment_4" + + + // $ANTLR start "rule__ScopeRule__ContextAssignment_1" + // InternalScope.g:24901:1: rule__ScopeRule__ContextAssignment_1 : ( ruleScopeContext ) ; + public final void rule__ScopeRule__ContextAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24905:1: ( ( ruleScopeContext ) ) + // InternalScope.g:24906:2: ( ruleScopeContext ) + { + // InternalScope.g:24906:2: ( ruleScopeContext ) + // InternalScope.g:24907:3: ruleScopeContext + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleScopeContext(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeRuleAccess().getContextScopeContextParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeRule__ContextAssignment_1" + + + // $ANTLR start "rule__ScopeRule__ExprsAssignment_3" + // InternalScope.g:24916:1: rule__ScopeRule__ExprsAssignment_3 : ( ruleScopeExpression ) ; + public final void rule__ScopeRule__ExprsAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24920:1: ( ( ruleScopeExpression ) ) + // InternalScope.g:24921:2: ( ruleScopeExpression ) + { + // InternalScope.g:24921:2: ( ruleScopeExpression ) + // InternalScope.g:24922:3: ruleScopeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleScopeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeRule__ExprsAssignment_3" + + + // $ANTLR start "rule__ScopeRule__ExprsAssignment_4_1" + // InternalScope.g:24931:1: rule__ScopeRule__ExprsAssignment_4_1 : ( ruleScopeExpression ) ; + public final void rule__ScopeRule__ExprsAssignment_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24935:1: ( ( ruleScopeExpression ) ) + // InternalScope.g:24936:2: ( ruleScopeExpression ) + { + // InternalScope.g:24936:2: ( ruleScopeExpression ) + // InternalScope.g:24937:3: ruleScopeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); + } + pushFollow(FOLLOW_2); + ruleScopeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeRuleAccess().getExprsScopeExpressionParserRuleCall_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeRule__ExprsAssignment_4_1" + + + // $ANTLR start "rule__ScopeContext__GlobalAssignment_0_0" + // InternalScope.g:24946:1: rule__ScopeContext__GlobalAssignment_0_0 : ( ( '*' ) ) ; + public final void rule__ScopeContext__GlobalAssignment_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24950:1: ( ( ( '*' ) ) ) + // InternalScope.g:24951:2: ( ( '*' ) ) + { + // InternalScope.g:24951:2: ( ( '*' ) ) + // InternalScope.g:24952:3: ( '*' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); + } + // InternalScope.g:24953:3: ( '*' ) + // InternalScope.g:24954:4: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeContext__GlobalAssignment_0_0" + + + // $ANTLR start "rule__ScopeContext__ContextTypeAssignment_0_1" + // InternalScope.g:24965:1: rule__ScopeContext__ContextTypeAssignment_0_1 : ( ( ruleQualifiedID ) ) ; + public final void rule__ScopeContext__ContextTypeAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24969:1: ( ( ( ruleQualifiedID ) ) ) + // InternalScope.g:24970:2: ( ( ruleQualifiedID ) ) + { + // InternalScope.g:24970:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:24971:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); + } + // InternalScope.g:24972:3: ( ruleQualifiedID ) + // InternalScope.g:24973:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getContextTypeEClassQualifiedIDParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getContextTypeEClassCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeContext__ContextTypeAssignment_0_1" + + + // $ANTLR start "rule__ScopeContext__GuardAssignment_1_1" + // InternalScope.g:24984:1: rule__ScopeContext__GuardAssignment_1_1 : ( ruleExpression ) ; + public final void rule__ScopeContext__GuardAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:24988:1: ( ( ruleExpression ) ) + // InternalScope.g:24989:2: ( ruleExpression ) + { + // InternalScope.g:24989:2: ( ruleExpression ) + // InternalScope.g:24990:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeContextAccess().getGuardExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeContext__GuardAssignment_1_1" + + + // $ANTLR start "rule__FactoryExpression__ExprAssignment_1" + // InternalScope.g:24999:1: rule__FactoryExpression__ExprAssignment_1 : ( ruleExpression ) ; + public final void rule__FactoryExpression__ExprAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25003:1: ( ( ruleExpression ) ) + // InternalScope.g:25004:2: ( ruleExpression ) + { + // InternalScope.g:25004:2: ( ruleExpression ) + // InternalScope.g:25005:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFactoryExpressionAccess().getExprExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FactoryExpression__ExprAssignment_1" + + + // $ANTLR start "rule__ScopeDelegation__DelegateAssignment_2_0" + // InternalScope.g:25014:1: rule__ScopeDelegation__DelegateAssignment_2_0 : ( ruleExpression ) ; + public final void rule__ScopeDelegation__DelegateAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25018:1: ( ( ruleExpression ) ) + // InternalScope.g:25019:2: ( ruleExpression ) + { + // InternalScope.g:25019:2: ( ruleExpression ) + // InternalScope.g:25020:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDelegationAccess().getDelegateExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDelegation__DelegateAssignment_2_0" + + + // $ANTLR start "rule__ScopeDelegation__ExternalAssignment_2_1" + // InternalScope.g:25029:1: rule__ScopeDelegation__ExternalAssignment_2_1 : ( ruleGlobalScopeExpression ) ; + public final void rule__ScopeDelegation__ExternalAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25033:1: ( ( ruleGlobalScopeExpression ) ) + // InternalScope.g:25034:2: ( ruleGlobalScopeExpression ) + { + // InternalScope.g:25034:2: ( ruleGlobalScopeExpression ) + // InternalScope.g:25035:3: ruleGlobalScopeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleGlobalScopeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDelegationAccess().getExternalGlobalScopeExpressionParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDelegation__ExternalAssignment_2_1" + + + // $ANTLR start "rule__ScopeDelegation__ScopeAssignment_3_1" + // InternalScope.g:25044:1: rule__ScopeDelegation__ScopeAssignment_3_1 : ( ( ruleIdentifier ) ) ; + public final void rule__ScopeDelegation__ScopeAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25048:1: ( ( ( ruleIdentifier ) ) ) + // InternalScope.g:25049:2: ( ( ruleIdentifier ) ) + { + // InternalScope.g:25049:2: ( ( ruleIdentifier ) ) + // InternalScope.g:25050:3: ( ruleIdentifier ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); + } + // InternalScope.g:25051:3: ( ruleIdentifier ) + // InternalScope.g:25052:4: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionIdentifierParserRuleCall_3_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getScopeDelegationAccess().getScopeScopeDefinitionCrossReference_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ScopeDelegation__ScopeAssignment_3_1" + + + // $ANTLR start "rule__NamedScopeExpression__CaseDefAssignment_1_0" + // InternalScope.g:25063:1: rule__NamedScopeExpression__CaseDefAssignment_1_0 : ( ( 'case' ) ) ; + public final void rule__NamedScopeExpression__CaseDefAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25067:1: ( ( ( 'case' ) ) ) + // InternalScope.g:25068:2: ( ( 'case' ) ) + { + // InternalScope.g:25068:2: ( ( 'case' ) ) + // InternalScope.g:25069:3: ( 'case' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); + } + // InternalScope.g:25070:3: ( 'case' ) + // InternalScope.g:25071:4: 'case' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); + } + match(input,74,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamedScopeExpression__CaseDefAssignment_1_0" + + + // $ANTLR start "rule__NamedScopeExpression__CasingAssignment_1_1" + // InternalScope.g:25082:1: rule__NamedScopeExpression__CasingAssignment_1_1 : ( ruleCasing ) ; + public final void rule__NamedScopeExpression__CasingAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25086:1: ( ( ruleCasing ) ) + // InternalScope.g:25087:2: ( ruleCasing ) + { + // InternalScope.g:25087:2: ( ruleCasing ) + // InternalScope.g:25088:3: ruleCasing + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleCasing(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamedScopeExpressionAccess().getCasingCasingEnumRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamedScopeExpression__CasingAssignment_1_1" + + + // $ANTLR start "rule__NamedScopeExpression__NamingAssignment_2_1" + // InternalScope.g:25097:1: rule__NamedScopeExpression__NamingAssignment_2_1 : ( ruleNaming ) ; + public final void rule__NamedScopeExpression__NamingAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25101:1: ( ( ruleNaming ) ) + // InternalScope.g:25102:2: ( ruleNaming ) + { + // InternalScope.g:25102:2: ( ruleNaming ) + // InternalScope.g:25103:3: ruleNaming + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleNaming(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamedScopeExpressionAccess().getNamingNamingParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamedScopeExpression__NamingAssignment_2_1" + + + // $ANTLR start "rule__GlobalScopeExpression__TypeAssignment_2" + // InternalScope.g:25112:1: rule__GlobalScopeExpression__TypeAssignment_2 : ( ( ruleQualifiedID ) ) ; + public final void rule__GlobalScopeExpression__TypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25116:1: ( ( ( ruleQualifiedID ) ) ) + // InternalScope.g:25117:2: ( ( ruleQualifiedID ) ) + { + // InternalScope.g:25117:2: ( ( ruleQualifiedID ) ) + // InternalScope.g:25118:3: ( ruleQualifiedID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); + } + // InternalScope.g:25119:3: ( ruleQualifiedID ) + // InternalScope.g:25120:4: ruleQualifiedID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassQualifiedIDParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getTypeEClassCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__TypeAssignment_2" + + + // $ANTLR start "rule__GlobalScopeExpression__NameAssignment_3_0_3" + // InternalScope.g:25131:1: rule__GlobalScopeExpression__NameAssignment_3_0_3 : ( ruleExpression ) ; + public final void rule__GlobalScopeExpression__NameAssignment_3_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25135:1: ( ( ruleExpression ) ) + // InternalScope.g:25136:2: ( ruleExpression ) + { + // InternalScope.g:25136:2: ( ruleExpression ) + // InternalScope.g:25137:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getNameExpressionParserRuleCall_3_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__NameAssignment_3_0_3" + + + // $ANTLR start "rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1" + // InternalScope.g:25146:1: rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1 : ( ( 'recursive' ) ) ; + public final void rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25150:1: ( ( ( 'recursive' ) ) ) + // InternalScope.g:25151:2: ( ( 'recursive' ) ) + { + // InternalScope.g:25151:2: ( ( 'recursive' ) ) + // InternalScope.g:25152:3: ( 'recursive' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); + } + // InternalScope.g:25153:3: ( 'recursive' ) + // InternalScope.g:25154:4: 'recursive' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); + } + match(input,117,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__RecursivePrefixAssignment_3_1_1" + + + // $ANTLR start "rule__GlobalScopeExpression__PrefixAssignment_3_1_4" + // InternalScope.g:25165:1: rule__GlobalScopeExpression__PrefixAssignment_3_1_4 : ( ruleExpression ) ; + public final void rule__GlobalScopeExpression__PrefixAssignment_3_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25169:1: ( ( ruleExpression ) ) + // InternalScope.g:25170:2: ( ruleExpression ) + { + // InternalScope.g:25170:2: ( ruleExpression ) + // InternalScope.g:25171:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getPrefixExpressionParserRuleCall_3_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__PrefixAssignment_3_1_4" + + + // $ANTLR start "rule__GlobalScopeExpression__DataAssignment_4_4" + // InternalScope.g:25180:1: rule__GlobalScopeExpression__DataAssignment_4_4 : ( ruleDataExpression ) ; + public final void rule__GlobalScopeExpression__DataAssignment_4_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25184:1: ( ( ruleDataExpression ) ) + // InternalScope.g:25185:2: ( ruleDataExpression ) + { + // InternalScope.g:25185:2: ( ruleDataExpression ) + // InternalScope.g:25186:3: ruleDataExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); + } + pushFollow(FOLLOW_2); + ruleDataExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__DataAssignment_4_4" + + + // $ANTLR start "rule__GlobalScopeExpression__DataAssignment_4_5_1" + // InternalScope.g:25195:1: rule__GlobalScopeExpression__DataAssignment_4_5_1 : ( ruleDataExpression ) ; + public final void rule__GlobalScopeExpression__DataAssignment_4_5_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25199:1: ( ( ruleDataExpression ) ) + // InternalScope.g:25200:2: ( ruleDataExpression ) + { + // InternalScope.g:25200:2: ( ruleDataExpression ) + // InternalScope.g:25201:3: ruleDataExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); + } + pushFollow(FOLLOW_2); + ruleDataExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDataDataExpressionParserRuleCall_4_5_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__DataAssignment_4_5_1" + + + // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_0" + // InternalScope.g:25210:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_0 : ( ( '*' ) ) ; + public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25214:1: ( ( ( '*' ) ) ) + // InternalScope.g:25215:2: ( ( '*' ) ) + { + // InternalScope.g:25215:2: ( ( '*' ) ) + // InternalScope.g:25216:3: ( '*' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); + } + // InternalScope.g:25217:3: ( '*' ) + // InternalScope.g:25218:4: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_0" + + + // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_1" + // InternalScope.g:25229:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_1 : ( ruleIdentifier ) ; + public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25233:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25234:2: ( ruleIdentifier ) + { + // InternalScope.g:25234:2: ( ruleIdentifier ) + // InternalScope.g:25235:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_1" + + + // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1" + // InternalScope.g:25244:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1 : ( ruleIdentifier ) ; + public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25248:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25249:2: ( ruleIdentifier ) + { + // InternalScope.g:25249:2: ( ruleIdentifier ) + // InternalScope.g:25250:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_1" + + + // $ANTLR start "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1" + // InternalScope.g:25259:1: rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1 : ( ruleIdentifier ) ; + public final void rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25263:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25264:2: ( ruleIdentifier ) + { + // InternalScope.g:25264:2: ( ruleIdentifier ) + // InternalScope.g:25265:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalScopeExpressionAccess().getDomainsIdentifierParserRuleCall_5_3_2_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalScopeExpression__DomainsAssignment_5_3_2_2_1" + + + // $ANTLR start "rule__MatchDataExpression__KeyAssignment_0" + // InternalScope.g:25274:1: rule__MatchDataExpression__KeyAssignment_0 : ( ruleIdentifier ) ; + public final void rule__MatchDataExpression__KeyAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25278:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25279:2: ( ruleIdentifier ) + { + // InternalScope.g:25279:2: ( ruleIdentifier ) + // InternalScope.g:25280:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMatchDataExpressionAccess().getKeyIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MatchDataExpression__KeyAssignment_0" + + + // $ANTLR start "rule__MatchDataExpression__ValueAssignment_2" + // InternalScope.g:25289:1: rule__MatchDataExpression__ValueAssignment_2 : ( ruleExpression ) ; + public final void rule__MatchDataExpression__ValueAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25293:1: ( ( ruleExpression ) ) + // InternalScope.g:25294:2: ( ruleExpression ) + { + // InternalScope.g:25294:2: ( ruleExpression ) + // InternalScope.g:25295:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMatchDataExpressionAccess().getValueExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MatchDataExpression__ValueAssignment_2" + + + // $ANTLR start "rule__LambdaDataExpression__DescAssignment_1" + // InternalScope.g:25304:1: rule__LambdaDataExpression__DescAssignment_1 : ( ruleIdentifier ) ; + public final void rule__LambdaDataExpression__DescAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25308:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25309:2: ( ruleIdentifier ) + { + // InternalScope.g:25309:2: ( ruleIdentifier ) + // InternalScope.g:25310:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLambdaDataExpressionAccess().getDescIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LambdaDataExpression__DescAssignment_1" + + + // $ANTLR start "rule__LambdaDataExpression__ValueAssignment_3" + // InternalScope.g:25319:1: rule__LambdaDataExpression__ValueAssignment_3 : ( ruleExpression ) ; + public final void rule__LambdaDataExpression__ValueAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25323:1: ( ( ruleExpression ) ) + // InternalScope.g:25324:2: ( ruleExpression ) + { + // InternalScope.g:25324:2: ( ruleExpression ) + // InternalScope.g:25325:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLambdaDataExpressionAccess().getValueExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LambdaDataExpression__ValueAssignment_3" + + + // $ANTLR start "rule__SimpleScopeExpression__ExprAssignment" + // InternalScope.g:25334:1: rule__SimpleScopeExpression__ExprAssignment : ( ruleExpression ) ; + public final void rule__SimpleScopeExpression__ExprAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25338:1: ( ( ruleExpression ) ) + // InternalScope.g:25339:2: ( ruleExpression ) + { + // InternalScope.g:25339:2: ( ruleExpression ) + // InternalScope.g:25340:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleScopeExpressionAccess().getExprExpressionParserRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleScopeExpression__ExprAssignment" + + + // $ANTLR start "rule__Naming__NamesAssignment_0_0_1" + // InternalScope.g:25349:1: rule__Naming__NamesAssignment_0_0_1 : ( ruleNamingExpression ) ; + public final void rule__Naming__NamesAssignment_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25353:1: ( ( ruleNamingExpression ) ) + // InternalScope.g:25354:2: ( ruleNamingExpression ) + { + // InternalScope.g:25354:2: ( ruleNamingExpression ) + // InternalScope.g:25355:3: ruleNamingExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleNamingExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Naming__NamesAssignment_0_0_1" + + + // $ANTLR start "rule__Naming__NamesAssignment_0_0_2_1" + // InternalScope.g:25364:1: rule__Naming__NamesAssignment_0_0_2_1 : ( ruleNamingExpression ) ; + public final void rule__Naming__NamesAssignment_0_0_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25368:1: ( ( ruleNamingExpression ) ) + // InternalScope.g:25369:2: ( ruleNamingExpression ) + { + // InternalScope.g:25369:2: ( ruleNamingExpression ) + // InternalScope.g:25370:3: ruleNamingExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleNamingExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_0_0_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Naming__NamesAssignment_0_0_2_1" + + + // $ANTLR start "rule__Naming__NamesAssignment_1" + // InternalScope.g:25379:1: rule__Naming__NamesAssignment_1 : ( ruleNamingExpression ) ; + public final void rule__Naming__NamesAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25383:1: ( ( ruleNamingExpression ) ) + // InternalScope.g:25384:2: ( ruleNamingExpression ) + { + // InternalScope.g:25384:2: ( ruleNamingExpression ) + // InternalScope.g:25385:3: ruleNamingExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleNamingExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingAccess().getNamesNamingExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Naming__NamesAssignment_1" + + + // $ANTLR start "rule__NamingExpression__ExportAssignment_0" + // InternalScope.g:25394:1: rule__NamingExpression__ExportAssignment_0 : ( ( 'export' ) ) ; + public final void rule__NamingExpression__ExportAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25398:1: ( ( ( 'export' ) ) ) + // InternalScope.g:25399:2: ( ( 'export' ) ) + { + // InternalScope.g:25399:2: ( ( 'export' ) ) + // InternalScope.g:25400:3: ( 'export' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); + } + // InternalScope.g:25401:3: ( 'export' ) + // InternalScope.g:25402:4: 'export' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); + } + match(input,118,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingExpression__ExportAssignment_0" + + + // $ANTLR start "rule__NamingExpression__FactoryAssignment_1_0" + // InternalScope.g:25413:1: rule__NamingExpression__FactoryAssignment_1_0 : ( ( 'factory' ) ) ; + public final void rule__NamingExpression__FactoryAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25417:1: ( ( ( 'factory' ) ) ) + // InternalScope.g:25418:2: ( ( 'factory' ) ) + { + // InternalScope.g:25418:2: ( ( 'factory' ) ) + // InternalScope.g:25419:3: ( 'factory' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); + } + // InternalScope.g:25420:3: ( 'factory' ) + // InternalScope.g:25421:4: 'factory' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); + } + match(input,84,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingExpression__FactoryAssignment_1_0" + + + // $ANTLR start "rule__NamingExpression__ExpressionAssignment_1_1" + // InternalScope.g:25432:1: rule__NamingExpression__ExpressionAssignment_1_1 : ( ruleExpression ) ; + public final void rule__NamingExpression__ExpressionAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25436:1: ( ( ruleExpression ) ) + // InternalScope.g:25437:2: ( ruleExpression ) + { + // InternalScope.g:25437:2: ( ruleExpression ) + // InternalScope.g:25438:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNamingExpressionAccess().getExpressionExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NamingExpression__ExpressionAssignment_1_1" + + + // $ANTLR start "rule__LetExpression__IdentifierAssignment_1" + // InternalScope.g:25447:1: rule__LetExpression__IdentifierAssignment_1 : ( ruleIdentifier ) ; + public final void rule__LetExpression__IdentifierAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25451:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25452:2: ( ruleIdentifier ) + { + // InternalScope.g:25452:2: ( ruleIdentifier ) + // InternalScope.g:25453:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getIdentifierIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__IdentifierAssignment_1" + + + // $ANTLR start "rule__LetExpression__VarExprAssignment_3" + // InternalScope.g:25462:1: rule__LetExpression__VarExprAssignment_3 : ( ruleExpression ) ; + public final void rule__LetExpression__VarExprAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25466:1: ( ( ruleExpression ) ) + // InternalScope.g:25467:2: ( ruleExpression ) + { + // InternalScope.g:25467:2: ( ruleExpression ) + // InternalScope.g:25468:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getVarExprExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__VarExprAssignment_3" + + + // $ANTLR start "rule__LetExpression__TargetAssignment_5" + // InternalScope.g:25477:1: rule__LetExpression__TargetAssignment_5 : ( ruleExpression ) ; + public final void rule__LetExpression__TargetAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25481:1: ( ( ruleExpression ) ) + // InternalScope.g:25482:2: ( ruleExpression ) + { + // InternalScope.g:25482:2: ( ruleExpression ) + // InternalScope.g:25483:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getLetExpressionAccess().getTargetExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__LetExpression__TargetAssignment_5" + + + // $ANTLR start "rule__CastedExpression__TypeAssignment_1" + // InternalScope.g:25492:1: rule__CastedExpression__TypeAssignment_1 : ( ruleType ) ; + public final void rule__CastedExpression__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25496:1: ( ( ruleType ) ) + // InternalScope.g:25497:2: ( ruleType ) + { + // InternalScope.g:25497:2: ( ruleType ) + // InternalScope.g:25498:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTypeTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__TypeAssignment_1" + + + // $ANTLR start "rule__CastedExpression__TargetAssignment_3" + // InternalScope.g:25507:1: rule__CastedExpression__TargetAssignment_3 : ( ruleExpression ) ; + public final void rule__CastedExpression__TargetAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25511:1: ( ( ruleExpression ) ) + // InternalScope.g:25512:2: ( ruleExpression ) + { + // InternalScope.g:25512:2: ( ruleExpression ) + // InternalScope.g:25513:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCastedExpressionAccess().getTargetExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CastedExpression__TargetAssignment_3" + + + // $ANTLR start "rule__ChainExpression__NextAssignment_1_2" + // InternalScope.g:25522:1: rule__ChainExpression__NextAssignment_1_2 : ( ruleChainedExpression ) ; + public final void rule__ChainExpression__NextAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25526:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:25527:2: ( ruleChainedExpression ) + { + // InternalScope.g:25527:2: ( ruleChainedExpression ) + // InternalScope.g:25528:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getChainExpressionAccess().getNextChainedExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ChainExpression__NextAssignment_1_2" + + + // $ANTLR start "rule__IfExpressionTri__ThenPartAssignment_1_2" + // InternalScope.g:25537:1: rule__IfExpressionTri__ThenPartAssignment_1_2 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionTri__ThenPartAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25541:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:25542:2: ( ruleChainedExpression ) + { + // InternalScope.g:25542:2: ( ruleChainedExpression ) + // InternalScope.g:25543:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getThenPartChainedExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__ThenPartAssignment_1_2" + + + // $ANTLR start "rule__IfExpressionTri__ElsePartAssignment_1_4" + // InternalScope.g:25552:1: rule__IfExpressionTri__ElsePartAssignment_1_4 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionTri__ElsePartAssignment_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25556:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:25557:2: ( ruleChainedExpression ) + { + // InternalScope.g:25557:2: ( ruleChainedExpression ) + // InternalScope.g:25558:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionTriAccess().getElsePartChainedExpressionParserRuleCall_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionTri__ElsePartAssignment_1_4" + + + // $ANTLR start "rule__IfExpressionKw__ConditionAssignment_1" + // InternalScope.g:25567:1: rule__IfExpressionKw__ConditionAssignment_1 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ConditionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25571:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:25572:2: ( ruleChainedExpression ) + { + // InternalScope.g:25572:2: ( ruleChainedExpression ) + // InternalScope.g:25573:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getConditionChainedExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ConditionAssignment_1" + + + // $ANTLR start "rule__IfExpressionKw__ThenPartAssignment_3" + // InternalScope.g:25582:1: rule__IfExpressionKw__ThenPartAssignment_3 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ThenPartAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25586:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:25587:2: ( ruleChainedExpression ) + { + // InternalScope.g:25587:2: ( ruleChainedExpression ) + // InternalScope.g:25588:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getThenPartChainedExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ThenPartAssignment_3" + + + // $ANTLR start "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + // InternalScope.g:25597:1: rule__IfExpressionKw__ElsePartAssignment_4_0_1 : ( ruleChainedExpression ) ; + public final void rule__IfExpressionKw__ElsePartAssignment_4_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25601:1: ( ( ruleChainedExpression ) ) + // InternalScope.g:25602:2: ( ruleChainedExpression ) + { + // InternalScope.g:25602:2: ( ruleChainedExpression ) + // InternalScope.g:25603:3: ruleChainedExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleChainedExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIfExpressionKwAccess().getElsePartChainedExpressionParserRuleCall_4_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IfExpressionKw__ElsePartAssignment_4_0_1" + + + // $ANTLR start "rule__SwitchExpression__SwitchExprAssignment_1_1" + // InternalScope.g:25612:1: rule__SwitchExpression__SwitchExprAssignment_1_1 : ( ruleOrExpression ) ; + public final void rule__SwitchExpression__SwitchExprAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25616:1: ( ( ruleOrExpression ) ) + // InternalScope.g:25617:2: ( ruleOrExpression ) + { + // InternalScope.g:25617:2: ( ruleOrExpression ) + // InternalScope.g:25618:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getSwitchExprOrExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__SwitchExprAssignment_1_1" + + + // $ANTLR start "rule__SwitchExpression__CaseAssignment_3" + // InternalScope.g:25627:1: rule__SwitchExpression__CaseAssignment_3 : ( ruleCase ) ; + public final void rule__SwitchExpression__CaseAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25631:1: ( ( ruleCase ) ) + // InternalScope.g:25632:2: ( ruleCase ) + { + // InternalScope.g:25632:2: ( ruleCase ) + // InternalScope.g:25633:3: ruleCase + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleCase(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getCaseCaseParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__CaseAssignment_3" + + + // $ANTLR start "rule__SwitchExpression__DefaultExprAssignment_6" + // InternalScope.g:25642:1: rule__SwitchExpression__DefaultExprAssignment_6 : ( ruleOrExpression ) ; + public final void rule__SwitchExpression__DefaultExprAssignment_6() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25646:1: ( ( ruleOrExpression ) ) + // InternalScope.g:25647:2: ( ruleOrExpression ) + { + // InternalScope.g:25647:2: ( ruleOrExpression ) + // InternalScope.g:25648:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSwitchExpressionAccess().getDefaultExprOrExpressionParserRuleCall_6_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SwitchExpression__DefaultExprAssignment_6" + + + // $ANTLR start "rule__Case__ConditionAssignment_1" + // InternalScope.g:25657:1: rule__Case__ConditionAssignment_1 : ( ruleOrExpression ) ; + public final void rule__Case__ConditionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25661:1: ( ( ruleOrExpression ) ) + // InternalScope.g:25662:2: ( ruleOrExpression ) + { + // InternalScope.g:25662:2: ( ruleOrExpression ) + // InternalScope.g:25663:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCaseAccess().getConditionOrExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Case__ConditionAssignment_1" + + + // $ANTLR start "rule__Case__ThenParAssignment_3" + // InternalScope.g:25672:1: rule__Case__ThenParAssignment_3 : ( ruleOrExpression ) ; + public final void rule__Case__ThenParAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25676:1: ( ( ruleOrExpression ) ) + // InternalScope.g:25677:2: ( ruleOrExpression ) + { + // InternalScope.g:25677:2: ( ruleOrExpression ) + // InternalScope.g:25678:3: ruleOrExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleOrExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCaseAccess().getThenParOrExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__Case__ThenParAssignment_3" + + + // $ANTLR start "rule__OrExpression__OperatorAssignment_1_1" + // InternalScope.g:25687:1: rule__OrExpression__OperatorAssignment_1_1 : ( ( '||' ) ) ; + public final void rule__OrExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25691:1: ( ( ( '||' ) ) ) + // InternalScope.g:25692:2: ( ( '||' ) ) + { + // InternalScope.g:25692:2: ( ( '||' ) ) + // InternalScope.g:25693:3: ( '||' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + // InternalScope.g:25694:3: ( '||' ) + // InternalScope.g:25695:4: '||' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + match(input,15,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OrExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__OrExpression__RightAssignment_1_2" + // InternalScope.g:25706:1: rule__OrExpression__RightAssignment_1_2 : ( ruleAndExpression ) ; + public final void rule__OrExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25710:1: ( ( ruleAndExpression ) ) + // InternalScope.g:25711:2: ( ruleAndExpression ) + { + // InternalScope.g:25711:2: ( ruleAndExpression ) + // InternalScope.g:25712:3: ruleAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOrExpressionAccess().getRightAndExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OrExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__AndExpression__OperatorAssignment_1_1" + // InternalScope.g:25721:1: rule__AndExpression__OperatorAssignment_1_1 : ( ( '&&' ) ) ; + public final void rule__AndExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25725:1: ( ( ( '&&' ) ) ) + // InternalScope.g:25726:2: ( ( '&&' ) ) + { + // InternalScope.g:25726:2: ( ( '&&' ) ) + // InternalScope.g:25727:3: ( '&&' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + // InternalScope.g:25728:3: ( '&&' ) + // InternalScope.g:25729:4: '&&' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + match(input,16,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AndExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__AndExpression__RightAssignment_1_2" + // InternalScope.g:25740:1: rule__AndExpression__RightAssignment_1_2 : ( ruleImpliesExpression ) ; + public final void rule__AndExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25744:1: ( ( ruleImpliesExpression ) ) + // InternalScope.g:25745:2: ( ruleImpliesExpression ) + { + // InternalScope.g:25745:2: ( ruleImpliesExpression ) + // InternalScope.g:25746:3: ruleImpliesExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleImpliesExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAndExpressionAccess().getRightImpliesExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AndExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__ImpliesExpression__OperatorAssignment_1_1" + // InternalScope.g:25755:1: rule__ImpliesExpression__OperatorAssignment_1_1 : ( ( 'implies' ) ) ; + public final void rule__ImpliesExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25759:1: ( ( ( 'implies' ) ) ) + // InternalScope.g:25760:2: ( ( 'implies' ) ) + { + // InternalScope.g:25760:2: ( ( 'implies' ) ) + // InternalScope.g:25761:3: ( 'implies' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + // InternalScope.g:25762:3: ( 'implies' ) + // InternalScope.g:25763:4: 'implies' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + match(input,119,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ImpliesExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__ImpliesExpression__RightAssignment_1_2" + // InternalScope.g:25774:1: rule__ImpliesExpression__RightAssignment_1_2 : ( ruleRelationalExpression ) ; + public final void rule__ImpliesExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25778:1: ( ( ruleRelationalExpression ) ) + // InternalScope.g:25779:2: ( ruleRelationalExpression ) + { + // InternalScope.g:25779:2: ( ruleRelationalExpression ) + // InternalScope.g:25780:3: ruleRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getImpliesExpressionAccess().getRightRelationalExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ImpliesExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__RelationalExpression__OperatorAssignment_1_1" + // InternalScope.g:25789:1: rule__RelationalExpression__OperatorAssignment_1_1 : ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ; + public final void rule__RelationalExpression__OperatorAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25793:1: ( ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) ) + // InternalScope.g:25794:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + { + // InternalScope.g:25794:2: ( ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) ) + // InternalScope.g:25795:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + } + // InternalScope.g:25796:3: ( rule__RelationalExpression__OperatorAlternatives_1_1_0 ) + // InternalScope.g:25796:4: rule__RelationalExpression__OperatorAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__RelationalExpression__OperatorAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getOperatorAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__OperatorAssignment_1_1" + + + // $ANTLR start "rule__RelationalExpression__RightAssignment_1_2" + // InternalScope.g:25804:1: rule__RelationalExpression__RightAssignment_1_2 : ( ruleAdditiveExpression ) ; + public final void rule__RelationalExpression__RightAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25808:1: ( ( ruleAdditiveExpression ) ) + // InternalScope.g:25809:2: ( ruleAdditiveExpression ) + { + // InternalScope.g:25809:2: ( ruleAdditiveExpression ) + // InternalScope.g:25810:3: ruleAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRelationalExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RelationalExpression__RightAssignment_1_2" + + + // $ANTLR start "rule__AdditiveExpression__NameAssignment_1_1" + // InternalScope.g:25819:1: rule__AdditiveExpression__NameAssignment_1_1 : ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ; + public final void rule__AdditiveExpression__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25823:1: ( ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) ) + // InternalScope.g:25824:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + { + // InternalScope.g:25824:2: ( ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) ) + // InternalScope.g:25825:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + } + // InternalScope.g:25826:3: ( rule__AdditiveExpression__NameAlternatives_1_1_0 ) + // InternalScope.g:25826:4: rule__AdditiveExpression__NameAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__AdditiveExpression__NameAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getNameAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__NameAssignment_1_1" + + + // $ANTLR start "rule__AdditiveExpression__ParamsAssignment_1_2" + // InternalScope.g:25834:1: rule__AdditiveExpression__ParamsAssignment_1_2 : ( ruleMultiplicativeExpression ) ; + public final void rule__AdditiveExpression__ParamsAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25838:1: ( ( ruleMultiplicativeExpression ) ) + // InternalScope.g:25839:2: ( ruleMultiplicativeExpression ) + { + // InternalScope.g:25839:2: ( ruleMultiplicativeExpression ) + // InternalScope.g:25840:3: ruleMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getAdditiveExpressionAccess().getParamsMultiplicativeExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__AdditiveExpression__ParamsAssignment_1_2" + + + // $ANTLR start "rule__MultiplicativeExpression__NameAssignment_1_1" + // InternalScope.g:25849:1: rule__MultiplicativeExpression__NameAssignment_1_1 : ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ; + public final void rule__MultiplicativeExpression__NameAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25853:1: ( ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) ) + // InternalScope.g:25854:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + { + // InternalScope.g:25854:2: ( ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) ) + // InternalScope.g:25855:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + } + // InternalScope.g:25856:3: ( rule__MultiplicativeExpression__NameAlternatives_1_1_0 ) + // InternalScope.g:25856:4: rule__MultiplicativeExpression__NameAlternatives_1_1_0 + { + pushFollow(FOLLOW_2); + rule__MultiplicativeExpression__NameAlternatives_1_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getNameAlternatives_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__NameAssignment_1_1" + + + // $ANTLR start "rule__MultiplicativeExpression__ParamsAssignment_1_2" + // InternalScope.g:25864:1: rule__MultiplicativeExpression__ParamsAssignment_1_2 : ( ruleUnaryOrInfixExpression ) ; + public final void rule__MultiplicativeExpression__ParamsAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25868:1: ( ( ruleUnaryOrInfixExpression ) ) + // InternalScope.g:25869:2: ( ruleUnaryOrInfixExpression ) + { + // InternalScope.g:25869:2: ( ruleUnaryOrInfixExpression ) + // InternalScope.g:25870:3: ruleUnaryOrInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleUnaryOrInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getMultiplicativeExpressionAccess().getParamsUnaryOrInfixExpressionParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__MultiplicativeExpression__ParamsAssignment_1_2" + + + // $ANTLR start "rule__UnaryExpression__NameAssignment_0" + // InternalScope.g:25879:1: rule__UnaryExpression__NameAssignment_0 : ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ; + public final void rule__UnaryExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25883:1: ( ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) ) + // InternalScope.g:25884:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + { + // InternalScope.g:25884:2: ( ( rule__UnaryExpression__NameAlternatives_0_0 ) ) + // InternalScope.g:25885:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + } + // InternalScope.g:25886:3: ( rule__UnaryExpression__NameAlternatives_0_0 ) + // InternalScope.g:25886:4: rule__UnaryExpression__NameAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__UnaryExpression__NameAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getNameAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__NameAssignment_0" + + + // $ANTLR start "rule__UnaryExpression__ParamsAssignment_1" + // InternalScope.g:25894:1: rule__UnaryExpression__ParamsAssignment_1 : ( ruleInfixExpression ) ; + public final void rule__UnaryExpression__ParamsAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25898:1: ( ( ruleInfixExpression ) ) + // InternalScope.g:25899:2: ( ruleInfixExpression ) + { + // InternalScope.g:25899:2: ( ruleInfixExpression ) + // InternalScope.g:25900:3: ruleInfixExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleInfixExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getUnaryExpressionAccess().getParamsInfixExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__UnaryExpression__ParamsAssignment_1" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_0_2" + // InternalScope.g:25909:1: rule__InfixExpression__NameAssignment_1_0_2 : ( ruleIdentifier ) ; + public final void rule__InfixExpression__NameAssignment_1_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25913:1: ( ( ruleIdentifier ) ) + // InternalScope.g:25914:2: ( ruleIdentifier ) + { + // InternalScope.g:25914:2: ( ruleIdentifier ) + // InternalScope.g:25915:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameIdentifierParserRuleCall_1_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_0_2" + + + // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_0" + // InternalScope.g:25924:1: rule__InfixExpression__ParamsAssignment_1_0_4_0 : ( ruleExpression ) ; + public final void rule__InfixExpression__ParamsAssignment_1_0_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25928:1: ( ( ruleExpression ) ) + // InternalScope.g:25929:2: ( ruleExpression ) + { + // InternalScope.g:25929:2: ( ruleExpression ) + // InternalScope.g:25930:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_0" + + + // $ANTLR start "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + // InternalScope.g:25939:1: rule__InfixExpression__ParamsAssignment_1_0_4_1_1 : ( ruleExpression ) ; + public final void rule__InfixExpression__ParamsAssignment_1_0_4_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25943:1: ( ( ruleExpression ) ) + // InternalScope.g:25944:2: ( ruleExpression ) + { + // InternalScope.g:25944:2: ( ruleExpression ) + // InternalScope.g:25945:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getParamsExpressionParserRuleCall_1_0_4_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ParamsAssignment_1_0_4_1_1" + + + // $ANTLR start "rule__InfixExpression__TypeAssignment_1_1_2" + // InternalScope.g:25954:1: rule__InfixExpression__TypeAssignment_1_1_2 : ( ruleType ) ; + public final void rule__InfixExpression__TypeAssignment_1_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25958:1: ( ( ruleType ) ) + // InternalScope.g:25959:2: ( ruleType ) + { + // InternalScope.g:25959:2: ( ruleType ) + // InternalScope.g:25960:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__TypeAssignment_1_1_2" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_2_2" + // InternalScope.g:25969:1: rule__InfixExpression__NameAssignment_1_2_2 : ( ( 'typeSelect' ) ) ; + public final void rule__InfixExpression__NameAssignment_1_2_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25973:1: ( ( ( 'typeSelect' ) ) ) + // InternalScope.g:25974:2: ( ( 'typeSelect' ) ) + { + // InternalScope.g:25974:2: ( ( 'typeSelect' ) ) + // InternalScope.g:25975:3: ( 'typeSelect' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + // InternalScope.g:25976:3: ( 'typeSelect' ) + // InternalScope.g:25977:4: 'typeSelect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + match(input,120,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_2_2" + + + // $ANTLR start "rule__InfixExpression__TypeAssignment_1_2_4" + // InternalScope.g:25988:1: rule__InfixExpression__TypeAssignment_1_2_4 : ( ruleType ) ; + public final void rule__InfixExpression__TypeAssignment_1_2_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:25992:1: ( ( ruleType ) ) + // InternalScope.g:25993:2: ( ruleType ) + { + // InternalScope.g:25993:2: ( ruleType ) + // InternalScope.g:25994:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getTypeTypeParserRuleCall_1_2_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__TypeAssignment_1_2_4" + + + // $ANTLR start "rule__InfixExpression__NameAssignment_1_3_2" + // InternalScope.g:26003:1: rule__InfixExpression__NameAssignment_1_3_2 : ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ; + public final void rule__InfixExpression__NameAssignment_1_3_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26007:1: ( ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) ) + // InternalScope.g:26008:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + { + // InternalScope.g:26008:2: ( ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) ) + // InternalScope.g:26009:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + } + // InternalScope.g:26010:3: ( rule__InfixExpression__NameAlternatives_1_3_2_0 ) + // InternalScope.g:26010:4: rule__InfixExpression__NameAlternatives_1_3_2_0 + { + pushFollow(FOLLOW_2); + rule__InfixExpression__NameAlternatives_1_3_2_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getNameAlternatives_1_3_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__NameAssignment_1_3_2" + + + // $ANTLR start "rule__InfixExpression__VarAssignment_1_3_4_0" + // InternalScope.g:26018:1: rule__InfixExpression__VarAssignment_1_3_4_0 : ( ruleIdentifier ) ; + public final void rule__InfixExpression__VarAssignment_1_3_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26022:1: ( ( ruleIdentifier ) ) + // InternalScope.g:26023:2: ( ruleIdentifier ) + { + // InternalScope.g:26023:2: ( ruleIdentifier ) + // InternalScope.g:26024:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getVarIdentifierParserRuleCall_1_3_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__VarAssignment_1_3_4_0" + + + // $ANTLR start "rule__InfixExpression__ExpAssignment_1_3_5" + // InternalScope.g:26033:1: rule__InfixExpression__ExpAssignment_1_3_5 : ( ruleExpression ) ; + public final void rule__InfixExpression__ExpAssignment_1_3_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26037:1: ( ( ruleExpression ) ) + // InternalScope.g:26038:2: ( ruleExpression ) + { + // InternalScope.g:26038:2: ( ruleExpression ) + // InternalScope.g:26039:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getInfixExpressionAccess().getExpExpressionParserRuleCall_1_3_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__InfixExpression__ExpAssignment_1_3_5" + + + // $ANTLR start "rule__BooleanLiteral__ValAssignment" + // InternalScope.g:26048:1: rule__BooleanLiteral__ValAssignment : ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ; + public final void rule__BooleanLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26052:1: ( ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) ) + // InternalScope.g:26053:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + { + // InternalScope.g:26053:2: ( ( rule__BooleanLiteral__ValAlternatives_0 ) ) + // InternalScope.g:26054:3: ( rule__BooleanLiteral__ValAlternatives_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); + } + // InternalScope.g:26055:3: ( rule__BooleanLiteral__ValAlternatives_0 ) + // InternalScope.g:26055:4: rule__BooleanLiteral__ValAlternatives_0 + { + pushFollow(FOLLOW_2); + rule__BooleanLiteral__ValAlternatives_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getBooleanLiteralAccess().getValAlternatives_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__BooleanLiteral__ValAssignment" + + + // $ANTLR start "rule__IntegerLiteral__ValAssignment" + // InternalScope.g:26063:1: rule__IntegerLiteral__ValAssignment : ( RULE_INT ) ; + public final void rule__IntegerLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26067:1: ( ( RULE_INT ) ) + // InternalScope.g:26068:2: ( RULE_INT ) + { + // InternalScope.g:26068:2: ( RULE_INT ) + // InternalScope.g:26069:3: RULE_INT + { + if ( state.backtracking==0 ) { + before(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + } + match(input,RULE_INT,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getIntegerLiteralAccess().getValINTTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__IntegerLiteral__ValAssignment" + + + // $ANTLR start "rule__NullLiteral__ValAssignment" + // InternalScope.g:26078:1: rule__NullLiteral__ValAssignment : ( ( 'null' ) ) ; + public final void rule__NullLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26082:1: ( ( ( 'null' ) ) ) + // InternalScope.g:26083:2: ( ( 'null' ) ) + { + // InternalScope.g:26083:2: ( ( 'null' ) ) + // InternalScope.g:26084:3: ( 'null' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + // InternalScope.g:26085:3: ( 'null' ) + // InternalScope.g:26086:4: 'null' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + match(input,108,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__NullLiteral__ValAssignment" + + + // $ANTLR start "rule__RealLiteral__ValAssignment" + // InternalScope.g:26097:1: rule__RealLiteral__ValAssignment : ( RULE_REAL ) ; + public final void rule__RealLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26101:1: ( ( RULE_REAL ) ) + // InternalScope.g:26102:2: ( RULE_REAL ) + { + // InternalScope.g:26102:2: ( RULE_REAL ) + // InternalScope.g:26103:3: RULE_REAL + { + if ( state.backtracking==0 ) { + before(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + } + match(input,RULE_REAL,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getRealLiteralAccess().getValREALTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__RealLiteral__ValAssignment" + + + // $ANTLR start "rule__StringLiteral__ValAssignment" + // InternalScope.g:26112:1: rule__StringLiteral__ValAssignment : ( RULE_STRING ) ; + public final void rule__StringLiteral__ValAssignment() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26116:1: ( ( RULE_STRING ) ) + // InternalScope.g:26117:2: ( RULE_STRING ) + { + // InternalScope.g:26117:2: ( RULE_STRING ) + // InternalScope.g:26118:3: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getStringLiteralAccess().getValSTRINGTerminalRuleCall_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__StringLiteral__ValAssignment" + + + // $ANTLR start "rule__GlobalVarExpression__NameAssignment_1" + // InternalScope.g:26127:1: rule__GlobalVarExpression__NameAssignment_1 : ( ruleIdentifier ) ; + public final void rule__GlobalVarExpression__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26131:1: ( ( ruleIdentifier ) ) + // InternalScope.g:26132:2: ( ruleIdentifier ) + { + // InternalScope.g:26132:2: ( ruleIdentifier ) + // InternalScope.g:26133:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getGlobalVarExpressionAccess().getNameIdentifierParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__GlobalVarExpression__NameAssignment_1" + + + // $ANTLR start "rule__FeatureCall__TypeAssignment_1" + // InternalScope.g:26142:1: rule__FeatureCall__TypeAssignment_1 : ( ruleType ) ; + public final void rule__FeatureCall__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26146:1: ( ( ruleType ) ) + // InternalScope.g:26147:2: ( ruleType ) + { + // InternalScope.g:26147:2: ( ruleType ) + // InternalScope.g:26148:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFeatureCallAccess().getTypeTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FeatureCall__TypeAssignment_1" + + + // $ANTLR start "rule__OperationCall__NameAssignment_0" + // InternalScope.g:26157:1: rule__OperationCall__NameAssignment_0 : ( ruleIdentifier ) ; + public final void rule__OperationCall__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26161:1: ( ( ruleIdentifier ) ) + // InternalScope.g:26162:2: ( ruleIdentifier ) + { + // InternalScope.g:26162:2: ( ruleIdentifier ) + // InternalScope.g:26163:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getNameIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__NameAssignment_0" + + + // $ANTLR start "rule__OperationCall__ParamsAssignment_2_0" + // InternalScope.g:26172:1: rule__OperationCall__ParamsAssignment_2_0 : ( ruleExpression ) ; + public final void rule__OperationCall__ParamsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26176:1: ( ( ruleExpression ) ) + // InternalScope.g:26177:2: ( ruleExpression ) + { + // InternalScope.g:26177:2: ( ruleExpression ) + // InternalScope.g:26178:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__ParamsAssignment_2_0" + + + // $ANTLR start "rule__OperationCall__ParamsAssignment_2_1_1" + // InternalScope.g:26187:1: rule__OperationCall__ParamsAssignment_2_1_1 : ( ruleExpression ) ; + public final void rule__OperationCall__ParamsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26191:1: ( ( ruleExpression ) ) + // InternalScope.g:26192:2: ( ruleExpression ) + { + // InternalScope.g:26192:2: ( ruleExpression ) + // InternalScope.g:26193:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getOperationCallAccess().getParamsExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__OperationCall__ParamsAssignment_2_1_1" + + + // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_0" + // InternalScope.g:26202:1: rule__ListLiteral__ElementsAssignment_2_0 : ( ruleExpression ) ; + public final void rule__ListLiteral__ElementsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26206:1: ( ( ruleExpression ) ) + // InternalScope.g:26207:2: ( ruleExpression ) + { + // InternalScope.g:26207:2: ( ruleExpression ) + // InternalScope.g:26208:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_0" + + + // $ANTLR start "rule__ListLiteral__ElementsAssignment_2_1_1" + // InternalScope.g:26217:1: rule__ListLiteral__ElementsAssignment_2_1_1 : ( ruleExpression ) ; + public final void rule__ListLiteral__ElementsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26221:1: ( ( ruleExpression ) ) + // InternalScope.g:26222:2: ( ruleExpression ) + { + // InternalScope.g:26222:2: ( ruleExpression ) + // InternalScope.g:26223:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getListLiteralAccess().getElementsExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ListLiteral__ElementsAssignment_2_1_1" + + + // $ANTLR start "rule__ConstructorCallExpression__TypeAssignment_1" + // InternalScope.g:26232:1: rule__ConstructorCallExpression__TypeAssignment_1 : ( ruleSimpleType ) ; + public final void rule__ConstructorCallExpression__TypeAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26236:1: ( ( ruleSimpleType ) ) + // InternalScope.g:26237:2: ( ruleSimpleType ) + { + // InternalScope.g:26237:2: ( ruleSimpleType ) + // InternalScope.g:26238:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getConstructorCallExpressionAccess().getTypeSimpleTypeParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__ConstructorCallExpression__TypeAssignment_1" + + + // $ANTLR start "rule__TypeSelectExpression__NameAssignment_0" + // InternalScope.g:26247:1: rule__TypeSelectExpression__NameAssignment_0 : ( ( 'typeSelect' ) ) ; + public final void rule__TypeSelectExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26251:1: ( ( ( 'typeSelect' ) ) ) + // InternalScope.g:26252:2: ( ( 'typeSelect' ) ) + { + // InternalScope.g:26252:2: ( ( 'typeSelect' ) ) + // InternalScope.g:26253:3: ( 'typeSelect' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + // InternalScope.g:26254:3: ( 'typeSelect' ) + // InternalScope.g:26255:4: 'typeSelect' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + match(input,120,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__NameAssignment_0" + + + // $ANTLR start "rule__TypeSelectExpression__TypeAssignment_2" + // InternalScope.g:26266:1: rule__TypeSelectExpression__TypeAssignment_2 : ( ruleType ) ; + public final void rule__TypeSelectExpression__TypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26270:1: ( ( ruleType ) ) + // InternalScope.g:26271:2: ( ruleType ) + { + // InternalScope.g:26271:2: ( ruleType ) + // InternalScope.g:26272:3: ruleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getTypeSelectExpressionAccess().getTypeTypeParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__TypeSelectExpression__TypeAssignment_2" + + + // $ANTLR start "rule__CollectionExpression__NameAssignment_0" + // InternalScope.g:26281:1: rule__CollectionExpression__NameAssignment_0 : ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ; + public final void rule__CollectionExpression__NameAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26285:1: ( ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) ) + // InternalScope.g:26286:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + { + // InternalScope.g:26286:2: ( ( rule__CollectionExpression__NameAlternatives_0_0 ) ) + // InternalScope.g:26287:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + } + // InternalScope.g:26288:3: ( rule__CollectionExpression__NameAlternatives_0_0 ) + // InternalScope.g:26288:4: rule__CollectionExpression__NameAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__CollectionExpression__NameAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getNameAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__NameAssignment_0" + + + // $ANTLR start "rule__CollectionExpression__VarAssignment_2_0" + // InternalScope.g:26296:1: rule__CollectionExpression__VarAssignment_2_0 : ( ruleIdentifier ) ; + public final void rule__CollectionExpression__VarAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26300:1: ( ( ruleIdentifier ) ) + // InternalScope.g:26301:2: ( ruleIdentifier ) + { + // InternalScope.g:26301:2: ( ruleIdentifier ) + // InternalScope.g:26302:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getVarIdentifierParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__VarAssignment_2_0" + + + // $ANTLR start "rule__CollectionExpression__ExpAssignment_3" + // InternalScope.g:26311:1: rule__CollectionExpression__ExpAssignment_3 : ( ruleExpression ) ; + public final void rule__CollectionExpression__ExpAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26315:1: ( ( ruleExpression ) ) + // InternalScope.g:26316:2: ( ruleExpression ) + { + // InternalScope.g:26316:2: ( ruleExpression ) + // InternalScope.g:26317:3: ruleExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionExpressionAccess().getExpExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionExpression__ExpAssignment_3" + + + // $ANTLR start "rule__CollectionType__ClAssignment_0" + // InternalScope.g:26326:1: rule__CollectionType__ClAssignment_0 : ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ; + public final void rule__CollectionType__ClAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26330:1: ( ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ) + // InternalScope.g:26331:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) + { + // InternalScope.g:26331:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) + // InternalScope.g:26332:3: ( rule__CollectionType__ClAlternatives_0_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); + } + // InternalScope.g:26333:3: ( rule__CollectionType__ClAlternatives_0_0 ) + // InternalScope.g:26333:4: rule__CollectionType__ClAlternatives_0_0 + { + pushFollow(FOLLOW_2); + rule__CollectionType__ClAlternatives_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__ClAssignment_0" + + + // $ANTLR start "rule__CollectionType__Id1Assignment_2" + // InternalScope.g:26341:1: rule__CollectionType__Id1Assignment_2 : ( ruleSimpleType ) ; + public final void rule__CollectionType__Id1Assignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26345:1: ( ( ruleSimpleType ) ) + // InternalScope.g:26346:2: ( ruleSimpleType ) + { + // InternalScope.g:26346:2: ( ruleSimpleType ) + // InternalScope.g:26347:3: ruleSimpleType + { + if ( state.backtracking==0 ) { + before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleSimpleType(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__CollectionType__Id1Assignment_2" + + + // $ANTLR start "rule__SimpleType__IdAssignment_0" + // InternalScope.g:26356:1: rule__SimpleType__IdAssignment_0 : ( ruleIdentifier ) ; + public final void rule__SimpleType__IdAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26360:1: ( ( ruleIdentifier ) ) + // InternalScope.g:26361:2: ( ruleIdentifier ) + { + // InternalScope.g:26361:2: ( ruleIdentifier ) + // InternalScope.g:26362:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__IdAssignment_0" + + + // $ANTLR start "rule__SimpleType__IdAssignment_1_1" + // InternalScope.g:26371:1: rule__SimpleType__IdAssignment_1_1 : ( ruleIdentifier ) ; + public final void rule__SimpleType__IdAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26375:1: ( ( ruleIdentifier ) ) + // InternalScope.g:26376:2: ( ruleIdentifier ) + { + // InternalScope.g:26376:2: ( ruleIdentifier ) + // InternalScope.g:26377:3: ruleIdentifier + { + if ( state.backtracking==0 ) { + before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleIdentifier(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__SimpleType__IdAssignment_1_1" + + + // $ANTLR start "rule__XAssignment__FeatureAssignment_0_1" + // InternalScope.g:26386:1: rule__XAssignment__FeatureAssignment_0_1 : ( ( ruleFeatureCallID ) ) ; + public final void rule__XAssignment__FeatureAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26390:1: ( ( ( ruleFeatureCallID ) ) ) + // InternalScope.g:26391:2: ( ( ruleFeatureCallID ) ) + { + // InternalScope.g:26391:2: ( ( ruleFeatureCallID ) ) + // InternalScope.g:26392:3: ( ruleFeatureCallID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + // InternalScope.g:26393:3: ( ruleFeatureCallID ) + // InternalScope.g:26394:4: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__FeatureAssignment_0_1" + + + // $ANTLR start "rule__XAssignment__ValueAssignment_0_3" + // InternalScope.g:26405:1: rule__XAssignment__ValueAssignment_0_3 : ( ruleXAssignment ) ; + public final void rule__XAssignment__ValueAssignment_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26409:1: ( ( ruleXAssignment ) ) + // InternalScope.g:26410:2: ( ruleXAssignment ) + { + // InternalScope.g:26410:2: ( ruleXAssignment ) + // InternalScope.g:26411:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__ValueAssignment_0_3" + + + // $ANTLR start "rule__XAssignment__FeatureAssignment_1_1_0_0_1" + // InternalScope.g:26420:1: rule__XAssignment__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpMultiAssign ) ) ; + public final void rule__XAssignment__FeatureAssignment_1_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26424:1: ( ( ( ruleOpMultiAssign ) ) ) + // InternalScope.g:26425:2: ( ( ruleOpMultiAssign ) ) + { + // InternalScope.g:26425:2: ( ( ruleOpMultiAssign ) ) + // InternalScope.g:26426:3: ( ruleOpMultiAssign ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + // InternalScope.g:26427:3: ( ruleOpMultiAssign ) + // InternalScope.g:26428:4: ruleOpMultiAssign + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__FeatureAssignment_1_1_0_0_1" + + + // $ANTLR start "rule__XAssignment__RightOperandAssignment_1_1_1" + // InternalScope.g:26439:1: rule__XAssignment__RightOperandAssignment_1_1_1 : ( ruleXAssignment ) ; + public final void rule__XAssignment__RightOperandAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26443:1: ( ( ruleXAssignment ) ) + // InternalScope.g:26444:2: ( ruleXAssignment ) + { + // InternalScope.g:26444:2: ( ruleXAssignment ) + // InternalScope.g:26445:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAssignment__RightOperandAssignment_1_1_1" + + + // $ANTLR start "rule__XOrExpression__FeatureAssignment_1_0_0_1" + // InternalScope.g:26454:1: rule__XOrExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOr ) ) ; + public final void rule__XOrExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26458:1: ( ( ( ruleOpOr ) ) ) + // InternalScope.g:26459:2: ( ( ruleOpOr ) ) + { + // InternalScope.g:26459:2: ( ( ruleOpOr ) ) + // InternalScope.g:26460:3: ( ruleOpOr ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalScope.g:26461:3: ( ruleOpOr ) + // InternalScope.g:26462:4: ruleOpOr + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XOrExpression__RightOperandAssignment_1_1" + // InternalScope.g:26473:1: rule__XOrExpression__RightOperandAssignment_1_1 : ( ruleXAndExpression ) ; + public final void rule__XOrExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26477:1: ( ( ruleXAndExpression ) ) + // InternalScope.g:26478:2: ( ruleXAndExpression ) + { + // InternalScope.g:26478:2: ( ruleXAndExpression ) + // InternalScope.g:26479:3: ruleXAndExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAndExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOrExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XAndExpression__FeatureAssignment_1_0_0_1" + // InternalScope.g:26488:1: rule__XAndExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAnd ) ) ; + public final void rule__XAndExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26492:1: ( ( ( ruleOpAnd ) ) ) + // InternalScope.g:26493:2: ( ( ruleOpAnd ) ) + { + // InternalScope.g:26493:2: ( ( ruleOpAnd ) ) + // InternalScope.g:26494:3: ( ruleOpAnd ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalScope.g:26495:3: ( ruleOpAnd ) + // InternalScope.g:26496:4: ruleOpAnd + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XAndExpression__RightOperandAssignment_1_1" + // InternalScope.g:26507:1: rule__XAndExpression__RightOperandAssignment_1_1 : ( ruleXEqualityExpression ) ; + public final void rule__XAndExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26511:1: ( ( ruleXEqualityExpression ) ) + // InternalScope.g:26512:2: ( ruleXEqualityExpression ) + { + // InternalScope.g:26512:2: ( ruleXEqualityExpression ) + // InternalScope.g:26513:3: ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAndExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XEqualityExpression__FeatureAssignment_1_0_0_1" + // InternalScope.g:26522:1: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpEquality ) ) ; + public final void rule__XEqualityExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26526:1: ( ( ( ruleOpEquality ) ) ) + // InternalScope.g:26527:2: ( ( ruleOpEquality ) ) + { + // InternalScope.g:26527:2: ( ( ruleOpEquality ) ) + // InternalScope.g:26528:3: ( ruleOpEquality ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalScope.g:26529:3: ( ruleOpEquality ) + // InternalScope.g:26530:4: ruleOpEquality + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XEqualityExpression__RightOperandAssignment_1_1" + // InternalScope.g:26541:1: rule__XEqualityExpression__RightOperandAssignment_1_1 : ( ruleXRelationalExpression ) ; + public final void rule__XEqualityExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26545:1: ( ( ruleXRelationalExpression ) ) + // InternalScope.g:26546:2: ( ruleXRelationalExpression ) + { + // InternalScope.g:26546:2: ( ruleXRelationalExpression ) + // InternalScope.g:26547:3: ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XEqualityExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XRelationalExpression__TypeAssignment_1_0_1" + // InternalScope.g:26556:1: rule__XRelationalExpression__TypeAssignment_1_0_1 : ( ruleJvmTypeReference ) ; + public final void rule__XRelationalExpression__TypeAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26560:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:26561:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:26561:2: ( ruleJvmTypeReference ) + // InternalScope.g:26562:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__TypeAssignment_1_0_1" + + + // $ANTLR start "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1" + // InternalScope.g:26571:1: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpCompare ) ) ; + public final void rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26575:1: ( ( ( ruleOpCompare ) ) ) + // InternalScope.g:26576:2: ( ( ruleOpCompare ) ) + { + // InternalScope.g:26576:2: ( ( ruleOpCompare ) ) + // InternalScope.g:26577:3: ( ruleOpCompare ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + // InternalScope.g:26578:3: ( ruleOpCompare ) + // InternalScope.g:26579:4: ruleOpCompare + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1" + + + // $ANTLR start "rule__XRelationalExpression__RightOperandAssignment_1_1_1" + // InternalScope.g:26590:1: rule__XRelationalExpression__RightOperandAssignment_1_1_1 : ( ruleXOtherOperatorExpression ) ; + public final void rule__XRelationalExpression__RightOperandAssignment_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26594:1: ( ( ruleXOtherOperatorExpression ) ) + // InternalScope.g:26595:2: ( ruleXOtherOperatorExpression ) + { + // InternalScope.g:26595:2: ( ruleXOtherOperatorExpression ) + // InternalScope.g:26596:3: ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XRelationalExpression__RightOperandAssignment_1_1_1" + + + // $ANTLR start "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1" + // InternalScope.g:26605:1: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOther ) ) ; + public final void rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26609:1: ( ( ( ruleOpOther ) ) ) + // InternalScope.g:26610:2: ( ( ruleOpOther ) ) + { + // InternalScope.g:26610:2: ( ( ruleOpOther ) ) + // InternalScope.g:26611:3: ( ruleOpOther ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalScope.g:26612:3: ( ruleOpOther ) + // InternalScope.g:26613:4: ruleOpOther + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XOtherOperatorExpression__RightOperandAssignment_1_1" + // InternalScope.g:26624:1: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 : ( ruleXAdditiveExpression ) ; + public final void rule__XOtherOperatorExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26628:1: ( ( ruleXAdditiveExpression ) ) + // InternalScope.g:26629:2: ( ruleXAdditiveExpression ) + { + // InternalScope.g:26629:2: ( ruleXAdditiveExpression ) + // InternalScope.g:26630:3: ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XOtherOperatorExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1" + // InternalScope.g:26639:1: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAdd ) ) ; + public final void rule__XAdditiveExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26643:1: ( ( ( ruleOpAdd ) ) ) + // InternalScope.g:26644:2: ( ( ruleOpAdd ) ) + { + // InternalScope.g:26644:2: ( ( ruleOpAdd ) ) + // InternalScope.g:26645:3: ( ruleOpAdd ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalScope.g:26646:3: ( ruleOpAdd ) + // InternalScope.g:26647:4: ruleOpAdd + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XAdditiveExpression__RightOperandAssignment_1_1" + // InternalScope.g:26658:1: rule__XAdditiveExpression__RightOperandAssignment_1_1 : ( ruleXMultiplicativeExpression ) ; + public final void rule__XAdditiveExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26662:1: ( ( ruleXMultiplicativeExpression ) ) + // InternalScope.g:26663:2: ( ruleXMultiplicativeExpression ) + { + // InternalScope.g:26663:2: ( ruleXMultiplicativeExpression ) + // InternalScope.g:26664:3: ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XAdditiveExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1" + // InternalScope.g:26673:1: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpMulti ) ) ; + public final void rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26677:1: ( ( ( ruleOpMulti ) ) ) + // InternalScope.g:26678:2: ( ( ruleOpMulti ) ) + { + // InternalScope.g:26678:2: ( ( ruleOpMulti ) ) + // InternalScope.g:26679:3: ( ruleOpMulti ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + // InternalScope.g:26680:3: ( ruleOpMulti ) + // InternalScope.g:26681:4: ruleOpMulti + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1" + + + // $ANTLR start "rule__XMultiplicativeExpression__RightOperandAssignment_1_1" + // InternalScope.g:26692:1: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 : ( ruleXUnaryOperation ) ; + public final void rule__XMultiplicativeExpression__RightOperandAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26696:1: ( ( ruleXUnaryOperation ) ) + // InternalScope.g:26697:2: ( ruleXUnaryOperation ) + { + // InternalScope.g:26697:2: ( ruleXUnaryOperation ) + // InternalScope.g:26698:3: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMultiplicativeExpression__RightOperandAssignment_1_1" + + + // $ANTLR start "rule__XUnaryOperation__FeatureAssignment_0_1" + // InternalScope.g:26707:1: rule__XUnaryOperation__FeatureAssignment_0_1 : ( ( ruleOpUnary ) ) ; + public final void rule__XUnaryOperation__FeatureAssignment_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26711:1: ( ( ( ruleOpUnary ) ) ) + // InternalScope.g:26712:2: ( ( ruleOpUnary ) ) + { + // InternalScope.g:26712:2: ( ( ruleOpUnary ) ) + // InternalScope.g:26713:3: ( ruleOpUnary ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + // InternalScope.g:26714:3: ( ruleOpUnary ) + // InternalScope.g:26715:4: ruleOpUnary + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__FeatureAssignment_0_1" + + + // $ANTLR start "rule__XUnaryOperation__OperandAssignment_0_2" + // InternalScope.g:26726:1: rule__XUnaryOperation__OperandAssignment_0_2 : ( ruleXUnaryOperation ) ; + public final void rule__XUnaryOperation__OperandAssignment_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26730:1: ( ( ruleXUnaryOperation ) ) + // InternalScope.g:26731:2: ( ruleXUnaryOperation ) + { + // InternalScope.g:26731:2: ( ruleXUnaryOperation ) + // InternalScope.g:26732:3: ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + pushFollow(FOLLOW_2); + ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XUnaryOperation__OperandAssignment_0_2" + + + // $ANTLR start "rule__XCastedExpression__TypeAssignment_1_1" + // InternalScope.g:26741:1: rule__XCastedExpression__TypeAssignment_1_1 : ( ruleJvmTypeReference ) ; + public final void rule__XCastedExpression__TypeAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26745:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:26746:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:26746:2: ( ruleJvmTypeReference ) + // InternalScope.g:26747:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCastedExpression__TypeAssignment_1_1" + + + // $ANTLR start "rule__XPostfixOperation__FeatureAssignment_1_0_1" + // InternalScope.g:26756:1: rule__XPostfixOperation__FeatureAssignment_1_0_1 : ( ( ruleOpPostfix ) ) ; + public final void rule__XPostfixOperation__FeatureAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26760:1: ( ( ( ruleOpPostfix ) ) ) + // InternalScope.g:26761:2: ( ( ruleOpPostfix ) ) + { + // InternalScope.g:26761:2: ( ( ruleOpPostfix ) ) + // InternalScope.g:26762:3: ( ruleOpPostfix ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + // InternalScope.g:26763:3: ( ruleOpPostfix ) + // InternalScope.g:26764:4: ruleOpPostfix + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XPostfixOperation__FeatureAssignment_1_0_1" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1" + // InternalScope.g:26775:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 : ( ( '::' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26779:1: ( ( ( '::' ) ) ) + // InternalScope.g:26780:2: ( ( '::' ) ) + { + // InternalScope.g:26780:2: ( ( '::' ) ) + // InternalScope.g:26781:3: ( '::' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + // InternalScope.g:26782:3: ( '::' ) + // InternalScope.g:26783:4: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2" + // InternalScope.g:26794:1: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 : ( ( ruleFeatureCallID ) ) ; + public final void rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26798:1: ( ( ( ruleFeatureCallID ) ) ) + // InternalScope.g:26799:2: ( ( ruleFeatureCallID ) ) + { + // InternalScope.g:26799:2: ( ( ruleFeatureCallID ) ) + // InternalScope.g:26800:3: ( ruleFeatureCallID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + // InternalScope.g:26801:3: ( ruleFeatureCallID ) + // InternalScope.g:26802:4: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2" + + + // $ANTLR start "rule__XMemberFeatureCall__ValueAssignment_1_0_1" + // InternalScope.g:26813:1: rule__XMemberFeatureCall__ValueAssignment_1_0_1 : ( ruleXAssignment ) ; + public final void rule__XMemberFeatureCall__ValueAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26817:1: ( ( ruleXAssignment ) ) + // InternalScope.g:26818:2: ( ruleXAssignment ) + { + // InternalScope.g:26818:2: ( ruleXAssignment ) + // InternalScope.g:26819:3: ruleXAssignment + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXAssignment(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ValueAssignment_1_0_1" + + + // $ANTLR start "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1" + // InternalScope.g:26828:1: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 : ( ( '?.' ) ) ; + public final void rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26832:1: ( ( ( '?.' ) ) ) + // InternalScope.g:26833:2: ( ( '?.' ) ) + { + // InternalScope.g:26833:2: ( ( '?.' ) ) + // InternalScope.g:26834:3: ( '?.' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + // InternalScope.g:26835:3: ( '?.' ) + // InternalScope.g:26836:4: '?.' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + match(input,121,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2" + // InternalScope.g:26847:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 : ( ( '::' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26851:1: ( ( ( '::' ) ) ) + // InternalScope.g:26852:2: ( ( '::' ) ) + { + // InternalScope.g:26852:2: ( ( '::' ) ) + // InternalScope.g:26853:3: ( '::' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + // InternalScope.g:26854:3: ( '::' ) + // InternalScope.g:26855:4: '::' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + match(input,93,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2" + + + // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1" + // InternalScope.g:26866:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26870:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:26871:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:26871:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:26872:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1" + // InternalScope.g:26881:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26885:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:26886:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:26886:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:26887:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1" + + + // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_1_2" + // InternalScope.g:26896:1: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 : ( ( ruleIdOrSuper ) ) ; + public final void rule__XMemberFeatureCall__FeatureAssignment_1_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26900:1: ( ( ( ruleIdOrSuper ) ) ) + // InternalScope.g:26901:2: ( ( ruleIdOrSuper ) ) + { + // InternalScope.g:26901:2: ( ( ruleIdOrSuper ) ) + // InternalScope.g:26902:3: ( ruleIdOrSuper ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + // InternalScope.g:26903:3: ( ruleIdOrSuper ) + // InternalScope.g:26904:4: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_1_2" + + + // $ANTLR start "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0" + // InternalScope.g:26915:1: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 : ( ( '(' ) ) ; + public final void rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26919:1: ( ( ( '(' ) ) ) + // InternalScope.g:26920:2: ( ( '(' ) ) + { + // InternalScope.g:26920:2: ( ( '(' ) ) + // InternalScope.g:26921:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + // InternalScope.g:26922:3: ( '(' ) + // InternalScope.g:26923:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0" + // InternalScope.g:26934:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 : ( ruleXShortClosure ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26938:1: ( ( ruleXShortClosure ) ) + // InternalScope.g:26939:2: ( ruleXShortClosure ) + { + // InternalScope.g:26939:2: ( ruleXShortClosure ) + // InternalScope.g:26940:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0" + // InternalScope.g:26949:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 : ( ruleXExpression ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26953:1: ( ( ruleXExpression ) ) + // InternalScope.g:26954:2: ( ruleXExpression ) + { + // InternalScope.g:26954:2: ( ruleXExpression ) + // InternalScope.g:26955:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1" + // InternalScope.g:26964:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26968:1: ( ( ruleXExpression ) ) + // InternalScope.g:26969:2: ( ruleXExpression ) + { + // InternalScope.g:26969:2: ( ruleXExpression ) + // InternalScope.g:26970:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1" + + + // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4" + // InternalScope.g:26979:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 : ( ruleXClosure ) ; + public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26983:1: ( ( ruleXClosure ) ) + // InternalScope.g:26984:2: ( ruleXClosure ) + { + // InternalScope.g:26984:2: ( ruleXClosure ) + // InternalScope.g:26985:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4" + + + // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_0" + // InternalScope.g:26994:1: rule__XSetLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ; + public final void rule__XSetLiteral__ElementsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:26998:1: ( ( ruleXExpression ) ) + // InternalScope.g:26999:2: ( ruleXExpression ) + { + // InternalScope.g:26999:2: ( ruleXExpression ) + // InternalScope.g:27000:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_0" + + + // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_1_1" + // InternalScope.g:27009:1: rule__XSetLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XSetLiteral__ElementsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27013:1: ( ( ruleXExpression ) ) + // InternalScope.g:27014:2: ( ruleXExpression ) + { + // InternalScope.g:27014:2: ( ruleXExpression ) + // InternalScope.g:27015:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_1_1" + + + // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_0" + // InternalScope.g:27024:1: rule__XListLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ; + public final void rule__XListLiteral__ElementsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27028:1: ( ( ruleXExpression ) ) + // InternalScope.g:27029:2: ( ruleXExpression ) + { + // InternalScope.g:27029:2: ( ruleXExpression ) + // InternalScope.g:27030:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_0" + + + // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_1_1" + // InternalScope.g:27039:1: rule__XListLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XListLiteral__ElementsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27043:1: ( ( ruleXExpression ) ) + // InternalScope.g:27044:2: ( ruleXExpression ) + { + // InternalScope.g:27044:2: ( ruleXExpression ) + // InternalScope.g:27045:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_1_1" + + + // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0" + // InternalScope.g:27054:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27058:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27059:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27059:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27060:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0" + + + // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1" + // InternalScope.g:27069:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27073:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27074:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27074:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27075:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1" + + + // $ANTLR start "rule__XClosure__ExplicitSyntaxAssignment_1_0_1" + // InternalScope.g:27084:1: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 : ( ( '|' ) ) ; + public final void rule__XClosure__ExplicitSyntaxAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27088:1: ( ( ( '|' ) ) ) + // InternalScope.g:27089:2: ( ( '|' ) ) + { + // InternalScope.g:27089:2: ( ( '|' ) ) + // InternalScope.g:27090:3: ( '|' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + // InternalScope.g:27091:3: ( '|' ) + // InternalScope.g:27092:4: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__ExplicitSyntaxAssignment_1_0_1" + + + // $ANTLR start "rule__XClosure__ExpressionAssignment_2" + // InternalScope.g:27103:1: rule__XClosure__ExpressionAssignment_2 : ( ruleXExpressionInClosure ) ; + public final void rule__XClosure__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27107:1: ( ( ruleXExpressionInClosure ) ) + // InternalScope.g:27108:2: ( ruleXExpressionInClosure ) + { + // InternalScope.g:27108:2: ( ruleXExpressionInClosure ) + // InternalScope.g:27109:3: ruleXExpressionInClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XClosure__ExpressionAssignment_2" + + + // $ANTLR start "rule__XExpressionInClosure__ExpressionsAssignment_1_0" + // InternalScope.g:27118:1: rule__XExpressionInClosure__ExpressionsAssignment_1_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XExpressionInClosure__ExpressionsAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27122:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:27123:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:27123:2: ( ruleXExpressionOrVarDeclaration ) + // InternalScope.g:27124:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XExpressionInClosure__ExpressionsAssignment_1_0" + + + // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0" + // InternalScope.g:27133:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27137:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27138:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27138:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27139:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0" + + + // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1" + // InternalScope.g:27148:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27152:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27153:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27153:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27154:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1" + + + // $ANTLR start "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2" + // InternalScope.g:27163:1: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 : ( ( '|' ) ) ; + public final void rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27167:1: ( ( ( '|' ) ) ) + // InternalScope.g:27168:2: ( ( '|' ) ) + { + // InternalScope.g:27168:2: ( ( '|' ) ) + // InternalScope.g:27169:3: ( '|' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + // InternalScope.g:27170:3: ( '|' ) + // InternalScope.g:27171:4: '|' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + match(input,92,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2" + + + // $ANTLR start "rule__XShortClosure__ExpressionAssignment_1" + // InternalScope.g:27182:1: rule__XShortClosure__ExpressionAssignment_1 : ( ruleXExpression ) ; + public final void rule__XShortClosure__ExpressionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27186:1: ( ( ruleXExpression ) ) + // InternalScope.g:27187:2: ( ruleXExpression ) + { + // InternalScope.g:27187:2: ( ruleXExpression ) + // InternalScope.g:27188:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XShortClosure__ExpressionAssignment_1" + + + // $ANTLR start "rule__XIfExpression__IfAssignment_3" + // InternalScope.g:27197:1: rule__XIfExpression__IfAssignment_3 : ( ruleXExpression ) ; + public final void rule__XIfExpression__IfAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27201:1: ( ( ruleXExpression ) ) + // InternalScope.g:27202:2: ( ruleXExpression ) + { + // InternalScope.g:27202:2: ( ruleXExpression ) + // InternalScope.g:27203:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__IfAssignment_3" + + + // $ANTLR start "rule__XIfExpression__ThenAssignment_5" + // InternalScope.g:27212:1: rule__XIfExpression__ThenAssignment_5 : ( ruleXExpression ) ; + public final void rule__XIfExpression__ThenAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27216:1: ( ( ruleXExpression ) ) + // InternalScope.g:27217:2: ( ruleXExpression ) + { + // InternalScope.g:27217:2: ( ruleXExpression ) + // InternalScope.g:27218:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__ThenAssignment_5" + + + // $ANTLR start "rule__XIfExpression__ElseAssignment_6_1" + // InternalScope.g:27227:1: rule__XIfExpression__ElseAssignment_6_1 : ( ruleXExpression ) ; + public final void rule__XIfExpression__ElseAssignment_6_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27231:1: ( ( ruleXExpression ) ) + // InternalScope.g:27232:2: ( ruleXExpression ) + { + // InternalScope.g:27232:2: ( ruleXExpression ) + // InternalScope.g:27233:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XIfExpression__ElseAssignment_6_1" + + + // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1" + // InternalScope.g:27242:1: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 : ( ruleJvmFormalParameter ) ; + public final void rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27246:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27247:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27247:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27248:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1" + + + // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_0_1" + // InternalScope.g:27257:1: rule__XSwitchExpression__SwitchAssignment_2_0_1 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__SwitchAssignment_2_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27261:1: ( ( ruleXExpression ) ) + // InternalScope.g:27262:2: ( ruleXExpression ) + { + // InternalScope.g:27262:2: ( ruleXExpression ) + // InternalScope.g:27263:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_0_1" + + + // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0" + // InternalScope.g:27272:1: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 : ( ruleJvmFormalParameter ) ; + public final void rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27276:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27277:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27277:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27278:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0" + + + // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_1_1" + // InternalScope.g:27287:1: rule__XSwitchExpression__SwitchAssignment_2_1_1 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__SwitchAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27291:1: ( ( ruleXExpression ) ) + // InternalScope.g:27292:2: ( ruleXExpression ) + { + // InternalScope.g:27292:2: ( ruleXExpression ) + // InternalScope.g:27293:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_1_1" + + + // $ANTLR start "rule__XSwitchExpression__CasesAssignment_4" + // InternalScope.g:27302:1: rule__XSwitchExpression__CasesAssignment_4 : ( ruleXCasePart ) ; + public final void rule__XSwitchExpression__CasesAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27306:1: ( ( ruleXCasePart ) ) + // InternalScope.g:27307:2: ( ruleXCasePart ) + { + // InternalScope.g:27307:2: ( ruleXCasePart ) + // InternalScope.g:27308:3: ruleXCasePart + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXCasePart(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__CasesAssignment_4" + + + // $ANTLR start "rule__XSwitchExpression__DefaultAssignment_5_2" + // InternalScope.g:27317:1: rule__XSwitchExpression__DefaultAssignment_5_2 : ( ruleXExpression ) ; + public final void rule__XSwitchExpression__DefaultAssignment_5_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27321:1: ( ( ruleXExpression ) ) + // InternalScope.g:27322:2: ( ruleXExpression ) + { + // InternalScope.g:27322:2: ( ruleXExpression ) + // InternalScope.g:27323:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSwitchExpression__DefaultAssignment_5_2" + + + // $ANTLR start "rule__XCasePart__TypeGuardAssignment_1" + // InternalScope.g:27332:1: rule__XCasePart__TypeGuardAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__XCasePart__TypeGuardAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27336:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:27337:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:27337:2: ( ruleJvmTypeReference ) + // InternalScope.g:27338:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__TypeGuardAssignment_1" + + + // $ANTLR start "rule__XCasePart__CaseAssignment_2_1" + // InternalScope.g:27347:1: rule__XCasePart__CaseAssignment_2_1 : ( ruleXExpression ) ; + public final void rule__XCasePart__CaseAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27351:1: ( ( ruleXExpression ) ) + // InternalScope.g:27352:2: ( ruleXExpression ) + { + // InternalScope.g:27352:2: ( ruleXExpression ) + // InternalScope.g:27353:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__CaseAssignment_2_1" + + + // $ANTLR start "rule__XCasePart__ThenAssignment_3_0_1" + // InternalScope.g:27362:1: rule__XCasePart__ThenAssignment_3_0_1 : ( ruleXExpression ) ; + public final void rule__XCasePart__ThenAssignment_3_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27366:1: ( ( ruleXExpression ) ) + // InternalScope.g:27367:2: ( ruleXExpression ) + { + // InternalScope.g:27367:2: ( ruleXExpression ) + // InternalScope.g:27368:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__ThenAssignment_3_0_1" + + + // $ANTLR start "rule__XCasePart__FallThroughAssignment_3_1" + // InternalScope.g:27377:1: rule__XCasePart__FallThroughAssignment_3_1 : ( ( ',' ) ) ; + public final void rule__XCasePart__FallThroughAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27381:1: ( ( ( ',' ) ) ) + // InternalScope.g:27382:2: ( ( ',' ) ) + { + // InternalScope.g:27382:2: ( ( ',' ) ) + // InternalScope.g:27383:3: ( ',' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + // InternalScope.g:27384:3: ( ',' ) + // InternalScope.g:27385:4: ',' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + match(input,86,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCasePart__FallThroughAssignment_3_1" + + + // $ANTLR start "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3" + // InternalScope.g:27396:1: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 : ( ruleJvmFormalParameter ) ; + public final void rule__XForLoopExpression__DeclaredParamAssignment_0_0_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27400:1: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:27401:2: ( ruleJvmFormalParameter ) + { + // InternalScope.g:27401:2: ( ruleJvmFormalParameter ) + // InternalScope.g:27402:3: ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + pushFollow(FOLLOW_2); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3" + + + // $ANTLR start "rule__XForLoopExpression__ForExpressionAssignment_1" + // InternalScope.g:27411:1: rule__XForLoopExpression__ForExpressionAssignment_1 : ( ruleXExpression ) ; + public final void rule__XForLoopExpression__ForExpressionAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27415:1: ( ( ruleXExpression ) ) + // InternalScope.g:27416:2: ( ruleXExpression ) + { + // InternalScope.g:27416:2: ( ruleXExpression ) + // InternalScope.g:27417:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__ForExpressionAssignment_1" + + + // $ANTLR start "rule__XForLoopExpression__EachExpressionAssignment_3" + // InternalScope.g:27426:1: rule__XForLoopExpression__EachExpressionAssignment_3 : ( ruleXExpression ) ; + public final void rule__XForLoopExpression__EachExpressionAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27430:1: ( ( ruleXExpression ) ) + // InternalScope.g:27431:2: ( ruleXExpression ) + { + // InternalScope.g:27431:2: ( ruleXExpression ) + // InternalScope.g:27432:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XForLoopExpression__EachExpressionAssignment_3" + + + // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0" + // InternalScope.g:27441:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27445:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:27446:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:27446:2: ( ruleXExpressionOrVarDeclaration ) + // InternalScope.g:27447:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0" + + + // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1" + // InternalScope.g:27456:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27460:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:27461:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:27461:2: ( ruleXExpressionOrVarDeclaration ) + // InternalScope.g:27462:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1" + + + // $ANTLR start "rule__XBasicForLoopExpression__ExpressionAssignment_5" + // InternalScope.g:27471:1: rule__XBasicForLoopExpression__ExpressionAssignment_5 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__ExpressionAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27475:1: ( ( ruleXExpression ) ) + // InternalScope.g:27476:2: ( ruleXExpression ) + { + // InternalScope.g:27476:2: ( ruleXExpression ) + // InternalScope.g:27477:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__ExpressionAssignment_5" + + + // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0" + // InternalScope.g:27486:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27490:1: ( ( ruleXExpression ) ) + // InternalScope.g:27491:2: ( ruleXExpression ) + { + // InternalScope.g:27491:2: ( ruleXExpression ) + // InternalScope.g:27492:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0" + + + // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1" + // InternalScope.g:27501:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27505:1: ( ( ruleXExpression ) ) + // InternalScope.g:27506:2: ( ruleXExpression ) + { + // InternalScope.g:27506:2: ( ruleXExpression ) + // InternalScope.g:27507:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1" + + + // $ANTLR start "rule__XBasicForLoopExpression__EachExpressionAssignment_9" + // InternalScope.g:27516:1: rule__XBasicForLoopExpression__EachExpressionAssignment_9 : ( ruleXExpression ) ; + public final void rule__XBasicForLoopExpression__EachExpressionAssignment_9() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27520:1: ( ( ruleXExpression ) ) + // InternalScope.g:27521:2: ( ruleXExpression ) + { + // InternalScope.g:27521:2: ( ruleXExpression ) + // InternalScope.g:27522:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBasicForLoopExpression__EachExpressionAssignment_9" + + + // $ANTLR start "rule__XWhileExpression__PredicateAssignment_3" + // InternalScope.g:27531:1: rule__XWhileExpression__PredicateAssignment_3 : ( ruleXExpression ) ; + public final void rule__XWhileExpression__PredicateAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27535:1: ( ( ruleXExpression ) ) + // InternalScope.g:27536:2: ( ruleXExpression ) + { + // InternalScope.g:27536:2: ( ruleXExpression ) + // InternalScope.g:27537:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__PredicateAssignment_3" + + + // $ANTLR start "rule__XWhileExpression__BodyAssignment_5" + // InternalScope.g:27546:1: rule__XWhileExpression__BodyAssignment_5 : ( ruleXExpression ) ; + public final void rule__XWhileExpression__BodyAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27550:1: ( ( ruleXExpression ) ) + // InternalScope.g:27551:2: ( ruleXExpression ) + { + // InternalScope.g:27551:2: ( ruleXExpression ) + // InternalScope.g:27552:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XWhileExpression__BodyAssignment_5" + + + // $ANTLR start "rule__XDoWhileExpression__BodyAssignment_2" + // InternalScope.g:27561:1: rule__XDoWhileExpression__BodyAssignment_2 : ( ruleXExpression ) ; + public final void rule__XDoWhileExpression__BodyAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27565:1: ( ( ruleXExpression ) ) + // InternalScope.g:27566:2: ( ruleXExpression ) + { + // InternalScope.g:27566:2: ( ruleXExpression ) + // InternalScope.g:27567:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__BodyAssignment_2" + + + // $ANTLR start "rule__XDoWhileExpression__PredicateAssignment_5" + // InternalScope.g:27576:1: rule__XDoWhileExpression__PredicateAssignment_5 : ( ruleXExpression ) ; + public final void rule__XDoWhileExpression__PredicateAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27580:1: ( ( ruleXExpression ) ) + // InternalScope.g:27581:2: ( ruleXExpression ) + { + // InternalScope.g:27581:2: ( ruleXExpression ) + // InternalScope.g:27582:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XDoWhileExpression__PredicateAssignment_5" + + + // $ANTLR start "rule__XBlockExpression__ExpressionsAssignment_2_0" + // InternalScope.g:27591:1: rule__XBlockExpression__ExpressionsAssignment_2_0 : ( ruleXExpressionOrVarDeclaration ) ; + public final void rule__XBlockExpression__ExpressionsAssignment_2_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27595:1: ( ( ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:27596:2: ( ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:27596:2: ( ruleXExpressionOrVarDeclaration ) + // InternalScope.g:27597:3: ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBlockExpression__ExpressionsAssignment_2_0" + + + // $ANTLR start "rule__XVariableDeclaration__WriteableAssignment_1_0" + // InternalScope.g:27606:1: rule__XVariableDeclaration__WriteableAssignment_1_0 : ( ( 'var' ) ) ; + public final void rule__XVariableDeclaration__WriteableAssignment_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27610:1: ( ( ( 'var' ) ) ) + // InternalScope.g:27611:2: ( ( 'var' ) ) + { + // InternalScope.g:27611:2: ( ( 'var' ) ) + // InternalScope.g:27612:3: ( 'var' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + // InternalScope.g:27613:3: ( 'var' ) + // InternalScope.g:27614:4: 'var' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + match(input,122,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__WriteableAssignment_1_0" + + + // $ANTLR start "rule__XVariableDeclaration__TypeAssignment_2_0_0_0" + // InternalScope.g:27625:1: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 : ( ruleJvmTypeReference ) ; + public final void rule__XVariableDeclaration__TypeAssignment_2_0_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27629:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:27630:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:27630:2: ( ruleJvmTypeReference ) + // InternalScope.g:27631:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__TypeAssignment_2_0_0_0" + + + // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_0_0_1" + // InternalScope.g:27640:1: rule__XVariableDeclaration__NameAssignment_2_0_0_1 : ( ruleValidID ) ; + public final void rule__XVariableDeclaration__NameAssignment_2_0_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27644:1: ( ( ruleValidID ) ) + // InternalScope.g:27645:2: ( ruleValidID ) + { + // InternalScope.g:27645:2: ( ruleValidID ) + // InternalScope.g:27646:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_0_0_1" + + + // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_1" + // InternalScope.g:27655:1: rule__XVariableDeclaration__NameAssignment_2_1 : ( ruleValidID ) ; + public final void rule__XVariableDeclaration__NameAssignment_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27659:1: ( ( ruleValidID ) ) + // InternalScope.g:27660:2: ( ruleValidID ) + { + // InternalScope.g:27660:2: ( ruleValidID ) + // InternalScope.g:27661:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_1" + + + // $ANTLR start "rule__XVariableDeclaration__RightAssignment_3_1" + // InternalScope.g:27670:1: rule__XVariableDeclaration__RightAssignment_3_1 : ( ruleXExpression ) ; + public final void rule__XVariableDeclaration__RightAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27674:1: ( ( ruleXExpression ) ) + // InternalScope.g:27675:2: ( ruleXExpression ) + { + // InternalScope.g:27675:2: ( ruleXExpression ) + // InternalScope.g:27676:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XVariableDeclaration__RightAssignment_3_1" + + + // $ANTLR start "rule__JvmFormalParameter__ParameterTypeAssignment_0" + // InternalScope.g:27685:1: rule__JvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ; + public final void rule__JvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27689:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:27690:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:27690:2: ( ruleJvmTypeReference ) + // InternalScope.g:27691:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__JvmFormalParameter__NameAssignment_1" + // InternalScope.g:27700:1: rule__JvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ; + public final void rule__JvmFormalParameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27704:1: ( ( ruleValidID ) ) + // InternalScope.g:27705:2: ( ruleValidID ) + { + // InternalScope.g:27705:2: ( ruleValidID ) + // InternalScope.g:27706:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmFormalParameter__NameAssignment_1" + + + // $ANTLR start "rule__FullJvmFormalParameter__ParameterTypeAssignment_0" + // InternalScope.g:27715:1: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ; + public final void rule__FullJvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27719:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:27720:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:27720:2: ( ruleJvmTypeReference ) + // InternalScope.g:27721:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__ParameterTypeAssignment_0" + + + // $ANTLR start "rule__FullJvmFormalParameter__NameAssignment_1" + // InternalScope.g:27730:1: rule__FullJvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ; + public final void rule__FullJvmFormalParameter__NameAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27734:1: ( ( ruleValidID ) ) + // InternalScope.g:27735:2: ( ruleValidID ) + { + // InternalScope.g:27735:2: ( ruleValidID ) + // InternalScope.g:27736:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__FullJvmFormalParameter__NameAssignment_1" + + + // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_1" + // InternalScope.g:27745:1: rule__XFeatureCall__TypeArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XFeatureCall__TypeArgumentsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27749:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:27750:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:27750:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:27751:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_1" + + + // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1" + // InternalScope.g:27760:1: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XFeatureCall__TypeArgumentsAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27764:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:27765:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:27765:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:27766:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1" + + + // $ANTLR start "rule__XFeatureCall__FeatureAssignment_2" + // InternalScope.g:27775:1: rule__XFeatureCall__FeatureAssignment_2 : ( ( ruleIdOrSuper ) ) ; + public final void rule__XFeatureCall__FeatureAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27779:1: ( ( ( ruleIdOrSuper ) ) ) + // InternalScope.g:27780:2: ( ( ruleIdOrSuper ) ) + { + // InternalScope.g:27780:2: ( ( ruleIdOrSuper ) ) + // InternalScope.g:27781:3: ( ruleIdOrSuper ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + // InternalScope.g:27782:3: ( ruleIdOrSuper ) + // InternalScope.g:27783:4: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureAssignment_2" + + + // $ANTLR start "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0" + // InternalScope.g:27794:1: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 : ( ( '(' ) ) ; + public final void rule__XFeatureCall__ExplicitOperationCallAssignment_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27798:1: ( ( ( '(' ) ) ) + // InternalScope.g:27799:2: ( ( '(' ) ) + { + // InternalScope.g:27799:2: ( ( '(' ) ) + // InternalScope.g:27800:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + // InternalScope.g:27801:3: ( '(' ) + // InternalScope.g:27802:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0" + // InternalScope.g:27813:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 : ( ruleXShortClosure ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27817:1: ( ( ruleXShortClosure ) ) + // InternalScope.g:27818:2: ( ruleXShortClosure ) + { + // InternalScope.g:27818:2: ( ruleXShortClosure ) + // InternalScope.g:27819:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0" + // InternalScope.g:27828:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 : ( ruleXExpression ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27832:1: ( ( ruleXExpression ) ) + // InternalScope.g:27833:2: ( ruleXExpression ) + { + // InternalScope.g:27833:2: ( ruleXExpression ) + // InternalScope.g:27834:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1" + // InternalScope.g:27843:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27847:1: ( ( ruleXExpression ) ) + // InternalScope.g:27848:2: ( ruleXExpression ) + { + // InternalScope.g:27848:2: ( ruleXExpression ) + // InternalScope.g:27849:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1" + + + // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_4" + // InternalScope.g:27858:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 : ( ruleXClosure ) ; + public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27862:1: ( ( ruleXClosure ) ) + // InternalScope.g:27863:2: ( ruleXClosure ) + { + // InternalScope.g:27863:2: ( ruleXClosure ) + // InternalScope.g:27864:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_4" + + + // $ANTLR start "rule__XConstructorCall__ConstructorAssignment_2" + // InternalScope.g:27873:1: rule__XConstructorCall__ConstructorAssignment_2 : ( ( ruleQualifiedName ) ) ; + public final void rule__XConstructorCall__ConstructorAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27877:1: ( ( ( ruleQualifiedName ) ) ) + // InternalScope.g:27878:2: ( ( ruleQualifiedName ) ) + { + // InternalScope.g:27878:2: ( ( ruleQualifiedName ) ) + // InternalScope.g:27879:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + // InternalScope.g:27880:3: ( ruleQualifiedName ) + // InternalScope.g:27881:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ConstructorAssignment_2" + + + // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_1" + // InternalScope.g:27892:1: rule__XConstructorCall__TypeArgumentsAssignment_3_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XConstructorCall__TypeArgumentsAssignment_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27896:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:27897:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:27897:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:27898:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_1" + + + // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1" + // InternalScope.g:27907:1: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__XConstructorCall__TypeArgumentsAssignment_3_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27911:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:27912:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:27912:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:27913:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1" + + + // $ANTLR start "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0" + // InternalScope.g:27922:1: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 : ( ( '(' ) ) ; + public final void rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27926:1: ( ( ( '(' ) ) ) + // InternalScope.g:27927:2: ( ( '(' ) ) + { + // InternalScope.g:27927:2: ( ( '(' ) ) + // InternalScope.g:27928:3: ( '(' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + // InternalScope.g:27929:3: ( '(' ) + // InternalScope.g:27930:4: '(' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + match(input,77,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_0" + // InternalScope.g:27941:1: rule__XConstructorCall__ArgumentsAssignment_4_1_0 : ( ruleXShortClosure ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27945:1: ( ( ruleXShortClosure ) ) + // InternalScope.g:27946:2: ( ruleXShortClosure ) + { + // InternalScope.g:27946:2: ( ruleXShortClosure ) + // InternalScope.g:27947:3: ruleXShortClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXShortClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0" + // InternalScope.g:27956:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 : ( ruleXExpression ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27960:1: ( ( ruleXExpression ) ) + // InternalScope.g:27961:2: ( ruleXExpression ) + { + // InternalScope.g:27961:2: ( ruleXExpression ) + // InternalScope.g:27962:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1" + // InternalScope.g:27971:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 : ( ruleXExpression ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27975:1: ( ( ruleXExpression ) ) + // InternalScope.g:27976:2: ( ruleXExpression ) + { + // InternalScope.g:27976:2: ( ruleXExpression ) + // InternalScope.g:27977:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1" + + + // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_5" + // InternalScope.g:27986:1: rule__XConstructorCall__ArgumentsAssignment_5 : ( ruleXClosure ) ; + public final void rule__XConstructorCall__ArgumentsAssignment_5() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:27990:1: ( ( ruleXClosure ) ) + // InternalScope.g:27991:2: ( ruleXClosure ) + { + // InternalScope.g:27991:2: ( ruleXClosure ) + // InternalScope.g:27992:3: ruleXClosure + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + pushFollow(FOLLOW_2); + ruleXClosure(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_5" + + + // $ANTLR start "rule__XBooleanLiteral__IsTrueAssignment_1_1" + // InternalScope.g:28001:1: rule__XBooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ; + public final void rule__XBooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28005:1: ( ( ( 'true' ) ) ) + // InternalScope.g:28006:2: ( ( 'true' ) ) + { + // InternalScope.g:28006:2: ( ( 'true' ) ) + // InternalScope.g:28007:3: ( 'true' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + // InternalScope.g:28008:3: ( 'true' ) + // InternalScope.g:28009:4: 'true' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + match(input,36,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XBooleanLiteral__IsTrueAssignment_1_1" + + + // $ANTLR start "rule__XNumberLiteral__ValueAssignment_1" + // InternalScope.g:28020:1: rule__XNumberLiteral__ValueAssignment_1 : ( ruleNumber ) ; + public final void rule__XNumberLiteral__ValueAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28024:1: ( ( ruleNumber ) ) + // InternalScope.g:28025:2: ( ruleNumber ) + { + // InternalScope.g:28025:2: ( ruleNumber ) + // InternalScope.g:28026:3: ruleNumber + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleNumber(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XNumberLiteral__ValueAssignment_1" + + + // $ANTLR start "rule__XStringLiteral__ValueAssignment_1" + // InternalScope.g:28035:1: rule__XStringLiteral__ValueAssignment_1 : ( RULE_STRING ) ; + public final void rule__XStringLiteral__ValueAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28039:1: ( ( RULE_STRING ) ) + // InternalScope.g:28040:2: ( RULE_STRING ) + { + // InternalScope.g:28040:2: ( RULE_STRING ) + // InternalScope.g:28041:3: RULE_STRING + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XStringLiteral__ValueAssignment_1" + + + // $ANTLR start "rule__XTypeLiteral__TypeAssignment_3" + // InternalScope.g:28050:1: rule__XTypeLiteral__TypeAssignment_3 : ( ( ruleQualifiedName ) ) ; + public final void rule__XTypeLiteral__TypeAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28054:1: ( ( ( ruleQualifiedName ) ) ) + // InternalScope.g:28055:2: ( ( ruleQualifiedName ) ) + { + // InternalScope.g:28055:2: ( ( ruleQualifiedName ) ) + // InternalScope.g:28056:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + // InternalScope.g:28057:3: ( ruleQualifiedName ) + // InternalScope.g:28058:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__TypeAssignment_3" + + + // $ANTLR start "rule__XTypeLiteral__ArrayDimensionsAssignment_4" + // InternalScope.g:28069:1: rule__XTypeLiteral__ArrayDimensionsAssignment_4 : ( ruleArrayBrackets ) ; + public final void rule__XTypeLiteral__ArrayDimensionsAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28073:1: ( ( ruleArrayBrackets ) ) + // InternalScope.g:28074:2: ( ruleArrayBrackets ) + { + // InternalScope.g:28074:2: ( ruleArrayBrackets ) + // InternalScope.g:28075:3: ruleArrayBrackets + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTypeLiteral__ArrayDimensionsAssignment_4" + + + // $ANTLR start "rule__XThrowExpression__ExpressionAssignment_2" + // InternalScope.g:28084:1: rule__XThrowExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XThrowExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28088:1: ( ( ruleXExpression ) ) + // InternalScope.g:28089:2: ( ruleXExpression ) + { + // InternalScope.g:28089:2: ( ruleXExpression ) + // InternalScope.g:28090:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XThrowExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XReturnExpression__ExpressionAssignment_2" + // InternalScope.g:28099:1: rule__XReturnExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XReturnExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28103:1: ( ( ruleXExpression ) ) + // InternalScope.g:28104:2: ( ruleXExpression ) + { + // InternalScope.g:28104:2: ( ruleXExpression ) + // InternalScope.g:28105:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XReturnExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__ExpressionAssignment_2" + // InternalScope.g:28114:1: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__ExpressionAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28118:1: ( ( ruleXExpression ) ) + // InternalScope.g:28119:2: ( ruleXExpression ) + { + // InternalScope.g:28119:2: ( ruleXExpression ) + // InternalScope.g:28120:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__ExpressionAssignment_2" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0" + // InternalScope.g:28129:1: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 : ( ruleXCatchClause ) ; + public final void rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28133:1: ( ( ruleXCatchClause ) ) + // InternalScope.g:28134:2: ( ruleXCatchClause ) + { + // InternalScope.g:28134:2: ( ruleXCatchClause ) + // InternalScope.g:28135:3: ruleXCatchClause + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleXCatchClause(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1" + // InternalScope.g:28144:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28148:1: ( ( ruleXExpression ) ) + // InternalScope.g:28149:2: ( ruleXExpression ) + { + // InternalScope.g:28149:2: ( ruleXExpression ) + // InternalScope.g:28150:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1" + + + // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1" + // InternalScope.g:28159:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 : ( ruleXExpression ) ; + public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28163:1: ( ( ruleXExpression ) ) + // InternalScope.g:28164:2: ( ruleXExpression ) + { + // InternalScope.g:28164:2: ( ruleXExpression ) + // InternalScope.g:28165:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1" + + + // $ANTLR start "rule__XSynchronizedExpression__ParamAssignment_1" + // InternalScope.g:28174:1: rule__XSynchronizedExpression__ParamAssignment_1 : ( ruleXExpression ) ; + public final void rule__XSynchronizedExpression__ParamAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28178:1: ( ( ruleXExpression ) ) + // InternalScope.g:28179:2: ( ruleXExpression ) + { + // InternalScope.g:28179:2: ( ruleXExpression ) + // InternalScope.g:28180:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__ParamAssignment_1" + + + // $ANTLR start "rule__XSynchronizedExpression__ExpressionAssignment_3" + // InternalScope.g:28189:1: rule__XSynchronizedExpression__ExpressionAssignment_3 : ( ruleXExpression ) ; + public final void rule__XSynchronizedExpression__ExpressionAssignment_3() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28193:1: ( ( ruleXExpression ) ) + // InternalScope.g:28194:2: ( ruleXExpression ) + { + // InternalScope.g:28194:2: ( ruleXExpression ) + // InternalScope.g:28195:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XSynchronizedExpression__ExpressionAssignment_3" + + + // $ANTLR start "rule__XCatchClause__DeclaredParamAssignment_2" + // InternalScope.g:28204:1: rule__XCatchClause__DeclaredParamAssignment_2 : ( ruleFullJvmFormalParameter ) ; + public final void rule__XCatchClause__DeclaredParamAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28208:1: ( ( ruleFullJvmFormalParameter ) ) + // InternalScope.g:28209:2: ( ruleFullJvmFormalParameter ) + { + // InternalScope.g:28209:2: ( ruleFullJvmFormalParameter ) + // InternalScope.g:28210:3: ruleFullJvmFormalParameter + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__DeclaredParamAssignment_2" + + + // $ANTLR start "rule__XCatchClause__ExpressionAssignment_4" + // InternalScope.g:28219:1: rule__XCatchClause__ExpressionAssignment_4 : ( ruleXExpression ) ; + public final void rule__XCatchClause__ExpressionAssignment_4() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28223:1: ( ( ruleXExpression ) ) + // InternalScope.g:28224:2: ( ruleXExpression ) + { + // InternalScope.g:28224:2: ( ruleXExpression ) + // InternalScope.g:28225:3: ruleXExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + pushFollow(FOLLOW_2); + ruleXExpression(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XCatchClause__ExpressionAssignment_4" + + + // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" + // InternalScope.g:28234:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28238:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28239:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28239:2: ( ruleJvmTypeReference ) + // InternalScope.g:28240:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0" + + + // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" + // InternalScope.g:28249:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28253:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28254:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28254:2: ( ruleJvmTypeReference ) + // InternalScope.g:28255:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1" + + + // $ANTLR start "rule__XFunctionTypeRef__ReturnTypeAssignment_2" + // InternalScope.g:28264:1: rule__XFunctionTypeRef__ReturnTypeAssignment_2 : ( ruleJvmTypeReference ) ; + public final void rule__XFunctionTypeRef__ReturnTypeAssignment_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28268:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28269:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28269:2: ( ruleJvmTypeReference ) + // InternalScope.g:28270:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XFunctionTypeRef__ReturnTypeAssignment_2" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_0" + // InternalScope.g:28279:1: rule__JvmParameterizedTypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ; + public final void rule__JvmParameterizedTypeReference__TypeAssignment_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28283:1: ( ( ( ruleQualifiedName ) ) ) + // InternalScope.g:28284:2: ( ( ruleQualifiedName ) ) + { + // InternalScope.g:28284:2: ( ( ruleQualifiedName ) ) + // InternalScope.g:28285:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + // InternalScope.g:28286:3: ( ruleQualifiedName ) + // InternalScope.g:28287:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_0" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" + // InternalScope.g:28298:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28302:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:28303:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:28303:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:28304:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" + // InternalScope.g:28313:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28317:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:28318:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:28318:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:28319:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" + // InternalScope.g:28328:1: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 : ( ( ruleValidID ) ) ; + public final void rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28332:1: ( ( ( ruleValidID ) ) ) + // InternalScope.g:28333:2: ( ( ruleValidID ) ) + { + // InternalScope.g:28333:2: ( ( ruleValidID ) ) + // InternalScope.g:28334:3: ( ruleValidID ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + // InternalScope.g:28335:3: ( ruleValidID ) + // InternalScope.g:28336:4: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" + // InternalScope.g:28347:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28351:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:28352:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:28352:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:28353:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1" + + + // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" + // InternalScope.g:28362:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 : ( ruleJvmArgumentTypeReference ) ; + public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28366:1: ( ( ruleJvmArgumentTypeReference ) ) + // InternalScope.g:28367:2: ( ruleJvmArgumentTypeReference ) + { + // InternalScope.g:28367:2: ( ruleJvmArgumentTypeReference ) + // InternalScope.g:28368:3: ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" + // InternalScope.g:28377:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 : ( ruleJvmUpperBound ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28381:1: ( ( ruleJvmUpperBound ) ) + // InternalScope.g:28382:2: ( ruleJvmUpperBound ) + { + // InternalScope.g:28382:2: ( ruleJvmUpperBound ) + // InternalScope.g:28383:3: ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" + // InternalScope.g:28392:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 : ( ruleJvmUpperBoundAnded ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28396:1: ( ( ruleJvmUpperBoundAnded ) ) + // InternalScope.g:28397:2: ( ruleJvmUpperBoundAnded ) + { + // InternalScope.g:28397:2: ( ruleJvmUpperBoundAnded ) + // InternalScope.g:28398:3: ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" + // InternalScope.g:28407:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 : ( ruleJvmLowerBound ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28411:1: ( ( ruleJvmLowerBound ) ) + // InternalScope.g:28412:2: ( ruleJvmLowerBound ) + { + // InternalScope.g:28412:2: ( ruleJvmLowerBound ) + // InternalScope.g:28413:3: ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + pushFollow(FOLLOW_2); + ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0" + + + // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" + // InternalScope.g:28422:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 : ( ruleJvmLowerBoundAnded ) ; + public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28426:1: ( ( ruleJvmLowerBoundAnded ) ) + // InternalScope.g:28427:2: ( ruleJvmLowerBoundAnded ) + { + // InternalScope.g:28427:2: ( ruleJvmLowerBoundAnded ) + // InternalScope.g:28428:3: ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1" + + + // $ANTLR start "rule__JvmUpperBound__TypeReferenceAssignment_1" + // InternalScope.g:28437:1: rule__JvmUpperBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmUpperBound__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28441:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28442:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28442:2: ( ruleJvmTypeReference ) + // InternalScope.g:28443:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBound__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" + // InternalScope.g:28452:1: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmUpperBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28456:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28457:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28457:2: ( ruleJvmTypeReference ) + // InternalScope.g:28458:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmLowerBound__TypeReferenceAssignment_1" + // InternalScope.g:28467:1: rule__JvmLowerBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmLowerBound__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28471:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28472:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28472:2: ( ruleJvmTypeReference ) + // InternalScope.g:28473:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBound__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" + // InternalScope.g:28482:1: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ; + public final void rule__JvmLowerBoundAnded__TypeReferenceAssignment_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28486:1: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:28487:2: ( ruleJvmTypeReference ) + { + // InternalScope.g:28487:2: ( ruleJvmTypeReference ) + // InternalScope.g:28488:3: ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + pushFollow(FOLLOW_2); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1" + + + // $ANTLR start "rule__XImportDeclaration__StaticAssignment_1_0_0" + // InternalScope.g:28497:1: rule__XImportDeclaration__StaticAssignment_1_0_0 : ( ( 'static' ) ) ; + public final void rule__XImportDeclaration__StaticAssignment_1_0_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28501:1: ( ( ( 'static' ) ) ) + // InternalScope.g:28502:2: ( ( 'static' ) ) + { + // InternalScope.g:28502:2: ( ( 'static' ) ) + // InternalScope.g:28503:3: ( 'static' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + // InternalScope.g:28504:3: ( 'static' ) + // InternalScope.g:28505:4: 'static' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + match(input,61,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__StaticAssignment_1_0_0" + + + // $ANTLR start "rule__XImportDeclaration__ExtensionAssignment_1_0_1" + // InternalScope.g:28516:1: rule__XImportDeclaration__ExtensionAssignment_1_0_1 : ( ( 'extension' ) ) ; + public final void rule__XImportDeclaration__ExtensionAssignment_1_0_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28520:1: ( ( ( 'extension' ) ) ) + // InternalScope.g:28521:2: ( ( 'extension' ) ) + { + // InternalScope.g:28521:2: ( ( 'extension' ) ) + // InternalScope.g:28522:3: ( 'extension' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + // InternalScope.g:28523:3: ( 'extension' ) + // InternalScope.g:28524:4: 'extension' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + match(input,63,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ExtensionAssignment_1_0_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" + // InternalScope.g:28535:1: rule__XImportDeclaration__ImportedTypeAssignment_1_0_2 : ( ( ruleQualifiedNameInStaticImport ) ) ; + public final void rule__XImportDeclaration__ImportedTypeAssignment_1_0_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28539:1: ( ( ( ruleQualifiedNameInStaticImport ) ) ) + // InternalScope.g:28540:2: ( ( ruleQualifiedNameInStaticImport ) ) + { + // InternalScope.g:28540:2: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalScope.g:28541:3: ( ruleQualifiedNameInStaticImport ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + // InternalScope.g:28542:3: ( ruleQualifiedNameInStaticImport ) + // InternalScope.g:28543:4: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_1_0_2_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_0_2" + + + // $ANTLR start "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" + // InternalScope.g:28554:1: rule__XImportDeclaration__WildcardAssignment_1_0_3_0 : ( ( '*' ) ) ; + public final void rule__XImportDeclaration__WildcardAssignment_1_0_3_0() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28558:1: ( ( ( '*' ) ) ) + // InternalScope.g:28559:2: ( ( '*' ) ) + { + // InternalScope.g:28559:2: ( ( '*' ) ) + // InternalScope.g:28560:3: ( '*' ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + // InternalScope.g:28561:3: ( '*' ) + // InternalScope.g:28562:4: '*' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + match(input,25,FOLLOW_2); if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__WildcardAssignment_1_0_3_0" + + + // $ANTLR start "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" + // InternalScope.g:28573:1: rule__XImportDeclaration__MemberNameAssignment_1_0_3_1 : ( ruleValidID ) ; + public final void rule__XImportDeclaration__MemberNameAssignment_1_0_3_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28577:1: ( ( ruleValidID ) ) + // InternalScope.g:28578:2: ( ruleValidID ) + { + // InternalScope.g:28578:2: ( ruleValidID ) + // InternalScope.g:28579:3: ruleValidID + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__MemberNameAssignment_1_0_3_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_1_1" + // InternalScope.g:28588:1: rule__XImportDeclaration__ImportedTypeAssignment_1_1 : ( ( ruleQualifiedName ) ) ; + public final void rule__XImportDeclaration__ImportedTypeAssignment_1_1() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28592:1: ( ( ( ruleQualifiedName ) ) ) + // InternalScope.g:28593:2: ( ( ruleQualifiedName ) ) + { + // InternalScope.g:28593:2: ( ( ruleQualifiedName ) ) + // InternalScope.g:28594:3: ( ruleQualifiedName ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + // InternalScope.g:28595:3: ( ruleQualifiedName ) + // InternalScope.g:28596:4: ruleQualifiedName + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); + } + pushFollow(FOLLOW_2); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_1_1_0_1()); + } + + } + + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_1_1" + + + // $ANTLR start "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" + // InternalScope.g:28607:1: rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 : ( ruleQualifiedNameWithWildcard ) ; + public final void rule__XImportDeclaration__ImportedNamespaceAssignment_1_2() throws RecognitionException { + + int stackSize = keepStackSize(); + + try { + // InternalScope.g:28611:1: ( ( ruleQualifiedNameWithWildcard ) ) + // InternalScope.g:28612:2: ( ruleQualifiedNameWithWildcard ) + { + // InternalScope.g:28612:2: ( ruleQualifiedNameWithWildcard ) + // InternalScope.g:28613:3: ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + pushFollow(FOLLOW_2); + ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return ; + if ( state.backtracking==0 ) { + after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + + } + + + } + + } + catch (RecognitionException re) { + reportError(re); + recover(input,re); + } + finally { + + restoreStackSize(stackSize); + + } + return ; + } + // $ANTLR end "rule__XImportDeclaration__ImportedNamespaceAssignment_1_2" + + // $ANTLR start synpred12_InternalScope + public final void synpred12_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:3619:2: ( ( ( rule__Naming__Group_0__0 ) ) ) + // InternalScope.g:3619:2: ( ( rule__Naming__Group_0__0 ) ) + { + // InternalScope.g:3619:2: ( ( rule__Naming__Group_0__0 ) ) + // InternalScope.g:3620:3: ( rule__Naming__Group_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getNamingAccess().getGroup_0()); + } + // InternalScope.g:3621:3: ( rule__Naming__Group_0__0 ) + // InternalScope.g:3621:4: rule__Naming__Group_0__0 + { + pushFollow(FOLLOW_2); + rule__Naming__Group_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred12_InternalScope + + // $ANTLR start synpred15_InternalScope + public final void synpred15_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:3667:2: ( ( ( ruleCastedExpression ) ) ) + // InternalScope.g:3667:2: ( ( ruleCastedExpression ) ) + { + // InternalScope.g:3667:2: ( ( ruleCastedExpression ) ) + // InternalScope.g:3668:3: ( ruleCastedExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); + } + // InternalScope.g:3669:3: ( ruleCastedExpression ) + // InternalScope.g:3669:4: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred15_InternalScope + + // $ANTLR start synpred83_InternalScope + public final void synpred83_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4420:2: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) ) + // InternalScope.g:4420:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + { + // InternalScope.g:4420:2: ( ( rule__OpOther__Group_6_1_0__0 ) ) + // InternalScope.g:4421:3: ( rule__OpOther__Group_6_1_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); + } + // InternalScope.g:4422:3: ( rule__OpOther__Group_6_1_0__0 ) + // InternalScope.g:4422:4: rule__OpOther__Group_6_1_0__0 + { + pushFollow(FOLLOW_2); + rule__OpOther__Group_6_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred83_InternalScope + + // $ANTLR start synpred84_InternalScope + public final void synpred84_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4426:2: ( ( '<' ) ) + // InternalScope.g:4426:2: ( '<' ) + { + // InternalScope.g:4426:2: ( '<' ) + // InternalScope.g:4427:3: '<' + { + if ( state.backtracking==0 ) { + before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + match(input,22,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred84_InternalScope + + // $ANTLR start synpred97_InternalScope + public final void synpred97_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4639:2: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) ) + // InternalScope.g:4639:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + { + // InternalScope.g:4639:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) + // InternalScope.g:4640:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); + } + // InternalScope.g:4641:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) + // InternalScope.g:4641:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred97_InternalScope + + // $ANTLR start synpred105_InternalScope + public final void synpred105_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4702:2: ( ( ( ruleXForLoopExpression ) ) ) + // InternalScope.g:4702:2: ( ( ruleXForLoopExpression ) ) + { + // InternalScope.g:4702:2: ( ( ruleXForLoopExpression ) ) + // InternalScope.g:4703:3: ( ruleXForLoopExpression ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + // InternalScope.g:4704:3: ( ruleXForLoopExpression ) + // InternalScope.g:4704:4: ruleXForLoopExpression + { + pushFollow(FOLLOW_2); + ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred105_InternalScope + + // $ANTLR start synpred106_InternalScope + public final void synpred106_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4708:2: ( ( ruleXBasicForLoopExpression ) ) + // InternalScope.g:4708:2: ( ruleXBasicForLoopExpression ) + { + // InternalScope.g:4708:2: ( ruleXBasicForLoopExpression ) + // InternalScope.g:4709:3: ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + pushFollow(FOLLOW_2); + ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred106_InternalScope + + // $ANTLR start synpred119_InternalScope + public final void synpred119_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4831:2: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) ) + // InternalScope.g:4831:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + { + // InternalScope.g:4831:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) ) + // InternalScope.g:4832:3: ( rule__XSwitchExpression__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); + } + // InternalScope.g:4833:3: ( rule__XSwitchExpression__Group_2_0__0 ) + // InternalScope.g:4833:4: rule__XSwitchExpression__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred119_InternalScope + + // $ANTLR start synpred123_InternalScope + public final void synpred123_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4915:2: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) ) + // InternalScope.g:4915:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + { + // InternalScope.g:4915:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) + // InternalScope.g:4916:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); + } + // InternalScope.g:4917:3: ( rule__XVariableDeclaration__Group_2_0__0 ) + // InternalScope.g:4917:4: rule__XVariableDeclaration__Group_2_0__0 + { + pushFollow(FOLLOW_2); + rule__XVariableDeclaration__Group_2_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred123_InternalScope + + // $ANTLR start synpred124_InternalScope + public final void synpred124_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4936:2: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) ) + // InternalScope.g:4936:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + { + // InternalScope.g:4936:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) + // InternalScope.g:4937:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); + } + // InternalScope.g:4938:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) + // InternalScope.g:4938:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred124_InternalScope + + // $ANTLR start synpred130_InternalScope + public final void synpred130_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5017:2: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) ) + // InternalScope.g:5017:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + { + // InternalScope.g:5017:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) + // InternalScope.g:5018:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + { + if ( state.backtracking==0 ) { + before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); + } + // InternalScope.g:5019:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) + // InternalScope.g:5019:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_4_1_0(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + } + // $ANTLR end synpred130_InternalScope + + // $ANTLR start synpred171_InternalScope + public final void synpred171_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9615:3: ( rule__IfExpressionKw__Group_4__0 ) + // InternalScope.g:9615:3: rule__IfExpressionKw__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__IfExpressionKw__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred171_InternalScope + + // $ANTLR start synpred190_InternalScope + public final void synpred190_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:13071:3: ( rule__XAssignment__Group_1_1__0 ) + // InternalScope.g:13071:3: rule__XAssignment__Group_1_1__0 + { + pushFollow(FOLLOW_2); + rule__XAssignment__Group_1_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred190_InternalScope + + // $ANTLR start synpred192_InternalScope + public final void synpred192_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:13422:3: ( rule__XOrExpression__Group_1__0 ) + // InternalScope.g:13422:3: rule__XOrExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XOrExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred192_InternalScope + + // $ANTLR start synpred193_InternalScope + public final void synpred193_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:13611:3: ( rule__XAndExpression__Group_1__0 ) + // InternalScope.g:13611:3: rule__XAndExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAndExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred193_InternalScope + + // $ANTLR start synpred194_InternalScope + public final void synpred194_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:13800:3: ( rule__XEqualityExpression__Group_1__0 ) + // InternalScope.g:13800:3: rule__XEqualityExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XEqualityExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred194_InternalScope + + // $ANTLR start synpred195_InternalScope + public final void synpred195_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:13989:3: ( rule__XRelationalExpression__Alternatives_1 ) + // InternalScope.g:13989:3: rule__XRelationalExpression__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XRelationalExpression__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred195_InternalScope + + // $ANTLR start synpred196_InternalScope + public final void synpred196_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:14367:3: ( rule__XOtherOperatorExpression__Group_1__0 ) + // InternalScope.g:14367:3: rule__XOtherOperatorExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XOtherOperatorExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred196_InternalScope + + // $ANTLR start synpred197_InternalScope + public final void synpred197_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:14880:3: ( rule__XAdditiveExpression__Group_1__0 ) + // InternalScope.g:14880:3: rule__XAdditiveExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XAdditiveExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred197_InternalScope + + // $ANTLR start synpred198_InternalScope + public final void synpred198_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:15069:3: ( rule__XMultiplicativeExpression__Group_1__0 ) + // InternalScope.g:15069:3: rule__XMultiplicativeExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XMultiplicativeExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred198_InternalScope + + // $ANTLR start synpred199_InternalScope + public final void synpred199_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:15339:3: ( rule__XCastedExpression__Group_1__0 ) + // InternalScope.g:15339:3: rule__XCastedExpression__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XCastedExpression__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred199_InternalScope + + // $ANTLR start synpred200_InternalScope + public final void synpred200_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:15528:3: ( rule__XPostfixOperation__Group_1__0 ) + // InternalScope.g:15528:3: rule__XPostfixOperation__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XPostfixOperation__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred200_InternalScope + + // $ANTLR start synpred201_InternalScope + public final void synpred201_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:15663:3: ( rule__XMemberFeatureCall__Alternatives_1 ) + // InternalScope.g:15663:3: rule__XMemberFeatureCall__Alternatives_1 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Alternatives_1(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred201_InternalScope + + // $ANTLR start synpred203_InternalScope + public final void synpred203_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:15961:3: ( rule__XMemberFeatureCall__Group_1_1_3__0 ) + // InternalScope.g:15961:3: rule__XMemberFeatureCall__Group_1_1_3__0 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__Group_1_1_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred203_InternalScope + + // $ANTLR start synpred204_InternalScope + public final void synpred204_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:15987:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 ) + // InternalScope.g:15987:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 + { + pushFollow(FOLLOW_2); + rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred204_InternalScope + + // $ANTLR start synpred212_InternalScope + public final void synpred212_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:16960:3: ( rule__XClosure__Group_1__0 ) + // InternalScope.g:16960:3: rule__XClosure__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__XClosure__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred212_InternalScope + + // $ANTLR start synpred219_InternalScope + public final void synpred219_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:17931:3: ( rule__XIfExpression__Group_6__0 ) + // InternalScope.g:17931:3: rule__XIfExpression__Group_6__0 + { + pushFollow(FOLLOW_2); + rule__XIfExpression__Group_6__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred219_InternalScope + + // $ANTLR start synpred222_InternalScope + public final void synpred222_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:18391:3: ( rule__XSwitchExpression__Group_2_1_0__0 ) + // InternalScope.g:18391:3: rule__XSwitchExpression__Group_2_1_0__0 + { + pushFollow(FOLLOW_2); + rule__XSwitchExpression__Group_2_1_0__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred222_InternalScope + + // $ANTLR start synpred235_InternalScope + public final void synpred235_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:20524:3: ( rule__XFeatureCall__Group_3__0 ) + // InternalScope.g:20524:3: rule__XFeatureCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred235_InternalScope + + // $ANTLR start synpred236_InternalScope + public final void synpred236_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:20550:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 ) + // InternalScope.g:20550:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 + { + pushFollow(FOLLOW_2); + rule__XFeatureCall__FeatureCallArgumentsAssignment_4(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred236_InternalScope + + // $ANTLR start synpred240_InternalScope + public final void synpred240_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:21010:3: ( rule__XConstructorCall__Group_3__0 ) + // InternalScope.g:21010:3: rule__XConstructorCall__Group_3__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_3__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred240_InternalScope + + // $ANTLR start synpred241_InternalScope + public final void synpred241_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:21037:3: ( rule__XConstructorCall__Group_4__0 ) + // InternalScope.g:21037:3: rule__XConstructorCall__Group_4__0 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__Group_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred241_InternalScope + + // $ANTLR start synpred242_InternalScope + public final void synpred242_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:21063:3: ( rule__XConstructorCall__ArgumentsAssignment_5 ) + // InternalScope.g:21063:3: rule__XConstructorCall__ArgumentsAssignment_5 + { + pushFollow(FOLLOW_2); + rule__XConstructorCall__ArgumentsAssignment_5(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred242_InternalScope + + // $ANTLR start synpred247_InternalScope + public final void synpred247_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:21954:3: ( rule__XReturnExpression__ExpressionAssignment_2 ) + // InternalScope.g:21954:3: rule__XReturnExpression__ExpressionAssignment_2 + { + pushFollow(FOLLOW_2); + rule__XReturnExpression__ExpressionAssignment_2(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred247_InternalScope + + // $ANTLR start synpred248_InternalScope + public final void synpred248_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:22096:4: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) + // InternalScope.g:22096:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred248_InternalScope + + // $ANTLR start synpred249_InternalScope + public final void synpred249_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:22123:3: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 ) + // InternalScope.g:22123:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0 + { + pushFollow(FOLLOW_2); + rule__XTryCatchFinallyExpression__Group_3_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred249_InternalScope + + // $ANTLR start synpred250_InternalScope + public final void synpred250_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:22636:3: ( rule__QualifiedName__Group_1__0 ) + // InternalScope.g:22636:3: rule__QualifiedName__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__QualifiedName__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred250_InternalScope + + // $ANTLR start synpred252_InternalScope + public final void synpred252_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:22852:3: ( rule__JvmTypeReference__Group_0_1__0 ) + // InternalScope.g:22852:3: rule__JvmTypeReference__Group_0_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmTypeReference__Group_0_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred252_InternalScope + + // $ANTLR start synpred256_InternalScope + public final void synpred256_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:23311:3: ( rule__JvmParameterizedTypeReference__Group_1__0 ) + // InternalScope.g:23311:3: rule__JvmParameterizedTypeReference__Group_1__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred256_InternalScope + + // $ANTLR start synpred258_InternalScope + public final void synpred258_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:23446:3: ( rule__JvmParameterizedTypeReference__Group_1_4__0 ) + // InternalScope.g:23446:3: rule__JvmParameterizedTypeReference__Group_1_4__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred258_InternalScope + + // $ANTLR start synpred259_InternalScope + public final void synpred259_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:23581:3: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 ) + // InternalScope.g:23581:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0 + { + pushFollow(FOLLOW_2); + rule__JvmParameterizedTypeReference__Group_1_4_2__0(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred259_InternalScope + + // Delegated rules + + public final boolean synpred123_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred123_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred240_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred240_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred194_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred194_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred199_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred199_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred203_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred203_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred15_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred15_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred196_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred196_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred242_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred242_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred258_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred258_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred222_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred222_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred235_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred235_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred256_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred256_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred201_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred201_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred248_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred248_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred250_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred250_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred83_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred83_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred219_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred219_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred105_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred105_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred198_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred198_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred252_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred252_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred130_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred130_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred124_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred124_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred212_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred212_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred259_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred259_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred193_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred193_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred204_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred204_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred195_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred195_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred106_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred106_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred241_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred241_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred236_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred236_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred12_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred12_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred249_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred249_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred197_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred197_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred200_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred200_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred97_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred97_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred247_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred247_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred84_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred84_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred171_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred171_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred119_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred119_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred192_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred192_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred190_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred190_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA2 dfa2 = new DFA2(this); + protected DFA10 dfa10 = new DFA10(this); + protected DFA12 dfa12 = new DFA12(this); + protected DFA33 dfa33 = new DFA33(this); + protected DFA41 dfa41 = new DFA41(this); + protected DFA44 dfa44 = new DFA44(this); + protected DFA45 dfa45 = new DFA45(this); + protected DFA48 dfa48 = new DFA48(this); + protected DFA53 dfa53 = new DFA53(this); + protected DFA56 dfa56 = new DFA56(this); + protected DFA65 dfa65 = new DFA65(this); + protected DFA115 dfa115 = new DFA115(this); + protected DFA121 dfa121 = new DFA121(this); + protected DFA128 dfa128 = new DFA128(this); + protected DFA129 dfa129 = new DFA129(this); + protected DFA137 dfa137 = new DFA137(this); + protected DFA147 dfa147 = new DFA147(this); + protected DFA160 dfa160 = new DFA160(this); + protected DFA161 dfa161 = new DFA161(this); + protected DFA165 dfa165 = new DFA165(this); + protected DFA166 dfa166 = new DFA166(this); + protected DFA167 dfa167 = new DFA167(this); + protected DFA172 dfa172 = new DFA172(this); + protected DFA181 dfa181 = new DFA181(this); + protected DFA184 dfa184 = new DFA184(this); + static final String dfa_1s = "\6\uffff"; + static final String dfa_2s = "\1\4\1\110\1\4\2\uffff\1\110"; + static final String dfa_3s = "\1\4\1\135\1\4\2\uffff\1\135"; + static final String dfa_4s = "\3\uffff\1\2\1\1\1\uffff"; + static final String dfa_5s = "\6\uffff}>"; + static final String[] dfa_6s = { + "\1\1", + "\1\4\6\uffff\1\3\15\uffff\1\2", + "\1\5", + "", + "", + "\1\4\6\uffff\1\3\15\uffff\1\2" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA2 extends DFA { + + public DFA2(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 2; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "3434:1: rule__ScopeDefinition__Alternatives_2 : ( ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) | ( ( rule__ScopeDefinition__Group_2_1__0 ) ) );"; + } + } + static final String dfa_7s = "\40\uffff"; + static final String dfa_8s = "\1\4\1\0\36\uffff"; + static final String dfa_9s = "\1\170\1\0\36\uffff"; + static final String dfa_10s = "\2\uffff\1\2\34\uffff\1\1"; + static final String dfa_11s = "\1\uffff\1\0\36\uffff}>"; + static final String[] dfa_12s = { + "\1\2\1\uffff\1\2\1\uffff\2\2\16\uffff\1\2\2\uffff\16\2\37\uffff\1\2\4\uffff\1\1\6\uffff\1\2\11\uffff\1\2\2\uffff\1\2\2\uffff\1\2\1\uffff\2\2\4\uffff\1\2\11\uffff\1\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); + static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); + static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); + static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); + static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); + static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); + + class DFA10 extends DFA { + + public DFA10(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 10; + this.eot = dfa_7; + this.eof = dfa_7; + this.min = dfa_8; + this.max = dfa_9; + this.accept = dfa_10; + this.special = dfa_11; + this.transition = dfa_12; + } + public String getDescription() { + return "3614:1: rule__Naming__Alternatives : ( ( ( rule__Naming__Group_0__0 ) ) | ( ( rule__Naming__NamesAssignment_1 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA10_1 = input.LA(1); + + + int index10_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred12_InternalScope()) ) {s = 31;} + + else if ( (true) ) {s = 2;} + + + input.seek(index10_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 10, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_13s = "\36\uffff"; + static final String dfa_14s = "\1\4\1\uffff\1\0\33\uffff"; + static final String dfa_15s = "\1\170\1\uffff\1\0\33\uffff"; + static final String dfa_16s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; + static final String dfa_17s = "\2\uffff\1\0\33\uffff}>"; + static final String[] dfa_18s = { + "\1\3\1\uffff\1\3\1\uffff\2\3\16\uffff\1\3\2\uffff\16\3\37\uffff\1\3\4\uffff\1\2\20\uffff\1\1\2\uffff\1\3\2\uffff\1\3\1\uffff\2\3\4\uffff\1\3\13\uffff\1\3", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); + static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s); + static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); + static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s); + static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); + static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); + + class DFA12 extends DFA { + + public DFA12(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 12; + this.eot = dfa_13; + this.eof = dfa_13; + this.min = dfa_14; + this.max = dfa_15; + this.accept = dfa_16; + this.special = dfa_17; + this.transition = dfa_18; + } + public String getDescription() { + return "3656:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA12_2 = input.LA(1); + + + int index12_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred15_InternalScope()) ) {s = 29;} + + else if ( (true) ) {s = 3;} + + + input.seek(index12_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 12, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_19s = "\13\uffff"; + static final String dfa_20s = "\1\25\2\uffff\1\25\7\uffff"; + static final String dfa_21s = "\1\65\2\uffff\1\62\7\uffff"; + static final String dfa_22s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\6\1\3"; + static final String dfa_23s = "\13\uffff}>"; + static final String[] dfa_24s = { + "\1\3\1\6\31\uffff\1\1\1\2\1\4\1\5\1\7\1\10", + "", + "", + "\1\11\34\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); + static final char[] dfa_20 = DFA.unpackEncodedStringToUnsignedChars(dfa_20s); + static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); + static final short[] dfa_22 = DFA.unpackEncodedString(dfa_22s); + static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); + static final short[][] dfa_24 = unpackEncodedStringArray(dfa_24s); + + class DFA33 extends DFA { + + public DFA33(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 33; + this.eot = dfa_19; + this.eof = dfa_19; + this.min = dfa_20; + this.max = dfa_21; + this.accept = dfa_22; + this.special = dfa_23; + this.transition = dfa_24; + } + public String getDescription() { + return "4331:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );"; + } + } + static final String dfa_25s = "\12\uffff"; + static final String dfa_26s = "\4\uffff\5\3\1\uffff"; + static final String dfa_27s = "\1\72\2\4\1\uffff\5\4\1\uffff"; + static final String dfa_28s = "\1\171\2\100\1\uffff\5\172\1\uffff"; + static final String dfa_29s = "\3\uffff\1\2\5\uffff\1\1"; + static final String dfa_30s = "\12\uffff}>"; + static final String[] dfa_31s = { + "\1\1\42\uffff\1\2\33\uffff\1\3", + "\1\4\21\uffff\1\3\45\uffff\1\5\1\6\1\7\1\10\1\3", + "\1\4\21\uffff\1\3\45\uffff\1\5\1\6\1\7\1\10\1\3", + "", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\4\uffff\1\3\2\uffff\4\3\1\uffff\3\3\2\uffff\2\3\2\uffff\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\3\3\1\uffff\15\3\5\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\4\uffff\1\3\2\uffff\4\3\1\uffff\3\3\2\uffff\2\3\2\uffff\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\3\3\1\uffff\15\3\5\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\4\uffff\1\3\2\uffff\4\3\1\uffff\3\3\2\uffff\2\3\2\uffff\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\3\3\1\uffff\15\3\5\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\4\uffff\1\3\2\uffff\4\3\1\uffff\3\3\2\uffff\2\3\2\uffff\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\3\3\1\uffff\15\3\5\uffff\2\3", + "\5\3\5\uffff\1\11\5\3\1\uffff\7\3\10\uffff\2\3\3\uffff\30\3\4\uffff\1\3\2\uffff\4\3\1\uffff\3\3\2\uffff\2\3\2\uffff\1\3\6\uffff\1\3\1\uffff\1\3\1\uffff\1\3\1\uffff\3\3\1\uffff\15\3\5\uffff\2\3", + "" + }; + + static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s); + static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s); + static final char[] dfa_27 = DFA.unpackEncodedStringToUnsignedChars(dfa_27s); + static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s); + static final short[] dfa_29 = DFA.unpackEncodedString(dfa_29s); + static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s); + static final short[][] dfa_31 = unpackEncodedStringArray(dfa_31s); + + class DFA41 extends DFA { + + public DFA41(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 41; + this.eot = dfa_25; + this.eof = dfa_26; + this.min = dfa_27; + this.max = dfa_28; + this.accept = dfa_29; + this.special = dfa_30; + this.transition = dfa_31; + } + public String getDescription() { + return "4565:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );"; + } + } + static final String dfa_32s = "\43\uffff"; + static final String dfa_33s = "\1\4\2\0\40\uffff"; + static final String dfa_34s = "\1\162\2\0\40\uffff"; + static final String dfa_35s = "\3\uffff\1\1\1\uffff\1\2\35\uffff"; + static final String dfa_36s = "\1\uffff\1\0\1\1\40\uffff}>"; + static final String[] dfa_37s = { + "\1\1\4\5\15\uffff\3\5\2\uffff\1\5\10\uffff\2\5\15\uffff\1\3\10\uffff\5\5\7\uffff\1\5\4\uffff\1\2\1\uffff\1\5\2\uffff\1\5\11\uffff\1\3\4\uffff\1\5\2\uffff\1\5\2\uffff\1\5\1\uffff\10\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_32 = DFA.unpackEncodedString(dfa_32s); + static final char[] dfa_33 = DFA.unpackEncodedStringToUnsignedChars(dfa_33s); + static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s); + static final short[] dfa_35 = DFA.unpackEncodedString(dfa_35s); + static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s); + static final short[][] dfa_37 = unpackEncodedStringArray(dfa_37s); + + class DFA44 extends DFA { + + public DFA44(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 44; + this.eot = dfa_32; + this.eof = dfa_32; + this.min = dfa_33; + this.max = dfa_34; + this.accept = dfa_35; + this.special = dfa_36; + this.transition = dfa_37; + } + public String getDescription() { + return "4634:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA44_1 = input.LA(1); + + + int index44_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred97_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index44_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA44_2 = input.LA(1); + + + int index44_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred97_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index44_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 44, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_38s = "\1\4\26\uffff\1\0\10\uffff"; + static final String dfa_39s = "\1\162\26\uffff\1\0\10\uffff"; + static final String dfa_40s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11"; + static final String dfa_41s = "\27\uffff\1\0\10\uffff}>"; + static final String[] dfa_42s = { + "\1\5\4\14\15\uffff\1\5\15\uffff\2\14\26\uffff\5\5\7\uffff\1\2\4\uffff\1\35\1\uffff\1\14\2\uffff\1\14\16\uffff\1\26\2\uffff\1\3\2\uffff\1\1\1\uffff\1\27\1\30\1\31\2\14\1\32\1\33\1\34\1\uffff\1\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_38 = DFA.unpackEncodedStringToUnsignedChars(dfa_38s); + static final char[] dfa_39 = DFA.unpackEncodedStringToUnsignedChars(dfa_39s); + static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s); + static final short[] dfa_41 = DFA.unpackEncodedString(dfa_41s); + static final short[][] dfa_42 = unpackEncodedStringArray(dfa_42s); + + class DFA45 extends DFA { + + public DFA45(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 45; + this.eot = dfa_7; + this.eof = dfa_7; + this.min = dfa_38; + this.max = dfa_39; + this.accept = dfa_40; + this.special = dfa_41; + this.transition = dfa_42; + } + public String getDescription() { + return "4655:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA45_23 = input.LA(1); + + + int index45_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred105_InternalScope()) ) {s = 30;} + + else if ( (synpred106_InternalScope()) ) {s = 31;} + + + input.seek(index45_23); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 45, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_43s = "\1\4\1\0\41\uffff"; + static final String dfa_44s = "\1\162\1\0\41\uffff"; + static final String dfa_45s = "\2\uffff\1\2\37\uffff\1\1"; + static final String dfa_46s = "\1\uffff\1\0\41\uffff}>"; + static final String[] dfa_47s = { + "\5\2\15\uffff\3\2\2\uffff\1\2\10\uffff\2\2\15\uffff\1\2\10\uffff\5\2\7\uffff\1\2\4\uffff\1\1\1\uffff\1\2\2\uffff\1\2\16\uffff\1\2\2\uffff\1\2\2\uffff\1\2\1\uffff\10\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_43 = DFA.unpackEncodedStringToUnsignedChars(dfa_43s); + static final char[] dfa_44 = DFA.unpackEncodedStringToUnsignedChars(dfa_44s); + static final short[] dfa_45 = DFA.unpackEncodedString(dfa_45s); + static final short[] dfa_46 = DFA.unpackEncodedString(dfa_46s); + static final short[][] dfa_47 = unpackEncodedStringArray(dfa_47s); + + class DFA48 extends DFA { + + public DFA48(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 48; + this.eot = dfa_32; + this.eof = dfa_32; + this.min = dfa_43; + this.max = dfa_44; + this.accept = dfa_45; + this.special = dfa_46; + this.transition = dfa_47; + } + public String getDescription() { + return "4826:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA48_1 = input.LA(1); + + + int index48_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred119_InternalScope()) ) {s = 34;} + + else if ( (true) ) {s = 2;} + + + input.seek(index48_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 48, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA53 extends DFA { + + public DFA53(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 53; + this.eot = dfa_32; + this.eof = dfa_32; + this.min = dfa_33; + this.max = dfa_34; + this.accept = dfa_35; + this.special = dfa_36; + this.transition = dfa_37; + } + public String getDescription() { + return "4931:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA53_1 = input.LA(1); + + + int index53_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred124_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index53_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA53_2 = input.LA(1); + + + int index53_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred124_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index53_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 53, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA56 extends DFA { + + public DFA56(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 56; + this.eot = dfa_32; + this.eof = dfa_32; + this.min = dfa_33; + this.max = dfa_34; + this.accept = dfa_35; + this.special = dfa_36; + this.transition = dfa_37; + } + public String getDescription() { + return "5012:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA56_1 = input.LA(1); + + + int index56_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred130_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index56_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA56_2 = input.LA(1); + + + int index56_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred130_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index56_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 56, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_48s = "\7\uffff"; + static final String dfa_49s = "\2\uffff\1\4\3\uffff\1\4"; + static final String dfa_50s = "\1\4\1\uffff\1\72\1\4\2\uffff\1\72"; + static final String dfa_51s = "\1\75\1\uffff\1\113\1\31\2\uffff\1\113"; + static final String dfa_52s = "\1\uffff\1\1\2\uffff\1\2\1\3\1\uffff"; + static final String dfa_53s = "\7\uffff}>"; + static final String[] dfa_54s = { + "\1\2\70\uffff\1\1", + "", + "\1\3\20\uffff\1\4", + "\1\6\24\uffff\1\5", + "", + "", + "\1\3\20\uffff\1\4" + }; + + static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s); + static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s); + static final char[] dfa_50 = DFA.unpackEncodedStringToUnsignedChars(dfa_50s); + static final char[] dfa_51 = DFA.unpackEncodedStringToUnsignedChars(dfa_51s); + static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s); + static final short[] dfa_53 = DFA.unpackEncodedString(dfa_53s); + static final short[][] dfa_54 = unpackEncodedStringArray(dfa_54s); + + class DFA65 extends DFA { + + public DFA65(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 65; + this.eot = dfa_48; + this.eof = dfa_49; + this.min = dfa_50; + this.max = dfa_51; + this.accept = dfa_52; + this.special = dfa_53; + this.transition = dfa_54; + } + public String getDescription() { + return "5201:1: rule__XImportDeclaration__Alternatives_1 : ( ( ( rule__XImportDeclaration__Group_1_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_1_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_1_2 ) ) );"; + } + } + static final String dfa_55s = "\1\10\11\uffff"; + static final String dfa_56s = "\1\4\7\0\2\uffff"; + static final String dfa_57s = "\1\172\7\0\2\uffff"; + static final String dfa_58s = "\10\uffff\1\2\1\1"; + static final String dfa_59s = "\1\uffff\1\0\1\6\1\4\1\3\1\1\1\5\1\2\2\uffff}>"; + static final String[] dfa_60s = { + "\5\10\6\uffff\5\10\1\uffff\1\7\1\6\5\10\10\uffff\2\10\3\uffff\1\1\1\2\1\3\1\4\1\5\23\10\4\uffff\1\10\2\uffff\4\10\1\uffff\3\10\2\uffff\2\10\2\uffff\1\10\6\uffff\1\10\1\uffff\1\10\1\uffff\1\10\1\uffff\3\10\1\uffff\15\10\5\uffff\2\10", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + static final short[] dfa_55 = DFA.unpackEncodedString(dfa_55s); + static final char[] dfa_56 = DFA.unpackEncodedStringToUnsignedChars(dfa_56s); + static final char[] dfa_57 = DFA.unpackEncodedStringToUnsignedChars(dfa_57s); + static final short[] dfa_58 = DFA.unpackEncodedString(dfa_58s); + static final short[] dfa_59 = DFA.unpackEncodedString(dfa_59s); + static final short[][] dfa_60 = unpackEncodedStringArray(dfa_60s); + + class DFA115 extends DFA { + + public DFA115(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 115; + this.eot = dfa_25; + this.eof = dfa_55; + this.min = dfa_56; + this.max = dfa_57; + this.accept = dfa_58; + this.special = dfa_59; + this.transition = dfa_60; + } + public String getDescription() { + return "13071:2: ( rule__XAssignment__Group_1_1__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA115_1 = input.LA(1); + + + int index115_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA115_5 = input.LA(1); + + + int index115_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_5); + if ( s>=0 ) return s; + break; + case 2 : + int LA115_7 = input.LA(1); + + + int index115_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_7); + if ( s>=0 ) return s; + break; + case 3 : + int LA115_4 = input.LA(1); + + + int index115_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA115_3 = input.LA(1); + + + int index115_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_3); + if ( s>=0 ) return s; + break; + case 5 : + int LA115_6 = input.LA(1); + + + int index115_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA115_2 = input.LA(1); + + + int index115_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred190_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index115_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 115, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_61s = "\1\1\12\uffff"; + static final String dfa_62s = "\1\4\1\uffff\10\0\1\uffff"; + static final String dfa_63s = "\1\172\1\uffff\10\0\1\uffff"; + static final String dfa_64s = "\1\uffff\1\2\10\uffff\1\1"; + static final String dfa_65s = "\2\uffff\1\2\1\6\1\7\1\3\1\5\1\1\1\0\1\4\1\uffff}>"; + static final String[] dfa_66s = { + "\5\1\6\uffff\5\1\1\uffff\1\3\1\2\5\1\10\uffff\2\1\3\uffff\7\1\1\4\1\5\1\6\1\7\1\10\1\11\13\1\4\uffff\1\1\2\uffff\4\1\1\uffff\3\1\2\uffff\2\1\2\uffff\1\1\6\uffff\1\1\1\uffff\1\1\1\uffff\1\1\1\uffff\3\1\1\uffff\15\1\5\uffff\2\1", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "" + }; + static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); + static final char[] dfa_62 = DFA.unpackEncodedStringToUnsignedChars(dfa_62s); + static final char[] dfa_63 = DFA.unpackEncodedStringToUnsignedChars(dfa_63s); + static final short[] dfa_64 = DFA.unpackEncodedString(dfa_64s); + static final short[] dfa_65 = DFA.unpackEncodedString(dfa_65s); + static final short[][] dfa_66 = unpackEncodedStringArray(dfa_66s); + + class DFA121 extends DFA { + + public DFA121(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 121; + this.eot = dfa_19; + this.eof = dfa_61; + this.min = dfa_62; + this.max = dfa_63; + this.accept = dfa_64; + this.special = dfa_65; + this.transition = dfa_66; + } + public String getDescription() { + return "()* loopback of 14367:2: ( rule__XOtherOperatorExpression__Group_1__0 )*"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA121_8 = input.LA(1); + + + int index121_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_8); + if ( s>=0 ) return s; + break; + case 1 : + int LA121_7 = input.LA(1); + + + int index121_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_7); + if ( s>=0 ) return s; + break; + case 2 : + int LA121_2 = input.LA(1); + + + int index121_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_2); + if ( s>=0 ) return s; + break; + case 3 : + int LA121_5 = input.LA(1); + + + int index121_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_5); + if ( s>=0 ) return s; + break; + case 4 : + int LA121_9 = input.LA(1); + + + int index121_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_9); + if ( s>=0 ) return s; + break; + case 5 : + int LA121_6 = input.LA(1); + + + int index121_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA121_3 = input.LA(1); + + + int index121_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_3); + if ( s>=0 ) return s; + break; + case 7 : + int LA121_4 = input.LA(1); + + + int index121_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred196_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index121_4); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 121, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_67s = "\116\uffff"; + static final String dfa_68s = "\1\2\115\uffff"; + static final String dfa_69s = "\1\4\1\0\114\uffff"; + static final String dfa_70s = "\1\172\1\0\114\uffff"; + static final String dfa_71s = "\2\uffff\1\2\112\uffff\1\1"; + static final String dfa_72s = "\1\uffff\1\0\114\uffff}>"; + static final String[] dfa_73s = { + "\5\2\6\uffff\5\2\1\uffff\7\2\10\uffff\2\2\3\uffff\30\2\4\uffff\1\2\2\uffff\4\2\1\uffff\1\1\2\2\2\uffff\2\2\2\uffff\1\2\6\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\15\2\5\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_67 = DFA.unpackEncodedString(dfa_67s); + static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s); + static final char[] dfa_69 = DFA.unpackEncodedStringToUnsignedChars(dfa_69s); + static final char[] dfa_70 = DFA.unpackEncodedStringToUnsignedChars(dfa_70s); + static final short[] dfa_71 = DFA.unpackEncodedString(dfa_71s); + static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s); + static final short[][] dfa_73 = unpackEncodedStringArray(dfa_73s); + + class DFA128 extends DFA { + + public DFA128(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 128; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_73; + } + public String getDescription() { + return "15961:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA128_1 = input.LA(1); + + + int index128_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred203_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index128_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 128, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_74s = { + "\5\2\6\uffff\5\2\1\uffff\7\2\10\uffff\2\2\3\uffff\30\2\4\uffff\1\2\2\uffff\4\2\1\uffff\3\2\2\uffff\1\1\1\2\2\uffff\1\2\6\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\15\2\5\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_74 = unpackEncodedStringArray(dfa_74s); + + class DFA129 extends DFA { + + public DFA129(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 129; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_74; + } + public String getDescription() { + return "15987:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA129_1 = input.LA(1); + + + int index129_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred204_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index129_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 129, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_75s = "\46\uffff"; + static final String dfa_76s = "\1\4\2\0\43\uffff"; + static final String dfa_77s = "\1\172\2\0\43\uffff"; + static final String dfa_78s = "\3\uffff\1\1\1\uffff\1\2\40\uffff"; + static final String dfa_79s = "\1\uffff\1\0\1\1\43\uffff}>"; + static final String[] dfa_80s = { + "\1\1\4\5\15\uffff\3\5\2\uffff\1\5\10\uffff\2\5\15\uffff\1\3\7\uffff\6\5\7\uffff\1\5\4\uffff\1\2\1\uffff\1\5\2\uffff\2\5\10\uffff\1\3\4\uffff\1\5\2\uffff\1\5\2\uffff\1\5\1\uffff\10\5\1\uffff\1\5\7\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_75 = DFA.unpackEncodedString(dfa_75s); + static final char[] dfa_76 = DFA.unpackEncodedStringToUnsignedChars(dfa_76s); + static final char[] dfa_77 = DFA.unpackEncodedStringToUnsignedChars(dfa_77s); + static final short[] dfa_78 = DFA.unpackEncodedString(dfa_78s); + static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s); + static final short[][] dfa_80 = unpackEncodedStringArray(dfa_80s); + + class DFA137 extends DFA { + + public DFA137(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 137; + this.eot = dfa_75; + this.eof = dfa_75; + this.min = dfa_76; + this.max = dfa_77; + this.accept = dfa_78; + this.special = dfa_79; + this.transition = dfa_80; + } + public String getDescription() { + return "16960:2: ( rule__XClosure__Group_1__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA137_1 = input.LA(1); + + + int index137_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred212_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index137_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA137_2 = input.LA(1); + + + int index137_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred212_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 5;} + + + input.seek(index137_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 137, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_81s = "\42\uffff"; + static final String dfa_82s = "\1\4\2\0\37\uffff"; + static final String dfa_83s = "\1\162\2\0\37\uffff"; + static final String dfa_84s = "\3\uffff\1\1\1\2\35\uffff"; + static final String dfa_85s = "\1\uffff\1\0\1\1\37\uffff}>"; + static final String[] dfa_86s = { + "\1\1\4\4\15\uffff\3\4\2\uffff\1\4\10\uffff\2\4\15\uffff\1\3\10\uffff\5\4\7\uffff\1\4\4\uffff\1\2\1\uffff\1\4\2\uffff\1\4\16\uffff\1\4\2\uffff\1\4\2\uffff\1\4\1\uffff\10\4\1\uffff\1\4", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_81 = DFA.unpackEncodedString(dfa_81s); + static final char[] dfa_82 = DFA.unpackEncodedStringToUnsignedChars(dfa_82s); + static final char[] dfa_83 = DFA.unpackEncodedStringToUnsignedChars(dfa_83s); + static final short[] dfa_84 = DFA.unpackEncodedString(dfa_84s); + static final short[] dfa_85 = DFA.unpackEncodedString(dfa_85s); + static final short[][] dfa_86 = unpackEncodedStringArray(dfa_86s); + + class DFA147 extends DFA { + + public DFA147(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 147; + this.eot = dfa_81; + this.eof = dfa_81; + this.min = dfa_82; + this.max = dfa_83; + this.accept = dfa_84; + this.special = dfa_85; + this.transition = dfa_86; + } + public String getDescription() { + return "18391:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA147_1 = input.LA(1); + + + int index147_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred222_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index147_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA147_2 = input.LA(1); + + + int index147_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred222_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index147_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 147, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA160 extends DFA { + + public DFA160(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 160; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_73; + } + public String getDescription() { + return "20524:2: ( rule__XFeatureCall__Group_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA160_1 = input.LA(1); + + + int index160_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred235_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index160_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 160, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA161 extends DFA { + + public DFA161(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 161; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_74; + } + public String getDescription() { + return "20550:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA161_1 = input.LA(1); + + + int index161_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred236_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index161_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 161, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_87s = { + "\5\2\6\uffff\5\2\1\uffff\1\2\1\1\5\2\10\uffff\2\2\3\uffff\30\2\4\uffff\1\2\2\uffff\4\2\1\uffff\3\2\2\uffff\2\2\2\uffff\1\2\6\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\15\2\5\uffff\2\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_87 = unpackEncodedStringArray(dfa_87s); + + class DFA165 extends DFA { + + public DFA165(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 165; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_87; + } + public String getDescription() { + return "21010:2: ( rule__XConstructorCall__Group_3__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA165_1 = input.LA(1); + + + int index165_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred240_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index165_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 165, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA166 extends DFA { + + public DFA166(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 166; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_73; + } + public String getDescription() { + return "21037:2: ( rule__XConstructorCall__Group_4__0 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA166_1 = input.LA(1); + + + int index166_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred241_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index166_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 166, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA167 extends DFA { + + public DFA167(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 167; + this.eot = dfa_67; + this.eof = dfa_68; + this.min = dfa_69; + this.max = dfa_70; + this.accept = dfa_71; + this.special = dfa_72; + this.transition = dfa_74; + } + public String getDescription() { + return "21063:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA167_1 = input.LA(1); + + + int index167_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred242_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index167_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 167, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_88s = "\1\41\115\uffff"; + static final String dfa_89s = "\1\4\40\0\55\uffff"; + static final String dfa_90s = "\1\172\40\0\55\uffff"; + static final String dfa_91s = "\41\uffff\1\2\53\uffff\1\1"; + static final String dfa_92s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>"; + static final String[] dfa_93s = { + "\1\1\1\23\1\24\1\25\1\27\6\uffff\5\41\1\uffff\1\41\1\15\1\10\1\7\2\41\1\6\10\uffff\1\22\1\21\3\uffff\23\41\1\2\1\3\1\4\1\5\1\16\4\uffff\1\41\2\uffff\1\12\3\41\1\uffff\1\40\1\41\1\17\2\uffff\1\20\1\41\2\uffff\1\41\6\uffff\1\41\1\uffff\1\41\1\uffff\1\31\1\uffff\1\41\1\13\1\41\1\uffff\1\11\1\41\1\32\1\33\1\34\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41\5\uffff\2\41", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[] dfa_88 = DFA.unpackEncodedString(dfa_88s); + static final char[] dfa_89 = DFA.unpackEncodedStringToUnsignedChars(dfa_89s); + static final char[] dfa_90 = DFA.unpackEncodedStringToUnsignedChars(dfa_90s); + static final short[] dfa_91 = DFA.unpackEncodedString(dfa_91s); + static final short[] dfa_92 = DFA.unpackEncodedString(dfa_92s); + static final short[][] dfa_93 = unpackEncodedStringArray(dfa_93s); + + class DFA172 extends DFA { + + public DFA172(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 172; + this.eot = dfa_67; + this.eof = dfa_88; + this.min = dfa_89; + this.max = dfa_90; + this.accept = dfa_91; + this.special = dfa_92; + this.transition = dfa_93; + } + public String getDescription() { + return "21954:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA172_1 = input.LA(1); + + + int index172_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA172_2 = input.LA(1); + + + int index172_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA172_3 = input.LA(1); + + + int index172_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA172_4 = input.LA(1); + + + int index172_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA172_5 = input.LA(1); + + + int index172_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA172_6 = input.LA(1); + + + int index172_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA172_7 = input.LA(1); + + + int index172_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA172_8 = input.LA(1); + + + int index172_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index172_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA172_9 = input.LA(1); - } + + int index172_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index172_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA172_10 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CollectionExpression__ExpAssignment_3" + + int index172_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + else if ( (true) ) {s = 33;} - // $ANTLR start "rule__CollectionType__ClAssignment_0" - // InternalScope.g:11715:1: rule__CollectionType__ClAssignment_0 : ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ; - public final void rule__CollectionType__ClAssignment_0() throws RecognitionException { + + input.seek(index172_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA172_11 = input.LA(1); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:11719:1: ( ( ( rule__CollectionType__ClAlternatives_0_0 ) ) ) - // InternalScope.g:11720:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) - { - // InternalScope.g:11720:2: ( ( rule__CollectionType__ClAlternatives_0_0 ) ) - // InternalScope.g:11721:3: ( rule__CollectionType__ClAlternatives_0_0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); - } - // InternalScope.g:11722:3: ( rule__CollectionType__ClAlternatives_0_0 ) - // InternalScope.g:11722:4: rule__CollectionType__ClAlternatives_0_0 - { - pushFollow(FOLLOW_2); - rule__CollectionType__ClAlternatives_0_0(); + + int index172_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; + else if ( (true) ) {s = 33;} - } + + input.seek(index172_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA172_12 = input.LA(1); - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getClAlternatives_0_0()); - } + + int index172_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index172_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA172_13 = input.LA(1); - } + + int index172_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index172_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA172_14 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__CollectionType__ClAssignment_0" + + int index172_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + else if ( (true) ) {s = 33;} - // $ANTLR start "rule__CollectionType__Id1Assignment_2" - // InternalScope.g:11730:1: rule__CollectionType__Id1Assignment_2 : ( ruleSimpleType ) ; - public final void rule__CollectionType__Id1Assignment_2() throws RecognitionException { + + input.seek(index172_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA172_15 = input.LA(1); - int stackSize = keepStackSize(); - - try { - // InternalScope.g:11734:1: ( ( ruleSimpleType ) ) - // InternalScope.g:11735:2: ( ruleSimpleType ) - { - // InternalScope.g:11735:2: ( ruleSimpleType ) - // InternalScope.g:11736:3: ruleSimpleType - { - if ( state.backtracking==0 ) { - before(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); - } - pushFollow(FOLLOW_2); - ruleSimpleType(); + + int index172_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getCollectionTypeAccess().getId1SimpleTypeParserRuleCall_2_0()); - } + else if ( (true) ) {s = 33;} - } + + input.seek(index172_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA172_16 = input.LA(1); + + int index172_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + input.seek(index172_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA172_17 = input.LA(1); - restoreStackSize(stackSize); + + int index172_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } - return ; - } - // $ANTLR end "rule__CollectionType__Id1Assignment_2" + else if ( (true) ) {s = 33;} + + input.seek(index172_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA172_18 = input.LA(1); - // $ANTLR start "rule__SimpleType__IdAssignment_0" - // InternalScope.g:11745:1: rule__SimpleType__IdAssignment_0 : ( ruleIdentifier ) ; - public final void rule__SimpleType__IdAssignment_0() throws RecognitionException { + + int index172_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - int stackSize = keepStackSize(); - - try { - // InternalScope.g:11749:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11750:2: ( ruleIdentifier ) - { - // InternalScope.g:11750:2: ( ruleIdentifier ) - // InternalScope.g:11751:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_0_0()); - } + + input.seek(index172_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA172_19 = input.LA(1); - } + + int index172_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index172_19); + if ( s>=0 ) return s; + break; + case 19 : + int LA172_20 = input.LA(1); - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + + int index172_20 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - restoreStackSize(stackSize); + else if ( (true) ) {s = 33;} - } - return ; - } - // $ANTLR end "rule__SimpleType__IdAssignment_0" + + input.seek(index172_20); + if ( s>=0 ) return s; + break; + case 20 : + int LA172_21 = input.LA(1); + + int index172_21 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - // $ANTLR start "rule__SimpleType__IdAssignment_1_1" - // InternalScope.g:11760:1: rule__SimpleType__IdAssignment_1_1 : ( ruleIdentifier ) ; - public final void rule__SimpleType__IdAssignment_1_1() throws RecognitionException { + else if ( (true) ) {s = 33;} - int stackSize = keepStackSize(); - - try { - // InternalScope.g:11764:1: ( ( ruleIdentifier ) ) - // InternalScope.g:11765:2: ( ruleIdentifier ) - { - // InternalScope.g:11765:2: ( ruleIdentifier ) - // InternalScope.g:11766:3: ruleIdentifier - { - if ( state.backtracking==0 ) { - before(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); - } - pushFollow(FOLLOW_2); - ruleIdentifier(); + + input.seek(index172_21); + if ( s>=0 ) return s; + break; + case 21 : + int LA172_22 = input.LA(1); - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - after(grammarAccess.getSimpleTypeAccess().getIdIdentifierParserRuleCall_1_1_0()); - } + + int index172_22 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index172_22); + if ( s>=0 ) return s; + break; + case 22 : + int LA172_23 = input.LA(1); - } + + int index172_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { + else if ( (true) ) {s = 33;} - restoreStackSize(stackSize); + + input.seek(index172_23); + if ( s>=0 ) return s; + break; + case 23 : + int LA172_24 = input.LA(1); - } - return ; - } - // $ANTLR end "rule__SimpleType__IdAssignment_1_1" + + int index172_24 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - // $ANTLR start synpred11_InternalScope - public final void synpred11_InternalScope_fragment() throws RecognitionException { - // InternalScope.g:1729:2: ( ( ( rule__Naming__Group_0__0 ) ) ) - // InternalScope.g:1729:2: ( ( rule__Naming__Group_0__0 ) ) - { - // InternalScope.g:1729:2: ( ( rule__Naming__Group_0__0 ) ) - // InternalScope.g:1730:3: ( rule__Naming__Group_0__0 ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getNamingAccess().getGroup_0()); - } - // InternalScope.g:1731:3: ( rule__Naming__Group_0__0 ) - // InternalScope.g:1731:4: rule__Naming__Group_0__0 - { - pushFollow(FOLLOW_2); - rule__Naming__Group_0__0(); + else if ( (true) ) {s = 33;} - state._fsp--; - if (state.failed) return ; + + input.seek(index172_24); + if ( s>=0 ) return s; + break; + case 24 : + int LA172_25 = input.LA(1); - } + + int index172_25 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } + + input.seek(index172_25); + if ( s>=0 ) return s; + break; + case 25 : + int LA172_26 = input.LA(1); + + int index172_26 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } - } - // $ANTLR end synpred11_InternalScope + else if ( (true) ) {s = 33;} - // $ANTLR start synpred14_InternalScope - public final void synpred14_InternalScope_fragment() throws RecognitionException { - // InternalScope.g:1777:2: ( ( ( ruleCastedExpression ) ) ) - // InternalScope.g:1777:2: ( ( ruleCastedExpression ) ) - { - // InternalScope.g:1777:2: ( ( ruleCastedExpression ) ) - // InternalScope.g:1778:3: ( ruleCastedExpression ) - { - if ( state.backtracking==0 ) { - before(grammarAccess.getExpressionAccess().getCastedExpressionParserRuleCall_1()); - } - // InternalScope.g:1779:3: ( ruleCastedExpression ) - // InternalScope.g:1779:4: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + + input.seek(index172_26); + if ( s>=0 ) return s; + break; + case 26 : + int LA172_27 = input.LA(1); - state._fsp--; - if (state.failed) return ; + + int index172_27 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - } + else if ( (true) ) {s = 33;} + + input.seek(index172_27); + if ( s>=0 ) return s; + break; + case 27 : + int LA172_28 = input.LA(1); - } + + int index172_28 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + else if ( (true) ) {s = 33;} - } - } - // $ANTLR end synpred14_InternalScope + + input.seek(index172_28); + if ( s>=0 ) return s; + break; + case 28 : + int LA172_29 = input.LA(1); - // $ANTLR start synpred88_InternalScope - public final void synpred88_InternalScope_fragment() throws RecognitionException { - // InternalScope.g:6648:3: ( rule__IfExpressionKw__Group_4__0 ) - // InternalScope.g:6648:3: rule__IfExpressionKw__Group_4__0 - { - pushFollow(FOLLOW_2); - rule__IfExpressionKw__Group_4__0(); + + int index172_29 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - state._fsp--; - if (state.failed) return ; + else if ( (true) ) {s = 33;} - } - } - // $ANTLR end synpred88_InternalScope + + input.seek(index172_29); + if ( s>=0 ) return s; + break; + case 29 : + int LA172_30 = input.LA(1); - // Delegated rules + + int index172_30 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - public final boolean synpred88_InternalScope() { - state.backtracking++; - int start = input.mark(); - try { - synpred88_InternalScope_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred14_InternalScope() { - state.backtracking++; - int start = input.mark(); - try { - synpred14_InternalScope_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred11_InternalScope() { - state.backtracking++; - int start = input.mark(); - try { - synpred11_InternalScope_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } + else if ( (true) ) {s = 33;} + + input.seek(index172_30); + if ( s>=0 ) return s; + break; + case 30 : + int LA172_31 = input.LA(1); - protected DFA1 dfa1 = new DFA1(this); - protected DFA9 dfa9 = new DFA9(this); - protected DFA11 dfa11 = new DFA11(this); - static final String dfa_1s = "\6\uffff"; - static final String dfa_2s = "\1\4\1\55\1\4\2\uffff\1\55"; - static final String dfa_3s = "\1\4\1\103\1\4\2\uffff\1\103"; - static final String dfa_4s = "\3\uffff\1\2\1\1\1\uffff"; - static final String dfa_5s = "\6\uffff}>"; - static final String[] dfa_6s = { - "\1\1", - "\1\4\7\uffff\1\3\15\uffff\1\2", - "\1\5", - "", - "", - "\1\4\7\uffff\1\3\15\uffff\1\2" - }; + + int index172_31 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} - static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); - static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); - static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); - static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); - static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); - static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + else if ( (true) ) {s = 33;} - class DFA1 extends DFA { + + input.seek(index172_31); + if ( s>=0 ) return s; + break; + case 31 : + int LA172_32 = input.LA(1); - public DFA1(BaseRecognizer recognizer) { - this.recognizer = recognizer; - this.decisionNumber = 1; - this.eot = dfa_1; - this.eof = dfa_1; - this.min = dfa_2; - this.max = dfa_3; - this.accept = dfa_4; - this.special = dfa_5; - this.transition = dfa_6; - } - public String getDescription() { - return "1544:1: rule__ScopeDefinition__Alternatives_2 : ( ( ( rule__ScopeDefinition__TargetTypeAssignment_2_0 ) ) | ( ( rule__ScopeDefinition__Group_2_1__0 ) ) );"; + + int index172_32 = input.index(); + input.rewind(); + s = -1; + if ( (synpred247_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index172_32); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 172, _s, input); + error(nvae); + throw nvae; } } - static final String dfa_7s = "\40\uffff"; - static final String dfa_8s = "\1\4\1\0\36\uffff"; - static final String dfa_9s = "\1\126\1\0\36\uffff"; - static final String dfa_10s = "\2\uffff\1\2\34\uffff\1\1"; - static final String dfa_11s = "\1\uffff\1\0\36\uffff}>"; - static final String[] dfa_12s = { - "\4\2\13\uffff\1\2\2\uffff\16\2\11\uffff\1\2\5\uffff\1\1\6\uffff\1\2\12\uffff\1\2\3\uffff\1\2\2\uffff\1\2\1\uffff\2\2\1\uffff\1\2\3\uffff\2\2", + static final String dfa_94s = "\117\uffff"; + static final String dfa_95s = "\1\2\116\uffff"; + static final String dfa_96s = "\1\4\1\0\115\uffff"; + static final String dfa_97s = "\1\172\1\0\115\uffff"; + static final String dfa_98s = "\2\uffff\1\2\113\uffff\1\1"; + static final String dfa_99s = "\1\uffff\1\0\115\uffff}>"; + static final String[] dfa_100s = { + "\5\2\6\uffff\5\2\1\uffff\1\2\1\1\5\2\10\uffff\2\2\3\uffff\30\2\4\uffff\1\2\2\uffff\4\2\1\uffff\3\2\2\uffff\2\2\2\uffff\1\2\6\uffff\1\2\1\uffff\1\2\1\uffff\1\2\1\uffff\3\2\1\uffff\16\2\4\uffff\2\2", "\1\uffff", "", "", @@ -38414,143 +96911,147 @@ public String getDescription() { "", "", "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", "" }; - static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); - static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); - static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); - static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); - static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); - static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); + static final short[] dfa_94 = DFA.unpackEncodedString(dfa_94s); + static final short[] dfa_95 = DFA.unpackEncodedString(dfa_95s); + static final char[] dfa_96 = DFA.unpackEncodedStringToUnsignedChars(dfa_96s); + static final char[] dfa_97 = DFA.unpackEncodedStringToUnsignedChars(dfa_97s); + static final short[] dfa_98 = DFA.unpackEncodedString(dfa_98s); + static final short[] dfa_99 = DFA.unpackEncodedString(dfa_99s); + static final short[][] dfa_100 = unpackEncodedStringArray(dfa_100s); - class DFA9 extends DFA { + class DFA181 extends DFA { - public DFA9(BaseRecognizer recognizer) { + public DFA181(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 9; - this.eot = dfa_7; - this.eof = dfa_7; - this.min = dfa_8; - this.max = dfa_9; - this.accept = dfa_10; - this.special = dfa_11; - this.transition = dfa_12; + this.decisionNumber = 181; + this.eot = dfa_94; + this.eof = dfa_95; + this.min = dfa_96; + this.max = dfa_97; + this.accept = dfa_98; + this.special = dfa_99; + this.transition = dfa_100; } public String getDescription() { - return "1724:1: rule__Naming__Alternatives : ( ( ( rule__Naming__Group_0__0 ) ) | ( ( rule__Naming__NamesAssignment_1 ) ) );"; + return "23311:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA9_1 = input.LA(1); + int LA181_1 = input.LA(1); - int index9_1 = input.index(); + int index181_1 = input.index(); input.rewind(); s = -1; - if ( (synpred11_InternalScope()) ) {s = 31;} + if ( (synpred256_InternalScope()) ) {s = 78;} else if ( (true) ) {s = 2;} - input.seek(index9_1); + input.seek(index181_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 9, _s, input); + new NoViableAltException(getDescription(), 181, _s, input); error(nvae); throw nvae; } } - static final String dfa_13s = "\36\uffff"; - static final String dfa_14s = "\1\4\1\uffff\1\0\33\uffff"; - static final String dfa_15s = "\1\126\1\uffff\1\0\33\uffff"; - static final String dfa_16s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; - static final String dfa_17s = "\2\uffff\1\0\33\uffff}>"; - static final String[] dfa_18s = { - "\4\3\13\uffff\1\3\2\uffff\16\3\11\uffff\1\3\5\uffff\1\2\21\uffff\1\1\3\uffff\1\3\2\uffff\1\3\1\uffff\2\3\5\uffff\2\3", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - }; - static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); - static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s); - static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); - static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s); - static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); - static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); + class DFA184 extends DFA { - class DFA11 extends DFA { - - public DFA11(BaseRecognizer recognizer) { + public DFA184(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 11; - this.eot = dfa_13; - this.eof = dfa_13; - this.min = dfa_14; - this.max = dfa_15; - this.accept = dfa_16; - this.special = dfa_17; - this.transition = dfa_18; + this.decisionNumber = 184; + this.eot = dfa_94; + this.eof = dfa_95; + this.min = dfa_96; + this.max = dfa_97; + this.accept = dfa_98; + this.special = dfa_99; + this.transition = dfa_100; } public String getDescription() { - return "1766:1: rule__Expression__Alternatives : ( ( ruleLetExpression ) | ( ( ruleCastedExpression ) ) | ( ruleChainExpression ) );"; + return "23581:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA11_2 = input.LA(1); + int LA184_1 = input.LA(1); - int index11_2 = input.index(); + int index184_1 = input.index(); input.rewind(); s = -1; - if ( (synpred14_InternalScope()) ) {s = 29;} + if ( (synpred259_InternalScope()) ) {s = 78;} - else if ( (true) ) {s = 3;} + else if ( (true) ) {s = 2;} - input.seek(index11_2); + input.seek(index184_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 11, _s, input); + new NoViableAltException(getDescription(), 184, _s, input); error(nvae); throw nvae; } @@ -38559,77 +97060,147 @@ public int specialStateTransition(int s, IntStream _input) throws NoViableAltExc public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x00049D8000000000L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000010000000002L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000040000000002L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000080000000002L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0004000000000002L}); - public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000020L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000020000000000L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000900000000000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000400000000010L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000012L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000003000000000L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0001000000000000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0408200FFFC800F0L,0x000000000062D220L}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0002000000000000L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0008000000000010L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0040000000000000L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000400000000000L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0040000000000002L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0010000000000000L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0020000000000000L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000100010L}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x2C08200FFFC800F0L,0x000000000062D220L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0082000000000000L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0080000000000002L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0100000000000000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0200000000000000L}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0008000000000000L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x2408200FFFC800F0L,0x000000000062D220L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x1010000000000000L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000820000000000L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x4000000000000000L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x8000000000000000L,0x0000000000010000L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0100000000000010L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x1000000000000002L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0008000000100010L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L}); - public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000008L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); - public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000010L}); - public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); - public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000E00000010L}); - public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L}); - public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L}); - public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); - public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000400L}); - public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); - public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0008200000000000L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000800000000000L,0x0000000000002000L}); - public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000800000000002L}); - public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0008200FFFC800F0L,0x000000000060C000L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000002L,0x0000000000100000L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x000000000003F000L}); - public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x000000000003F002L}); - public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x00000000000C0000L}); - public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x00000000000C0002L}); - public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000300000L}); - public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000300002L}); - public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0418200FFFC800F0L,0x000000000062D220L}); - public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x1000000000000000L}); - public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L}); - public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x000000007F800000L}); - public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0408600FFFC800F0L,0x000000000062D220L}); + public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000012L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000010L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0xC000000000000000L,0x00000000000014D0L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x4000000000000002L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x8000000000000002L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000040L}); + public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000100L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000480L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000200L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000006L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000004000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x000001FFF9000350L,0x014010D240102100L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000000000010L,0x0000000000002000L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000002000010L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x000001FFF9000350L,0x014010D240B02100L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020800L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000000002L,0x0000000000020000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x000001FFF9000350L,0x014010D240902100L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000000000000000L,0x0000000000404000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000420L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000000L,0x0020000002000000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000000000L,0x0000000004000000L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000010L,0x0000000000040000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000002L,0x0000000000400000L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000002000010L,0x0000000000002000L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000010000000L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000002L,0x0000000020000000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0400000000000000L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0400000000000002L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000000080000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x000001C000000010L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0001000000000000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0001000000000002L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002100L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000002000000400L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000400L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x000001FFF9000350L,0x010010C000002100L}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000008000L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000008002L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000010000L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000010002L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0000000000000000L,0x0080000000000000L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000002L,0x0080000000000000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x00000000007E0000L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x00000000007E0002L}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000001800000L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000001800002L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000006000000L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000006000002L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x000001FFF9000350L,0x014010D240106100L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000000000000L,0x0100000000000000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000FF0000000L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x000001FFF9000350L,0x014010D240102300L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0xF000000000000010L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xF000003009C001F0L,0x0005FE920004A101L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x00003E0000600000L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000000000280000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000C00000060000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000C00000060002L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000680000L,0x0000010000000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000680002L,0x0000010000000000L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0008000000000010L,0x0000000000002000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000000000L,0x0000010000000000L}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x003F000000600000L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x003F000000600002L}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0004000000000000L}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0008000000400000L}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x00C0000006000000L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x00C0000006000002L}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000009800000L}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000020L}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0300000000000000L}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0400000000000000L,0x0200000020000000L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0400000000000002L,0x0200000020000000L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0400000000000000L,0x0000000020000000L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0xF000000000400010L,0x0000000000000001L}); + public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000000L,0x0000000000042000L}); + public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0008000000000010L,0x0000000100002000L}); + public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000200000L,0x0000000000400000L}); + public static final BitSet FOLLOW_103 = new BitSet(new long[]{0xF008003009C001F0L,0x0005FE921004E101L}); + public static final BitSet FOLLOW_104 = new BitSet(new long[]{0xF008003009C001F0L,0x0005FE921004A101L}); + public static final BitSet FOLLOW_105 = new BitSet(new long[]{0xF008003009C001F0L,0x0005FE921004A301L}); + public static final BitSet FOLLOW_106 = new BitSet(new long[]{0xF008003009C001F0L,0x0005FE92100CA101L}); + public static final BitSet FOLLOW_107 = new BitSet(new long[]{0xF808003009C001F0L,0x0405FE921004A101L}); + public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0008000000000010L,0x0000000010002000L}); + public static final BitSet FOLLOW_109 = new BitSet(new long[]{0xF808003009C001F2L,0x0405FE921004A101L}); + public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); + public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L}); + public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0008000000000010L,0x0000002080402600L}); + public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0008000000000012L,0x0000000080402400L}); + public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0008000000000010L,0x0000000080402400L}); + public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000000000000L,0x0000020000000000L}); + public static final BitSet FOLLOW_116 = new BitSet(new long[]{0xF808003009C001F0L,0x0405FE921004A901L}); + public static final BitSet FOLLOW_117 = new BitSet(new long[]{0xF008003009C001F0L,0x0005FE921004A901L}); + public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000000000L,0x0000080000000000L}); + public static final BitSet FOLLOW_120 = new BitSet(new long[]{0xF808003009C001F0L,0x0405FE921004A301L}); + public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0800000000000000L,0x0400000000000000L}); + public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000000000000L,0x0000008000000000L}); + public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x0000000000400000L,0x0000000000042000L}); + public static final BitSet FOLLOW_124 = new BitSet(new long[]{0x0000003000000000L}); + public static final BitSet FOLLOW_125 = new BitSet(new long[]{0x0000000000000000L,0x0000100000000000L}); + public static final BitSet FOLLOW_126 = new BitSet(new long[]{0x00000000000000E0L}); + public static final BitSet FOLLOW_127 = new BitSet(new long[]{0x00000030000001E0L,0x0000300000048000L}); + public static final BitSet FOLLOW_128 = new BitSet(new long[]{0x0000000000000000L,0x0000000000044000L}); + public static final BitSet FOLLOW_129 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L}); + public static final BitSet FOLLOW_130 = new BitSet(new long[]{0x0000000000000000L,0x0000400000000000L}); + public static final BitSet FOLLOW_131 = new BitSet(new long[]{0x0000000000000000L,0x0000800000000000L}); + public static final BitSet FOLLOW_132 = new BitSet(new long[]{0x0000000000000000L,0x0001000000000000L}); + public static final BitSet FOLLOW_133 = new BitSet(new long[]{0x0000000000000000L,0x000A000000000000L}); + public static final BitSet FOLLOW_134 = new BitSet(new long[]{0x0000000000000000L,0x0002000000000000L}); + public static final BitSet FOLLOW_135 = new BitSet(new long[]{0x0000000000000002L,0x0008000000000000L}); + public static final BitSet FOLLOW_136 = new BitSet(new long[]{0x0000000000000000L,0x0004000000000000L}); + public static final BitSet FOLLOW_137 = new BitSet(new long[]{0x00000000000000C0L}); + public static final BitSet FOLLOW_138 = new BitSet(new long[]{0x0008000000000010L,0x0000000000006000L}); + public static final BitSet FOLLOW_139 = new BitSet(new long[]{0x1000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_140 = new BitSet(new long[]{0x0000000000000000L,0x0010000000000000L}); + public static final BitSet FOLLOW_141 = new BitSet(new long[]{0x0000000000000002L,0x0010000000000000L}); + public static final BitSet FOLLOW_142 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_143 = new BitSet(new long[]{0x2000000000000010L}); + public static final BitSet FOLLOW_144 = new BitSet(new long[]{0x8000000000000010L}); } \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.scope.ui/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.scope.ui/META-INF/MANIFEST.MF index e77d8a35ed..283c50a34a 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ui/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.scope.ui/META-INF/MANIFEST.MF @@ -19,9 +19,13 @@ Require-Bundle: org.eclipse.xtext.ui, com.avaloq.tools.ddk.xtext.expression, com.avaloq.tools.ddk.xtext.ui, org.eclipse.compare, - org.eclipse.jdt.ui + org.eclipse.jdt.ui, + org.eclipse.xtext.xbase.ui, + org.eclipse.jdt.debug.ui, + org.eclipse.xtext.common.types.ui Export-Package: com.avaloq.tools.ddk.xtext.scope.ui, com.avaloq.tools.ddk.xtext.scope.ui.contentassist, - com.avaloq.tools.ddk.xtext.scope.ui.quickfix + com.avaloq.tools.ddk.xtext.scope.ui.quickfix, + com.avaloq.tools.ddk.xtext.scope.ui.editor Import-Package: org.apache.log4j Automatic-Module-Name: com.avaloq.tools.ddk.xtext.scope.ui diff --git a/com.avaloq.tools.ddk.xtext.scope.ui/plugin.xml_gen b/com.avaloq.tools.ddk.xtext.scope.ui/plugin.xml_gen index 1d30f0a5c8..22777e5f71 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ui/plugin.xml_gen +++ b/com.avaloq.tools.ddk.xtext.scope.ui/plugin.xml_gen @@ -9,6 +9,7 @@ default="true" extensions="scope" id="com.avaloq.tools.ddk.xtext.scope.Scope" + matchingStrategy="com.avaloq.tools.ddk.xtext.scope.ui.ScopeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher" name="Scope Editor"> @@ -310,6 +311,164 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + provideIAllContainersState() { return Access.getJavaProjectsState(); } + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Class bindXtextDocumentProvider() { + return XbaseDocumentProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment + public Class bindOpenGeneratedFileHandler() { + return XbaseOpenGeneratedFileHandler.class; + } + // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2 public Class bindIProposalConflictHelper() { return AntlrProposalConflictHelper.class; @@ -111,11 +155,6 @@ public void configureContentAssistLexerProvider(Binder binder) { binder.bind(InternalScopeLexer.class).toProvider(LexerProvider.create(InternalScopeLexer.class)); } - // contributed by org.eclipse.xtext.xtext.generator.exporting.SimpleNamesFragment2 - public Class bindIDependentElementsCalculator() { - return DefaultDependentElementsCalculator.class; - } - // contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2 public void configureIResourceDescriptionsBuilderScope(Binder binder) { binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(CurrentDescriptions.ResourceSetAware.class); @@ -171,6 +210,84 @@ public Class bindIContentProposalProvider() return ScopeProposalProvider.class; } + // contributed by org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2 + public Class bindPrefixMatcher() { + return FQNPrefixMatcher.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindFindReferencesHandler() { + return JvmModelFindReferenceHandler.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindReferenceQueryExecutor() { + return JvmModelReferenceQueryExecutor.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIDependentElementsCalculator() { + return JvmModelDependentElementsCalculator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameRefactoringProvider() { + return CombinedJvmJdtRenameRefactoringProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIReferenceUpdater() { + return XbaseReferenceUpdater.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameContextFactory() { + return CombinedJvmJdtRenameContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIRenameStrategy() { + return DefaultJvmModelRenameStrategy.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindJdtRenameParticipant$ContextFactory() { + return JvmModelJdtRenameParticipantContext.ContextFactory.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindOutlineNodeElementOpener() { + return JvmOutlineNodeElementOpener.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindGlobalURIEditorOpener() { + return GlobalDerivedMemberAwareURIEditorOpener.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIJavaSearchParticipation() { + return IJavaSearchParticipation.No.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public void configureLanguageSpecificURIEditorOpener(Binder binder) { + if (PlatformUI.isWorkbenchRunning()) { + binder.bind(IURIEditorOpener.class).annotatedWith(LanguageSpecific.class).to(DerivedMemberAwareEditorOpener.class); + binder.bind(IDerivedMemberAwareEditorOpener.class).to(DerivedMemberAwareEditorOpener.class); + } + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindJavaTypeQuickfixes() { + return JavaTypeQuickfixesNoImportSection.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindXtextEditor() { + return ScopeEditor.class; + } + // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 public Class bindIXtextBuilderParticipant() { return BuilderParticipant.class; diff --git a/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/editor/ScopeEditor.java b/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/editor/ScopeEditor.java new file mode 100644 index 0000000000..117cc54b35 --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/editor/ScopeEditor.java @@ -0,0 +1,13 @@ +/* + * generated by Xtext + */ +package com.avaloq.tools.ddk.xtext.scope.ui.editor; + +import org.eclipse.xtext.xbase.ui.editor.XbaseEditor; + +/** + * This class was generated. Customizations should only happen in a newly + * introduced subclass. + */ +public class ScopeEditor extends XbaseEditor { +} diff --git a/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/internal/ScopeActivator.java b/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/internal/ScopeActivator.java index 523a3391c9..7f5afa7d89 100644 --- a/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/internal/ScopeActivator.java +++ b/com.avaloq.tools.ddk.xtext.scope.ui/src-gen/com/avaloq/tools/ddk/xtext/scope/ui/internal/ScopeActivator.java @@ -5,10 +5,10 @@ import com.avaloq.tools.ddk.xtext.scope.ScopeRuntimeModule; import com.avaloq.tools.ddk.xtext.scope.ui.ScopeUiModule; -import com.google.common.collect.Maps; import com.google.inject.Guice; import com.google.inject.Injector; import java.util.Collections; +import java.util.HashMap; import java.util.Map; import org.apache.log4j.Logger; import org.eclipse.ui.plugin.AbstractUIPlugin; @@ -29,7 +29,7 @@ public class ScopeActivator extends AbstractUIPlugin { private static ScopeActivator INSTANCE; - private Map injectors = Collections.synchronizedMap(Maps. newHashMapWithExpectedSize(1)); + private Map injectors = Collections.synchronizedMap(new HashMap<>(2)); @Override public void start(BundleContext context) throws Exception { diff --git a/com.avaloq.tools.ddk.xtext.scope/META-INF/MANIFEST.MF b/com.avaloq.tools.ddk.xtext.scope/META-INF/MANIFEST.MF index fb349c7600..84c4fc2da9 100644 --- a/com.avaloq.tools.ddk.xtext.scope/META-INF/MANIFEST.MF +++ b/com.avaloq.tools.ddk.xtext.scope/META-INF/MANIFEST.MF @@ -6,9 +6,9 @@ Bundle-Version: 17.3.1.qualifier Bundle-Vendor: Avaloq Group AG Bundle-RequiredExecutionEnvironment: JavaSE-21 Require-Bundle: org.eclipse.xtext, + org.eclipse.xtext.xbase, + org.eclipse.xtext.common.types, com.avaloq.tools.ddk.xtext.expression;visibility:=reexport, - org.eclipse.xtend, - org.eclipse.xtend.typesystem.emf, org.eclipse.emf.mwe2.launch;resolution:=optional, org.eclipse.xtext.util, org.eclipse.emf.ecore, @@ -18,8 +18,10 @@ Require-Bundle: org.eclipse.xtext, com.avaloq.tools.ddk.xtext, org.eclipse.core.resources, org.eclipse.core.runtime, - org.eclipse.xtext.xbase.lib -Import-Package: org.apache.logging.log4j + org.eclipse.xtext.xbase.lib, + org.objectweb.asm +Import-Package: org.apache.logging.log4j, + org.apache.log4j Export-Package: com.avaloq.tools.ddk.xtext.scope, com.avaloq.tools.ddk.xtext.scope.parser.antlr, com.avaloq.tools.ddk.xtext.scope.parser.antlr.internal, @@ -31,5 +33,6 @@ Export-Package: com.avaloq.tools.ddk.xtext.scope, com.avaloq.tools.ddk.xtext.scope.scoping, com.avaloq.tools.ddk.xtext.scope.formatting, com.avaloq.tools.ddk.xtext.scope.serializer, - com.avaloq.tools.ddk.xtext.scope.generator + com.avaloq.tools.ddk.xtext.scope.generator, + com.avaloq.tools.ddk.xtext.scope.jvmmodel Automatic-Module-Name: com.avaloq.tools.ddk.xtext.scope diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/AbstractScopeRuntimeModule.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/AbstractScopeRuntimeModule.java index fd6e616c43..6f604e3cc4 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/AbstractScopeRuntimeModule.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/AbstractScopeRuntimeModule.java @@ -3,7 +3,7 @@ */ package com.avaloq.tools.ddk.xtext.scope; -import com.avaloq.tools.ddk.xtext.scope.generator.ScopeGenerator; +import com.avaloq.tools.ddk.xtext.scope.jvmmodel.ScopeJvmModelInferrer; import com.avaloq.tools.ddk.xtext.scope.parser.antlr.ScopeAntlrTokenFileProvider; import com.avaloq.tools.ddk.xtext.scope.parser.antlr.ScopeParser; import com.avaloq.tools.ddk.xtext.scope.parser.antlr.internal.InternalScopeLexer; @@ -18,7 +18,7 @@ import java.util.Properties; import org.eclipse.xtext.Constants; import org.eclipse.xtext.IGrammarAccess; -import org.eclipse.xtext.generator.IGenerator2; +import org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider; import org.eclipse.xtext.naming.IQualifiedNameProvider; import org.eclipse.xtext.naming.SimpleNameProvider; import org.eclipse.xtext.parser.IParser; @@ -31,6 +31,7 @@ import org.eclipse.xtext.parser.antlr.LexerBindings; import org.eclipse.xtext.parser.antlr.LexerProvider; import org.eclipse.xtext.resource.IContainer; +import org.eclipse.xtext.resource.ILocationInFileProvider; import org.eclipse.xtext.resource.IResourceDescriptions; import org.eclipse.xtext.resource.containers.IAllContainersState; import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider; @@ -41,20 +42,31 @@ import org.eclipse.xtext.scoping.IScopeProvider; import org.eclipse.xtext.scoping.IgnoreCaseLinking; import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; -import org.eclipse.xtext.scoping.impl.DefaultGlobalScopeProvider; -import org.eclipse.xtext.scoping.impl.ImportedNamespaceAwareLocalScopeProvider; import org.eclipse.xtext.serializer.ISerializer; import org.eclipse.xtext.serializer.impl.Serializer; import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer; import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer; -import org.eclipse.xtext.service.DefaultRuntimeModule; import org.eclipse.xtext.service.SingletonBinding; +import org.eclipse.xtext.validation.IResourceValidator; +import org.eclipse.xtext.xbase.DefaultXbaseRuntimeModule; +import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator; +import org.eclipse.xtext.xbase.imports.RewritableImportSection; +import org.eclipse.xtext.xbase.jvmmodel.IJvmModelInferrer; +import org.eclipse.xtext.xbase.jvmmodel.JvmLocationInFileProvider; +import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider; +import org.eclipse.xtext.xbase.scoping.batch.IBatchScopeProvider; +import org.eclipse.xtext.xbase.typesystem.internal.DefaultBatchTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.DefaultReentrantTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareBatchTypeResolver; +import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareReentrantTypeResolver; +import org.eclipse.xtext.xbase.validation.FeatureNameValidator; +import org.eclipse.xtext.xbase.validation.LogicalContainerAwareFeatureNameValidator; /** * Manual modifications go to {@link ScopeRuntimeModule}. */ @SuppressWarnings("all") -public abstract class AbstractScopeRuntimeModule extends DefaultRuntimeModule { +public abstract class AbstractScopeRuntimeModule extends DefaultXbaseRuntimeModule { protected Properties properties = null; @@ -142,18 +154,13 @@ public Class bindScopeValidator() { } // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public Class bindIScopeProvider() { + public Class bindIBatchScopeProvider() { return ScopeScopeProvider.class; } // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 public void configureIScopeProviderDelegate(Binder binder) { - binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(ImportedNamespaceAwareLocalScopeProvider.class); - } - - // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 - public Class bindIGlobalScopeProvider() { - return DefaultGlobalScopeProvider.class; + binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(XImportSectionNamespaceScopeProvider.class); } // contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2 @@ -186,9 +193,46 @@ public void configureIResourceDescriptionsPersisted(Binder binder) { binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class); } - // contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2 - public Class bindIGenerator2() { - return ScopeGenerator.class; + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public void configureRewritableImportSectionEnablement(Binder binder) { + binder.bind(Boolean.TYPE) + .annotatedWith(Names.named(RewritableImportSection.Factory.REWRITABLEIMPORTSECTION_ENABLEMENT)) + .toInstance(Boolean.FALSE); + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindILocationInFileProvider() { + return JvmLocationInFileProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIGlobalScopeProvider() { + return TypesAwareDefaultGlobalScopeProvider.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindFeatureNameValidator() { + return LogicalContainerAwareFeatureNameValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindDefaultBatchTypeResolver() { + return LogicalContainerAwareBatchTypeResolver.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindDefaultReentrantTypeResolver() { + return LogicalContainerAwareReentrantTypeResolver.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIResourceValidator() { + return DerivedStateAwareResourceValidator.class; + } + + // contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2 + public Class bindIJvmModelInferrer() { + return ScopeJvmModelInferrer.class; } } diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/Scope.xtextbin b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/Scope.xtextbin index 686afbfc9f2691a58f9384c2484e72b0b7568462..0fc4b1adfd31712b7f9d41e6e7fd662446cc3477 100644 GIT binary patch literal 25555 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 hOQU6{vV7LolyV) literal 11236 zcma)Ccbpr=^}pHGO1ggTri2=7V;hSSnq&KRW_`8~+_*a%8)J+(?VW{n(jn>WGrfhD zP(l(QA=D(46i7k{H4q>_Ae7J(N(eQSK}#13oA<-wV$)P@ZkX866i>|n{CQ7HDOcHec^eNrpR{&4v#h*&9+ zoL@{245W*elTQ!$lY0vTGt%qRxxx`M%7sF%G$WH)H)EJ^GfKUML4QU!|F@fmN`A&@ zmMlvMYq$SL(;prz`lV8~ke|^}d9*DXYCD2+g@0fNKm(BM@rwi5d^%T(jm`Ld*}Pv` zkj-TLd{1GWpDzigd2Qr1786!;sL?f)^848GV z&&5S-EWY?fKi}(T7KNX!dVguUcU`*QPgs-wOPJ9U4E64*j^0Ai|EgjsQQu*p>ntl} z$J4oNx)k?`A?(K9TpCg8%lgHnWi@onO_$RoU1v3{%MAdtwo|%q1~~+CgLN%L3W!!6FTwnl_4<~b17X!a0~g86;H&A7)zz( zwjgeI&b7A-32#rrI{?;dcdSFij$jh|x@c(i)0HinIBwlTMU&OC&@We2Z8vSu53}q#yDgQfX%;cJ z7XePV83Zks^UK2ZMN6YZR_f0)k2uLbKV2Rw`i)tn;0x;^RgQs5t5?Y7{9dM)K>65E z8M4P|qsPOT-J8>fhX2L^L~VD|Kg*)#N%`ZmpGGjV$w;{F{f^#k%uWK(1!+dT`|_DuA^*-^Q3 zj2wGWxZkDy)%x+=z^Z=!9zX9a-0wp(+IK&o3_2J8-1GQ+K3KLPgJ$#5-nzh0U5yC+ zP*eR8g)fBgXf0gZxj&AGU!=o#F~u)o@H_je!255o-Aj$^W$d|D^jxGJ)-H#&xcd`& zp6wIvPr<*Tw~)_d*?l^=KMR-$_X-F(<+XlZxK~1~o{yO6!63aVl)9SHY>$oU%N9#z zblTF$V71(zYv+DJBtKX3h5Jh)@v(yRD}xjS?Haya%b-Px_Y||X`|C&)exq@JOX2Gv z+`L53uV6oByT6M_Uauv8Pstk~*&_2b^XA5g=uKMmW{Tbd(b1h4TUozUjj!$A8WI14 z7Qc<+w?lkfm!H#XY&sX!_+v!l4y|z~HSU7O7@1+**ZWcVKSkvKN6X($`FkM0#iF5H zISWq61tYZXjcEN@Yu!h!`=K>qSw3CdxTM&b@5>HHEj)H%4jxBO?AB%qQIEDgFY)lMA!h!=!Vz`=Swg ziN0VPY8v3h%TS5C|D?(*P-#^t7yNX-qWP-Pe2to;QmNW@0K5*@V%Ujl|No`^e?w2B z;t&S^n|O@(Vf*g~gZcv`NcVjregMR# z#Y4GV1@1!w_YvV*QmIHIus)7r{V(a}p{(&fA>OCN>+;i8yw42Y=LRp*2)r+%c>f{7 zm)M~=T^(|vE$gVN7fUJ7pD}4+w}x~qZH^D@@??w;*yc%x4>N>}8;L|Hku(yd2)TNg zkPRT&64Vo++p;mBDVsPtFJ8~>l$B|9V9I@qi6SPMlIsvXbaw6+i-u_P!ax0x$9b0Yn#h(VxTE_ zna8z6$P}B4{^7cr^+CcP#s;AzB#VTGd;y!l;GM-nqEslB)kY!r;7ebjDD@bYx_Uq~ z_Y9-C7kFWg>fM;!o31nH`#{S&8V~!j*&iO%k(p_tCw1Wv#BLUYG@C)xkW0c4E(M!P8Lo4 z86{2-Q#i==;UL%mxtgprOi^Z~jo}bDl8_hzM~xKK#e?1_%VQ`52jsEZzvD>xc+<(F zMLeX6T1uW^7@kOmmC0}t&0;bLd9rr;TSPd;Ahg#aoN5qGtMT!4e65{!XHX7NW(85T zq)P}+yEEBL&S$}5Ql3qV=NOAP0Eu$e1q7mcZjHt7>1_CYz*Mv05AasWhUej>HXEML z<}e#xz?U!^{tz$GZ1^KKhS~5!zErc}kMT;!E(&|`V(_YD!%M=>zLa9jhL^E9%!ZeT z9nAWnl6DyRpR(mCJ*s~ebbd@;!KhqW9eif2Bv6eBc~wm~uI5fj{+y^&g=D#a!v(;y zTBsRfx>&fMcF=lFXz5y73d;iw^BPOPsj>81ZRt8%m?q@!_?LT9dHqOBx?;FT8xrz{ z(9(^xbd%}no0)=8YnxqQWw{3^&&U!SvbO-YGRyRmaw`}lfVqo_pXgDUjH<%y<$erNC{;5SCLWb zBQK|2Ku0o8ICBR_(V%OYLzePGNh~ zB|liV-yz+1LD#{Nk#EcQ48`|J5l5>03R)k4mLop|q}CPkBXFq3P*eCgq`(@2k@^HO zNfS&h@u`u}f%*(mNnC@ZQPm3hxzSrTq_TiZE~DkAXmuQa*{jj9^;;dB{^=Z z798ZNRvhHUrhm1ATz%7p+^X852f~SoY7|^;)UAtni)5?O@Kd$eY7G30;RLYS1}DdI zkg9R)z!L7xc!#6L>qz3hO-FJ9999znT0gf?##tpU8q^kqY_oArshoc;cu($(CT1LtQBf|7;DYudvik>KclGyM+s^N(bnn}3#C%! z4lG!|)sCS*B3?PqRV;kK693drm?hxAWQaP#piN@?WO$LlSr9(kYKno`nPI8N@tXb) zkEX(-n3@KPi2y>V=^&XL3~t?YP<9b*j+zlfL8X9THR23>X&@ouYFC(Jo>#ktF0-() z(boE_3GMmVAfZTMz5U%C=vOx#82d=S$S>4!520RrmPl66+Im07YH8<)3 zUG6YWWb>@|s!q(KsrhuGGixdaiY=$%lpByqxRPwp*4hB$l!(hMYV{C=yb)h zMhACEO>mb+sHp=;tKCW9A{nDxJKsh9ZZK+DtUq=Kd~MZZSS=$fq=uSiFk23033VWI z)rwFQG**V4eGvEr*;TCqqeO4I6xuwPHdl*L^&R=4f$Bv|0@)cN!6l12#DK1`V(|_N z>Jb`hjJgJ(qi-k3Yt( zf~K-&ss?>x2K(WR&^q+Ws37cfdB3htwQZF%ff-=OfcZ!X^i5umnnKM$8RT?j^@OCQ ziqN$%;e*>NOx6+&&LPP%d0|l*Vy6Y9^gvlpi4CBX2n^b4*bv!BA^;1%!~BuDJB|{G z7z#Lbv?ikqqbWii3)nbdedFnIggw6MX=H<;PA~>etnsue0aGVwQzw(FKg^^Sx7)Gw z@uJ0ifJ>)xEc{+fQdBPtDZye^oijq_yP*sl&!yNm19W{86YK~SZey5c5?qtQXz@lyorh?( z>1851EY26`S}buFFj&|yj1WMqcsG+!tf%4{Q>Y7r$r@9pkWv?cXypt~T};nWEvrk6 zC+boiZkADv!5v?ZIdxN)b9nuP95}o%qF6))BMLPX7LzNW)P&0!{!*o)btSc~ifCP3 z(bDzPjzawcdJRS2{02n#$SPiSW_xZ2;uK_2yXx)DqZc0P&a~L_@?RIMAVys+N@P^ zrbC}?b&CPMmB6^ninan<-@vHbbcAmQW};so-UQ>6WfZDOq3+mR81H02?jpPiK5Ho* ze4%tD)s7Chn-JK=-2;Sp{}Ar_HQRd`DhzMM>M6J!#LInrK^C~5!kiFhx;{YQ2P*@x zIu~ulB8qW)C^`VE0`Tx*_!d)-5aQ7a#9SOX;-@57BW?AVfp|O$Q568h6X<}r;_Zvx ztNDdKp;$YikWf$R&^-ml_1N_3-=}B~pAJ2IhE3cH;Kw=oQbY0jMe+J&d~gV+yQIq5 zR=k3tQ_qpn#PF0Jn6PMH?yzK0J9WIad-^}aFm0SuXs+SG?8j*$N-NE}J^u`#DFS~B=K zlu(}-^-uX1-SQdvvMHEzpVQ+n5b{?3dMX<0|A-*gUozIXkE(4KF|Upt>7v2^cHjKZwCG-$~NNz;|tWTbTi>L3RU3u;}U7?v82b?O}!+ zP9ME$3F7Tp0rFUKcq}UEBd`x00gCg@D`&rQVV!X$dIGg zTN(l!0C5{-qSr-PWI9tfc-@rUz)>Fj^LoO;vWzNo<_K>&R3ht@$6FYzSAbsu5wp$m zR`NO6W(lDttG(5HwOVznb?Q8Iow`{)=I={En!I^xgF0T#L7j!4#Qq<0 Cor@#@ diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.g b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.g index cf985402a5..28340166a0 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.g +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.g @@ -3701,7 +3701,7 @@ ruleIntegerLiteral returns [EObject current=null] $current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.INT"); + "org.eclipse.xtext.xbase.Xbase.INT"); } ) ) @@ -3802,7 +3802,7 @@ ruleStringLiteral returns [EObject current=null] $current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.STRING"); + "org.eclipse.xtext.xbase.Xtype.STRING"); } ) ) @@ -4595,6 +4595,6288 @@ ruleIdentifier returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToke } ; +// Entry rule entryRuleXExpression +entryRuleXExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionRule()); } + iv_ruleXExpression=ruleXExpression + { $current=$iv_ruleXExpression.current; } + EOF; + +// Rule XExpression +ruleXExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + { + newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + this_XAssignment_0=ruleXAssignment + { + $current = $this_XAssignment_0.current; + afterParserOrEnumRuleCall(); + } +; + +// Entry rule entryRuleXAssignment +entryRuleXAssignment returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAssignmentRule()); } + iv_ruleXAssignment=ruleXAssignment + { $current=$iv_ruleXAssignment.current; } + EOF; + +// Rule XAssignment +ruleXAssignment returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAssignmentRule()); + } + } + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + ruleFeatureCallID + { + afterParserOrEnumRuleCall(); + } + ) + ) + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + } + ruleOpSingleAssign + { + afterParserOrEnumRuleCall(); + } + ( + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + } + lv_value_3_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + $current, + "value", + lv_value_3_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + } + this_XOrExpression_4=ruleXOrExpression + { + $current = $this_XOrExpression_4.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpMultiAssign + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAssignmentRule()); + } + } + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + ruleOpMultiAssign + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + } + lv_rightOperand_7_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_7_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) + ) +; + +// Entry rule entryRuleOpSingleAssign +entryRuleOpSingleAssign returns [String current=null]: + { newCompositeNode(grammarAccess.getOpSingleAssignRule()); } + iv_ruleOpSingleAssign=ruleOpSingleAssign + { $current=$iv_ruleOpSingleAssign.current.getText(); } + EOF; + +// Rule OpSingleAssign +ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + } +; + +// Entry rule entryRuleOpMultiAssign +entryRuleOpMultiAssign returns [String current=null]: + { newCompositeNode(grammarAccess.getOpMultiAssignRule()); } + iv_ruleOpMultiAssign=ruleOpMultiAssign + { $current=$iv_ruleOpMultiAssign.current.getText(); } + EOF; + +// Rule OpMultiAssign +ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='+=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + } + | + kw='-=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + } + | + kw='*=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + } + | + kw='/=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + } + | + kw='%=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + } + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + } + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + } + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + } + ) + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + } + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + } + )? + kw='>=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + } + ) + ) +; + +// Entry rule entryRuleXOrExpression +entryRuleXOrExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXOrExpressionRule()); } + iv_ruleXOrExpression=ruleXOrExpression + { $current=$iv_ruleXOrExpression.current; } + EOF; + +// Rule XOrExpression +ruleXOrExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + } + this_XAndExpression_0=ruleXAndExpression + { + $current = $this_XAndExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpOr + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXOrExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpOr + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXAndExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXOrExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAndExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpOr +entryRuleOpOr returns [String current=null]: + { newCompositeNode(grammarAccess.getOpOrRule()); } + iv_ruleOpOr=ruleOpOr + { $current=$iv_ruleOpOr.current.getText(); } + EOF; + +// Rule OpOr +ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='||' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + } +; + +// Entry rule entryRuleXAndExpression +entryRuleXAndExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAndExpressionRule()); } + iv_ruleXAndExpression=ruleXAndExpression + { $current=$iv_ruleXAndExpression.current; } + EOF; + +// Rule XAndExpression +ruleXAndExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + } + this_XEqualityExpression_0=ruleXEqualityExpression + { + $current = $this_XEqualityExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpAnd + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAndExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpAnd + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXEqualityExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAndExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XEqualityExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpAnd +entryRuleOpAnd returns [String current=null]: + { newCompositeNode(grammarAccess.getOpAndRule()); } + iv_ruleOpAnd=ruleOpAnd + { $current=$iv_ruleOpAnd.current.getText(); } + EOF; + +// Rule OpAnd +ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + kw='&&' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + } +; + +// Entry rule entryRuleXEqualityExpression +entryRuleXEqualityExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXEqualityExpressionRule()); } + iv_ruleXEqualityExpression=ruleXEqualityExpression + { $current=$iv_ruleXEqualityExpression.current; } + EOF; + +// Rule XEqualityExpression +ruleXEqualityExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + } + this_XRelationalExpression_0=ruleXRelationalExpression + { + $current = $this_XRelationalExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpEquality + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXEqualityExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpEquality + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXRelationalExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XRelationalExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpEquality +entryRuleOpEquality returns [String current=null]: + { newCompositeNode(grammarAccess.getOpEqualityRule()); } + iv_ruleOpEquality=ruleOpEquality + { $current=$iv_ruleOpEquality.current.getText(); } + EOF; + +// Rule OpEquality +ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='==' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + } + | + kw='!=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + } + | + kw='===' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + } + | + kw='!==' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXRelationalExpression +entryRuleXRelationalExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXRelationalExpressionRule()); } + iv_ruleXRelationalExpression=ruleXRelationalExpression + { $current=$iv_ruleXRelationalExpression.current; } + EOF; + +// Rule XRelationalExpression +ruleXRelationalExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + } + this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression + { + $current = $this_XOtherOperatorExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + ( + (( + ( + ) + 'instanceof' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), + $current); + } + ) + otherlv_2='instanceof' + { + newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + (( + ( + ) + ( + ( + ruleOpCompare + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXRelationalExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + } + ruleOpCompare + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + } + lv_rightOperand_6_0=ruleXOtherOperatorExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_6_0, + "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + )* + ) +; + +// Entry rule entryRuleOpCompare +entryRuleOpCompare returns [String current=null]: + { newCompositeNode(grammarAccess.getOpCompareRule()); } + iv_ruleOpCompare=ruleOpCompare + { $current=$iv_ruleOpCompare.current.getText(); } + EOF; + +// Rule OpCompare +ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='>=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + } + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + } + kw='=' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + } + ) + | + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + } + | + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXOtherOperatorExpression +entryRuleXOtherOperatorExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); } + iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression + { $current=$iv_ruleXOtherOperatorExpression.current; } + EOF; + +// Rule XOtherOperatorExpression +ruleXOtherOperatorExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + } + this_XAdditiveExpression_0=ruleXAdditiveExpression + { + $current = $this_XAdditiveExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpOther + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpOther + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXAdditiveExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpOther +entryRuleOpOther returns [String current=null]: + { newCompositeNode(grammarAccess.getOpOtherRule()); } + iv_ruleOpOther=ruleOpOther + { $current=$iv_ruleOpOther.current.getText(); } + EOF; + +// Rule OpOther +ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='->' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + } + | + kw='..<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + } + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + } + kw='..' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + } + ) + | + kw='..' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + } + | + kw='=>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + } + | + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + } + ( + ( + (( + '>' + '>' + ) + )=> + ( + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + } + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + } + ) + ) + | + kw='>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + } + ) + ) + | + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + } + ( + ( + (( + '<' + '<' + ) + )=> + ( + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + } + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + } + ) + ) + | + kw='<' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + } + | + kw='=>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + } + ) + ) + | + kw='<>' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + } + | + kw='?:' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + } + ) +; + +// Entry rule entryRuleXAdditiveExpression +entryRuleXAdditiveExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); } + iv_ruleXAdditiveExpression=ruleXAdditiveExpression + { $current=$iv_ruleXAdditiveExpression.current; } + EOF; + +// Rule XAdditiveExpression +ruleXAdditiveExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + } + this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression + { + $current = $this_XMultiplicativeExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpAdd + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXAdditiveExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpAdd + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXMultiplicativeExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpAdd +entryRuleOpAdd returns [String current=null]: + { newCompositeNode(grammarAccess.getOpAddRule()); } + iv_ruleOpAdd=ruleOpAdd + { $current=$iv_ruleOpAdd.current.getText(); } + EOF; + +// Rule OpAdd +ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='+' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + } + | + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + } + ) +; + +// Entry rule entryRuleXMultiplicativeExpression +entryRuleXMultiplicativeExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); } + iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression + { $current=$iv_ruleXMultiplicativeExpression.current; } + EOF; + +// Rule XMultiplicativeExpression +ruleXMultiplicativeExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + } + this_XUnaryOperation_0=ruleXUnaryOperation + { + $current = $this_XUnaryOperation_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + ( + ( + ruleOpMulti + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule()); + } + } + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + } + ruleOpMulti + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + } + lv_rightOperand_3_0=ruleXUnaryOperation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule()); + } + set( + $current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleOpMulti +entryRuleOpMulti returns [String current=null]: + { newCompositeNode(grammarAccess.getOpMultiRule()); } + iv_ruleOpMulti=ruleOpMulti + { $current=$iv_ruleOpMulti.current.getText(); } + EOF; + +// Rule OpMulti +ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + } + | + kw='**' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + } + | + kw='/' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + } + | + kw='%' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + } + ) +; + +// Entry rule entryRuleXUnaryOperation +entryRuleXUnaryOperation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXUnaryOperationRule()); } + iv_ruleXUnaryOperation=ruleXUnaryOperation + { $current=$iv_ruleXUnaryOperation.current; } + EOF; + +// Rule XUnaryOperation +ruleXUnaryOperation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXUnaryOperationRule()); + } + } + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + } + ruleOpUnary + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + } + lv_operand_2_0=ruleXUnaryOperation + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXUnaryOperationRule()); + } + set( + $current, + "operand", + lv_operand_2_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + { + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + } + this_XCastedExpression_3=ruleXCastedExpression + { + $current = $this_XCastedExpression_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleOpUnary +entryRuleOpUnary returns [String current=null]: + { newCompositeNode(grammarAccess.getOpUnaryRule()); } + iv_ruleOpUnary=ruleOpUnary + { $current=$iv_ruleOpUnary.current.getText(); } + EOF; + +// Rule OpUnary +ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='!' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + } + | + kw='-' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + } + | + kw='+' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + } + ) +; + +// Entry rule entryRuleXCastedExpression +entryRuleXCastedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCastedExpressionRule()); } + iv_ruleXCastedExpression=ruleXCastedExpression + { $current=$iv_ruleXCastedExpression.current; } + EOF; + +// Rule XCastedExpression +ruleXCastedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + } + this_XPostfixOperation_0=ruleXPostfixOperation + { + $current = $this_XPostfixOperation_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + (( + ( + ) + 'as' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(), + $current); + } + ) + otherlv_2='as' + { + newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCastedExpressionRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) +; + +// Entry rule entryRuleXPostfixOperation +entryRuleXPostfixOperation returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXPostfixOperationRule()); } + iv_ruleXPostfixOperation=ruleXPostfixOperation + { $current=$iv_ruleXPostfixOperation.current; } + EOF; + +// Rule XPostfixOperation +ruleXPostfixOperation returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + } + this_XMemberFeatureCall_0=ruleXMemberFeatureCall + { + $current = $this_XMemberFeatureCall_0.current; + afterParserOrEnumRuleCall(); + } + ( + (( + ( + ) + ( + ( + ruleOpPostfix + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(), + $current); + } + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXPostfixOperationRule()); + } + } + { + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + } + ruleOpPostfix + { + afterParserOrEnumRuleCall(); + } + ) + ) + ) + )? + ) +; + +// Entry rule entryRuleOpPostfix +entryRuleOpPostfix returns [String current=null]: + { newCompositeNode(grammarAccess.getOpPostfixRule()); } + iv_ruleOpPostfix=ruleOpPostfix + { $current=$iv_ruleOpPostfix.current.getText(); } + EOF; + +// Rule OpPostfix +ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='++' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + } + | + kw='--' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + } + ) +; + +// Entry rule entryRuleXMemberFeatureCall +entryRuleXMemberFeatureCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); } + iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall + { $current=$iv_ruleXMemberFeatureCall.current; } + EOF; + +// Rule XMemberFeatureCall +ruleXMemberFeatureCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + } + this_XPrimaryExpression_0=ruleXPrimaryExpression + { + $current = $this_XPrimaryExpression_0.current; + afterParserOrEnumRuleCall(); + } + ( + ( + ( + (( + ( + ) + ( + '.' + | + ( + ( + '::' + ) + ) + ) + ( + ( + ruleFeatureCallID + ) + ) + ruleOpSingleAssign + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(), + $current); + } + ) + ( + otherlv_2='.' + { + newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + } + | + ( + ( + lv_explicitStatic_3_0='::' + { + newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitStatic", lv_explicitStatic_3_0 != null, "::"); + } + ) + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + } + ruleFeatureCallID + { + afterParserOrEnumRuleCall(); + } + ) + ) + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + } + ruleOpSingleAssign + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + } + lv_value_6_0=ruleXAssignment + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + set( + $current, + "value", + lv_value_6_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + (( + ( + ) + ( + '.' + | + ( + ( + '?.' + ) + ) + | + ( + ( + '::' + ) + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), + $current); + } + ) + ( + otherlv_8='.' + { + newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + } + | + ( + ( + lv_nullSafe_9_0='?.' + { + newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "nullSafe", lv_nullSafe_9_0 != null, "?."); + } + ) + ) + | + ( + ( + lv_explicitStatic_10_0='::' + { + newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitStatic", lv_explicitStatic_10_0 != null, "::"); + } + ) + ) + ) + ) + ) + ( + otherlv_11='<' + { + newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + } + lv_typeArguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_13=',' + { + newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + } + lv_typeArguments_14_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_14_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_15='>' + { + newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + } + ruleIdOrSuper + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitOperationCall_17_0='(' + { + newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed($current, "explicitOperationCall", lv_explicitOperationCall_17_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + } + lv_memberCallArguments_18_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_18_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + } + lv_memberCallArguments_19_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_19_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_20=',' + { + newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + } + lv_memberCallArguments_21_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_21_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_22=')' + { + newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + } + lv_memberCallArguments_23_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + $current, + "memberCallArguments", + lv_memberCallArguments_23_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) + )* + ) +; + +// Entry rule entryRuleXPrimaryExpression +entryRuleXPrimaryExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); } + iv_ruleXPrimaryExpression=ruleXPrimaryExpression + { $current=$iv_ruleXPrimaryExpression.current; } + EOF; + +// Rule XPrimaryExpression +ruleXPrimaryExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + } + this_XConstructorCall_0=ruleXConstructorCall + { + $current = $this_XConstructorCall_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + } + this_XBlockExpression_1=ruleXBlockExpression + { + $current = $this_XBlockExpression_1.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + } + this_XSwitchExpression_2=ruleXSwitchExpression + { + $current = $this_XSwitchExpression_2.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + 'synchronized' + '(' + ) + )=> + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + } + this_XSynchronizedExpression_3=ruleXSynchronizedExpression + { + $current = $this_XSynchronizedExpression_3.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + } + this_XFeatureCall_4=ruleXFeatureCall + { + $current = $this_XFeatureCall_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + } + this_XLiteral_5=ruleXLiteral + { + $current = $this_XLiteral_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + } + this_XIfExpression_6=ruleXIfExpression + { + $current = $this_XIfExpression_6.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + 'for' + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + } + this_XForLoopExpression_7=ruleXForLoopExpression + { + $current = $this_XForLoopExpression_7.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + } + this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression + { + $current = $this_XBasicForLoopExpression_8.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + } + this_XWhileExpression_9=ruleXWhileExpression + { + $current = $this_XWhileExpression_9.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + } + this_XDoWhileExpression_10=ruleXDoWhileExpression + { + $current = $this_XDoWhileExpression_10.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + } + this_XThrowExpression_11=ruleXThrowExpression + { + $current = $this_XThrowExpression_11.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + } + this_XReturnExpression_12=ruleXReturnExpression + { + $current = $this_XReturnExpression_12.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + } + this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression + { + $current = $this_XTryCatchFinallyExpression_13.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + } + this_XParenthesizedExpression_14=ruleXParenthesizedExpression + { + $current = $this_XParenthesizedExpression_14.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXLiteral +entryRuleXLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXLiteralRule()); } + iv_ruleXLiteral=ruleXLiteral + { $current=$iv_ruleXLiteral.current; } + EOF; + +// Rule XLiteral +ruleXLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + } + this_XCollectionLiteral_0=ruleXCollectionLiteral + { + $current = $this_XCollectionLiteral_0.current; + afterParserOrEnumRuleCall(); + } + | + ( + (( + ( + ) + '[' + ) + )=> + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + } + this_XClosure_1=ruleXClosure + { + $current = $this_XClosure_1.current; + afterParserOrEnumRuleCall(); + } + ) + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + } + this_XBooleanLiteral_2=ruleXBooleanLiteral + { + $current = $this_XBooleanLiteral_2.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + } + this_XNumberLiteral_3=ruleXNumberLiteral + { + $current = $this_XNumberLiteral_3.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + } + this_XNullLiteral_4=ruleXNullLiteral + { + $current = $this_XNullLiteral_4.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + } + this_XStringLiteral_5=ruleXStringLiteral + { + $current = $this_XStringLiteral_5.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + } + this_XTypeLiteral_6=ruleXTypeLiteral + { + $current = $this_XTypeLiteral_6.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXCollectionLiteral +entryRuleXCollectionLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCollectionLiteralRule()); } + iv_ruleXCollectionLiteral=ruleXCollectionLiteral + { $current=$iv_ruleXCollectionLiteral.current; } + EOF; + +// Rule XCollectionLiteral +ruleXCollectionLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + } + this_XSetLiteral_0=ruleXSetLiteral + { + $current = $this_XSetLiteral_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + } + this_XListLiteral_1=ruleXListLiteral + { + $current = $this_XListLiteral_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXSetLiteral +entryRuleXSetLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSetLiteralRule()); } + iv_ruleXSetLiteral=ruleXSetLiteral + { $current=$iv_ruleXSetLiteral.current; } + EOF; + +// Rule XSetLiteral +ruleXSetLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(), + $current); + } + ) + otherlv_1='#' + { + newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + } + otherlv_2='{' + { + newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + lv_elements_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + $current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + lv_elements_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + $current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6='}' + { + newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleXListLiteral +entryRuleXListLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXListLiteralRule()); } + iv_ruleXListLiteral=ruleXListLiteral + { $current=$iv_ruleXListLiteral.current; } + EOF; + +// Rule XListLiteral +ruleXListLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(), + $current); + } + ) + otherlv_1='#' + { + newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + } + otherlv_2='[' + { + newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + } + lv_elements_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + $current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + } + lv_elements_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + $current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=']' + { + newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + } + ) +; + +// Entry rule entryRuleXClosure +entryRuleXClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXClosureRule()); } + iv_ruleXClosure=ruleXClosure + { $current=$iv_ruleXClosure.current; } + EOF; + +// Rule XClosure +ruleXClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + '[' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(), + $current); + } + ) + otherlv_1='[' + { + newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + } + ) + ) + ( + (( + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + } + lv_declaredFormalParameters_2_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_2_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + } + lv_declaredFormalParameters_4_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_4_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + lv_explicitSyntax_5_0='|' + { + newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXClosureRule()); + } + setWithLastConsumed($current, "explicitSyntax", lv_explicitSyntax_5_0 != null, "|"); + } + ) + ) + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + } + lv_expression_6_0=ruleXExpressionInClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + set( + $current, + "expression", + lv_expression_6_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_7=']' + { + newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + } + ) +; + +// Entry rule entryRuleXExpressionInClosure +entryRuleXExpressionInClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionInClosureRule()); } + iv_ruleXExpressionInClosure=ruleXExpressionInClosure + { $current=$iv_ruleXExpressionInClosure.current; } + EOF; + +// Rule XExpressionInClosure +ruleXExpressionInClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(), + $current); + } + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + } + lv_expressions_1_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule()); + } + add( + $current, + "expressions", + lv_expressions_1_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=';' + { + newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + } + )? + )* + ) +; + +// Entry rule entryRuleXShortClosure +entryRuleXShortClosure returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXShortClosureRule()); } + iv_ruleXShortClosure=ruleXShortClosure + { $current=$iv_ruleXShortClosure.current; } + EOF; + +// Rule XShortClosure +ruleXShortClosure returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(), + $current); + } + ) + ( + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + } + lv_declaredFormalParameters_1_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_1_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + } + lv_declaredFormalParameters_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + $current, + "declaredFormalParameters", + lv_declaredFormalParameters_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + ( + ( + lv_explicitSyntax_4_0='|' + { + newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXShortClosureRule()); + } + setWithLastConsumed($current, "explicitSyntax", lv_explicitSyntax_4_0 != null, "|"); + } + ) + ) + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + } + lv_expression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + set( + $current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXParenthesizedExpression +entryRuleXParenthesizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); } + iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression + { $current=$iv_ruleXParenthesizedExpression.current; } + EOF; + +// Rule XParenthesizedExpression +ruleXParenthesizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + } + { + newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + } + this_XExpression_1=ruleXExpression + { + $current = $this_XExpression_1.current; + afterParserOrEnumRuleCall(); + } + otherlv_2=')' + { + newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + } + ) +; + +// Entry rule entryRuleXIfExpression +entryRuleXIfExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXIfExpressionRule()); } + iv_ruleXIfExpression=ruleXIfExpression + { $current=$iv_ruleXIfExpression.current; } + EOF; + +// Rule XIfExpression +ruleXIfExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(), + $current); + } + ) + otherlv_1='if' + { + newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + } + lv_if_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "if", + lv_if_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + } + lv_then_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('else')=> + otherlv_6='else' + { + newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + } + lv_else_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + $current, + "else", + lv_else_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleXSwitchExpression +entryRuleXSwitchExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSwitchExpressionRule()); } + iv_ruleXSwitchExpression=ruleXSwitchExpression + { $current=$iv_ruleXSwitchExpression.current; } + EOF; + +// Rule XSwitchExpression +ruleXSwitchExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(), + $current); + } + ) + otherlv_1='switch' + { + newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + } + ( + ( + ( + (( + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + } + lv_declaredParam_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + } + lv_switch_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "switch", + lv_switch_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + } + ) + | + ( + ( + (( + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + } + lv_declaredParam_7_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_7_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_8=':' + { + newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + } + lv_switch_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "switch", + lv_switch_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + otherlv_10='{' + { + newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + } + lv_cases_11_0=ruleXCasePart + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + add( + $current, + "cases", + lv_cases_11_0, + "org.eclipse.xtext.xbase.Xbase.XCasePart"); + afterParserOrEnumRuleCall(); + } + ) + )* + ( + otherlv_12='default' + { + newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + } + otherlv_13=':' + { + newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + } + lv_default_14_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + $current, + "default", + lv_default_14_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + otherlv_15='}' + { + newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + } + ) +; + +// Entry rule entryRuleXCasePart +entryRuleXCasePart returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCasePartRule()); } + iv_ruleXCasePart=ruleXCasePart + { $current=$iv_ruleXCasePart.current; } + EOF; + +// Rule XCasePart +ruleXCasePart returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXCasePartAccess().getXCasePartAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeGuard_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "typeGuard", + lv_typeGuard_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + otherlv_2='case' + { + newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + } + lv_case_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "case", + lv_case_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ( + ( + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + } + lv_then_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + $current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + | + ( + ( + lv_fallThrough_6_0=',' + { + newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXCasePartRule()); + } + setWithLastConsumed($current, "fallThrough", lv_fallThrough_6_0 != null, ","); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleXForLoopExpression +entryRuleXForLoopExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXForLoopExpressionRule()); } + iv_ruleXForLoopExpression=ruleXForLoopExpression + { $current=$iv_ruleXForLoopExpression.current; } + EOF; + +// Rule XForLoopExpression +ruleXForLoopExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + 'for' + '(' + ( + ( + ruleJvmFormalParameter + ) + ) + ':' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(), + $current); + } + ) + otherlv_1='for' + { + newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + } + lv_declaredParam_3_0=ruleJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=':' + { + newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + } + lv_forExpression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "forExpression", + lv_forExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + } + lv_eachExpression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + $current, + "eachExpression", + lv_eachExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXBasicForLoopExpression +entryRuleXBasicForLoopExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); } + iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression + { $current=$iv_ruleXBasicForLoopExpression.current; } + EOF; + +// Rule XBasicForLoopExpression +ruleXBasicForLoopExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(), + $current); + } + ) + otherlv_1='for' + { + newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + } + lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "initExpressions", + lv_initExpressions_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_4=',' + { + newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + } + lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "initExpressions", + lv_initExpressions_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_6=';' + { + newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + } + lv_expression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + $current, + "expression", + lv_expression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + )? + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + } + lv_updateExpressions_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "updateExpressions", + lv_updateExpressions_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_10=',' + { + newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + } + lv_updateExpressions_11_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + $current, + "updateExpressions", + lv_updateExpressions_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_12=')' + { + newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + } + lv_eachExpression_13_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + $current, + "eachExpression", + lv_eachExpression_13_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXWhileExpression +entryRuleXWhileExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXWhileExpressionRule()); } + iv_ruleXWhileExpression=ruleXWhileExpression + { $current=$iv_ruleXWhileExpression.current; } + EOF; + +// Rule XWhileExpression +ruleXWhileExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(), + $current); + } + ) + otherlv_1='while' + { + newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + } + lv_predicate_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + $current, + "predicate", + lv_predicate_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + } + lv_body_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + $current, + "body", + lv_body_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXDoWhileExpression +entryRuleXDoWhileExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); } + iv_ruleXDoWhileExpression=ruleXDoWhileExpression + { $current=$iv_ruleXDoWhileExpression.current; } + EOF; + +// Rule XDoWhileExpression +ruleXDoWhileExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(), + $current); + } + ) + otherlv_1='do' + { + newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + } + lv_body_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + $current, + "body", + lv_body_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3='while' + { + newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + } + otherlv_4='(' + { + newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + } + lv_predicate_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + $current, + "predicate", + lv_predicate_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_6=')' + { + newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + } + ) +; + +// Entry rule entryRuleXBlockExpression +entryRuleXBlockExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBlockExpressionRule()); } + iv_ruleXBlockExpression=ruleXBlockExpression + { $current=$iv_ruleXBlockExpression.current; } + EOF; + +// Rule XBlockExpression +ruleXBlockExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(), + $current); + } + ) + otherlv_1='{' + { + newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + } + lv_expressions_2_0=ruleXExpressionOrVarDeclaration + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXBlockExpressionRule()); + } + add( + $current, + "expressions", + lv_expressions_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=';' + { + newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + } + )? + )* + otherlv_4='}' + { + newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + } + ) +; + +// Entry rule entryRuleXExpressionOrVarDeclaration +entryRuleXExpressionOrVarDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); } + iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration + { $current=$iv_ruleXExpressionOrVarDeclaration.current; } + EOF; + +// Rule XExpressionOrVarDeclaration +ruleXExpressionOrVarDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + } + this_XVariableDeclaration_0=ruleXVariableDeclaration + { + $current = $this_XVariableDeclaration_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + } + this_XExpression_1=ruleXExpression + { + $current = $this_XExpression_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleXVariableDeclaration +entryRuleXVariableDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXVariableDeclarationRule()); } + iv_ruleXVariableDeclaration=ruleXVariableDeclaration + { $current=$iv_ruleXVariableDeclaration.current; } + EOF; + +// Rule XVariableDeclaration +ruleXVariableDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(), + $current); + } + ) + ( + ( + ( + lv_writeable_1_0='var' + { + newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXVariableDeclarationRule()); + } + setWithLastConsumed($current, "writeable", lv_writeable_1_0 != null, "var"); + } + ) + ) + | + otherlv_2='val' + { + newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + } + ) + ( + ( + (( + ( + ( + ruleJvmTypeReference + ) + ) + ( + ( + ruleValidID + ) + ) + ) + )=> + ( + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + } + lv_type_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + } + lv_name_4_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "name", + lv_name_4_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + } + lv_name_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "name", + lv_name_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_6='=' + { + newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + } + lv_right_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + $current, + "right", + lv_right_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) +; + +// Entry rule entryRuleJvmFormalParameter +entryRuleJvmFormalParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmFormalParameterRule()); } + iv_ruleJvmFormalParameter=ruleJvmFormalParameter + { $current=$iv_ruleJvmFormalParameter.current; } + EOF; + +// Rule JvmFormalParameter +ruleJvmFormalParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + lv_parameterType_0_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + $current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + )? + ( + ( + { + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + lv_name_1_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleFullJvmFormalParameter +entryRuleFullJvmFormalParameter returns [EObject current=null]: + { newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); } + iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter + { $current=$iv_ruleFullJvmFormalParameter.current; } + EOF; + +// Rule FullJvmFormalParameter +ruleFullJvmFormalParameter returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + } + lv_parameterType_0_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + $current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + } + lv_name_1_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + $current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXFeatureCall +entryRuleXFeatureCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFeatureCallRule()); } + iv_ruleXFeatureCall=ruleXFeatureCall + { $current=$iv_ruleXFeatureCall.current; } + EOF; + +// Rule XFeatureCall +ruleXFeatureCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(), + $current); + } + ) + ( + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_typeArguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_typeArguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + } + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + } + ruleIdOrSuper + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitOperationCall_7_0='(' + { + newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + setWithLastConsumed($current, "explicitOperationCall", lv_explicitOperationCall_7_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + } + lv_featureCallArguments_8_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_8_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + } + lv_featureCallArguments_9_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_10=',' + { + newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + } + lv_featureCallArguments_11_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_12=')' + { + newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + } + lv_featureCallArguments_13_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + $current, + "featureCallArguments", + lv_featureCallArguments_13_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleFeatureCallID +entryRuleFeatureCallID returns [String current=null]: + { newCompositeNode(grammarAccess.getFeatureCallIDRule()); } + iv_ruleFeatureCallID=ruleFeatureCallID + { $current=$iv_ruleFeatureCallID.current.getText(); } + EOF; + +// Rule FeatureCallID +ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + | + kw='extends' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + } + | + kw='static' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + } + | + kw='import' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + } + | + kw='extension' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + } + ) +; + +// Entry rule entryRuleIdOrSuper +entryRuleIdOrSuper returns [String current=null]: + { newCompositeNode(grammarAccess.getIdOrSuperRule()); } + iv_ruleIdOrSuper=ruleIdOrSuper + { $current=$iv_ruleIdOrSuper.current.getText(); } + EOF; + +// Rule IdOrSuper +ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + } + this_FeatureCallID_0=ruleFeatureCallID + { + $current.merge(this_FeatureCallID_0); + } + { + afterParserOrEnumRuleCall(); + } + | + kw='super' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + } + ) +; + +// Entry rule entryRuleXConstructorCall +entryRuleXConstructorCall returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXConstructorCallRule()); } + iv_ruleXConstructorCall=ruleXConstructorCall + { $current=$iv_ruleXConstructorCall.current; } + EOF; + +// Rule XConstructorCall +ruleXConstructorCall returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(), + $current); + } + ) + otherlv_1='new' + { + newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + } + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_3='<' + { + newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + } + lv_typeArguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_5=',' + { + newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + } + lv_typeArguments_6_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "typeArguments", + lv_typeArguments_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_7='>' + { + newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + } + )? + ( + ( + (( + '(' + ) + )=> + ( + lv_explicitConstructorCall_8_0='(' + { + newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + setWithLastConsumed($current, "explicitConstructorCall", lv_explicitConstructorCall_8_0 != null, "("); + } + ) + ) + ( + ( + (( + ( + ) + ( + ( + ( + ruleJvmFormalParameter + ) + ) + ( + ',' + ( + ( + ruleJvmFormalParameter + ) + ) + )* + )? + ( + ( + '|' + ) + ) + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + } + lv_arguments_9_0=ruleXShortClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + } + lv_arguments_10_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + } + lv_arguments_12_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + ) + )? + otherlv_13=')' + { + newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + } + )? + ( + (( + ( + ) + '[' + ) + )=> + ( + { + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + } + lv_arguments_14_0=ruleXClosure + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + $current, + "arguments", + lv_arguments_14_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleXBooleanLiteral +entryRuleXBooleanLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXBooleanLiteralRule()); } + iv_ruleXBooleanLiteral=ruleXBooleanLiteral + { $current=$iv_ruleXBooleanLiteral.current; } + EOF; + +// Rule XBooleanLiteral +ruleXBooleanLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(), + $current); + } + ) + ( + otherlv_1='false' + { + newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + } + | + ( + ( + lv_isTrue_2_0='true' + { + newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXBooleanLiteralRule()); + } + setWithLastConsumed($current, "isTrue", lv_isTrue_2_0 != null, "true"); + } + ) + ) + ) + ) +; + +// Entry rule entryRuleXNullLiteral +entryRuleXNullLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXNullLiteralRule()); } + iv_ruleXNullLiteral=ruleXNullLiteral + { $current=$iv_ruleXNullLiteral.current; } + EOF; + +// Rule XNullLiteral +ruleXNullLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(), + $current); + } + ) + otherlv_1='null' + { + newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + } + ) +; + +// Entry rule entryRuleXNumberLiteral +entryRuleXNumberLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXNumberLiteralRule()); } + iv_ruleXNumberLiteral=ruleXNumberLiteral + { $current=$iv_ruleXNumberLiteral.current; } + EOF; + +// Rule XNumberLiteral +ruleXNumberLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(), + $current); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + } + lv_value_1_0=ruleNumber + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXNumberLiteralRule()); + } + set( + $current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xbase.Number"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXStringLiteral +entryRuleXStringLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXStringLiteralRule()); } + iv_ruleXStringLiteral=ruleXStringLiteral + { $current=$iv_ruleXStringLiteral.current; } + EOF; + +// Rule XStringLiteral +ruleXStringLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(), + $current); + } + ) + ( + ( + lv_value_1_0=RULE_STRING + { + newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXStringLiteralRule()); + } + setWithLastConsumed( + $current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + } + ) + ) + ) +; + +// Entry rule entryRuleXTypeLiteral +entryRuleXTypeLiteral returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXTypeLiteralRule()); } + iv_ruleXTypeLiteral=ruleXTypeLiteral + { $current=$iv_ruleXTypeLiteral.current; } + EOF; + +// Rule XTypeLiteral +ruleXTypeLiteral returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(), + $current); + } + ) + otherlv_1='typeof' + { + newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + } + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXTypeLiteralRule()); + } + } + { + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + } + lv_arrayDimensions_4_0=ruleArrayBrackets + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTypeLiteralRule()); + } + add( + $current, + "arrayDimensions", + lv_arrayDimensions_4_0, + "org.eclipse.xtext.xbase.Xtype.ArrayBrackets"); + afterParserOrEnumRuleCall(); + } + ) + )* + otherlv_5=')' + { + newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + } + ) +; + +// Entry rule entryRuleXThrowExpression +entryRuleXThrowExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXThrowExpressionRule()); } + iv_ruleXThrowExpression=ruleXThrowExpression + { $current=$iv_ruleXThrowExpression.current; } + EOF; + +// Rule XThrowExpression +ruleXThrowExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(), + $current); + } + ) + otherlv_1='throw' + { + newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXThrowExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXReturnExpression +entryRuleXReturnExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXReturnExpressionRule()); } + iv_ruleXReturnExpression=ruleXReturnExpression + { $current=$iv_ruleXReturnExpression.current; } + EOF; + +// Rule XReturnExpression +ruleXReturnExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(), + $current); + } + ) + otherlv_1='return' + { + newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + } + ( + ('extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING)=> + ( + { + newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXReturnExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + )? + ) +; + +// Entry rule entryRuleXTryCatchFinallyExpression +entryRuleXTryCatchFinallyExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); } + iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression + { $current=$iv_ruleXTryCatchFinallyExpression.current; } + EOF; + +// Rule XTryCatchFinallyExpression +ruleXTryCatchFinallyExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(), + $current); + } + ) + otherlv_1='try' + { + newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + } + lv_expression_2_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + ('catch')=> + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + } + lv_catchClauses_3_0=ruleXCatchClause + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + add( + $current, + "catchClauses", + lv_catchClauses_3_0, + "org.eclipse.xtext.xbase.Xbase.XCatchClause"); + afterParserOrEnumRuleCall(); + } + ) + )+ + ( + ( + ('finally')=> + otherlv_4='finally' + { + newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + } + lv_finallyExpression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "finallyExpression", + lv_finallyExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + )? + ) + | + ( + otherlv_6='finally' + { + newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + } + lv_finallyExpression_7_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + $current, + "finallyExpression", + lv_finallyExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + ) +; + +// Entry rule entryRuleXSynchronizedExpression +entryRuleXSynchronizedExpression returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); } + iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression + { $current=$iv_ruleXSynchronizedExpression.current; } + EOF; + +// Rule XSynchronizedExpression +ruleXSynchronizedExpression returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + (( + ( + ) + 'synchronized' + '(' + ) + )=> + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(), + $current); + } + ) + otherlv_1='synchronized' + { + newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + } + otherlv_2='(' + { + newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + } + lv_param_3_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + $current, + "param", + lv_param_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + } + lv_expression_5_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + $current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleXCatchClause +entryRuleXCatchClause returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXCatchClauseRule()); } + iv_ruleXCatchClause=ruleXCatchClause + { $current=$iv_ruleXCatchClause.current; } + EOF; + +// Rule XCatchClause +ruleXCatchClause returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ('catch')=> + otherlv_0='catch' + { + newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + } + ) + otherlv_1='(' + { + newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + } + lv_declaredParam_2_0=ruleFullJvmFormalParameter + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + $current, + "declaredParam", + lv_declaredParam_2_0, + "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter"); + afterParserOrEnumRuleCall(); + } + ) + ) + otherlv_3=')' + { + newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + } + lv_expression_4_0=ruleXExpression + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + $current, + "expression", + lv_expression_4_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedName +entryRuleQualifiedName returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameRule()); } + iv_ruleQualifiedName=ruleQualifiedName + { $current=$iv_ruleQualifiedName.current.getText(); } + EOF; + +// Rule QualifiedName +ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + ( + ( + ('.')=> + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + } + ) + { + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + } + this_ValidID_2=ruleValidID + { + $current.merge(this_ValidID_2); + } + { + afterParserOrEnumRuleCall(); + } + )* + ) +; + +// Entry rule entryRuleNumber +entryRuleNumber returns [String current=null]@init { + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +}: + { newCompositeNode(grammarAccess.getNumberRule()); } + iv_ruleNumber=ruleNumber + { $current=$iv_ruleNumber.current.getText(); } + EOF; +finally { + myHiddenTokenState.restore(); +} + +// Rule Number +ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); +} +@after { + leaveRule(); +}: + ( + this_HEX_0=RULE_HEX + { + $current.merge(this_HEX_0); + } + { + newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + } + | + ( + ( + this_INT_1=RULE_INT + { + $current.merge(this_INT_1); + } + { + newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + } + | + this_DECIMAL_2=RULE_DECIMAL + { + $current.merge(this_DECIMAL_2); + } + { + newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + } + ) + ( + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + } + ( + this_INT_4=RULE_INT + { + $current.merge(this_INT_4); + } + { + newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + } + | + this_DECIMAL_5=RULE_DECIMAL + { + $current.merge(this_DECIMAL_5); + } + { + newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + } + ) + )? + ) + ) +; +finally { + myHiddenTokenState.restore(); +} + +// Entry rule entryRuleJvmTypeReference +entryRuleJvmTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); } + iv_ruleJvmTypeReference=ruleJvmTypeReference + { $current=$iv_ruleJvmTypeReference.current; } + EOF; + +// Rule JvmTypeReference +ruleJvmTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + } + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference + { + $current = $this_JvmParameterizedTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + ( + (( + ( + ) + ruleArrayBrackets + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + $current); + } + ) + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + } + ruleArrayBrackets + { + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + { + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + } + this_XFunctionTypeRef_3=ruleXFunctionTypeRef + { + $current = $this_XFunctionTypeRef_3.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleArrayBrackets +entryRuleArrayBrackets returns [String current=null]: + { newCompositeNode(grammarAccess.getArrayBracketsRule()); } + iv_ruleArrayBrackets=ruleArrayBrackets + { $current=$iv_ruleArrayBrackets.current.getText(); } + EOF; + +// Rule ArrayBrackets +ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + kw='[' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + } + kw=']' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + } + ) +; + +// Entry rule entryRuleXFunctionTypeRef +entryRuleXFunctionTypeRef returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); } + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef + { $current=$iv_ruleXFunctionTypeRef.current; } + EOF; + +// Rule XFunctionTypeRef +ruleXFunctionTypeRef returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + otherlv_0='(' + { + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + } + ( + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + } + lv_paramTypes_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_2=',' + { + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + } + lv_paramTypes_3_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + $current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + )? + otherlv_4=')' + { + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + } + )? + otherlv_5='=>' + { + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + } + ( + ( + { + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + } + lv_returnType_6_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + $current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmParameterizedTypeReference +entryRuleJvmParameterizedTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); } + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference + { $current=$iv_ruleJvmParameterizedTypeReference.current; } + EOF; + +// Rule JvmParameterizedTypeReference +ruleJvmParameterizedTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_1='<' + { + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + } + lv_arguments_2_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_3=',' + { + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + } + lv_arguments_4_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_5='>' + { + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + } + ( + ( + (( + ( + ) + '.' + ) + )=> + ( + ( + { + $current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + $current); + } + ) + otherlv_7='.' + { + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + } + ) + ) + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + } + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + } + ruleValidID + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ('<')=> + otherlv_9='<' + { + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + } + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + } + lv_arguments_10_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + otherlv_11=',' + { + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + } + lv_arguments_12_0=ruleJvmArgumentTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + $current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + )* + otherlv_13='>' + { + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + } + )? + )* + )? + ) +; + +// Entry rule entryRuleJvmArgumentTypeReference +entryRuleJvmArgumentTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); } + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference + { $current=$iv_ruleJvmArgumentTypeReference.current; } + EOF; + +// Rule JvmArgumentTypeReference +ruleJvmArgumentTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + } + this_JvmTypeReference_0=ruleJvmTypeReference + { + $current = $this_JvmTypeReference_0.current; + afterParserOrEnumRuleCall(); + } + | + { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + } + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference + { + $current = $this_JvmWildcardTypeReference_1.current; + afterParserOrEnumRuleCall(); + } + ) +; + +// Entry rule entryRuleJvmWildcardTypeReference +entryRuleJvmWildcardTypeReference returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); } + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference + { $current=$iv_ruleJvmWildcardTypeReference.current; } + EOF; + +// Rule JvmWildcardTypeReference +ruleJvmWildcardTypeReference returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + ( + { + $current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + $current); + } + ) + otherlv_1='?' + { + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + } + ( + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + } + lv_constraints_2_0=ruleJvmUpperBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + } + lv_constraints_3_0=ruleJvmUpperBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + | + ( + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + } + lv_constraints_4_0=ruleJvmLowerBound + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + } + lv_constraints_5_0=ruleJvmLowerBoundAnded + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + $current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + } + ) + )* + ) + )? + ) +; + +// Entry rule entryRuleJvmUpperBound +entryRuleJvmUpperBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundRule()); } + iv_ruleJvmUpperBound=ruleJvmUpperBound + { $current=$iv_ruleJvmUpperBound.current; } + EOF; + +// Rule JvmUpperBound +ruleJvmUpperBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='extends' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmUpperBoundAnded +entryRuleJvmUpperBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); } + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded + { $current=$iv_ruleJvmUpperBoundAnded.current; } + EOF; + +// Rule JvmUpperBoundAnded +ruleJvmUpperBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBound +entryRuleJvmLowerBound returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundRule()); } + iv_ruleJvmLowerBound=ruleJvmLowerBound + { $current=$iv_ruleJvmLowerBound.current; } + EOF; + +// Rule JvmLowerBound +ruleJvmLowerBound returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='super' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleJvmLowerBoundAnded +entryRuleJvmLowerBoundAnded returns [EObject current=null]: + { newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); } + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded + { $current=$iv_ruleJvmLowerBoundAnded.current; } + EOF; + +// Rule JvmLowerBoundAnded +ruleJvmLowerBoundAnded returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='&' + { + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + } + ( + ( + { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + } + lv_typeReference_1_0=ruleJvmTypeReference + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + $current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) +; + +// Entry rule entryRuleQualifiedNameWithWildcard +entryRuleQualifiedNameWithWildcard returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); } + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard + { $current=$iv_ruleQualifiedNameWithWildcard.current.getText(); } + EOF; + +// Rule QualifiedNameWithWildcard +ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + } + this_QualifiedName_0=ruleQualifiedName + { + $current.merge(this_QualifiedName_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + } + kw='*' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + } + ) +; + +// Entry rule entryRuleValidID +entryRuleValidID returns [String current=null]: + { newCompositeNode(grammarAccess.getValidIDRule()); } + iv_ruleValidID=ruleValidID + { $current=$iv_ruleValidID.current.getText(); } + EOF; + +// Rule ValidID +ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + this_ID_0=RULE_ID + { + $current.merge(this_ID_0); + } + { + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + } +; + +// Entry rule entryRuleXImportDeclaration +entryRuleXImportDeclaration returns [EObject current=null]: + { newCompositeNode(grammarAccess.getXImportDeclarationRule()); } + iv_ruleXImportDeclaration=ruleXImportDeclaration + { $current=$iv_ruleXImportDeclaration.current; } + EOF; + +// Rule XImportDeclaration +ruleXImportDeclaration returns [EObject current=null] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + otherlv_0='import' + { + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + } + ( + ( + ( + ( + lv_static_1_0='static' + { + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "static", lv_static_1_0 != null, "static"); + } + ) + ) + ( + ( + lv_extension_2_0='extension' + { + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "extension", lv_extension_2_0 != null, "extension"); + } + ) + )? + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + } + ruleQualifiedNameInStaticImport + { + afterParserOrEnumRuleCall(); + } + ) + ) + ( + ( + ( + lv_wildcard_4_0='*' + { + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + } + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed($current, "wildcard", lv_wildcard_4_0 != null, "*"); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + } + lv_memberName_5_0=ruleValidID + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ) + | + ( + ( + { + if ($current==null) { + $current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + } + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + } + ruleQualifiedName + { + afterParserOrEnumRuleCall(); + } + ) + ) + | + ( + ( + { + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + } + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard + { + if ($current==null) { + $current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + $current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + } + ) + ) + ) + ( + otherlv_8=';' + { + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + } + )? + ) +; + +// Entry rule entryRuleQualifiedNameInStaticImport +entryRuleQualifiedNameInStaticImport returns [String current=null]: + { newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); } + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport + { $current=$iv_ruleQualifiedNameInStaticImport.current.getText(); } + EOF; + +// Rule QualifiedNameInStaticImport +ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] +@init { + enterRule(); +} +@after { + leaveRule(); +}: + ( + { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + } + this_ValidID_0=ruleValidID + { + $current.merge(this_ValidID_0); + } + { + afterParserOrEnumRuleCall(); + } + kw='.' + { + $current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + } + )+ +; + // Rule Casing ruleCasing returns [Enumerator current=null] @init { @@ -4624,11 +10906,15 @@ ruleCasing returns [Enumerator current=null] RULE_REAL : ('0'..'9')* '.' ('0'..'9')*; -RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; +RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?; + +RULE_INT : '0'..'9' ('0'..'9'|'_')*; + +RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?; -RULE_INT : ('0'..'9')+; +RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; -RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\''); +RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?); RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/'; diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.tokens b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.tokens index fca4fcb8ef..10e085ceb1 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.tokens +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScope.tokens @@ -1,88 +1,145 @@ -'!'=67 -'!='=59 -'#'=27 -'&&'=56 -'('=25 -')'=26 -'*'=30 -'+'=64 -','=35 -'-'=65 -'->'=48 -'.'=45 -'/'=66 -':'=47 -'::'=44 -';'=23 -'<'=63 -'<='=61 -'='=22 -'=='=58 -'>'=62 -'>='=60 -'>>'=29 -'?'=49 -'Collection'=82 -'GLOBALVAR'=80 -'List'=83 -'Set'=84 -'['=31 -']'=32 -'as'=15 -'case'=18 -'collect'=69 -'context'=28 -'data'=40 -'default'=54 -'domains'=41 -'else'=52 -'exists'=73 -'export'=43 -'extension'=16 -'factory'=33 -'false'=78 -'find'=36 -'forAll'=76 -'if'=50 -'implies'=57 -'import'=14 -'inject'=17 -'insensitive'=86 -'key'=37 -'let'=46 -'naming'=19 -'new'=81 -'notExists'=74 -'null'=79 -'prefix'=39 -'recursive'=38 -'reject'=72 -'scope'=24 -'scopeof'=34 -'scoping'=12 -'select'=70 -'selectFirst'=71 -'sensitive'=85 -'sortBy'=75 -'switch'=53 -'then'=51 -'true'=77 -'typeSelect'=68 -'with'=13 -'{'=20 -'|'=42 -'||'=55 -'}'=21 -RULE_ANY_OTHER=11 +'!'=69 +'!='=61 +'!=='=93 +'#'=29 +'%'=101 +'%='=91 +'&&'=58 +'&'=120 +'('=27 +')'=28 +'*'=32 +'**'=100 +'*='=89 +'+'=66 +'++'=102 +'+='=87 +','=37 +'-'=67 +'--'=103 +'-='=88 +'->'=50 +'.'=47 +'..'=96 +'..<'=95 +'/'=68 +'/='=90 +':'=49 +'::'=46 +';'=25 +'<'=65 +'<='=63 +'<>'=98 +'='=24 +'=='=60 +'==='=92 +'=>'=97 +'>'=64 +'>='=62 +'>>'=31 +'?'=51 +'?.'=104 +'?:'=99 +'Collection'=84 +'GLOBALVAR'=82 +'List'=85 +'Set'=86 +'['=33 +']'=34 +'as'=17 +'case'=20 +'catch'=119 +'collect'=71 +'context'=30 +'data'=42 +'default'=56 +'do'=107 +'domains'=43 +'else'=54 +'exists'=75 +'export'=45 +'extends'=110 +'extension'=18 +'factory'=35 +'false'=80 +'finally'=117 +'find'=38 +'for'=105 +'forAll'=78 +'if'=52 +'implies'=59 +'import'=16 +'inject'=19 +'insensitive'=122 +'instanceof'=94 +'key'=39 +'let'=48 +'naming'=21 +'new'=83 +'notExists'=76 +'null'=81 +'prefix'=41 +'recursive'=40 +'reject'=74 +'return'=115 +'scope'=26 +'scopeof'=36 +'scoping'=14 +'select'=72 +'selectFirst'=73 +'sensitive'=121 +'sortBy'=77 +'static'=111 +'super'=112 +'switch'=55 +'synchronized'=118 +'then'=53 +'throw'=114 +'true'=79 +'try'=116 +'typeSelect'=70 +'typeof'=113 +'val'=109 +'var'=108 +'while'=106 +'with'=15 +'{'=22 +'|'=44 +'||'=57 +'}'=23 +RULE_ANY_OTHER=13 +RULE_DECIMAL=9 +RULE_HEX=8 RULE_ID=7 RULE_INT=5 -RULE_ML_COMMENT=8 +RULE_ML_COMMENT=10 RULE_REAL=6 -RULE_SL_COMMENT=9 +RULE_SL_COMMENT=11 RULE_STRING=4 -RULE_WS=10 -T__12=12 -T__13=13 +RULE_WS=12 +T__100=100 +T__101=101 +T__102=102 +T__103=103 +T__104=104 +T__105=105 +T__106=106 +T__107=107 +T__108=108 +T__109=109 +T__110=110 +T__111=111 +T__112=112 +T__113=113 +T__114=114 +T__115=115 +T__116=116 +T__117=117 +T__118=118 +T__119=119 +T__120=120 +T__121=121 +T__122=122 T__14=14 T__15=15 T__16=16 @@ -156,3 +213,16 @@ T__83=83 T__84=84 T__85=85 T__86=86 +T__87=87 +T__88=88 +T__89=89 +T__90=90 +T__91=91 +T__92=92 +T__93=93 +T__94=94 +T__95=95 +T__96=96 +T__97=97 +T__98=98 +T__99=99 diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeLexer.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeLexer.java index 38e7d80ffa..e63e63c2e2 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeLexer.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeLexer.java @@ -12,19 +12,12 @@ @SuppressWarnings("all") public class InternalScopeLexer extends Lexer { + public static final int RULE_HEX=8; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -34,55 +27,26 @@ public class InternalScopeLexer extends Lexer { public static final int T__61=61; public static final int RULE_ID=7; public static final int RULE_REAL=6; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; public static final int RULE_INT=5; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=4; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int T__82=82; - public static final int T__83=83; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -90,12 +54,84 @@ public class InternalScopeLexer extends Lexer { public static final int T__46=46; public static final int T__47=47; public static final int T__40=40; - public static final int T__84=84; public static final int T__41=41; - public static final int T__85=85; public static final int T__42=42; - public static final int T__86=86; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__122=122; + public static final int T__70=70; + public static final int T__121=121; + public static final int T__71=71; + public static final int T__72=72; + public static final int T__120=120; + public static final int RULE_STRING=4; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__119=119; + public static final int T__78=78; + public static final int T__118=118; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -110,57 +146,15 @@ public InternalScopeLexer(CharStream input, RecognizerSharedState state) { } public String getGrammarFileName() { return "InternalScope.g"; } - // $ANTLR start "T__12" - public final void mT__12() throws RecognitionException { - try { - int _type = T__12; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:11:7: ( 'scoping' ) - // InternalScope.g:11:9: 'scoping' - { - match("scoping"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__12" - - // $ANTLR start "T__13" - public final void mT__13() throws RecognitionException { - try { - int _type = T__13; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:12:7: ( 'with' ) - // InternalScope.g:12:9: 'with' - { - match("with"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__13" - // $ANTLR start "T__14" public final void mT__14() throws RecognitionException { try { int _type = T__14; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:13:7: ( 'import' ) - // InternalScope.g:13:9: 'import' + // InternalScope.g:11:7: ( 'scoping' ) + // InternalScope.g:11:9: 'scoping' { - match("import"); + match("scoping"); } @@ -178,10 +172,10 @@ public final void mT__15() throws RecognitionException { try { int _type = T__15; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:14:7: ( 'as' ) - // InternalScope.g:14:9: 'as' + // InternalScope.g:12:7: ( 'with' ) + // InternalScope.g:12:9: 'with' { - match("as"); + match("with"); } @@ -199,10 +193,10 @@ public final void mT__16() throws RecognitionException { try { int _type = T__16; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:15:7: ( 'extension' ) - // InternalScope.g:15:9: 'extension' + // InternalScope.g:13:7: ( 'import' ) + // InternalScope.g:13:9: 'import' { - match("extension"); + match("import"); } @@ -220,10 +214,10 @@ public final void mT__17() throws RecognitionException { try { int _type = T__17; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:16:7: ( 'inject' ) - // InternalScope.g:16:9: 'inject' + // InternalScope.g:14:7: ( 'as' ) + // InternalScope.g:14:9: 'as' { - match("inject"); + match("as"); } @@ -241,10 +235,10 @@ public final void mT__18() throws RecognitionException { try { int _type = T__18; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:17:7: ( 'case' ) - // InternalScope.g:17:9: 'case' + // InternalScope.g:15:7: ( 'extension' ) + // InternalScope.g:15:9: 'extension' { - match("case"); + match("extension"); } @@ -262,10 +256,10 @@ public final void mT__19() throws RecognitionException { try { int _type = T__19; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:18:7: ( 'naming' ) - // InternalScope.g:18:9: 'naming' + // InternalScope.g:16:7: ( 'inject' ) + // InternalScope.g:16:9: 'inject' { - match("naming"); + match("inject"); } @@ -283,10 +277,11 @@ public final void mT__20() throws RecognitionException { try { int _type = T__20; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:19:7: ( '{' ) - // InternalScope.g:19:9: '{' + // InternalScope.g:17:7: ( 'case' ) + // InternalScope.g:17:9: 'case' { - match('{'); + match("case"); + } @@ -303,10 +298,11 @@ public final void mT__21() throws RecognitionException { try { int _type = T__21; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:20:7: ( '}' ) - // InternalScope.g:20:9: '}' + // InternalScope.g:18:7: ( 'naming' ) + // InternalScope.g:18:9: 'naming' { - match('}'); + match("naming"); + } @@ -323,10 +319,10 @@ public final void mT__22() throws RecognitionException { try { int _type = T__22; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:21:7: ( '=' ) - // InternalScope.g:21:9: '=' + // InternalScope.g:19:7: ( '{' ) + // InternalScope.g:19:9: '{' { - match('='); + match('{'); } @@ -343,10 +339,10 @@ public final void mT__23() throws RecognitionException { try { int _type = T__23; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:22:7: ( ';' ) - // InternalScope.g:22:9: ';' + // InternalScope.g:20:7: ( '}' ) + // InternalScope.g:20:9: '}' { - match(';'); + match('}'); } @@ -363,11 +359,10 @@ public final void mT__24() throws RecognitionException { try { int _type = T__24; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:23:7: ( 'scope' ) - // InternalScope.g:23:9: 'scope' + // InternalScope.g:21:7: ( '=' ) + // InternalScope.g:21:9: '=' { - match("scope"); - + match('='); } @@ -384,10 +379,10 @@ public final void mT__25() throws RecognitionException { try { int _type = T__25; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:24:7: ( '(' ) - // InternalScope.g:24:9: '(' + // InternalScope.g:22:7: ( ';' ) + // InternalScope.g:22:9: ';' { - match('('); + match(';'); } @@ -404,10 +399,11 @@ public final void mT__26() throws RecognitionException { try { int _type = T__26; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:25:7: ( ')' ) - // InternalScope.g:25:9: ')' + // InternalScope.g:23:7: ( 'scope' ) + // InternalScope.g:23:9: 'scope' { - match(')'); + match("scope"); + } @@ -424,10 +420,10 @@ public final void mT__27() throws RecognitionException { try { int _type = T__27; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:26:7: ( '#' ) - // InternalScope.g:26:9: '#' + // InternalScope.g:24:7: ( '(' ) + // InternalScope.g:24:9: '(' { - match('#'); + match('('); } @@ -444,11 +440,10 @@ public final void mT__28() throws RecognitionException { try { int _type = T__28; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:27:7: ( 'context' ) - // InternalScope.g:27:9: 'context' + // InternalScope.g:25:7: ( ')' ) + // InternalScope.g:25:9: ')' { - match("context"); - + match(')'); } @@ -465,11 +460,10 @@ public final void mT__29() throws RecognitionException { try { int _type = T__29; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:28:7: ( '>>' ) - // InternalScope.g:28:9: '>>' + // InternalScope.g:26:7: ( '#' ) + // InternalScope.g:26:9: '#' { - match(">>"); - + match('#'); } @@ -486,10 +480,11 @@ public final void mT__30() throws RecognitionException { try { int _type = T__30; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:29:7: ( '*' ) - // InternalScope.g:29:9: '*' + // InternalScope.g:27:7: ( 'context' ) + // InternalScope.g:27:9: 'context' { - match('*'); + match("context"); + } @@ -506,10 +501,11 @@ public final void mT__31() throws RecognitionException { try { int _type = T__31; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:30:7: ( '[' ) - // InternalScope.g:30:9: '[' + // InternalScope.g:28:7: ( '>>' ) + // InternalScope.g:28:9: '>>' { - match('['); + match(">>"); + } @@ -526,10 +522,10 @@ public final void mT__32() throws RecognitionException { try { int _type = T__32; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:31:7: ( ']' ) - // InternalScope.g:31:9: ']' + // InternalScope.g:29:7: ( '*' ) + // InternalScope.g:29:9: '*' { - match(']'); + match('*'); } @@ -546,11 +542,10 @@ public final void mT__33() throws RecognitionException { try { int _type = T__33; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:32:7: ( 'factory' ) - // InternalScope.g:32:9: 'factory' + // InternalScope.g:30:7: ( '[' ) + // InternalScope.g:30:9: '[' { - match("factory"); - + match('['); } @@ -567,11 +562,10 @@ public final void mT__34() throws RecognitionException { try { int _type = T__34; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:33:7: ( 'scopeof' ) - // InternalScope.g:33:9: 'scopeof' + // InternalScope.g:31:7: ( ']' ) + // InternalScope.g:31:9: ']' { - match("scopeof"); - + match(']'); } @@ -588,10 +582,11 @@ public final void mT__35() throws RecognitionException { try { int _type = T__35; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:34:7: ( ',' ) - // InternalScope.g:34:9: ',' + // InternalScope.g:32:7: ( 'factory' ) + // InternalScope.g:32:9: 'factory' { - match(','); + match("factory"); + } @@ -608,10 +603,10 @@ public final void mT__36() throws RecognitionException { try { int _type = T__36; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:35:7: ( 'find' ) - // InternalScope.g:35:9: 'find' + // InternalScope.g:33:7: ( 'scopeof' ) + // InternalScope.g:33:9: 'scopeof' { - match("find"); + match("scopeof"); } @@ -629,11 +624,10 @@ public final void mT__37() throws RecognitionException { try { int _type = T__37; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:36:7: ( 'key' ) - // InternalScope.g:36:9: 'key' - { - match("key"); - + // InternalScope.g:34:7: ( ',' ) + // InternalScope.g:34:9: ',' + { + match(','); } @@ -650,10 +644,10 @@ public final void mT__38() throws RecognitionException { try { int _type = T__38; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:37:7: ( 'recursive' ) - // InternalScope.g:37:9: 'recursive' + // InternalScope.g:35:7: ( 'find' ) + // InternalScope.g:35:9: 'find' { - match("recursive"); + match("find"); } @@ -671,10 +665,10 @@ public final void mT__39() throws RecognitionException { try { int _type = T__39; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:38:7: ( 'prefix' ) - // InternalScope.g:38:9: 'prefix' + // InternalScope.g:36:7: ( 'key' ) + // InternalScope.g:36:9: 'key' { - match("prefix"); + match("key"); } @@ -692,10 +686,10 @@ public final void mT__40() throws RecognitionException { try { int _type = T__40; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:39:7: ( 'data' ) - // InternalScope.g:39:9: 'data' + // InternalScope.g:37:7: ( 'recursive' ) + // InternalScope.g:37:9: 'recursive' { - match("data"); + match("recursive"); } @@ -713,10 +707,10 @@ public final void mT__41() throws RecognitionException { try { int _type = T__41; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:40:7: ( 'domains' ) - // InternalScope.g:40:9: 'domains' + // InternalScope.g:38:7: ( 'prefix' ) + // InternalScope.g:38:9: 'prefix' { - match("domains"); + match("prefix"); } @@ -734,10 +728,11 @@ public final void mT__42() throws RecognitionException { try { int _type = T__42; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:41:7: ( '|' ) - // InternalScope.g:41:9: '|' + // InternalScope.g:39:7: ( 'data' ) + // InternalScope.g:39:9: 'data' { - match('|'); + match("data"); + } @@ -754,10 +749,10 @@ public final void mT__43() throws RecognitionException { try { int _type = T__43; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:42:7: ( 'export' ) - // InternalScope.g:42:9: 'export' + // InternalScope.g:40:7: ( 'domains' ) + // InternalScope.g:40:9: 'domains' { - match("export"); + match("domains"); } @@ -775,11 +770,10 @@ public final void mT__44() throws RecognitionException { try { int _type = T__44; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:43:7: ( '::' ) - // InternalScope.g:43:9: '::' + // InternalScope.g:41:7: ( '|' ) + // InternalScope.g:41:9: '|' { - match("::"); - + match('|'); } @@ -796,10 +790,11 @@ public final void mT__45() throws RecognitionException { try { int _type = T__45; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:44:7: ( '.' ) - // InternalScope.g:44:9: '.' + // InternalScope.g:42:7: ( 'export' ) + // InternalScope.g:42:9: 'export' { - match('.'); + match("export"); + } @@ -816,10 +811,10 @@ public final void mT__46() throws RecognitionException { try { int _type = T__46; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:45:7: ( 'let' ) - // InternalScope.g:45:9: 'let' + // InternalScope.g:43:7: ( '::' ) + // InternalScope.g:43:9: '::' { - match("let"); + match("::"); } @@ -837,10 +832,10 @@ public final void mT__47() throws RecognitionException { try { int _type = T__47; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:46:7: ( ':' ) - // InternalScope.g:46:9: ':' + // InternalScope.g:44:7: ( '.' ) + // InternalScope.g:44:9: '.' { - match(':'); + match('.'); } @@ -857,10 +852,10 @@ public final void mT__48() throws RecognitionException { try { int _type = T__48; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:47:7: ( '->' ) - // InternalScope.g:47:9: '->' + // InternalScope.g:45:7: ( 'let' ) + // InternalScope.g:45:9: 'let' { - match("->"); + match("let"); } @@ -878,10 +873,10 @@ public final void mT__49() throws RecognitionException { try { int _type = T__49; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:48:7: ( '?' ) - // InternalScope.g:48:9: '?' + // InternalScope.g:46:7: ( ':' ) + // InternalScope.g:46:9: ':' { - match('?'); + match(':'); } @@ -898,10 +893,10 @@ public final void mT__50() throws RecognitionException { try { int _type = T__50; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:49:7: ( 'if' ) - // InternalScope.g:49:9: 'if' + // InternalScope.g:47:7: ( '->' ) + // InternalScope.g:47:9: '->' { - match("if"); + match("->"); } @@ -919,11 +914,10 @@ public final void mT__51() throws RecognitionException { try { int _type = T__51; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:50:7: ( 'then' ) - // InternalScope.g:50:9: 'then' + // InternalScope.g:48:7: ( '?' ) + // InternalScope.g:48:9: '?' { - match("then"); - + match('?'); } @@ -940,10 +934,10 @@ public final void mT__52() throws RecognitionException { try { int _type = T__52; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:51:7: ( 'else' ) - // InternalScope.g:51:9: 'else' + // InternalScope.g:49:7: ( 'if' ) + // InternalScope.g:49:9: 'if' { - match("else"); + match("if"); } @@ -961,10 +955,10 @@ public final void mT__53() throws RecognitionException { try { int _type = T__53; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:52:7: ( 'switch' ) - // InternalScope.g:52:9: 'switch' + // InternalScope.g:50:7: ( 'then' ) + // InternalScope.g:50:9: 'then' { - match("switch"); + match("then"); } @@ -982,10 +976,10 @@ public final void mT__54() throws RecognitionException { try { int _type = T__54; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:53:7: ( 'default' ) - // InternalScope.g:53:9: 'default' + // InternalScope.g:51:7: ( 'else' ) + // InternalScope.g:51:9: 'else' { - match("default"); + match("else"); } @@ -1003,10 +997,10 @@ public final void mT__55() throws RecognitionException { try { int _type = T__55; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:54:7: ( '||' ) - // InternalScope.g:54:9: '||' + // InternalScope.g:52:7: ( 'switch' ) + // InternalScope.g:52:9: 'switch' { - match("||"); + match("switch"); } @@ -1024,10 +1018,10 @@ public final void mT__56() throws RecognitionException { try { int _type = T__56; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:55:7: ( '&&' ) - // InternalScope.g:55:9: '&&' + // InternalScope.g:53:7: ( 'default' ) + // InternalScope.g:53:9: 'default' { - match("&&"); + match("default"); } @@ -1045,10 +1039,10 @@ public final void mT__57() throws RecognitionException { try { int _type = T__57; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:56:7: ( 'implies' ) - // InternalScope.g:56:9: 'implies' + // InternalScope.g:54:7: ( '||' ) + // InternalScope.g:54:9: '||' { - match("implies"); + match("||"); } @@ -1066,10 +1060,10 @@ public final void mT__58() throws RecognitionException { try { int _type = T__58; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:57:7: ( '==' ) - // InternalScope.g:57:9: '==' + // InternalScope.g:55:7: ( '&&' ) + // InternalScope.g:55:9: '&&' { - match("=="); + match("&&"); } @@ -1087,10 +1081,10 @@ public final void mT__59() throws RecognitionException { try { int _type = T__59; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:58:7: ( '!=' ) - // InternalScope.g:58:9: '!=' + // InternalScope.g:56:7: ( 'implies' ) + // InternalScope.g:56:9: 'implies' { - match("!="); + match("implies"); } @@ -1108,10 +1102,10 @@ public final void mT__60() throws RecognitionException { try { int _type = T__60; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:59:7: ( '>=' ) - // InternalScope.g:59:9: '>=' + // InternalScope.g:57:7: ( '==' ) + // InternalScope.g:57:9: '==' { - match(">="); + match("=="); } @@ -1129,10 +1123,10 @@ public final void mT__61() throws RecognitionException { try { int _type = T__61; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:60:7: ( '<=' ) - // InternalScope.g:60:9: '<=' + // InternalScope.g:58:7: ( '!=' ) + // InternalScope.g:58:9: '!=' { - match("<="); + match("!="); } @@ -1150,10 +1144,11 @@ public final void mT__62() throws RecognitionException { try { int _type = T__62; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:61:7: ( '>' ) - // InternalScope.g:61:9: '>' + // InternalScope.g:59:7: ( '>=' ) + // InternalScope.g:59:9: '>=' { - match('>'); + match(">="); + } @@ -1170,10 +1165,11 @@ public final void mT__63() throws RecognitionException { try { int _type = T__63; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:62:7: ( '<' ) - // InternalScope.g:62:9: '<' + // InternalScope.g:60:7: ( '<=' ) + // InternalScope.g:60:9: '<=' { - match('<'); + match("<="); + } @@ -1190,10 +1186,10 @@ public final void mT__64() throws RecognitionException { try { int _type = T__64; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:63:7: ( '+' ) - // InternalScope.g:63:9: '+' + // InternalScope.g:61:7: ( '>' ) + // InternalScope.g:61:9: '>' { - match('+'); + match('>'); } @@ -1210,10 +1206,10 @@ public final void mT__65() throws RecognitionException { try { int _type = T__65; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:64:7: ( '-' ) - // InternalScope.g:64:9: '-' + // InternalScope.g:62:7: ( '<' ) + // InternalScope.g:62:9: '<' { - match('-'); + match('<'); } @@ -1230,10 +1226,10 @@ public final void mT__66() throws RecognitionException { try { int _type = T__66; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:65:7: ( '/' ) - // InternalScope.g:65:9: '/' + // InternalScope.g:63:7: ( '+' ) + // InternalScope.g:63:9: '+' { - match('/'); + match('+'); } @@ -1250,10 +1246,10 @@ public final void mT__67() throws RecognitionException { try { int _type = T__67; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:66:7: ( '!' ) - // InternalScope.g:66:9: '!' + // InternalScope.g:64:7: ( '-' ) + // InternalScope.g:64:9: '-' { - match('!'); + match('-'); } @@ -1270,11 +1266,10 @@ public final void mT__68() throws RecognitionException { try { int _type = T__68; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:67:7: ( 'typeSelect' ) - // InternalScope.g:67:9: 'typeSelect' + // InternalScope.g:65:7: ( '/' ) + // InternalScope.g:65:9: '/' { - match("typeSelect"); - + match('/'); } @@ -1291,11 +1286,10 @@ public final void mT__69() throws RecognitionException { try { int _type = T__69; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:68:7: ( 'collect' ) - // InternalScope.g:68:9: 'collect' + // InternalScope.g:66:7: ( '!' ) + // InternalScope.g:66:9: '!' { - match("collect"); - + match('!'); } @@ -1312,10 +1306,10 @@ public final void mT__70() throws RecognitionException { try { int _type = T__70; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:69:7: ( 'select' ) - // InternalScope.g:69:9: 'select' + // InternalScope.g:67:7: ( 'typeSelect' ) + // InternalScope.g:67:9: 'typeSelect' { - match("select"); + match("typeSelect"); } @@ -1333,10 +1327,10 @@ public final void mT__71() throws RecognitionException { try { int _type = T__71; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:70:7: ( 'selectFirst' ) - // InternalScope.g:70:9: 'selectFirst' + // InternalScope.g:68:7: ( 'collect' ) + // InternalScope.g:68:9: 'collect' { - match("selectFirst"); + match("collect"); } @@ -1354,10 +1348,10 @@ public final void mT__72() throws RecognitionException { try { int _type = T__72; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:71:7: ( 'reject' ) - // InternalScope.g:71:9: 'reject' + // InternalScope.g:69:7: ( 'select' ) + // InternalScope.g:69:9: 'select' { - match("reject"); + match("select"); } @@ -1375,10 +1369,10 @@ public final void mT__73() throws RecognitionException { try { int _type = T__73; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:72:7: ( 'exists' ) - // InternalScope.g:72:9: 'exists' + // InternalScope.g:70:7: ( 'selectFirst' ) + // InternalScope.g:70:9: 'selectFirst' { - match("exists"); + match("selectFirst"); } @@ -1396,10 +1390,10 @@ public final void mT__74() throws RecognitionException { try { int _type = T__74; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:73:7: ( 'notExists' ) - // InternalScope.g:73:9: 'notExists' + // InternalScope.g:71:7: ( 'reject' ) + // InternalScope.g:71:9: 'reject' { - match("notExists"); + match("reject"); } @@ -1417,10 +1411,10 @@ public final void mT__75() throws RecognitionException { try { int _type = T__75; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:74:7: ( 'sortBy' ) - // InternalScope.g:74:9: 'sortBy' + // InternalScope.g:72:7: ( 'exists' ) + // InternalScope.g:72:9: 'exists' { - match("sortBy"); + match("exists"); } @@ -1438,10 +1432,10 @@ public final void mT__76() throws RecognitionException { try { int _type = T__76; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:75:7: ( 'forAll' ) - // InternalScope.g:75:9: 'forAll' + // InternalScope.g:73:7: ( 'notExists' ) + // InternalScope.g:73:9: 'notExists' { - match("forAll"); + match("notExists"); } @@ -1459,10 +1453,10 @@ public final void mT__77() throws RecognitionException { try { int _type = T__77; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:76:7: ( 'true' ) - // InternalScope.g:76:9: 'true' + // InternalScope.g:74:7: ( 'sortBy' ) + // InternalScope.g:74:9: 'sortBy' { - match("true"); + match("sortBy"); } @@ -1480,10 +1474,10 @@ public final void mT__78() throws RecognitionException { try { int _type = T__78; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:77:7: ( 'false' ) - // InternalScope.g:77:9: 'false' + // InternalScope.g:75:7: ( 'forAll' ) + // InternalScope.g:75:9: 'forAll' { - match("false"); + match("forAll"); } @@ -1501,10 +1495,10 @@ public final void mT__79() throws RecognitionException { try { int _type = T__79; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:78:7: ( 'null' ) - // InternalScope.g:78:9: 'null' + // InternalScope.g:76:7: ( 'true' ) + // InternalScope.g:76:9: 'true' { - match("null"); + match("true"); } @@ -1522,10 +1516,10 @@ public final void mT__80() throws RecognitionException { try { int _type = T__80; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:79:7: ( 'GLOBALVAR' ) - // InternalScope.g:79:9: 'GLOBALVAR' + // InternalScope.g:77:7: ( 'false' ) + // InternalScope.g:77:9: 'false' { - match("GLOBALVAR"); + match("false"); } @@ -1543,10 +1537,10 @@ public final void mT__81() throws RecognitionException { try { int _type = T__81; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:80:7: ( 'new' ) - // InternalScope.g:80:9: 'new' + // InternalScope.g:78:7: ( 'null' ) + // InternalScope.g:78:9: 'null' { - match("new"); + match("null"); } @@ -1564,10 +1558,10 @@ public final void mT__82() throws RecognitionException { try { int _type = T__82; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:81:7: ( 'Collection' ) - // InternalScope.g:81:9: 'Collection' + // InternalScope.g:79:7: ( 'GLOBALVAR' ) + // InternalScope.g:79:9: 'GLOBALVAR' { - match("Collection"); + match("GLOBALVAR"); } @@ -1585,10 +1579,10 @@ public final void mT__83() throws RecognitionException { try { int _type = T__83; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:82:7: ( 'List' ) - // InternalScope.g:82:9: 'List' + // InternalScope.g:80:7: ( 'new' ) + // InternalScope.g:80:9: 'new' { - match("List"); + match("new"); } @@ -1606,10 +1600,10 @@ public final void mT__84() throws RecognitionException { try { int _type = T__84; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:83:7: ( 'Set' ) - // InternalScope.g:83:9: 'Set' + // InternalScope.g:81:7: ( 'Collection' ) + // InternalScope.g:81:9: 'Collection' { - match("Set"); + match("Collection"); } @@ -1627,10 +1621,10 @@ public final void mT__85() throws RecognitionException { try { int _type = T__85; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:84:7: ( 'sensitive' ) - // InternalScope.g:84:9: 'sensitive' + // InternalScope.g:82:7: ( 'List' ) + // InternalScope.g:82:9: 'List' { - match("sensitive"); + match("List"); } @@ -1648,10 +1642,10 @@ public final void mT__86() throws RecognitionException { try { int _type = T__86; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:85:7: ( 'insensitive' ) - // InternalScope.g:85:9: 'insensitive' + // InternalScope.g:83:7: ( 'Set' ) + // InternalScope.g:83:9: 'Set' { - match("insensitive"); + match("Set"); } @@ -1664,64 +1658,78 @@ public final void mT__86() throws RecognitionException { } // $ANTLR end "T__86" - // $ANTLR start "RULE_REAL" - public final void mRULE_REAL() throws RecognitionException { + // $ANTLR start "T__87" + public final void mT__87() throws RecognitionException { try { - int _type = RULE_REAL; + int _type = T__87; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4625:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) - // InternalScope.g:4625:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + // InternalScope.g:84:7: ( '+=' ) + // InternalScope.g:84:9: '+=' { - // InternalScope.g:4625:13: ( '0' .. '9' )* - loop1: - do { - int alt1=2; - int LA1_0 = input.LA(1); + match("+="); - if ( ((LA1_0>='0' && LA1_0<='9')) ) { - alt1=1; - } + } - switch (alt1) { - case 1 : - // InternalScope.g:4625:14: '0' .. '9' - { - matchRange('0','9'); + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__87" - } - break; + // $ANTLR start "T__88" + public final void mT__88() throws RecognitionException { + try { + int _type = T__88; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:85:7: ( '-=' ) + // InternalScope.g:85:9: '-=' + { + match("-="); - default : - break loop1; - } - } while (true); - match('.'); - // InternalScope.g:4625:29: ( '0' .. '9' )* - loop2: - do { - int alt2=2; - int LA2_0 = input.LA(1); + } - if ( ((LA2_0>='0' && LA2_0<='9')) ) { - alt2=1; - } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__88" + + // $ANTLR start "T__89" + public final void mT__89() throws RecognitionException { + try { + int _type = T__89; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:86:7: ( '*=' ) + // InternalScope.g:86:9: '*=' + { + match("*="); - switch (alt2) { - case 1 : - // InternalScope.g:4625:30: '0' .. '9' - { - matchRange('0','9'); + } - } - break; + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__89" - default : - break loop2; - } - } while (true); + // $ANTLR start "T__90" + public final void mT__90() throws RecognitionException { + try { + int _type = T__90; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:87:7: ( '/=' ) + // InternalScope.g:87:9: '/=' + { + match("/="); } @@ -1732,75 +1740,101 @@ public final void mRULE_REAL() throws RecognitionException { finally { } } - // $ANTLR end "RULE_REAL" + // $ANTLR end "T__90" - // $ANTLR start "RULE_ID" - public final void mRULE_ID() throws RecognitionException { + // $ANTLR start "T__91" + public final void mT__91() throws RecognitionException { try { - int _type = RULE_ID; + int _type = T__91; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4627:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // InternalScope.g:4627:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* + // InternalScope.g:88:7: ( '%=' ) + // InternalScope.g:88:9: '%=' { - // InternalScope.g:4627:11: ( '^' )? - int alt3=2; - int LA3_0 = input.LA(1); + match("%="); + - if ( (LA3_0=='^') ) { - alt3=1; } - switch (alt3) { - case 1 : - // InternalScope.g:4627:11: '^' - { - match('^'); - } - break; + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__91" - } + // $ANTLR start "T__92" + public final void mT__92() throws RecognitionException { + try { + int _type = T__92; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:89:7: ( '===' ) + // InternalScope.g:89:9: '===' + { + match("==="); - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { - input.consume(); } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - // InternalScope.g:4627:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop4: - do { - int alt4=2; - int LA4_0 = input.LA(1); + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__92" - if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='Z')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='z')) ) { - alt4=1; - } + // $ANTLR start "T__93" + public final void mT__93() throws RecognitionException { + try { + int _type = T__93; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:90:7: ( '!==' ) + // InternalScope.g:90:9: '!==' + { + match("!=="); - switch (alt4) { - case 1 : - // InternalScope.g: - { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { - input.consume(); + } - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__93" + // $ANTLR start "T__94" + public final void mT__94() throws RecognitionException { + try { + int _type = T__94; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:91:7: ( 'instanceof' ) + // InternalScope.g:91:9: 'instanceof' + { + match("instanceof"); - } - break; - default : - break loop4; - } - } while (true); + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__94" + + // $ANTLR start "T__95" + public final void mT__95() throws RecognitionException { + try { + int _type = T__95; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:92:7: ( '..<' ) + // InternalScope.g:92:9: '..<' + { + match("..<"); } @@ -1811,45 +1845,38 @@ public final void mRULE_ID() throws RecognitionException { finally { } } - // $ANTLR end "RULE_ID" + // $ANTLR end "T__95" - // $ANTLR start "RULE_INT" - public final void mRULE_INT() throws RecognitionException { + // $ANTLR start "T__96" + public final void mT__96() throws RecognitionException { try { - int _type = RULE_INT; + int _type = T__96; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4629:10: ( ( '0' .. '9' )+ ) - // InternalScope.g:4629:12: ( '0' .. '9' )+ + // InternalScope.g:93:7: ( '..' ) + // InternalScope.g:93:9: '..' { - // InternalScope.g:4629:12: ( '0' .. '9' )+ - int cnt5=0; - loop5: - do { - int alt5=2; - int LA5_0 = input.LA(1); - - if ( ((LA5_0>='0' && LA5_0<='9')) ) { - alt5=1; - } + match(".."); - switch (alt5) { - case 1 : - // InternalScope.g:4629:13: '0' .. '9' - { - matchRange('0','9'); + } - } - break; + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__96" - default : - if ( cnt5 >= 1 ) break loop5; - EarlyExitException eee = - new EarlyExitException(5, input); - throw eee; - } - cnt5++; - } while (true); + // $ANTLR start "T__97" + public final void mT__97() throws RecognitionException { + try { + int _type = T__97; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:94:7: ( '=>' ) + // InternalScope.g:94:9: '=>' + { + match("=>"); } @@ -1860,63 +1887,1094 @@ public final void mRULE_INT() throws RecognitionException { finally { } } - // $ANTLR end "RULE_INT" + // $ANTLR end "T__97" - // $ANTLR start "RULE_STRING" - public final void mRULE_STRING() throws RecognitionException { + // $ANTLR start "T__98" + public final void mT__98() throws RecognitionException { try { - int _type = RULE_STRING; + int _type = T__98; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4631:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) ) - // InternalScope.g:4631:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) + // InternalScope.g:95:7: ( '<>' ) + // InternalScope.g:95:9: '<>' { - // InternalScope.g:4631:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) - int alt8=2; - int LA8_0 = input.LA(1); + match("<>"); - if ( (LA8_0=='\"') ) { - alt8=1; - } - else if ( (LA8_0=='\'') ) { - alt8=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 8, 0, input); - throw nvae; } - switch (alt8) { - case 1 : - // InternalScope.g:4631:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' - { - match('\"'); - // InternalScope.g:4631:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* - loop6: - do { - int alt6=3; - int LA6_0 = input.LA(1); - if ( (LA6_0=='\\') ) { - alt6=1; - } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; - } + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__98" + // $ANTLR start "T__99" + public final void mT__99() throws RecognitionException { + try { + int _type = T__99; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:96:7: ( '?:' ) + // InternalScope.g:96:9: '?:' + { + match("?:"); - switch (alt6) { - case 1 : - // InternalScope.g:4631:21: '\\\\' . - { - match('\\'); - matchAny(); - } - break; - case 2 : - // InternalScope.g:4631:28: ~ ( ( '\\\\' | '\"' ) ) - { + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__99" + + // $ANTLR start "T__100" + public final void mT__100() throws RecognitionException { + try { + int _type = T__100; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:97:8: ( '**' ) + // InternalScope.g:97:10: '**' + { + match("**"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__100" + + // $ANTLR start "T__101" + public final void mT__101() throws RecognitionException { + try { + int _type = T__101; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:98:8: ( '%' ) + // InternalScope.g:98:10: '%' + { + match('%'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__101" + + // $ANTLR start "T__102" + public final void mT__102() throws RecognitionException { + try { + int _type = T__102; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:99:8: ( '++' ) + // InternalScope.g:99:10: '++' + { + match("++"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__102" + + // $ANTLR start "T__103" + public final void mT__103() throws RecognitionException { + try { + int _type = T__103; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:100:8: ( '--' ) + // InternalScope.g:100:10: '--' + { + match("--"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__103" + + // $ANTLR start "T__104" + public final void mT__104() throws RecognitionException { + try { + int _type = T__104; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:101:8: ( '?.' ) + // InternalScope.g:101:10: '?.' + { + match("?."); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__104" + + // $ANTLR start "T__105" + public final void mT__105() throws RecognitionException { + try { + int _type = T__105; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:102:8: ( 'for' ) + // InternalScope.g:102:10: 'for' + { + match("for"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__105" + + // $ANTLR start "T__106" + public final void mT__106() throws RecognitionException { + try { + int _type = T__106; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:103:8: ( 'while' ) + // InternalScope.g:103:10: 'while' + { + match("while"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__106" + + // $ANTLR start "T__107" + public final void mT__107() throws RecognitionException { + try { + int _type = T__107; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:104:8: ( 'do' ) + // InternalScope.g:104:10: 'do' + { + match("do"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__107" + + // $ANTLR start "T__108" + public final void mT__108() throws RecognitionException { + try { + int _type = T__108; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:105:8: ( 'var' ) + // InternalScope.g:105:10: 'var' + { + match("var"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__108" + + // $ANTLR start "T__109" + public final void mT__109() throws RecognitionException { + try { + int _type = T__109; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:106:8: ( 'val' ) + // InternalScope.g:106:10: 'val' + { + match("val"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__109" + + // $ANTLR start "T__110" + public final void mT__110() throws RecognitionException { + try { + int _type = T__110; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:107:8: ( 'extends' ) + // InternalScope.g:107:10: 'extends' + { + match("extends"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__110" + + // $ANTLR start "T__111" + public final void mT__111() throws RecognitionException { + try { + int _type = T__111; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:108:8: ( 'static' ) + // InternalScope.g:108:10: 'static' + { + match("static"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__111" + + // $ANTLR start "T__112" + public final void mT__112() throws RecognitionException { + try { + int _type = T__112; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:109:8: ( 'super' ) + // InternalScope.g:109:10: 'super' + { + match("super"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__112" + + // $ANTLR start "T__113" + public final void mT__113() throws RecognitionException { + try { + int _type = T__113; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:110:8: ( 'typeof' ) + // InternalScope.g:110:10: 'typeof' + { + match("typeof"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__113" + + // $ANTLR start "T__114" + public final void mT__114() throws RecognitionException { + try { + int _type = T__114; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:111:8: ( 'throw' ) + // InternalScope.g:111:10: 'throw' + { + match("throw"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__114" + + // $ANTLR start "T__115" + public final void mT__115() throws RecognitionException { + try { + int _type = T__115; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:112:8: ( 'return' ) + // InternalScope.g:112:10: 'return' + { + match("return"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__115" + + // $ANTLR start "T__116" + public final void mT__116() throws RecognitionException { + try { + int _type = T__116; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:113:8: ( 'try' ) + // InternalScope.g:113:10: 'try' + { + match("try"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__116" + + // $ANTLR start "T__117" + public final void mT__117() throws RecognitionException { + try { + int _type = T__117; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:114:8: ( 'finally' ) + // InternalScope.g:114:10: 'finally' + { + match("finally"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__117" + + // $ANTLR start "T__118" + public final void mT__118() throws RecognitionException { + try { + int _type = T__118; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:115:8: ( 'synchronized' ) + // InternalScope.g:115:10: 'synchronized' + { + match("synchronized"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__118" + + // $ANTLR start "T__119" + public final void mT__119() throws RecognitionException { + try { + int _type = T__119; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:116:8: ( 'catch' ) + // InternalScope.g:116:10: 'catch' + { + match("catch"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__119" + + // $ANTLR start "T__120" + public final void mT__120() throws RecognitionException { + try { + int _type = T__120; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:117:8: ( '&' ) + // InternalScope.g:117:10: '&' + { + match('&'); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__120" + + // $ANTLR start "T__121" + public final void mT__121() throws RecognitionException { + try { + int _type = T__121; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:118:8: ( 'sensitive' ) + // InternalScope.g:118:10: 'sensitive' + { + match("sensitive"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__121" + + // $ANTLR start "T__122" + public final void mT__122() throws RecognitionException { + try { + int _type = T__122; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:119:8: ( 'insensitive' ) + // InternalScope.g:119:10: 'insensitive' + { + match("insensitive"); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "T__122" + + // $ANTLR start "RULE_REAL" + public final void mRULE_REAL() throws RecognitionException { + try { + int _type = RULE_REAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10907:11: ( ( '0' .. '9' )* '.' ( '0' .. '9' )* ) + // InternalScope.g:10907:13: ( '0' .. '9' )* '.' ( '0' .. '9' )* + { + // InternalScope.g:10907:13: ( '0' .. '9' )* + loop1: + do { + int alt1=2; + int LA1_0 = input.LA(1); + + if ( ((LA1_0>='0' && LA1_0<='9')) ) { + alt1=1; + } + + + switch (alt1) { + case 1 : + // InternalScope.g:10907:14: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop1; + } + } while (true); + + match('.'); + // InternalScope.g:10907:29: ( '0' .. '9' )* + loop2: + do { + int alt2=2; + int LA2_0 = input.LA(1); + + if ( ((LA2_0>='0' && LA2_0<='9')) ) { + alt2=1; + } + + + switch (alt2) { + case 1 : + // InternalScope.g:10907:30: '0' .. '9' + { + matchRange('0','9'); + + } + break; + + default : + break loop2; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_REAL" + + // $ANTLR start "RULE_HEX" + public final void mRULE_HEX() throws RecognitionException { + try { + int _type = RULE_HEX; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10909:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? ) + // InternalScope.g:10909:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + { + // InternalScope.g:10909:12: ( '0x' | '0X' ) + int alt3=2; + int LA3_0 = input.LA(1); + + if ( (LA3_0=='0') ) { + int LA3_1 = input.LA(2); + + if ( (LA3_1=='x') ) { + alt3=1; + } + else if ( (LA3_1=='X') ) { + alt3=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 1, input); + + throw nvae; + } + } + else { + NoViableAltException nvae = + new NoViableAltException("", 3, 0, input); + + throw nvae; + } + switch (alt3) { + case 1 : + // InternalScope.g:10909:13: '0x' + { + match("0x"); + + + } + break; + case 2 : + // InternalScope.g:10909:18: '0X' + { + match("0X"); + + + } + break; + + } + + // InternalScope.g:10909:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ + int cnt4=0; + loop4: + do { + int alt4=2; + int LA4_0 = input.LA(1); + + if ( ((LA4_0>='0' && LA4_0<='9')||(LA4_0>='A' && LA4_0<='F')||LA4_0=='_'||(LA4_0>='a' && LA4_0<='f')) ) { + alt4=1; + } + + + switch (alt4) { + case 1 : + // InternalScope.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt4 >= 1 ) break loop4; + EarlyExitException eee = + new EarlyExitException(4, input); + throw eee; + } + cnt4++; + } while (true); + + // InternalScope.g:10909:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? + int alt6=2; + int LA6_0 = input.LA(1); + + if ( (LA6_0=='#') ) { + alt6=1; + } + switch (alt6) { + case 1 : + // InternalScope.g:10909:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + { + match('#'); + // InternalScope.g:10909:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) + int alt5=2; + int LA5_0 = input.LA(1); + + if ( (LA5_0=='B'||LA5_0=='b') ) { + alt5=1; + } + else if ( (LA5_0=='L'||LA5_0=='l') ) { + alt5=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 5, 0, input); + + throw nvae; + } + switch (alt5) { + case 1 : + // InternalScope.g:10909:64: ( 'b' | 'B' ) ( 'i' | 'I' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='I'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalScope.g:10909:84: ( 'l' | 'L' ) + { + if ( input.LA(1)=='L'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_HEX" + + // $ANTLR start "RULE_INT" + public final void mRULE_INT() throws RecognitionException { + try { + int _type = RULE_INT; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10911:10: ( '0' .. '9' ( '0' .. '9' | '_' )* ) + // InternalScope.g:10911:12: '0' .. '9' ( '0' .. '9' | '_' )* + { + matchRange('0','9'); + // InternalScope.g:10911:21: ( '0' .. '9' | '_' )* + loop7: + do { + int alt7=2; + int LA7_0 = input.LA(1); + + if ( ((LA7_0>='0' && LA7_0<='9')||LA7_0=='_') ) { + alt7=1; + } + + + switch (alt7) { + case 1 : + // InternalScope.g: + { + if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop7; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_INT" + + // $ANTLR start "RULE_DECIMAL" + public final void mRULE_DECIMAL() throws RecognitionException { + try { + int _type = RULE_DECIMAL; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10913:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? ) + // InternalScope.g:10913:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + { + mRULE_INT(); + // InternalScope.g:10913:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? + int alt9=2; + int LA9_0 = input.LA(1); + + if ( (LA9_0=='E'||LA9_0=='e') ) { + alt9=1; + } + switch (alt9) { + case 1 : + // InternalScope.g:10913:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT + { + if ( input.LA(1)=='E'||input.LA(1)=='e' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalScope.g:10913:36: ( '+' | '-' )? + int alt8=2; + int LA8_0 = input.LA(1); + + if ( (LA8_0=='+'||LA8_0=='-') ) { + alt8=1; + } + switch (alt8) { + case 1 : + // InternalScope.g: + { + if ( input.LA(1)=='+'||input.LA(1)=='-' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + mRULE_INT(); + + } + break; + + } + + // InternalScope.g:10913:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? + int alt10=3; + int LA10_0 = input.LA(1); + + if ( (LA10_0=='B'||LA10_0=='b') ) { + alt10=1; + } + else if ( (LA10_0=='D'||LA10_0=='F'||LA10_0=='L'||LA10_0=='d'||LA10_0=='f'||LA10_0=='l') ) { + alt10=2; + } + switch (alt10) { + case 1 : + // InternalScope.g:10913:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) + { + if ( input.LA(1)=='B'||input.LA(1)=='b' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + case 2 : + // InternalScope.g:10913:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) + { + if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + } + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_DECIMAL" + + // $ANTLR start "RULE_ID" + public final void mRULE_ID() throws RecognitionException { + try { + int _type = RULE_ID; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10915:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* ) + // InternalScope.g:10915:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + { + // InternalScope.g:10915:11: ( '^' )? + int alt11=2; + int LA11_0 = input.LA(1); + + if ( (LA11_0=='^') ) { + alt11=1; + } + switch (alt11) { + case 1 : + // InternalScope.g:10915:11: '^' + { + match('^'); + + } + break; + + } + + if ( input.LA(1)=='$'||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + // InternalScope.g:10915:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* + loop12: + do { + int alt12=2; + int LA12_0 = input.LA(1); + + if ( (LA12_0=='$'||(LA12_0>='0' && LA12_0<='9')||(LA12_0>='A' && LA12_0<='Z')||LA12_0=='_'||(LA12_0>='a' && LA12_0<='z')) ) { + alt12=1; + } + + + switch (alt12) { + case 1 : + // InternalScope.g: + { + if ( input.LA(1)=='$'||(input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + break loop12; + } + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ID" + + // $ANTLR start "RULE_STRING" + public final void mRULE_STRING() throws RecognitionException { + try { + int _type = RULE_STRING; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10917:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) ) + // InternalScope.g:10917:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + { + // InternalScope.g:10917:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) + int alt17=2; + int LA17_0 = input.LA(1); + + if ( (LA17_0=='\"') ) { + alt17=1; + } + else if ( (LA17_0=='\'') ) { + alt17=2; + } + else { + NoViableAltException nvae = + new NoViableAltException("", 17, 0, input); + + throw nvae; + } + switch (alt17) { + case 1 : + // InternalScope.g:10917:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? + { + match('\"'); + // InternalScope.g:10917:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* + loop13: + do { + int alt13=3; + int LA13_0 = input.LA(1); + + if ( (LA13_0=='\\') ) { + alt13=1; + } + else if ( ((LA13_0>='\u0000' && LA13_0<='!')||(LA13_0>='#' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) { + alt13=2; + } + + + switch (alt13) { + case 1 : + // InternalScope.g:10917:21: '\\\\' . + { + match('\\'); + matchAny(); + + } + break; + case 2 : + // InternalScope.g:10917:28: ~ ( ( '\\\\' | '\"' ) ) + { if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1931,35 +2989,52 @@ else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>= break; default : - break loop6; + break loop13; } } while (true); - match('\"'); + // InternalScope.g:10917:44: ( '\"' )? + int alt14=2; + int LA14_0 = input.LA(1); + + if ( (LA14_0=='\"') ) { + alt14=1; + } + switch (alt14) { + case 1 : + // InternalScope.g:10917:44: '\"' + { + match('\"'); + + } + break; + + } + } break; case 2 : - // InternalScope.g:4631:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' + // InternalScope.g:10917:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? { match('\''); - // InternalScope.g:4631:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* - loop7: + // InternalScope.g:10917:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* + loop15: do { - int alt7=3; - int LA7_0 = input.LA(1); + int alt15=3; + int LA15_0 = input.LA(1); - if ( (LA7_0=='\\') ) { - alt7=1; + if ( (LA15_0=='\\') ) { + alt15=1; } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; + else if ( ((LA15_0>='\u0000' && LA15_0<='&')||(LA15_0>='(' && LA15_0<='[')||(LA15_0>=']' && LA15_0<='\uFFFF')) ) { + alt15=2; } - switch (alt7) { + switch (alt15) { case 1 : - // InternalScope.g:4631:54: '\\\\' . + // InternalScope.g:10917:55: '\\\\' . { match('\\'); matchAny(); @@ -1967,7 +3042,7 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= } break; case 2 : - // InternalScope.g:4631:61: ~ ( ( '\\\\' | '\\'' ) ) + // InternalScope.g:10917:62: ~ ( ( '\\\\' | '\\'' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -1983,11 +3058,28 @@ else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>= break; default : - break loop7; + break loop15; } } while (true); - match('\''); + // InternalScope.g:10917:79: ( '\\'' )? + int alt16=2; + int LA16_0 = input.LA(1); + + if ( (LA16_0=='\'') ) { + alt16=1; + } + switch (alt16) { + case 1 : + // InternalScope.g:10917:79: '\\'' + { + match('\''); + + } + break; + + } + } break; @@ -2010,37 +3102,37 @@ public final void mRULE_ML_COMMENT() throws RecognitionException { try { int _type = RULE_ML_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4633:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) - // InternalScope.g:4633:19: '/*' ( options {greedy=false; } : . )* '*/' + // InternalScope.g:10919:17: ( '/*' ( options {greedy=false; } : . )* '*/' ) + // InternalScope.g:10919:19: '/*' ( options {greedy=false; } : . )* '*/' { match("/*"); - // InternalScope.g:4633:24: ( options {greedy=false; } : . )* - loop9: + // InternalScope.g:10919:24: ( options {greedy=false; } : . )* + loop18: do { - int alt9=2; - int LA9_0 = input.LA(1); + int alt18=2; + int LA18_0 = input.LA(1); - if ( (LA9_0=='*') ) { - int LA9_1 = input.LA(2); + if ( (LA18_0=='*') ) { + int LA18_1 = input.LA(2); - if ( (LA9_1=='/') ) { - alt9=2; + if ( (LA18_1=='/') ) { + alt18=2; } - else if ( ((LA9_1>='\u0000' && LA9_1<='.')||(LA9_1>='0' && LA9_1<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_1>='\u0000' && LA18_1<='.')||(LA18_1>='0' && LA18_1<='\uFFFF')) ) { + alt18=1; } } - else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { - alt9=1; + else if ( ((LA18_0>='\u0000' && LA18_0<=')')||(LA18_0>='+' && LA18_0<='\uFFFF')) ) { + alt18=1; } - switch (alt9) { + switch (alt18) { case 1 : - // InternalScope.g:4633:52: . + // InternalScope.g:10919:52: . { matchAny(); @@ -2048,7 +3140,7 @@ else if ( ((LA9_0>='\u0000' && LA9_0<=')')||(LA9_0>='+' && LA9_0<='\uFFFF')) ) { break; default : - break loop9; + break loop18; } } while (true); @@ -2070,25 +3162,25 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { try { int _type = RULE_SL_COMMENT; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4635:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) - // InternalScope.g:4635:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? + // InternalScope.g:10921:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? ) + // InternalScope.g:10921:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? { match("//"); - // InternalScope.g:4635:24: (~ ( ( '\\n' | '\\r' ) ) )* - loop10: + // InternalScope.g:10921:24: (~ ( ( '\\n' | '\\r' ) ) )* + loop19: do { - int alt10=2; - int LA10_0 = input.LA(1); + int alt19=2; + int LA19_0 = input.LA(1); - if ( ((LA10_0>='\u0000' && LA10_0<='\t')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\uFFFF')) ) { - alt10=1; + if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { + alt19=1; } - switch (alt10) { + switch (alt19) { case 1 : - // InternalScope.g:4635:24: ~ ( ( '\\n' | '\\r' ) ) + // InternalScope.g:10921:24: ~ ( ( '\\n' | '\\r' ) ) { if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { input.consume(); @@ -2104,31 +3196,31 @@ public final void mRULE_SL_COMMENT() throws RecognitionException { break; default : - break loop10; + break loop19; } } while (true); - // InternalScope.g:4635:40: ( ( '\\r' )? '\\n' )? - int alt12=2; - int LA12_0 = input.LA(1); + // InternalScope.g:10921:40: ( ( '\\r' )? '\\n' )? + int alt21=2; + int LA21_0 = input.LA(1); - if ( (LA12_0=='\n'||LA12_0=='\r') ) { - alt12=1; + if ( (LA21_0=='\n'||LA21_0=='\r') ) { + alt21=1; } - switch (alt12) { + switch (alt21) { case 1 : - // InternalScope.g:4635:41: ( '\\r' )? '\\n' + // InternalScope.g:10921:41: ( '\\r' )? '\\n' { - // InternalScope.g:4635:41: ( '\\r' )? - int alt11=2; - int LA11_0 = input.LA(1); + // InternalScope.g:10921:41: ( '\\r' )? + int alt20=2; + int LA20_0 = input.LA(1); - if ( (LA11_0=='\r') ) { - alt11=1; + if ( (LA20_0=='\r') ) { + alt20=1; } - switch (alt11) { + switch (alt20) { case 1 : - // InternalScope.g:4635:41: '\\r' + // InternalScope.g:10921:41: '\\r' { match('\r'); @@ -2160,659 +3252,911 @@ public final void mRULE_WS() throws RecognitionException { try { int _type = RULE_WS; int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4637:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) - // InternalScope.g:4637:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + // InternalScope.g:10923:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) + // InternalScope.g:10923:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ { - // InternalScope.g:4637:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ - int cnt13=0; - loop13: + // InternalScope.g:10923:11: ( ' ' | '\\t' | '\\r' | '\\n' )+ + int cnt22=0; + loop22: do { - int alt13=2; - int LA13_0 = input.LA(1); + int alt22=2; + int LA22_0 = input.LA(1); + + if ( ((LA22_0>='\t' && LA22_0<='\n')||LA22_0=='\r'||LA22_0==' ') ) { + alt22=1; + } + + + switch (alt22) { + case 1 : + // InternalScope.g: + { + if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { + input.consume(); + + } + else { + MismatchedSetException mse = new MismatchedSetException(null,input); + recover(mse); + throw mse;} + + + } + break; + + default : + if ( cnt22 >= 1 ) break loop22; + EarlyExitException eee = + new EarlyExitException(22, input); + throw eee; + } + cnt22++; + } while (true); + + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_WS" + + // $ANTLR start "RULE_ANY_OTHER" + public final void mRULE_ANY_OTHER() throws RecognitionException { + try { + int _type = RULE_ANY_OTHER; + int _channel = DEFAULT_TOKEN_CHANNEL; + // InternalScope.g:10925:16: ( . ) + // InternalScope.g:10925:18: . + { + matchAny(); + + } + + state.type = _type; + state.channel = _channel; + } + finally { + } + } + // $ANTLR end "RULE_ANY_OTHER" + + public void mTokens() throws RecognitionException { + // InternalScope.g:1:8: ( T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | T__87 | T__88 | T__89 | T__90 | T__91 | T__92 | T__93 | T__94 | T__95 | T__96 | T__97 | T__98 | T__99 | T__100 | T__101 | T__102 | T__103 | T__104 | T__105 | T__106 | T__107 | T__108 | T__109 | T__110 | T__111 | T__112 | T__113 | T__114 | T__115 | T__116 | T__117 | T__118 | T__119 | T__120 | T__121 | T__122 | RULE_REAL | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) + int alt23=119; + alt23 = dfa23.predict(input); + switch (alt23) { + case 1 : + // InternalScope.g:1:10: T__14 + { + mT__14(); + + } + break; + case 2 : + // InternalScope.g:1:16: T__15 + { + mT__15(); + + } + break; + case 3 : + // InternalScope.g:1:22: T__16 + { + mT__16(); + + } + break; + case 4 : + // InternalScope.g:1:28: T__17 + { + mT__17(); + + } + break; + case 5 : + // InternalScope.g:1:34: T__18 + { + mT__18(); + + } + break; + case 6 : + // InternalScope.g:1:40: T__19 + { + mT__19(); + + } + break; + case 7 : + // InternalScope.g:1:46: T__20 + { + mT__20(); + + } + break; + case 8 : + // InternalScope.g:1:52: T__21 + { + mT__21(); + + } + break; + case 9 : + // InternalScope.g:1:58: T__22 + { + mT__22(); + + } + break; + case 10 : + // InternalScope.g:1:64: T__23 + { + mT__23(); + + } + break; + case 11 : + // InternalScope.g:1:70: T__24 + { + mT__24(); + + } + break; + case 12 : + // InternalScope.g:1:76: T__25 + { + mT__25(); + + } + break; + case 13 : + // InternalScope.g:1:82: T__26 + { + mT__26(); + + } + break; + case 14 : + // InternalScope.g:1:88: T__27 + { + mT__27(); + + } + break; + case 15 : + // InternalScope.g:1:94: T__28 + { + mT__28(); + + } + break; + case 16 : + // InternalScope.g:1:100: T__29 + { + mT__29(); + + } + break; + case 17 : + // InternalScope.g:1:106: T__30 + { + mT__30(); + + } + break; + case 18 : + // InternalScope.g:1:112: T__31 + { + mT__31(); + + } + break; + case 19 : + // InternalScope.g:1:118: T__32 + { + mT__32(); + + } + break; + case 20 : + // InternalScope.g:1:124: T__33 + { + mT__33(); + + } + break; + case 21 : + // InternalScope.g:1:130: T__34 + { + mT__34(); + + } + break; + case 22 : + // InternalScope.g:1:136: T__35 + { + mT__35(); - if ( ((LA13_0>='\t' && LA13_0<='\n')||LA13_0=='\r'||LA13_0==' ') ) { - alt13=1; } + break; + case 23 : + // InternalScope.g:1:142: T__36 + { + mT__36(); + } + break; + case 24 : + // InternalScope.g:1:148: T__37 + { + mT__37(); - switch (alt13) { - case 1 : - // InternalScope.g: - { - if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) { - input.consume(); + } + break; + case 25 : + // InternalScope.g:1:154: T__38 + { + mT__38(); - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} + } + break; + case 26 : + // InternalScope.g:1:160: T__39 + { + mT__39(); + } + break; + case 27 : + // InternalScope.g:1:166: T__40 + { + mT__40(); - } - break; + } + break; + case 28 : + // InternalScope.g:1:172: T__41 + { + mT__41(); - default : - if ( cnt13 >= 1 ) break loop13; - EarlyExitException eee = - new EarlyExitException(13, input); - throw eee; } - cnt13++; - } while (true); + break; + case 29 : + // InternalScope.g:1:178: T__42 + { + mT__42(); + } + break; + case 30 : + // InternalScope.g:1:184: T__43 + { + mT__43(); - } + } + break; + case 31 : + // InternalScope.g:1:190: T__44 + { + mT__44(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_WS" + } + break; + case 32 : + // InternalScope.g:1:196: T__45 + { + mT__45(); - // $ANTLR start "RULE_ANY_OTHER" - public final void mRULE_ANY_OTHER() throws RecognitionException { - try { - int _type = RULE_ANY_OTHER; - int _channel = DEFAULT_TOKEN_CHANNEL; - // InternalScope.g:4639:16: ( . ) - // InternalScope.g:4639:18: . - { - matchAny(); + } + break; + case 33 : + // InternalScope.g:1:202: T__46 + { + mT__46(); - } + } + break; + case 34 : + // InternalScope.g:1:208: T__47 + { + mT__47(); - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "RULE_ANY_OTHER" + } + break; + case 35 : + // InternalScope.g:1:214: T__48 + { + mT__48(); - public void mTokens() throws RecognitionException { - // InternalScope.g:1:8: ( T__12 | T__13 | T__14 | T__15 | T__16 | T__17 | T__18 | T__19 | T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | T__67 | T__68 | T__69 | T__70 | T__71 | T__72 | T__73 | T__74 | T__75 | T__76 | T__77 | T__78 | T__79 | T__80 | T__81 | T__82 | T__83 | T__84 | T__85 | T__86 | RULE_REAL | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER ) - int alt14=83; - alt14 = dfa14.predict(input); - switch (alt14) { - case 1 : - // InternalScope.g:1:10: T__12 + } + break; + case 36 : + // InternalScope.g:1:220: T__49 { - mT__12(); + mT__49(); } break; - case 2 : - // InternalScope.g:1:16: T__13 + case 37 : + // InternalScope.g:1:226: T__50 { - mT__13(); + mT__50(); } break; - case 3 : - // InternalScope.g:1:22: T__14 + case 38 : + // InternalScope.g:1:232: T__51 { - mT__14(); + mT__51(); } break; - case 4 : - // InternalScope.g:1:28: T__15 + case 39 : + // InternalScope.g:1:238: T__52 { - mT__15(); + mT__52(); } break; - case 5 : - // InternalScope.g:1:34: T__16 + case 40 : + // InternalScope.g:1:244: T__53 { - mT__16(); + mT__53(); } break; - case 6 : - // InternalScope.g:1:40: T__17 + case 41 : + // InternalScope.g:1:250: T__54 { - mT__17(); + mT__54(); } break; - case 7 : - // InternalScope.g:1:46: T__18 + case 42 : + // InternalScope.g:1:256: T__55 { - mT__18(); + mT__55(); } break; - case 8 : - // InternalScope.g:1:52: T__19 + case 43 : + // InternalScope.g:1:262: T__56 { - mT__19(); + mT__56(); } break; - case 9 : - // InternalScope.g:1:58: T__20 + case 44 : + // InternalScope.g:1:268: T__57 { - mT__20(); + mT__57(); } break; - case 10 : - // InternalScope.g:1:64: T__21 + case 45 : + // InternalScope.g:1:274: T__58 { - mT__21(); + mT__58(); } break; - case 11 : - // InternalScope.g:1:70: T__22 + case 46 : + // InternalScope.g:1:280: T__59 { - mT__22(); + mT__59(); } break; - case 12 : - // InternalScope.g:1:76: T__23 + case 47 : + // InternalScope.g:1:286: T__60 { - mT__23(); + mT__60(); } break; - case 13 : - // InternalScope.g:1:82: T__24 + case 48 : + // InternalScope.g:1:292: T__61 { - mT__24(); + mT__61(); } break; - case 14 : - // InternalScope.g:1:88: T__25 + case 49 : + // InternalScope.g:1:298: T__62 { - mT__25(); + mT__62(); } break; - case 15 : - // InternalScope.g:1:94: T__26 + case 50 : + // InternalScope.g:1:304: T__63 { - mT__26(); + mT__63(); } break; - case 16 : - // InternalScope.g:1:100: T__27 + case 51 : + // InternalScope.g:1:310: T__64 { - mT__27(); + mT__64(); } break; - case 17 : - // InternalScope.g:1:106: T__28 + case 52 : + // InternalScope.g:1:316: T__65 { - mT__28(); + mT__65(); } break; - case 18 : - // InternalScope.g:1:112: T__29 + case 53 : + // InternalScope.g:1:322: T__66 { - mT__29(); + mT__66(); } break; - case 19 : - // InternalScope.g:1:118: T__30 + case 54 : + // InternalScope.g:1:328: T__67 { - mT__30(); + mT__67(); } break; - case 20 : - // InternalScope.g:1:124: T__31 + case 55 : + // InternalScope.g:1:334: T__68 { - mT__31(); + mT__68(); } break; - case 21 : - // InternalScope.g:1:130: T__32 + case 56 : + // InternalScope.g:1:340: T__69 { - mT__32(); + mT__69(); } break; - case 22 : - // InternalScope.g:1:136: T__33 + case 57 : + // InternalScope.g:1:346: T__70 { - mT__33(); + mT__70(); } break; - case 23 : - // InternalScope.g:1:142: T__34 + case 58 : + // InternalScope.g:1:352: T__71 { - mT__34(); + mT__71(); } break; - case 24 : - // InternalScope.g:1:148: T__35 + case 59 : + // InternalScope.g:1:358: T__72 { - mT__35(); + mT__72(); } break; - case 25 : - // InternalScope.g:1:154: T__36 + case 60 : + // InternalScope.g:1:364: T__73 { - mT__36(); + mT__73(); } break; - case 26 : - // InternalScope.g:1:160: T__37 + case 61 : + // InternalScope.g:1:370: T__74 { - mT__37(); + mT__74(); } break; - case 27 : - // InternalScope.g:1:166: T__38 + case 62 : + // InternalScope.g:1:376: T__75 { - mT__38(); + mT__75(); } break; - case 28 : - // InternalScope.g:1:172: T__39 + case 63 : + // InternalScope.g:1:382: T__76 { - mT__39(); + mT__76(); } break; - case 29 : - // InternalScope.g:1:178: T__40 + case 64 : + // InternalScope.g:1:388: T__77 { - mT__40(); + mT__77(); } break; - case 30 : - // InternalScope.g:1:184: T__41 + case 65 : + // InternalScope.g:1:394: T__78 { - mT__41(); + mT__78(); } break; - case 31 : - // InternalScope.g:1:190: T__42 + case 66 : + // InternalScope.g:1:400: T__79 { - mT__42(); + mT__79(); } break; - case 32 : - // InternalScope.g:1:196: T__43 + case 67 : + // InternalScope.g:1:406: T__80 { - mT__43(); + mT__80(); } break; - case 33 : - // InternalScope.g:1:202: T__44 + case 68 : + // InternalScope.g:1:412: T__81 { - mT__44(); + mT__81(); } break; - case 34 : - // InternalScope.g:1:208: T__45 + case 69 : + // InternalScope.g:1:418: T__82 { - mT__45(); + mT__82(); } break; - case 35 : - // InternalScope.g:1:214: T__46 + case 70 : + // InternalScope.g:1:424: T__83 { - mT__46(); + mT__83(); } break; - case 36 : - // InternalScope.g:1:220: T__47 + case 71 : + // InternalScope.g:1:430: T__84 { - mT__47(); + mT__84(); + + } + break; + case 72 : + // InternalScope.g:1:436: T__85 + { + mT__85(); } break; - case 37 : - // InternalScope.g:1:226: T__48 + case 73 : + // InternalScope.g:1:442: T__86 { - mT__48(); + mT__86(); } break; - case 38 : - // InternalScope.g:1:232: T__49 + case 74 : + // InternalScope.g:1:448: T__87 { - mT__49(); + mT__87(); } break; - case 39 : - // InternalScope.g:1:238: T__50 + case 75 : + // InternalScope.g:1:454: T__88 { - mT__50(); + mT__88(); } break; - case 40 : - // InternalScope.g:1:244: T__51 + case 76 : + // InternalScope.g:1:460: T__89 { - mT__51(); + mT__89(); } break; - case 41 : - // InternalScope.g:1:250: T__52 + case 77 : + // InternalScope.g:1:466: T__90 { - mT__52(); + mT__90(); } break; - case 42 : - // InternalScope.g:1:256: T__53 + case 78 : + // InternalScope.g:1:472: T__91 { - mT__53(); + mT__91(); } break; - case 43 : - // InternalScope.g:1:262: T__54 + case 79 : + // InternalScope.g:1:478: T__92 { - mT__54(); + mT__92(); } break; - case 44 : - // InternalScope.g:1:268: T__55 + case 80 : + // InternalScope.g:1:484: T__93 { - mT__55(); + mT__93(); } break; - case 45 : - // InternalScope.g:1:274: T__56 + case 81 : + // InternalScope.g:1:490: T__94 { - mT__56(); + mT__94(); } break; - case 46 : - // InternalScope.g:1:280: T__57 + case 82 : + // InternalScope.g:1:496: T__95 { - mT__57(); + mT__95(); } break; - case 47 : - // InternalScope.g:1:286: T__58 + case 83 : + // InternalScope.g:1:502: T__96 { - mT__58(); + mT__96(); } break; - case 48 : - // InternalScope.g:1:292: T__59 + case 84 : + // InternalScope.g:1:508: T__97 { - mT__59(); + mT__97(); } break; - case 49 : - // InternalScope.g:1:298: T__60 + case 85 : + // InternalScope.g:1:514: T__98 { - mT__60(); + mT__98(); } break; - case 50 : - // InternalScope.g:1:304: T__61 + case 86 : + // InternalScope.g:1:520: T__99 { - mT__61(); + mT__99(); } break; - case 51 : - // InternalScope.g:1:310: T__62 + case 87 : + // InternalScope.g:1:526: T__100 { - mT__62(); + mT__100(); } break; - case 52 : - // InternalScope.g:1:316: T__63 + case 88 : + // InternalScope.g:1:533: T__101 { - mT__63(); + mT__101(); } break; - case 53 : - // InternalScope.g:1:322: T__64 + case 89 : + // InternalScope.g:1:540: T__102 { - mT__64(); + mT__102(); } break; - case 54 : - // InternalScope.g:1:328: T__65 + case 90 : + // InternalScope.g:1:547: T__103 { - mT__65(); + mT__103(); } break; - case 55 : - // InternalScope.g:1:334: T__66 + case 91 : + // InternalScope.g:1:554: T__104 { - mT__66(); + mT__104(); } break; - case 56 : - // InternalScope.g:1:340: T__67 + case 92 : + // InternalScope.g:1:561: T__105 { - mT__67(); + mT__105(); } break; - case 57 : - // InternalScope.g:1:346: T__68 + case 93 : + // InternalScope.g:1:568: T__106 { - mT__68(); + mT__106(); } break; - case 58 : - // InternalScope.g:1:352: T__69 + case 94 : + // InternalScope.g:1:575: T__107 { - mT__69(); + mT__107(); } break; - case 59 : - // InternalScope.g:1:358: T__70 + case 95 : + // InternalScope.g:1:582: T__108 { - mT__70(); + mT__108(); } break; - case 60 : - // InternalScope.g:1:364: T__71 + case 96 : + // InternalScope.g:1:589: T__109 { - mT__71(); + mT__109(); } break; - case 61 : - // InternalScope.g:1:370: T__72 + case 97 : + // InternalScope.g:1:596: T__110 { - mT__72(); + mT__110(); } break; - case 62 : - // InternalScope.g:1:376: T__73 + case 98 : + // InternalScope.g:1:603: T__111 { - mT__73(); + mT__111(); } break; - case 63 : - // InternalScope.g:1:382: T__74 + case 99 : + // InternalScope.g:1:610: T__112 { - mT__74(); + mT__112(); } break; - case 64 : - // InternalScope.g:1:388: T__75 + case 100 : + // InternalScope.g:1:617: T__113 { - mT__75(); + mT__113(); } break; - case 65 : - // InternalScope.g:1:394: T__76 + case 101 : + // InternalScope.g:1:624: T__114 { - mT__76(); + mT__114(); } break; - case 66 : - // InternalScope.g:1:400: T__77 + case 102 : + // InternalScope.g:1:631: T__115 { - mT__77(); + mT__115(); } break; - case 67 : - // InternalScope.g:1:406: T__78 + case 103 : + // InternalScope.g:1:638: T__116 { - mT__78(); + mT__116(); } break; - case 68 : - // InternalScope.g:1:412: T__79 + case 104 : + // InternalScope.g:1:645: T__117 { - mT__79(); + mT__117(); } break; - case 69 : - // InternalScope.g:1:418: T__80 + case 105 : + // InternalScope.g:1:652: T__118 { - mT__80(); + mT__118(); } break; - case 70 : - // InternalScope.g:1:424: T__81 + case 106 : + // InternalScope.g:1:659: T__119 { - mT__81(); + mT__119(); } break; - case 71 : - // InternalScope.g:1:430: T__82 + case 107 : + // InternalScope.g:1:666: T__120 { - mT__82(); + mT__120(); } break; - case 72 : - // InternalScope.g:1:436: T__83 + case 108 : + // InternalScope.g:1:673: T__121 { - mT__83(); + mT__121(); } break; - case 73 : - // InternalScope.g:1:442: T__84 + case 109 : + // InternalScope.g:1:680: T__122 { - mT__84(); + mT__122(); } break; - case 74 : - // InternalScope.g:1:448: T__85 + case 110 : + // InternalScope.g:1:687: RULE_REAL { - mT__85(); + mRULE_REAL(); } break; - case 75 : - // InternalScope.g:1:454: T__86 + case 111 : + // InternalScope.g:1:697: RULE_HEX { - mT__86(); + mRULE_HEX(); } break; - case 76 : - // InternalScope.g:1:460: RULE_REAL + case 112 : + // InternalScope.g:1:706: RULE_INT { - mRULE_REAL(); + mRULE_INT(); } break; - case 77 : - // InternalScope.g:1:470: RULE_ID + case 113 : + // InternalScope.g:1:715: RULE_DECIMAL { - mRULE_ID(); + mRULE_DECIMAL(); } break; - case 78 : - // InternalScope.g:1:478: RULE_INT + case 114 : + // InternalScope.g:1:728: RULE_ID { - mRULE_INT(); + mRULE_ID(); } break; - case 79 : - // InternalScope.g:1:487: RULE_STRING + case 115 : + // InternalScope.g:1:736: RULE_STRING { mRULE_STRING(); } break; - case 80 : - // InternalScope.g:1:499: RULE_ML_COMMENT + case 116 : + // InternalScope.g:1:748: RULE_ML_COMMENT { mRULE_ML_COMMENT(); } break; - case 81 : - // InternalScope.g:1:515: RULE_SL_COMMENT + case 117 : + // InternalScope.g:1:764: RULE_SL_COMMENT { mRULE_SL_COMMENT(); } break; - case 82 : - // InternalScope.g:1:531: RULE_WS + case 118 : + // InternalScope.g:1:780: RULE_WS { mRULE_WS(); } break; - case 83 : - // InternalScope.g:1:539: RULE_ANY_OTHER + case 119 : + // InternalScope.g:1:788: RULE_ANY_OTHER { mRULE_ANY_OTHER(); @@ -2824,517 +4168,599 @@ public void mTokens() throws RecognitionException { } - protected DFA14 dfa14 = new DFA14(this); - static final String DFA14_eotS = - "\1\uffff\7\64\2\uffff\1\105\4\uffff\1\114\3\uffff\1\64\1\uffff\4\64\1\133\1\135\1\136\1\64\1\142\1\uffff\1\64\1\57\1\151\1\153\1\uffff\1\157\4\64\1\164\1\57\1\uffff\2\57\2\uffff\4\64\1\uffff\3\64\1\u0081\1\u0082\10\64\16\uffff\3\64\1\uffff\6\64\6\uffff\1\64\3\uffff\3\64\11\uffff\4\64\1\uffff\1\164\2\uffff\11\64\2\uffff\12\64\1\u00b5\4\64\1\u00ba\6\64\1\u00c1\6\64\1\u00c8\5\64\1\u00cf\7\64\1\u00d7\1\u00d8\4\64\1\u00dd\1\uffff\2\64\1\u00e0\1\64\1\uffff\3\64\1\u00e5\2\64\1\uffff\1\u00e8\1\64\1\u00ea\2\64\1\u00ed\1\uffff\1\64\1\u00f0\4\64\1\uffff\7\64\2\uffff\4\64\1\uffff\1\64\1\u0101\1\uffff\4\64\1\uffff\2\64\1\uffff\1\64\1\uffff\2\64\1\uffff\2\64\1\uffff\1\u010d\1\u010f\1\64\1\u0111\1\u0112\1\64\1\u0114\2\64\1\u0117\1\u0118\2\64\1\u011b\2\64\1\uffff\1\u011e\1\64\1\u0120\1\u0121\5\64\1\u0127\1\u0128\1\uffff\1\64\1\uffff\1\64\2\uffff\1\u012b\1\uffff\2\64\2\uffff\1\u012e\1\u012f\1\uffff\1\64\1\u0131\1\uffff\1\64\2\uffff\1\u0133\1\u0134\3\64\2\uffff\2\64\1\uffff\2\64\2\uffff\1\64\1\uffff\1\64\2\uffff\4\64\1\u0142\1\64\1\u0144\1\u0145\1\u0146\1\64\1\u0148\2\64\1\uffff\1\64\3\uffff\1\u014c\1\uffff\1\u014d\1\u014e\1\u014f\4\uffff"; - static final String DFA14_eofS = - "\u0150\uffff"; - static final String DFA14_minS = - "\1\0\1\143\1\151\1\146\1\163\1\154\2\141\2\uffff\1\75\4\uffff\1\75\3\uffff\1\141\1\uffff\2\145\1\162\1\141\1\174\1\72\1\60\1\145\1\76\1\uffff\1\150\1\46\2\75\1\uffff\1\52\1\114\1\157\1\151\1\145\1\56\1\101\1\uffff\2\0\2\uffff\1\157\1\151\1\154\1\162\1\uffff\1\164\1\160\1\152\2\60\1\151\2\163\1\154\1\155\1\164\1\154\1\167\16\uffff\1\143\1\156\1\162\1\uffff\1\171\1\143\1\145\1\164\1\155\1\146\6\uffff\1\164\3\uffff\1\145\1\160\1\165\11\uffff\1\117\1\154\1\163\1\164\1\uffff\1\56\2\uffff\1\160\1\164\1\145\1\163\1\164\1\150\1\154\2\145\2\uffff\1\145\1\157\1\163\2\145\1\164\1\154\1\151\1\105\1\154\1\60\1\164\1\163\1\144\1\101\1\60\1\165\1\145\1\146\3\141\1\60\1\156\2\145\1\102\1\154\1\164\1\60\1\145\2\143\1\151\1\102\1\60\1\162\1\151\1\143\2\156\1\162\1\164\2\60\2\145\1\156\1\170\1\60\1\uffff\1\157\1\145\1\60\1\154\1\uffff\1\162\1\143\1\151\1\60\1\151\1\165\1\uffff\1\60\1\123\1\60\1\101\1\145\1\60\1\uffff\1\156\1\60\1\150\2\164\1\171\1\uffff\1\164\1\145\1\164\2\163\1\164\1\163\2\uffff\1\170\1\143\1\147\1\151\1\uffff\1\162\1\60\1\uffff\1\154\1\163\1\164\1\170\1\uffff\1\156\1\154\1\uffff\1\145\1\uffff\1\114\1\143\1\uffff\1\147\1\146\1\uffff\2\60\1\151\2\60\1\163\1\60\2\151\2\60\2\164\1\60\1\163\1\171\1\uffff\1\60\1\151\2\60\1\163\1\164\1\154\1\126\1\164\2\60\1\uffff\1\151\1\uffff\1\166\2\uffff\1\60\1\uffff\1\164\1\157\2\uffff\2\60\1\uffff\1\164\1\60\1\uffff\1\166\2\uffff\2\60\1\145\1\101\1\151\2\uffff\1\162\1\145\1\uffff\1\151\1\156\2\uffff\1\163\1\uffff\1\145\2\uffff\1\143\1\122\1\157\1\163\1\60\1\166\3\60\1\164\1\60\1\156\1\164\1\uffff\1\145\3\uffff\1\60\1\uffff\3\60\4\uffff"; - static final String DFA14_maxS = - "\1\uffff\1\167\1\151\1\156\1\163\1\170\1\157\1\165\2\uffff\1\75\4\uffff\1\76\3\uffff\1\157\1\uffff\2\145\1\162\1\157\1\174\1\72\1\71\1\145\1\76\1\uffff\1\171\1\46\2\75\1\uffff\1\57\1\114\1\157\1\151\1\145\1\71\1\172\1\uffff\2\uffff\2\uffff\1\157\1\151\1\156\1\162\1\uffff\1\164\1\160\1\163\2\172\1\164\2\163\1\156\1\155\1\164\1\154\1\167\16\uffff\1\154\1\156\1\162\1\uffff\1\171\1\152\1\145\1\164\1\155\1\146\6\uffff\1\164\3\uffff\1\145\1\160\1\165\11\uffff\1\117\1\154\1\163\1\164\1\uffff\1\71\2\uffff\1\160\1\164\1\145\1\163\1\164\1\150\1\157\2\145\2\uffff\1\145\1\157\1\163\2\145\1\164\1\154\1\151\1\105\1\154\1\172\1\164\1\163\1\144\1\101\1\172\1\165\1\145\1\146\3\141\1\172\1\156\2\145\1\102\1\154\1\164\1\172\1\151\2\143\1\151\1\102\1\172\1\162\1\151\1\143\2\156\1\162\1\164\2\172\2\145\1\156\1\170\1\172\1\uffff\1\157\1\145\1\172\1\154\1\uffff\1\162\1\143\1\151\1\172\1\151\1\165\1\uffff\1\172\1\123\1\172\1\101\1\145\1\172\1\uffff\1\156\1\172\1\150\2\164\1\171\1\uffff\1\164\1\145\1\164\2\163\1\164\1\163\2\uffff\1\170\1\143\1\147\1\151\1\uffff\1\162\1\172\1\uffff\1\154\1\163\1\164\1\170\1\uffff\1\156\1\154\1\uffff\1\145\1\uffff\1\114\1\143\1\uffff\1\147\1\146\1\uffff\2\172\1\151\2\172\1\163\1\172\2\151\2\172\2\164\1\172\1\163\1\171\1\uffff\1\172\1\151\2\172\1\163\1\164\1\154\1\126\1\164\2\172\1\uffff\1\151\1\uffff\1\166\2\uffff\1\172\1\uffff\1\164\1\157\2\uffff\2\172\1\uffff\1\164\1\172\1\uffff\1\166\2\uffff\2\172\1\145\1\101\1\151\2\uffff\1\162\1\145\1\uffff\1\151\1\156\2\uffff\1\163\1\uffff\1\145\2\uffff\1\143\1\122\1\157\1\163\1\172\1\166\3\172\1\164\1\172\1\156\1\164\1\uffff\1\145\3\uffff\1\172\1\uffff\3\172\4\uffff"; - static final String DFA14_acceptS = - "\10\uffff\1\11\1\12\1\uffff\1\14\1\16\1\17\1\20\1\uffff\1\23\1\24\1\25\1\uffff\1\30\11\uffff\1\46\4\uffff\1\65\7\uffff\1\115\2\uffff\1\122\1\123\4\uffff\1\115\15\uffff\1\11\1\12\1\57\1\13\1\14\1\16\1\17\1\20\1\22\1\61\1\63\1\23\1\24\1\25\3\uffff\1\30\6\uffff\1\54\1\37\1\41\1\44\1\42\1\114\1\uffff\1\45\1\66\1\46\3\uffff\1\55\1\60\1\70\1\62\1\64\1\65\1\120\1\121\1\67\4\uffff\1\116\1\uffff\1\117\1\122\11\uffff\1\47\1\4\62\uffff\1\106\4\uffff\1\32\6\uffff\1\43\6\uffff\1\111\6\uffff\1\2\7\uffff\1\51\1\7\4\uffff\1\104\2\uffff\1\31\4\uffff\1\35\2\uffff\1\50\1\uffff\1\102\2\uffff\1\110\2\uffff\1\15\20\uffff\1\103\13\uffff\1\52\1\uffff\1\73\1\uffff\1\100\1\3\1\uffff\1\6\2\uffff\1\40\1\76\2\uffff\1\10\2\uffff\1\101\1\uffff\1\75\1\34\5\uffff\1\1\1\27\2\uffff\1\56\2\uffff\1\21\1\72\1\uffff\1\26\1\uffff\1\36\1\53\15\uffff\1\112\1\uffff\1\5\1\77\1\33\1\uffff\1\105\3\uffff\1\71\1\107\1\74\1\113"; - static final String DFA14_specialS = - "\1\2\53\uffff\1\0\1\1\u0122\uffff}>"; - static final String[] DFA14_transitionS = { - "\11\57\2\56\2\57\1\56\22\57\1\56\1\41\1\54\1\16\2\57\1\40\1\55\1\14\1\15\1\20\1\43\1\24\1\35\1\33\1\44\12\51\1\32\1\13\1\42\1\12\1\17\1\36\1\57\2\53\1\46\3\53\1\45\4\53\1\47\6\53\1\50\7\53\1\21\1\57\1\22\1\52\1\53\1\57\1\4\1\53\1\6\1\30\1\5\1\23\2\53\1\3\1\53\1\25\1\34\1\53\1\7\1\53\1\27\1\53\1\26\1\1\1\37\2\53\1\2\3\53\1\10\1\31\1\11\uff82\57", - "\1\60\1\uffff\1\62\11\uffff\1\63\7\uffff\1\61", - "\1\65", - "\1\70\6\uffff\1\66\1\67", - "\1\71", - "\1\73\13\uffff\1\72", - "\1\74\15\uffff\1\75", - "\1\76\3\uffff\1\101\11\uffff\1\77\5\uffff\1\100", - "", + protected DFA23 dfa23 = new DFA23(this); + static final String DFA23_eotS = + "\1\uffff\7\72\2\uffff\1\115\4\uffff\1\124\1\127\2\uffff\1\72\1\uffff\4\72\1\145\1\147\1\151\1\72\1\157\1\162\1\72\1\167\1\171\1\174\1\177\1\u0083\4\72\1\u0089\1\72\2\u008d\1\62\5\uffff\7\72\1\uffff\4\72\1\u009f\1\u00a0\10\72\2\uffff\1\u00ae\16\uffff\3\72\1\uffff\4\72\1\u00ba\1\72\4\uffff\1\u00bd\2\uffff\1\72\7\uffff\3\72\2\uffff\1\u00c5\13\uffff\4\72\2\uffff\1\72\1\uffff\1\u008d\2\uffff\1\u008d\2\uffff\15\72\2\uffff\13\72\1\u00e6\2\uffff\3\72\1\u00ec\1\u00ed\6\72\1\uffff\1\72\2\uffff\1\u00f5\4\72\1\u00fa\2\uffff\3\72\1\u00fe\1\u00ff\1\u0100\10\72\1\u010a\11\72\1\u0114\1\u0115\5\72\1\u011b\1\uffff\2\72\1\u011e\2\72\2\uffff\4\72\1\u0125\2\72\1\uffff\1\u0128\2\72\1\u012c\1\uffff\2\72\1\u012f\3\uffff\1\72\1\u0132\5\72\1\u0138\1\72\1\uffff\1\u013a\10\72\2\uffff\1\u0144\4\72\1\uffff\1\72\1\u014a\1\uffff\6\72\1\uffff\2\72\1\uffff\1\u0153\2\72\1\uffff\2\72\1\uffff\2\72\1\uffff\1\u015a\1\u015c\1\72\1\u015e\1\u015f\1\uffff\1\72\1\uffff\1\u0161\1\72\1\u0163\4\72\1\u0168\1\u0169\1\uffff\2\72\1\u016c\2\72\1\uffff\1\72\1\u0170\1\72\1\u0172\1\u0173\1\u0174\2\72\1\uffff\1\72\1\u0178\2\72\1\u017b\1\u017c\1\uffff\1\72\1\uffff\1\72\2\uffff\1\72\1\uffff\1\u0180\1\uffff\3\72\1\u0184\2\uffff\1\u0185\1\u0186\1\uffff\1\72\1\u0188\1\u0189\1\uffff\1\72\3\uffff\1\u018b\1\u018c\1\72\1\uffff\2\72\2\uffff\3\72\1\uffff\3\72\3\uffff\1\72\2\uffff\1\72\2\uffff\4\72\1\u019c\3\72\1\u01a0\1\u01a1\1\u01a2\1\72\1\u01a4\2\72\1\uffff\1\72\1\u01a8\1\72\3\uffff\1\u01aa\1\uffff\1\u01ab\1\u01ac\1\72\1\uffff\1\u01ae\3\uffff\1\u01af\2\uffff"; + static final String DFA23_eofS = + "\u01b0\uffff"; + static final String DFA23_minS = + "\1\0\1\143\1\150\1\146\1\163\1\154\2\141\2\uffff\1\75\4\uffff\1\75\1\52\2\uffff\1\141\1\uffff\2\145\1\162\1\141\1\174\1\72\1\56\1\145\1\55\1\56\1\150\1\46\2\75\1\53\1\52\1\114\1\157\1\151\1\145\1\75\1\141\2\56\1\44\5\uffff\1\157\1\151\1\154\1\162\1\141\1\160\1\156\1\uffff\1\164\1\151\1\160\1\152\2\44\1\151\2\163\1\154\1\155\1\164\1\154\1\167\2\uffff\1\75\16\uffff\1\143\1\156\1\162\1\uffff\1\171\1\143\1\145\1\164\1\44\1\146\4\uffff\1\74\2\uffff\1\164\7\uffff\1\145\1\160\1\165\2\uffff\1\75\13\uffff\1\117\1\154\1\163\1\164\2\uffff\1\154\1\uffff\1\56\2\uffff\1\60\2\uffff\1\160\1\164\1\145\1\163\2\164\1\145\1\143\1\150\2\154\2\145\2\uffff\1\145\1\157\1\163\2\145\1\143\1\164\1\154\1\151\1\105\1\154\1\44\2\uffff\1\164\1\163\1\141\2\44\1\165\1\145\1\165\1\146\2\141\1\uffff\1\141\2\uffff\1\44\1\156\1\157\2\145\1\44\2\uffff\1\102\1\154\1\164\3\44\1\145\2\143\1\151\1\102\1\151\1\162\1\150\1\44\1\145\1\162\1\151\1\143\1\141\2\156\1\162\1\164\2\44\1\150\2\145\1\156\1\170\1\44\1\uffff\1\157\1\145\1\44\2\154\2\uffff\1\162\1\143\1\162\1\151\1\44\1\151\1\165\1\uffff\1\44\1\167\1\123\1\44\1\uffff\1\101\1\145\1\44\3\uffff\1\156\1\44\1\150\2\164\1\171\1\143\1\44\1\162\1\uffff\1\44\1\164\1\145\1\164\1\156\1\163\1\144\1\164\1\163\2\uffff\1\44\1\170\1\143\1\147\1\151\1\uffff\1\162\1\44\1\uffff\2\154\1\163\1\164\1\156\1\170\1\uffff\1\156\1\154\1\uffff\1\44\1\145\1\146\1\uffff\1\114\1\143\1\uffff\1\147\1\146\1\uffff\2\44\1\151\2\44\1\uffff\1\157\1\uffff\1\44\1\163\1\44\1\143\2\151\1\163\2\44\1\uffff\2\164\1\44\1\163\1\171\1\uffff\1\171\1\44\1\151\3\44\1\163\1\164\1\uffff\1\154\1\44\1\126\1\164\2\44\1\uffff\1\151\1\uffff\1\166\2\uffff\1\156\1\uffff\1\44\1\uffff\1\145\1\164\1\157\1\44\2\uffff\2\44\1\uffff\1\164\2\44\1\uffff\1\166\3\uffff\2\44\1\145\1\uffff\1\101\1\151\2\uffff\1\162\1\145\1\151\1\uffff\1\157\1\151\1\156\3\uffff\1\163\2\uffff\1\145\2\uffff\1\143\1\122\1\157\1\163\1\44\1\172\1\146\1\166\3\44\1\164\1\44\1\156\1\164\1\uffff\1\145\1\44\1\145\3\uffff\1\44\1\uffff\2\44\1\144\1\uffff\1\44\3\uffff\1\44\2\uffff"; + static final String DFA23_maxS = + "\1\uffff\1\171\1\151\1\156\1\163\1\170\1\157\1\165\2\uffff\1\76\4\uffff\1\76\1\75\2\uffff\1\157\1\uffff\2\145\1\162\1\157\1\174\1\72\1\71\1\145\1\76\1\72\1\171\1\46\1\75\1\76\2\75\1\114\1\157\1\151\1\145\1\75\1\141\1\170\1\154\1\172\5\uffff\1\157\1\151\1\156\1\162\1\141\1\160\1\156\1\uffff\1\164\1\151\1\160\1\163\2\172\1\164\1\163\1\164\1\156\1\155\1\164\1\154\1\167\2\uffff\1\75\16\uffff\1\154\1\156\1\162\1\uffff\1\171\1\164\1\145\1\164\1\172\1\146\4\uffff\1\74\2\uffff\1\164\7\uffff\1\162\1\160\1\171\2\uffff\1\75\13\uffff\1\117\1\154\1\163\1\164\2\uffff\1\162\1\uffff\1\154\2\uffff\1\154\2\uffff\1\160\1\164\1\145\1\163\2\164\1\145\1\143\1\150\1\154\1\157\1\145\1\164\2\uffff\1\145\1\157\1\163\2\145\1\143\1\164\1\154\1\151\1\105\1\154\1\172\2\uffff\1\164\1\163\1\144\2\172\1\165\1\145\1\165\1\146\2\141\1\uffff\1\141\2\uffff\1\172\1\156\1\157\2\145\1\172\2\uffff\1\102\1\154\1\164\3\172\1\151\2\143\1\151\1\102\1\151\1\162\1\150\1\172\1\145\1\162\1\151\1\143\1\141\2\156\1\162\1\164\2\172\1\150\2\145\1\156\1\170\1\172\1\uffff\1\157\1\145\1\172\2\154\2\uffff\1\162\1\143\1\162\1\151\1\172\1\151\1\165\1\uffff\1\172\1\167\1\157\1\172\1\uffff\1\101\1\145\1\172\3\uffff\1\156\1\172\1\150\2\164\1\171\1\143\1\172\1\162\1\uffff\1\172\1\164\1\145\1\164\1\156\2\163\1\164\1\163\2\uffff\1\172\1\170\1\143\1\147\1\151\1\uffff\1\162\1\172\1\uffff\2\154\1\163\1\164\1\156\1\170\1\uffff\1\156\1\154\1\uffff\1\172\1\145\1\146\1\uffff\1\114\1\143\1\uffff\1\147\1\146\1\uffff\2\172\1\151\2\172\1\uffff\1\157\1\uffff\1\172\1\163\1\172\1\143\2\151\1\163\2\172\1\uffff\2\164\1\172\1\163\1\171\1\uffff\1\171\1\172\1\151\3\172\1\163\1\164\1\uffff\1\154\1\172\1\126\1\164\2\172\1\uffff\1\151\1\uffff\1\166\2\uffff\1\156\1\uffff\1\172\1\uffff\1\145\1\164\1\157\1\172\2\uffff\2\172\1\uffff\1\164\2\172\1\uffff\1\166\3\uffff\2\172\1\145\1\uffff\1\101\1\151\2\uffff\1\162\1\145\1\151\1\uffff\1\157\1\151\1\156\3\uffff\1\163\2\uffff\1\145\2\uffff\1\143\1\122\1\157\1\163\2\172\1\146\1\166\3\172\1\164\1\172\1\156\1\164\1\uffff\1\145\1\172\1\145\3\uffff\1\172\1\uffff\2\172\1\144\1\uffff\1\172\3\uffff\1\172\2\uffff"; + static final String DFA23_acceptS = + "\10\uffff\1\11\1\12\1\uffff\1\14\1\16\1\17\1\20\2\uffff\1\24\1\25\1\uffff\1\30\31\uffff\1\162\2\163\1\166\1\167\7\uffff\1\162\16\uffff\1\11\1\12\1\uffff\1\124\1\13\1\14\1\16\1\17\1\20\1\22\1\61\1\63\1\114\1\127\1\23\1\24\1\25\3\uffff\1\30\6\uffff\1\54\1\37\1\41\1\44\1\uffff\1\42\1\156\1\uffff\1\45\1\113\1\132\1\66\1\126\1\133\1\46\3\uffff\1\55\1\153\1\uffff\1\70\1\62\1\125\1\64\1\112\1\131\1\65\1\115\1\164\1\165\1\67\4\uffff\1\116\1\130\1\uffff\1\157\1\uffff\1\160\1\161\1\uffff\1\163\1\166\15\uffff\1\47\1\4\14\uffff\1\117\1\57\13\uffff\1\136\1\uffff\1\122\1\123\6\uffff\1\120\1\60\40\uffff\1\106\5\uffff\1\134\1\32\7\uffff\1\43\4\uffff\1\147\3\uffff\1\111\1\137\1\140\11\uffff\1\2\11\uffff\1\51\1\7\5\uffff\1\104\2\uffff\1\31\6\uffff\1\35\2\uffff\1\50\3\uffff\1\102\2\uffff\1\110\2\uffff\1\15\5\uffff\1\143\1\uffff\1\135\11\uffff\1\152\5\uffff\1\103\10\uffff\1\145\6\uffff\1\52\1\uffff\1\73\1\uffff\1\100\1\142\1\uffff\1\3\1\uffff\1\6\4\uffff\1\40\1\76\2\uffff\1\10\3\uffff\1\101\1\uffff\1\75\1\146\1\34\3\uffff\1\144\2\uffff\1\1\1\27\3\uffff\1\56\3\uffff\1\141\1\21\1\72\1\uffff\1\26\1\150\1\uffff\1\36\1\53\17\uffff\1\154\3\uffff\1\5\1\77\1\33\1\uffff\1\105\3\uffff\1\121\1\uffff\1\71\1\107\1\74\1\uffff\1\155\1\151"; + static final String DFA23_specialS = + "\1\0\u01af\uffff}>"; + static final String[] DFA23_transitionS = { + "\11\62\2\61\2\62\1\61\22\62\1\61\1\41\1\57\1\16\1\56\1\51\1\40\1\60\1\14\1\15\1\20\1\43\1\24\1\35\1\33\1\44\1\53\11\54\1\32\1\13\1\42\1\12\1\17\1\36\1\62\2\56\1\46\3\56\1\45\4\56\1\47\6\56\1\50\7\56\1\21\1\62\1\22\1\55\1\56\1\62\1\4\1\56\1\6\1\30\1\5\1\23\2\56\1\3\1\56\1\25\1\34\1\56\1\7\1\56\1\27\1\56\1\26\1\1\1\37\1\56\1\52\1\2\3\56\1\10\1\31\1\11\uff82\62", + "\1\63\1\uffff\1\65\11\uffff\1\66\4\uffff\1\67\1\70\1\uffff\1\64\1\uffff\1\71", + "\1\74\1\73", + "\1\77\6\uffff\1\75\1\76", + "\1\100", + "\1\102\13\uffff\1\101", + "\1\103\15\uffff\1\104", + "\1\105\3\uffff\1\110\11\uffff\1\106\5\uffff\1\107", "", - "\1\104", "", + "\1\113\1\114", "", "", "", - "\1\113\1\112", "", + "\1\123\1\122", + "\1\126\22\uffff\1\125", "", "", - "\1\120\7\uffff\1\121\5\uffff\1\122", + "\1\132\7\uffff\1\133\5\uffff\1\134", "", - "\1\124", - "\1\125", - "\1\126", - "\1\127\3\uffff\1\131\11\uffff\1\130", - "\1\132", - "\1\134", - "\12\137", + "\1\136", + "\1\137", "\1\140", - "\1\141", - "", - "\1\144\11\uffff\1\146\6\uffff\1\145", - "\1\147", - "\1\150", - "\1\152", - "", - "\1\155\4\uffff\1\156", - "\1\160", - "\1\161", - "\1\162", - "\1\163", - "\1\137\1\uffff\12\165", - "\32\64\4\uffff\1\64\1\uffff\32\64", - "", - "\0\166", - "\0\166", - "", - "", + "\1\141\3\uffff\1\143\11\uffff\1\142", + "\1\144", + "\1\146", + "\1\150\1\uffff\12\152", + "\1\153", + "\1\156\17\uffff\1\155\1\154", + "\1\161\13\uffff\1\160", + "\1\163\11\uffff\1\165\6\uffff\1\164", + "\1\166", "\1\170", - "\1\171", - "\1\172\1\uffff\1\173", - "\1\174", - "", - "\1\175", - "\1\176", - "\1\177\10\uffff\1\u0080", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u0085\6\uffff\1\u0084\3\uffff\1\u0083", + "\1\172\1\173", + "\1\176\21\uffff\1\175", + "\1\u0081\4\uffff\1\u0082\15\uffff\1\u0080", + "\1\u0084", + "\1\u0085", "\1\u0086", "\1\u0087", - "\1\u0089\1\uffff\1\u0088", + "\1\u0088", "\1\u008a", - "\1\u008b", - "\1\u008c", - "\1\u008d", + "\1\152\1\uffff\12\u008c\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\13\uffff\1\u008b\6\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\13\uffff\1\u008b", + "\1\152\1\uffff\12\u008c\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\22\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e", + "\1\72\34\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", "", "", "", "", + "\1\u0092", + "\1\u0093", + "\1\u0094\1\uffff\1\u0095", + "\1\u0096", + "\1\u0097", + "\1\u0098", + "\1\u0099", "", + "\1\u009a", + "\1\u009b", + "\1\u009c", + "\1\u009d\10\uffff\1\u009e", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u00a3\6\uffff\1\u00a2\3\uffff\1\u00a1", + "\1\u00a4", + "\1\u00a5\1\u00a6", + "\1\u00a8\1\uffff\1\u00a7", + "\1\u00a9", + "\1\u00aa", + "\1\u00ab", + "\1\u00ac", "", "", + "\1\u00ad", "", "", "", "", "", "", - "\1\u008e\10\uffff\1\u008f", - "\1\u0090", - "\1\u0091", "", - "\1\u0092", - "\1\u0093\6\uffff\1\u0094", - "\1\u0095", - "\1\u0096", - "\1\u0097", - "\1\u0098", "", "", "", "", "", "", - "\1\u0099", "", + "\1\u00af\10\uffff\1\u00b0", + "\1\u00b1", + "\1\u00b2", "", + "\1\u00b3", + "\1\u00b4\6\uffff\1\u00b5\11\uffff\1\u00b6", + "\1\u00b7", + "\1\u00b8", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\14\72\1\u00b9\15\72", + "\1\u00bb", "", - "\1\u009a", - "\1\u009b", - "\1\u009c", "", "", "", + "\1\u00bc", "", "", + "\1\u00be", "", "", "", "", - "\1\u009d", - "\1\u009e", - "\1\u009f", - "\1\u00a0", "", - "\1\137\1\uffff\12\165", "", "", - "\1\u00a1", - "\1\u00a2", - "\1\u00a3", - "\1\u00a4", - "\1\u00a5", - "\1\u00a6", - "\1\u00a8\2\uffff\1\u00a7", - "\1\u00a9", - "\1\u00aa", + "\1\u00bf\14\uffff\1\u00c0", + "\1\u00c1", + "\1\u00c2\3\uffff\1\u00c3", "", "", - "\1\u00ab", - "\1\u00ac", - "\1\u00ad", - "\1\u00ae", - "\1\u00af", - "\1\u00b0", - "\1\u00b1", - "\1\u00b2", - "\1\u00b3", - "\1\u00b4", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00b6", - "\1\u00b7", - "\1\u00b8", - "\1\u00b9", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00bb", - "\1\u00bc", - "\1\u00bd", - "\1\u00be", - "\1\u00bf", - "\1\u00c0", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00c2", - "\1\u00c3", "\1\u00c4", - "\1\u00c5", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", "\1\u00c6", "\1\u00c7", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00ca\3\uffff\1\u00c9", - "\1\u00cb", + "\1\u00c8", + "\1\u00c9", + "", + "", + "\1\u00cb\5\uffff\1\u00ca", + "", + "\1\152\1\uffff\12\u008c\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\22\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e", + "", + "", + "\12\u008f\10\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e\22\uffff\1\u008f\2\uffff\1\u008e\1\uffff\3\u008e\5\uffff\1\u008e", + "", + "", "\1\u00cc", "\1\u00cd", "\1\u00ce", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u00cf", "\1\u00d0", "\1\u00d1", "\1\u00d2", "\1\u00d3", "\1\u00d4", "\1\u00d5", - "\1\u00d6", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00d9", - "\1\u00da", + "\1\u00d7\2\uffff\1\u00d6", + "\1\u00d8", + "\1\u00da\16\uffff\1\u00d9", + "", + "", "\1\u00db", "\1\u00dc", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "", + "\1\u00dd", "\1\u00de", "\1\u00df", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u00e0", "\1\u00e1", - "", "\1\u00e2", "\1\u00e3", "\1\u00e4", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00e6", - "\1\u00e7", + "\1\u00e5", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00e9", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u00eb", - "\1\u00ec", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", "", + "\1\u00e7", + "\1\u00e8", + "\1\u00ea\2\uffff\1\u00e9", + "\1\72\13\uffff\12\72\7\uffff\1\u00eb\31\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u00ee", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\16\64\1\u00ef\13\64", + "\1\u00ef", + "\1\u00f0", "\1\u00f1", "\1\u00f2", "\1\u00f3", + "", "\1\u00f4", "", - "\1\u00f5", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u00f6", "\1\u00f7", "\1\u00f8", "\1\u00f9", - "\1\u00fa", - "\1\u00fb", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", "", + "\1\u00fb", "\1\u00fc", "\1\u00fd", - "\1\u00fe", - "\1\u00ff", - "", - "\1\u0100", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "", - "\1\u0102", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0102\3\uffff\1\u0101", "\1\u0103", "\1\u0104", "\1\u0105", - "", "\1\u0106", "\1\u0107", - "", "\1\u0108", - "", "\1\u0109", - "\1\u010a", - "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u010b", "\1\u010c", - "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\5\64\1\u010e\24\64\4\uffff\1\64\1\uffff\32\64", + "\1\u010d", + "\1\u010e", + "\1\u010f", "\1\u0110", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u0111", + "\1\u0112", "\1\u0113", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\1\u0115", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u0116", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u0117", + "\1\u0118", "\1\u0119", "\1\u011a", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "", "\1\u011c", "\1\u011d", - "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u011f", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u0120", + "", + "", + "\1\u0121", "\1\u0122", "\1\u0123", "\1\u0124", - "\1\u0125", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u0126", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u0127", "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u0129", + "\1\u012a\33\uffff\1\u012b", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", - "\1\u012a", - "", - "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "", - "\1\u012c", "\1\u012d", + "\1\u012e", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", "", "\1\u0130", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "", - "\1\u0132", - "", - "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\16\72\1\u0131\13\72", + "\1\u0133", + "\1\u0134", "\1\u0135", "\1\u0136", "\1\u0137", - "", - "", - "\1\u0138", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u0139", "", - "\1\u013a", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "\1\u013b", - "", - "", "\1\u013c", - "", "\1\u013d", - "", - "", "\1\u013e", "\1\u013f", - "\1\u0140", - "\1\u0141", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u0141\16\uffff\1\u0140", + "\1\u0142", "\1\u0143", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0145", + "\1\u0146", "\1\u0147", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\u0148", + "", "\1\u0149", - "\1\u014a", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", "\1\u014b", + "\1\u014c", + "\1\u014d", + "\1\u014e", + "\1\u014f", + "\1\u0150", + "", + "\1\u0151", + "\1\u0152", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0154", + "\1\u0155", + "", + "\1\u0156", + "\1\u0157", + "", + "\1\u0158", + "\1\u0159", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\5\72\1\u015b\24\72\4\uffff\1\72\1\uffff\32\72", + "\1\u015d", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "", + "\1\u0160", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0162", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0164", + "\1\u0165", + "\1\u0166", + "\1\u0167", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "", + "\1\u016a", + "\1\u016b", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u016d", + "\1\u016e", + "", + "\1\u016f", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0171", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0175", + "\1\u0176", + "", + "\1\u0177", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u0179", + "\1\u017a", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "", + "\1\u017d", + "", + "\1\u017e", + "", + "", + "\1\u017f", "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", + "\1\u0181", + "\1\u0182", + "\1\u0183", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", "", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", - "\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", + "\1\u0187", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", + "\1\u018a", + "", + "", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u018d", + "", + "\1\u018e", + "\1\u018f", + "", + "", + "\1\u0190", + "\1\u0191", + "\1\u0192", + "", + "\1\u0193", + "\1\u0194", + "\1\u0195", + "", + "", + "", + "\1\u0196", + "", + "", + "\1\u0197", + "", + "", + "\1\u0198", + "\1\u0199", + "\1\u019a", + "\1\u019b", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u019d", + "\1\u019e", + "\1\u019f", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u01a3", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u01a5", + "\1\u01a6", + "", + "\1\u01a7", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u01a9", + "", + "", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "\1\u01ad", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", + "", + "", + "", + "\1\72\13\uffff\12\72\7\uffff\32\72\4\uffff\1\72\1\uffff\32\72", "", "" }; - static final short[] DFA14_eot = DFA.unpackEncodedString(DFA14_eotS); - static final short[] DFA14_eof = DFA.unpackEncodedString(DFA14_eofS); - static final char[] DFA14_min = DFA.unpackEncodedStringToUnsignedChars(DFA14_minS); - static final char[] DFA14_max = DFA.unpackEncodedStringToUnsignedChars(DFA14_maxS); - static final short[] DFA14_accept = DFA.unpackEncodedString(DFA14_acceptS); - static final short[] DFA14_special = DFA.unpackEncodedString(DFA14_specialS); - static final short[][] DFA14_transition; + static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); + static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); + static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); + static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); + static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); + static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); + static final short[][] DFA23_transition; static { - int numStates = DFA14_transitionS.length; - DFA14_transition = new short[numStates][]; + int numStates = DFA23_transitionS.length; + DFA23_transition = new short[numStates][]; for (int i=0; i='\u0000' && LA14_44<='\uFFFF')) ) {s = 118;} - - else s = 47; - - if ( s>=0 ) return s; - break; - case 1 : - int LA14_45 = input.LA(1); + int LA23_0 = input.LA(1); s = -1; - if ( ((LA14_45>='\u0000' && LA14_45<='\uFFFF')) ) {s = 118;} + if ( (LA23_0=='s') ) {s = 1;} - else s = 47; + else if ( (LA23_0=='w') ) {s = 2;} - if ( s>=0 ) return s; - break; - case 2 : - int LA14_0 = input.LA(1); + else if ( (LA23_0=='i') ) {s = 3;} - s = -1; - if ( (LA14_0=='s') ) {s = 1;} + else if ( (LA23_0=='a') ) {s = 4;} - else if ( (LA14_0=='w') ) {s = 2;} + else if ( (LA23_0=='e') ) {s = 5;} - else if ( (LA14_0=='i') ) {s = 3;} + else if ( (LA23_0=='c') ) {s = 6;} - else if ( (LA14_0=='a') ) {s = 4;} + else if ( (LA23_0=='n') ) {s = 7;} - else if ( (LA14_0=='e') ) {s = 5;} + else if ( (LA23_0=='{') ) {s = 8;} - else if ( (LA14_0=='c') ) {s = 6;} + else if ( (LA23_0=='}') ) {s = 9;} - else if ( (LA14_0=='n') ) {s = 7;} + else if ( (LA23_0=='=') ) {s = 10;} - else if ( (LA14_0=='{') ) {s = 8;} + else if ( (LA23_0==';') ) {s = 11;} - else if ( (LA14_0=='}') ) {s = 9;} + else if ( (LA23_0=='(') ) {s = 12;} - else if ( (LA14_0=='=') ) {s = 10;} + else if ( (LA23_0==')') ) {s = 13;} - else if ( (LA14_0==';') ) {s = 11;} + else if ( (LA23_0=='#') ) {s = 14;} - else if ( (LA14_0=='(') ) {s = 12;} + else if ( (LA23_0=='>') ) {s = 15;} - else if ( (LA14_0==')') ) {s = 13;} + else if ( (LA23_0=='*') ) {s = 16;} - else if ( (LA14_0=='#') ) {s = 14;} + else if ( (LA23_0=='[') ) {s = 17;} - else if ( (LA14_0=='>') ) {s = 15;} + else if ( (LA23_0==']') ) {s = 18;} - else if ( (LA14_0=='*') ) {s = 16;} + else if ( (LA23_0=='f') ) {s = 19;} - else if ( (LA14_0=='[') ) {s = 17;} + else if ( (LA23_0==',') ) {s = 20;} - else if ( (LA14_0==']') ) {s = 18;} + else if ( (LA23_0=='k') ) {s = 21;} - else if ( (LA14_0=='f') ) {s = 19;} + else if ( (LA23_0=='r') ) {s = 22;} - else if ( (LA14_0==',') ) {s = 20;} + else if ( (LA23_0=='p') ) {s = 23;} - else if ( (LA14_0=='k') ) {s = 21;} + else if ( (LA23_0=='d') ) {s = 24;} - else if ( (LA14_0=='r') ) {s = 22;} + else if ( (LA23_0=='|') ) {s = 25;} - else if ( (LA14_0=='p') ) {s = 23;} + else if ( (LA23_0==':') ) {s = 26;} - else if ( (LA14_0=='d') ) {s = 24;} + else if ( (LA23_0=='.') ) {s = 27;} - else if ( (LA14_0=='|') ) {s = 25;} + else if ( (LA23_0=='l') ) {s = 28;} - else if ( (LA14_0==':') ) {s = 26;} + else if ( (LA23_0=='-') ) {s = 29;} - else if ( (LA14_0=='.') ) {s = 27;} + else if ( (LA23_0=='?') ) {s = 30;} - else if ( (LA14_0=='l') ) {s = 28;} + else if ( (LA23_0=='t') ) {s = 31;} - else if ( (LA14_0=='-') ) {s = 29;} + else if ( (LA23_0=='&') ) {s = 32;} - else if ( (LA14_0=='?') ) {s = 30;} + else if ( (LA23_0=='!') ) {s = 33;} - else if ( (LA14_0=='t') ) {s = 31;} + else if ( (LA23_0=='<') ) {s = 34;} - else if ( (LA14_0=='&') ) {s = 32;} + else if ( (LA23_0=='+') ) {s = 35;} - else if ( (LA14_0=='!') ) {s = 33;} + else if ( (LA23_0=='/') ) {s = 36;} - else if ( (LA14_0=='<') ) {s = 34;} + else if ( (LA23_0=='G') ) {s = 37;} - else if ( (LA14_0=='+') ) {s = 35;} + else if ( (LA23_0=='C') ) {s = 38;} - else if ( (LA14_0=='/') ) {s = 36;} + else if ( (LA23_0=='L') ) {s = 39;} - else if ( (LA14_0=='G') ) {s = 37;} + else if ( (LA23_0=='S') ) {s = 40;} - else if ( (LA14_0=='C') ) {s = 38;} + else if ( (LA23_0=='%') ) {s = 41;} - else if ( (LA14_0=='L') ) {s = 39;} + else if ( (LA23_0=='v') ) {s = 42;} - else if ( (LA14_0=='S') ) {s = 40;} + else if ( (LA23_0=='0') ) {s = 43;} - else if ( ((LA14_0>='0' && LA14_0<='9')) ) {s = 41;} + else if ( ((LA23_0>='1' && LA23_0<='9')) ) {s = 44;} - else if ( (LA14_0=='^') ) {s = 42;} + else if ( (LA23_0=='^') ) {s = 45;} - else if ( ((LA14_0>='A' && LA14_0<='B')||(LA14_0>='D' && LA14_0<='F')||(LA14_0>='H' && LA14_0<='K')||(LA14_0>='M' && LA14_0<='R')||(LA14_0>='T' && LA14_0<='Z')||LA14_0=='_'||LA14_0=='b'||(LA14_0>='g' && LA14_0<='h')||LA14_0=='j'||LA14_0=='m'||LA14_0=='o'||LA14_0=='q'||(LA14_0>='u' && LA14_0<='v')||(LA14_0>='x' && LA14_0<='z')) ) {s = 43;} + else if ( (LA23_0=='$'||(LA23_0>='A' && LA23_0<='B')||(LA23_0>='D' && LA23_0<='F')||(LA23_0>='H' && LA23_0<='K')||(LA23_0>='M' && LA23_0<='R')||(LA23_0>='T' && LA23_0<='Z')||LA23_0=='_'||LA23_0=='b'||(LA23_0>='g' && LA23_0<='h')||LA23_0=='j'||LA23_0=='m'||LA23_0=='o'||LA23_0=='q'||LA23_0=='u'||(LA23_0>='x' && LA23_0<='z')) ) {s = 46;} - else if ( (LA14_0=='\"') ) {s = 44;} + else if ( (LA23_0=='\"') ) {s = 47;} - else if ( (LA14_0=='\'') ) {s = 45;} + else if ( (LA23_0=='\'') ) {s = 48;} - else if ( ((LA14_0>='\t' && LA14_0<='\n')||LA14_0=='\r'||LA14_0==' ') ) {s = 46;} + else if ( ((LA23_0>='\t' && LA23_0<='\n')||LA23_0=='\r'||LA23_0==' ') ) {s = 49;} - else if ( ((LA14_0>='\u0000' && LA14_0<='\b')||(LA14_0>='\u000B' && LA14_0<='\f')||(LA14_0>='\u000E' && LA14_0<='\u001F')||(LA14_0>='$' && LA14_0<='%')||LA14_0=='@'||LA14_0=='\\'||LA14_0=='`'||(LA14_0>='~' && LA14_0<='\uFFFF')) ) {s = 47;} + else if ( ((LA23_0>='\u0000' && LA23_0<='\b')||(LA23_0>='\u000B' && LA23_0<='\f')||(LA23_0>='\u000E' && LA23_0<='\u001F')||LA23_0=='@'||LA23_0=='\\'||LA23_0=='`'||(LA23_0>='~' && LA23_0<='\uFFFF')) ) {s = 50;} if ( s>=0 ) return s; break; } NoViableAltException nvae = - new NoViableAltException(getDescription(), 14, _s, input); + new NoViableAltException(getDescription(), 23, _s, input); error(nvae); throw nvae; } diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeParser.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeParser.java index d6c09a4bd0..fdd1a82e1a 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeParser.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/parser/antlr/internal/InternalScopeParser.java @@ -23,21 +23,14 @@ @SuppressWarnings("all") public class InternalScopeParser extends AbstractInternalAntlrParser { public static final String[] tokenNames = new String[] { - "", "", "", "", "RULE_STRING", "RULE_INT", "RULE_REAL", "RULE_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'scoping'", "'with'", "'import'", "'as'", "'extension'", "'inject'", "'case'", "'naming'", "'{'", "'}'", "'='", "';'", "'scope'", "'('", "')'", "'#'", "'context'", "'>>'", "'*'", "'['", "']'", "'factory'", "'scopeof'", "','", "'find'", "'key'", "'recursive'", "'prefix'", "'data'", "'domains'", "'|'", "'export'", "'::'", "'.'", "'let'", "':'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'||'", "'&&'", "'implies'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'/'", "'!'", "'typeSelect'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'null'", "'GLOBALVAR'", "'new'", "'Collection'", "'List'", "'Set'", "'sensitive'", "'insensitive'" + "", "", "", "", "RULE_STRING", "RULE_INT", "RULE_REAL", "RULE_ID", "RULE_HEX", "RULE_DECIMAL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'scoping'", "'with'", "'import'", "'as'", "'extension'", "'inject'", "'case'", "'naming'", "'{'", "'}'", "'='", "';'", "'scope'", "'('", "')'", "'#'", "'context'", "'>>'", "'*'", "'['", "']'", "'factory'", "'scopeof'", "','", "'find'", "'key'", "'recursive'", "'prefix'", "'data'", "'domains'", "'|'", "'export'", "'::'", "'.'", "'let'", "':'", "'->'", "'?'", "'if'", "'then'", "'else'", "'switch'", "'default'", "'||'", "'&&'", "'implies'", "'=='", "'!='", "'>='", "'<='", "'>'", "'<'", "'+'", "'-'", "'/'", "'!'", "'typeSelect'", "'collect'", "'select'", "'selectFirst'", "'reject'", "'exists'", "'notExists'", "'sortBy'", "'forAll'", "'true'", "'false'", "'null'", "'GLOBALVAR'", "'new'", "'Collection'", "'List'", "'Set'", "'+='", "'-='", "'*='", "'/='", "'%='", "'==='", "'!=='", "'instanceof'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'**'", "'%'", "'++'", "'--'", "'?.'", "'for'", "'while'", "'do'", "'var'", "'val'", "'extends'", "'static'", "'super'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'&'", "'sensitive'", "'insensitive'" }; + public static final int RULE_HEX=8; public static final int T__50=50; - public static final int T__19=19; - public static final int T__15=15; public static final int T__59=59; - public static final int T__16=16; - public static final int T__17=17; - public static final int T__18=18; public static final int T__55=55; - public static final int T__12=12; public static final int T__56=56; - public static final int T__13=13; public static final int T__57=57; - public static final int T__14=14; public static final int T__58=58; public static final int T__51=51; public static final int T__52=52; @@ -47,55 +40,26 @@ public class InternalScopeParser extends AbstractInternalAntlrParser { public static final int T__61=61; public static final int RULE_ID=7; public static final int RULE_REAL=6; - public static final int T__26=26; - public static final int T__27=27; - public static final int T__28=28; public static final int RULE_INT=5; - public static final int T__29=29; - public static final int T__22=22; public static final int T__66=66; - public static final int RULE_ML_COMMENT=8; - public static final int T__23=23; + public static final int RULE_ML_COMMENT=10; public static final int T__67=67; - public static final int T__24=24; public static final int T__68=68; - public static final int T__25=25; public static final int T__69=69; public static final int T__62=62; public static final int T__63=63; - public static final int T__20=20; public static final int T__64=64; - public static final int T__21=21; public static final int T__65=65; - public static final int T__70=70; - public static final int T__71=71; - public static final int T__72=72; - public static final int RULE_STRING=4; - public static final int RULE_SL_COMMENT=9; public static final int T__37=37; public static final int T__38=38; public static final int T__39=39; public static final int T__33=33; - public static final int T__77=77; public static final int T__34=34; - public static final int T__78=78; public static final int T__35=35; - public static final int T__79=79; public static final int T__36=36; - public static final int T__73=73; - public static final int EOF=-1; public static final int T__30=30; - public static final int T__74=74; public static final int T__31=31; - public static final int T__75=75; public static final int T__32=32; - public static final int T__76=76; - public static final int T__80=80; - public static final int T__81=81; - public static final int T__82=82; - public static final int T__83=83; - public static final int RULE_WS=10; - public static final int RULE_ANY_OTHER=11; public static final int T__48=48; public static final int T__49=49; public static final int T__44=44; @@ -103,12 +67,84 @@ public class InternalScopeParser extends AbstractInternalAntlrParser { public static final int T__46=46; public static final int T__47=47; public static final int T__40=40; - public static final int T__84=84; public static final int T__41=41; - public static final int T__85=85; public static final int T__42=42; - public static final int T__86=86; public static final int T__43=43; + public static final int T__91=91; + public static final int T__100=100; + public static final int T__92=92; + public static final int T__93=93; + public static final int T__102=102; + public static final int T__94=94; + public static final int T__101=101; + public static final int T__90=90; + public static final int T__19=19; + public static final int T__15=15; + public static final int T__16=16; + public static final int T__17=17; + public static final int T__18=18; + public static final int T__99=99; + public static final int T__14=14; + public static final int T__95=95; + public static final int T__96=96; + public static final int T__97=97; + public static final int T__98=98; + public static final int RULE_DECIMAL=9; + public static final int T__26=26; + public static final int T__27=27; + public static final int T__28=28; + public static final int T__29=29; + public static final int T__22=22; + public static final int T__23=23; + public static final int T__24=24; + public static final int T__25=25; + public static final int T__20=20; + public static final int T__21=21; + public static final int T__122=122; + public static final int T__70=70; + public static final int T__121=121; + public static final int T__71=71; + public static final int T__72=72; + public static final int T__120=120; + public static final int RULE_STRING=4; + public static final int RULE_SL_COMMENT=11; + public static final int T__77=77; + public static final int T__119=119; + public static final int T__78=78; + public static final int T__118=118; + public static final int T__79=79; + public static final int T__73=73; + public static final int T__115=115; + public static final int EOF=-1; + public static final int T__74=74; + public static final int T__114=114; + public static final int T__75=75; + public static final int T__117=117; + public static final int T__76=76; + public static final int T__116=116; + public static final int T__80=80; + public static final int T__111=111; + public static final int T__81=81; + public static final int T__110=110; + public static final int T__82=82; + public static final int T__113=113; + public static final int T__83=83; + public static final int T__112=112; + public static final int RULE_WS=12; + public static final int RULE_ANY_OTHER=13; + public static final int T__88=88; + public static final int T__108=108; + public static final int T__89=89; + public static final int T__107=107; + public static final int T__109=109; + public static final int T__84=84; + public static final int T__104=104; + public static final int T__85=85; + public static final int T__103=103; + public static final int T__86=86; + public static final int T__106=106; + public static final int T__87=87; + public static final int T__105=105; // delegates // delegators @@ -219,7 +255,7 @@ public final EObject ruleScopeModel() throws RecognitionException { // InternalScope.g:79:2: (otherlv_0= 'scoping' ( (lv_name_1_0= ruleDottedID ) ) (otherlv_2= 'with' ( ( ruleDottedID ) ) )? ( (lv_imports_4_0= ruleImport ) )* ( (lv_extensions_5_0= ruleExtension ) )* ( (lv_injections_6_0= ruleInjection ) )* ( (lv_naming_7_0= ruleNamingSection ) )? ( (lv_scopes_8_0= ruleScopeDefinition ) )* ) // InternalScope.g:80:3: otherlv_0= 'scoping' ( (lv_name_1_0= ruleDottedID ) ) (otherlv_2= 'with' ( ( ruleDottedID ) ) )? ( (lv_imports_4_0= ruleImport ) )* ( (lv_extensions_5_0= ruleExtension ) )* ( (lv_injections_6_0= ruleInjection ) )* ( (lv_naming_7_0= ruleNamingSection ) )? ( (lv_scopes_8_0= ruleScopeDefinition ) )* { - otherlv_0=(Token)match(input,12,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,14,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getScopeModelAccess().getScopingKeyword_0()); @@ -264,14 +300,14 @@ public final EObject ruleScopeModel() throws RecognitionException { int alt1=2; int LA1_0 = input.LA(1); - if ( (LA1_0==13) ) { + if ( (LA1_0==15) ) { alt1=1; } switch (alt1) { case 1 : // InternalScope.g:104:4: otherlv_2= 'with' ( ( ruleDottedID ) ) { - otherlv_2=(Token)match(input,13,FOLLOW_3); if (state.failed) return current; + otherlv_2=(Token)match(input,15,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getScopeModelAccess().getWithKeyword_2_0()); @@ -323,7 +359,7 @@ public final EObject ruleScopeModel() throws RecognitionException { int alt2=2; int LA2_0 = input.LA(1); - if ( (LA2_0==14) ) { + if ( (LA2_0==16) ) { alt2=1; } @@ -376,7 +412,7 @@ public final EObject ruleScopeModel() throws RecognitionException { int alt3=2; int LA3_0 = input.LA(1); - if ( (LA3_0==16) ) { + if ( (LA3_0==18) ) { alt3=1; } @@ -429,7 +465,7 @@ public final EObject ruleScopeModel() throws RecognitionException { int alt4=2; int LA4_0 = input.LA(1); - if ( (LA4_0==17) ) { + if ( (LA4_0==19) ) { alt4=1; } @@ -480,7 +516,7 @@ public final EObject ruleScopeModel() throws RecognitionException { int alt5=2; int LA5_0 = input.LA(1); - if ( ((LA5_0>=18 && LA5_0<=19)) ) { + if ( ((LA5_0>=20 && LA5_0<=21)) ) { alt5=1; } switch (alt5) { @@ -528,7 +564,7 @@ public final EObject ruleScopeModel() throws RecognitionException { int alt6=2; int LA6_0 = input.LA(1); - if ( (LA6_0==24) ) { + if ( (LA6_0==26) ) { alt6=1; } @@ -660,7 +696,7 @@ public final EObject ruleImport() throws RecognitionException { // InternalScope.g:238:2: (otherlv_0= 'import' ( (otherlv_1= RULE_STRING ) ) (otherlv_2= 'as' ( (lv_name_3_0= ruleIdentifier ) ) )? ) // InternalScope.g:239:3: otherlv_0= 'import' ( (otherlv_1= RULE_STRING ) ) (otherlv_2= 'as' ( (lv_name_3_0= ruleIdentifier ) ) )? { - otherlv_0=(Token)match(input,14,FOLLOW_9); if (state.failed) return current; + otherlv_0=(Token)match(input,16,FOLLOW_9); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getImportAccess().getImportKeyword_0()); @@ -695,14 +731,14 @@ public final EObject ruleImport() throws RecognitionException { int alt7=2; int LA7_0 = input.LA(1); - if ( (LA7_0==15) ) { + if ( (LA7_0==17) ) { alt7=1; } switch (alt7) { case 1 : // InternalScope.g:257:4: otherlv_2= 'as' ( (lv_name_3_0= ruleIdentifier ) ) { - otherlv_2=(Token)match(input,15,FOLLOW_3); if (state.failed) return current; + otherlv_2=(Token)match(input,17,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getImportAccess().getAsKeyword_2_0()); @@ -832,7 +868,7 @@ public final EObject ruleExtension() throws RecognitionException { // InternalScope.g:299:2: (otherlv_0= 'extension' ( (lv_extension_1_0= ruleQualifiedID ) ) ) // InternalScope.g:300:3: otherlv_0= 'extension' ( (lv_extension_1_0= ruleQualifiedID ) ) { - otherlv_0=(Token)match(input,16,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,18,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getExtensionAccess().getExtensionKeyword_0()); @@ -959,7 +995,7 @@ public final EObject ruleInjection() throws RecognitionException { // InternalScope.g:341:2: (otherlv_0= 'inject' ( (lv_type_1_0= ruleDottedID ) ) otherlv_2= 'as' ( (lv_name_3_0= ruleIdentifier ) ) ) // InternalScope.g:342:3: otherlv_0= 'inject' ( (lv_type_1_0= ruleDottedID ) ) otherlv_2= 'as' ( (lv_name_3_0= ruleIdentifier ) ) { - otherlv_0=(Token)match(input,17,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,19,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getInjectionAccess().getInjectKeyword_0()); @@ -1000,7 +1036,7 @@ public final EObject ruleInjection() throws RecognitionException { } - otherlv_2=(Token)match(input,15,FOLLOW_3); if (state.failed) return current; + otherlv_2=(Token)match(input,17,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getInjectionAccess().getAsKeyword_2()); @@ -1146,14 +1182,14 @@ public final EObject ruleNamingSection() throws RecognitionException { int alt8=2; int LA8_0 = input.LA(1); - if ( (LA8_0==18) ) { + if ( (LA8_0==20) ) { alt8=1; } switch (alt8) { case 1 : // InternalScope.g:415:4: otherlv_1= 'case' ( (lv_casing_2_0= ruleCasing ) ) { - otherlv_1=(Token)match(input,18,FOLLOW_12); if (state.failed) return current; + otherlv_1=(Token)match(input,20,FOLLOW_12); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getNamingSectionAccess().getCaseKeyword_1_0()); @@ -1200,13 +1236,13 @@ public final EObject ruleNamingSection() throws RecognitionException { } - otherlv_3=(Token)match(input,19,FOLLOW_14); if (state.failed) return current; + otherlv_3=(Token)match(input,21,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getNamingSectionAccess().getNamingKeyword_2()); } - otherlv_4=(Token)match(input,20,FOLLOW_15); if (state.failed) return current; + otherlv_4=(Token)match(input,22,FOLLOW_15); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getNamingSectionAccess().getLeftCurlyBracketKeyword_3()); @@ -1265,7 +1301,7 @@ public final EObject ruleNamingSection() throws RecognitionException { } } while (true); - otherlv_6=(Token)match(input,21,FOLLOW_2); if (state.failed) return current; + otherlv_6=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getNamingSectionAccess().getRightCurlyBracketKeyword_5()); @@ -1389,7 +1425,7 @@ public final EObject ruleNamingDefinition() throws RecognitionException { } - otherlv_1=(Token)match(input,22,FOLLOW_17); if (state.failed) return current; + otherlv_1=(Token)match(input,24,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getNamingDefinitionAccess().getEqualsSignKeyword_1()); @@ -1430,7 +1466,7 @@ public final EObject ruleNamingDefinition() throws RecognitionException { } - otherlv_3=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,25,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getNamingDefinitionAccess().getSemicolonKeyword_3()); @@ -1526,7 +1562,7 @@ public final EObject ruleScopeDefinition() throws RecognitionException { // InternalScope.g:550:2: (otherlv_0= 'scope' (otherlv_1= '(' ( (lv_name_2_0= ruleIdentifier ) ) otherlv_3= ')' )? ( ( ( ruleQualifiedID ) ) | ( ( ( ruleQualifiedID ) ) otherlv_6= '#' ( ( ruleIdentifier ) ) ) ) otherlv_8= '{' ( (lv_rules_9_0= ruleScopeRule ) )+ otherlv_10= '}' ) // InternalScope.g:551:3: otherlv_0= 'scope' (otherlv_1= '(' ( (lv_name_2_0= ruleIdentifier ) ) otherlv_3= ')' )? ( ( ( ruleQualifiedID ) ) | ( ( ( ruleQualifiedID ) ) otherlv_6= '#' ( ( ruleIdentifier ) ) ) ) otherlv_8= '{' ( (lv_rules_9_0= ruleScopeRule ) )+ otherlv_10= '}' { - otherlv_0=(Token)match(input,24,FOLLOW_19); if (state.failed) return current; + otherlv_0=(Token)match(input,26,FOLLOW_19); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getScopeDefinitionAccess().getScopeKeyword_0()); @@ -1536,14 +1572,14 @@ public final EObject ruleScopeDefinition() throws RecognitionException { int alt10=2; int LA10_0 = input.LA(1); - if ( (LA10_0==25) ) { + if ( (LA10_0==27) ) { alt10=1; } switch (alt10) { case 1 : // InternalScope.g:556:4: otherlv_1= '(' ( (lv_name_2_0= ruleIdentifier ) ) otherlv_3= ')' { - otherlv_1=(Token)match(input,25,FOLLOW_3); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getScopeDefinitionAccess().getLeftParenthesisKeyword_1_0()); @@ -1584,7 +1620,7 @@ public final EObject ruleScopeDefinition() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_3); if (state.failed) return current; + otherlv_3=(Token)match(input,28,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getScopeDefinitionAccess().getRightParenthesisKeyword_1_2()); @@ -1680,7 +1716,7 @@ public final EObject ruleScopeDefinition() throws RecognitionException { } - otherlv_6=(Token)match(input,27,FOLLOW_3); if (state.failed) return current; + otherlv_6=(Token)match(input,29,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getScopeDefinitionAccess().getNumberSignKeyword_2_1_1()); @@ -1729,7 +1765,7 @@ public final EObject ruleScopeDefinition() throws RecognitionException { } - otherlv_8=(Token)match(input,20,FOLLOW_22); if (state.failed) return current; + otherlv_8=(Token)match(input,22,FOLLOW_22); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_8, grammarAccess.getScopeDefinitionAccess().getLeftCurlyBracketKeyword_3()); @@ -1742,7 +1778,7 @@ public final EObject ruleScopeDefinition() throws RecognitionException { int alt12=2; int LA12_0 = input.LA(1); - if ( (LA12_0==28) ) { + if ( (LA12_0==30) ) { alt12=1; } @@ -1794,7 +1830,7 @@ public final EObject ruleScopeDefinition() throws RecognitionException { cnt12++; } while (true); - otherlv_10=(Token)match(input,21,FOLLOW_2); if (state.failed) return current; + otherlv_10=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_10, grammarAccess.getScopeDefinitionAccess().getRightCurlyBracketKeyword_5()); @@ -1890,7 +1926,7 @@ public final EObject ruleScopeRule() throws RecognitionException { // InternalScope.g:686:2: (otherlv_0= 'context' ( (lv_context_1_0= ruleScopeContext ) ) otherlv_2= '=' ( (lv_exprs_3_0= ruleScopeExpression ) ) (otherlv_4= '>>' ( (lv_exprs_5_0= ruleScopeExpression ) ) )* otherlv_6= ';' ) // InternalScope.g:687:3: otherlv_0= 'context' ( (lv_context_1_0= ruleScopeContext ) ) otherlv_2= '=' ( (lv_exprs_3_0= ruleScopeExpression ) ) (otherlv_4= '>>' ( (lv_exprs_5_0= ruleScopeExpression ) ) )* otherlv_6= ';' { - otherlv_0=(Token)match(input,28,FOLLOW_24); if (state.failed) return current; + otherlv_0=(Token)match(input,30,FOLLOW_24); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getScopeRuleAccess().getContextKeyword_0()); @@ -1931,7 +1967,7 @@ public final EObject ruleScopeRule() throws RecognitionException { } - otherlv_2=(Token)match(input,22,FOLLOW_25); if (state.failed) return current; + otherlv_2=(Token)match(input,24,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getScopeRuleAccess().getEqualsSignKeyword_2()); @@ -1978,7 +2014,7 @@ public final EObject ruleScopeRule() throws RecognitionException { int alt13=2; int LA13_0 = input.LA(1); - if ( (LA13_0==29) ) { + if ( (LA13_0==31) ) { alt13=1; } @@ -1987,7 +2023,7 @@ public final EObject ruleScopeRule() throws RecognitionException { case 1 : // InternalScope.g:734:4: otherlv_4= '>>' ( (lv_exprs_5_0= ruleScopeExpression ) ) { - otherlv_4=(Token)match(input,29,FOLLOW_25); if (state.failed) return current; + otherlv_4=(Token)match(input,31,FOLLOW_25); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getScopeRuleAccess().getGreaterThanSignGreaterThanSignKeyword_4_0()); @@ -2037,7 +2073,7 @@ public final EObject ruleScopeRule() throws RecognitionException { } } while (true); - otherlv_6=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + otherlv_6=(Token)match(input,25,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getScopeRuleAccess().getSemicolonKeyword_5()); @@ -2132,7 +2168,7 @@ public final EObject ruleScopeContext() throws RecognitionException { int alt14=2; int LA14_0 = input.LA(1); - if ( (LA14_0==30) ) { + if ( (LA14_0==32) ) { alt14=1; } else if ( (LA14_0==RULE_ID) ) { @@ -2155,7 +2191,7 @@ else if ( (LA14_0==RULE_ID) ) { // InternalScope.g:783:5: (lv_global_0_0= '*' ) // InternalScope.g:784:6: lv_global_0_0= '*' { - lv_global_0_0=(Token)match(input,30,FOLLOW_27); if (state.failed) return current; + lv_global_0_0=(Token)match(input,32,FOLLOW_27); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_global_0_0, grammarAccess.getScopeContextAccess().getGlobalAsteriskKeyword_0_0_0()); @@ -2225,14 +2261,14 @@ else if ( (LA14_0==RULE_ID) ) { int alt15=2; int LA15_0 = input.LA(1); - if ( (LA15_0==31) ) { + if ( (LA15_0==33) ) { alt15=1; } switch (alt15) { case 1 : // InternalScope.g:815:4: otherlv_2= '[' ( (lv_guard_3_0= ruleExpression ) ) otherlv_4= ']' { - otherlv_2=(Token)match(input,31,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,33,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getScopeContextAccess().getLeftSquareBracketKeyword_1_0()); @@ -2273,7 +2309,7 @@ else if ( (LA14_0==RULE_ID) ) { } - otherlv_4=(Token)match(input,32,FOLLOW_2); if (state.failed) return current; + otherlv_4=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getScopeContextAccess().getRightSquareBracketKeyword_1_2()); @@ -2371,12 +2407,12 @@ public final EObject ruleScopeExpression() throws RecognitionException { // InternalScope.g:861:2: (this_ScopeDelegation_0= ruleScopeDelegation | this_FactoryExpression_1= ruleFactoryExpression | this_NamedScopeExpression_2= ruleNamedScopeExpression ) int alt16=3; switch ( input.LA(1) ) { - case 34: + case 36: { alt16=1; } break; - case 33: + case 35: { alt16=2; } @@ -2385,15 +2421,13 @@ public final EObject ruleScopeExpression() throws RecognitionException { case RULE_INT: case RULE_REAL: case RULE_ID: - case 20: - case 25: - case 36: - case 46: - case 50: - case 53: - case 65: + case 22: + case 27: + case 38: + case 48: + case 52: + case 55: case 67: - case 68: case 69: case 70: case 71: @@ -2410,6 +2444,8 @@ public final EObject ruleScopeExpression() throws RecognitionException { case 82: case 83: case 84: + case 85: + case 86: { alt16=3; } @@ -2572,7 +2608,7 @@ public final EObject ruleFactoryExpression() throws RecognitionException { // InternalScope.g:906:2: (otherlv_0= 'factory' ( (lv_expr_1_0= ruleExpression ) ) ) // InternalScope.g:907:3: otherlv_0= 'factory' ( (lv_expr_1_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,33,FOLLOW_17); if (state.failed) return current; + otherlv_0=(Token)match(input,35,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getFactoryExpressionAccess().getFactoryKeyword_0()); @@ -2701,13 +2737,13 @@ public final EObject ruleScopeDelegation() throws RecognitionException { // InternalScope.g:948:2: (otherlv_0= 'scopeof' otherlv_1= '(' ( ( (lv_delegate_2_0= ruleExpression ) ) | ( (lv_external_3_0= ruleGlobalScopeExpression ) ) ) (otherlv_4= ',' ( ( ruleIdentifier ) ) )? otherlv_6= ')' ) // InternalScope.g:949:3: otherlv_0= 'scopeof' otherlv_1= '(' ( ( (lv_delegate_2_0= ruleExpression ) ) | ( (lv_external_3_0= ruleGlobalScopeExpression ) ) ) (otherlv_4= ',' ( ( ruleIdentifier ) ) )? otherlv_6= ')' { - otherlv_0=(Token)match(input,34,FOLLOW_29); if (state.failed) return current; + otherlv_0=(Token)match(input,36,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getScopeDelegationAccess().getScopeofKeyword_0()); } - otherlv_1=(Token)match(input,25,FOLLOW_30); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_30); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getScopeDelegationAccess().getLeftParenthesisKeyword_1()); @@ -2717,10 +2753,10 @@ public final EObject ruleScopeDelegation() throws RecognitionException { int alt17=2; int LA17_0 = input.LA(1); - if ( ((LA17_0>=RULE_STRING && LA17_0<=RULE_ID)||LA17_0==20||LA17_0==25||LA17_0==46||LA17_0==50||LA17_0==53||LA17_0==65||(LA17_0>=67 && LA17_0<=84)) ) { + if ( ((LA17_0>=RULE_STRING && LA17_0<=RULE_ID)||LA17_0==22||LA17_0==27||LA17_0==48||LA17_0==52||LA17_0==55||LA17_0==67||(LA17_0>=69 && LA17_0<=86)) ) { alt17=1; } - else if ( (LA17_0==36) ) { + else if ( (LA17_0==38) ) { alt17=2; } else { @@ -2820,14 +2856,14 @@ else if ( (LA17_0==36) ) { int alt18=2; int LA18_0 = input.LA(1); - if ( (LA18_0==35) ) { + if ( (LA18_0==37) ) { alt18=1; } switch (alt18) { case 1 : // InternalScope.g:999:4: otherlv_4= ',' ( ( ruleIdentifier ) ) { - otherlv_4=(Token)match(input,35,FOLLOW_3); if (state.failed) return current; + otherlv_4=(Token)match(input,37,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getScopeDelegationAccess().getCommaKeyword_3_0()); @@ -2873,7 +2909,7 @@ else if ( (LA17_0==36) ) { } - otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_6=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getScopeDelegationAccess().getRightParenthesisKeyword_4()); @@ -2973,10 +3009,10 @@ public final EObject ruleNamedScopeExpression() throws RecognitionException { int alt19=2; int LA19_0 = input.LA(1); - if ( (LA19_0==36) ) { + if ( (LA19_0==38) ) { alt19=1; } - else if ( ((LA19_0>=RULE_STRING && LA19_0<=RULE_ID)||LA19_0==20||LA19_0==25||LA19_0==46||LA19_0==50||LA19_0==53||LA19_0==65||(LA19_0>=67 && LA19_0<=84)) ) { + else if ( ((LA19_0>=RULE_STRING && LA19_0<=RULE_ID)||LA19_0==22||LA19_0==27||LA19_0==48||LA19_0==52||LA19_0==55||LA19_0==67||(LA19_0>=69 && LA19_0<=86)) ) { alt19=2; } else { @@ -3038,7 +3074,7 @@ else if ( ((LA19_0>=RULE_STRING && LA19_0<=RULE_ID)||LA19_0==20||LA19_0==25||LA1 int alt20=2; int LA20_0 = input.LA(1); - if ( (LA20_0==18) ) { + if ( (LA20_0==20) ) { alt20=1; } switch (alt20) { @@ -3051,7 +3087,7 @@ else if ( ((LA19_0>=RULE_STRING && LA19_0<=RULE_ID)||LA19_0==20||LA19_0==25||LA1 // InternalScope.g:1064:5: (lv_caseDef_2_0= 'case' ) // InternalScope.g:1065:6: lv_caseDef_2_0= 'case' { - lv_caseDef_2_0=(Token)match(input,18,FOLLOW_12); if (state.failed) return current; + lv_caseDef_2_0=(Token)match(input,20,FOLLOW_12); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_caseDef_2_0, grammarAccess.getNamedScopeExpressionAccess().getCaseDefCaseKeyword_1_0_0()); @@ -3116,14 +3152,14 @@ else if ( ((LA19_0>=RULE_STRING && LA19_0<=RULE_ID)||LA19_0==20||LA19_0==25||LA1 int alt21=2; int LA21_0 = input.LA(1); - if ( (LA21_0==15) ) { + if ( (LA21_0==17) ) { alt21=1; } switch (alt21) { case 1 : // InternalScope.g:1098:4: otherlv_4= 'as' ( (lv_naming_5_0= ruleNaming ) ) { - otherlv_4=(Token)match(input,15,FOLLOW_17); if (state.failed) return current; + otherlv_4=(Token)match(input,17,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getNamedScopeExpressionAccess().getAsKeyword_2_0()); @@ -3287,13 +3323,13 @@ public final EObject ruleGlobalScopeExpression() throws RecognitionException { // InternalScope.g:1140:2: (otherlv_0= 'find' otherlv_1= '(' ( ( ruleQualifiedID ) ) ( (otherlv_3= ',' otherlv_4= 'key' otherlv_5= '=' ( (lv_name_6_0= ruleExpression ) ) ) | (otherlv_7= ',' ( (lv_recursivePrefix_8_0= 'recursive' ) )? otherlv_9= 'prefix' otherlv_10= '=' ( (lv_prefix_11_0= ruleExpression ) ) ) )? (otherlv_12= ',' otherlv_13= 'data' otherlv_14= '=' otherlv_15= '(' ( (lv_data_16_0= ruleDataExpression ) ) (otherlv_17= ',' ( (lv_data_18_0= ruleDataExpression ) ) )* otherlv_19= ')' )? (otherlv_20= ',' otherlv_21= 'domains' otherlv_22= '=' ( ( (lv_domains_23_0= '*' ) ) | ( (lv_domains_24_0= ruleIdentifier ) ) | (otherlv_25= '(' ( (lv_domains_26_0= ruleIdentifier ) ) (otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) )* otherlv_29= ')' ) ) )? otherlv_30= ')' ) // InternalScope.g:1141:3: otherlv_0= 'find' otherlv_1= '(' ( ( ruleQualifiedID ) ) ( (otherlv_3= ',' otherlv_4= 'key' otherlv_5= '=' ( (lv_name_6_0= ruleExpression ) ) ) | (otherlv_7= ',' ( (lv_recursivePrefix_8_0= 'recursive' ) )? otherlv_9= 'prefix' otherlv_10= '=' ( (lv_prefix_11_0= ruleExpression ) ) ) )? (otherlv_12= ',' otherlv_13= 'data' otherlv_14= '=' otherlv_15= '(' ( (lv_data_16_0= ruleDataExpression ) ) (otherlv_17= ',' ( (lv_data_18_0= ruleDataExpression ) ) )* otherlv_19= ')' )? (otherlv_20= ',' otherlv_21= 'domains' otherlv_22= '=' ( ( (lv_domains_23_0= '*' ) ) | ( (lv_domains_24_0= ruleIdentifier ) ) | (otherlv_25= '(' ( (lv_domains_26_0= ruleIdentifier ) ) (otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) )* otherlv_29= ')' ) ) )? otherlv_30= ')' { - otherlv_0=(Token)match(input,36,FOLLOW_29); if (state.failed) return current; + otherlv_0=(Token)match(input,38,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getGlobalScopeExpressionAccess().getFindKeyword_0()); } - otherlv_1=(Token)match(input,25,FOLLOW_3); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_1()); @@ -3337,13 +3373,13 @@ public final EObject ruleGlobalScopeExpression() throws RecognitionException { int alt23=3; int LA23_0 = input.LA(1); - if ( (LA23_0==35) ) { + if ( (LA23_0==37) ) { int LA23_1 = input.LA(2); - if ( (LA23_1==37) ) { + if ( (LA23_1==39) ) { alt23=1; } - else if ( ((LA23_1>=38 && LA23_1<=39)) ) { + else if ( ((LA23_1>=40 && LA23_1<=41)) ) { alt23=2; } } @@ -3354,19 +3390,19 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { // InternalScope.g:1166:4: (otherlv_3= ',' otherlv_4= 'key' otherlv_5= '=' ( (lv_name_6_0= ruleExpression ) ) ) // InternalScope.g:1167:5: otherlv_3= ',' otherlv_4= 'key' otherlv_5= '=' ( (lv_name_6_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,35,FOLLOW_33); if (state.failed) return current; + otherlv_3=(Token)match(input,37,FOLLOW_33); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_0_0()); } - otherlv_4=(Token)match(input,37,FOLLOW_16); if (state.failed) return current; + otherlv_4=(Token)match(input,39,FOLLOW_16); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getGlobalScopeExpressionAccess().getKeyKeyword_3_0_1()); } - otherlv_5=(Token)match(input,22,FOLLOW_17); if (state.failed) return current; + otherlv_5=(Token)match(input,24,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_0_2()); @@ -3419,7 +3455,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { // InternalScope.g:1200:4: (otherlv_7= ',' ( (lv_recursivePrefix_8_0= 'recursive' ) )? otherlv_9= 'prefix' otherlv_10= '=' ( (lv_prefix_11_0= ruleExpression ) ) ) // InternalScope.g:1201:5: otherlv_7= ',' ( (lv_recursivePrefix_8_0= 'recursive' ) )? otherlv_9= 'prefix' otherlv_10= '=' ( (lv_prefix_11_0= ruleExpression ) ) { - otherlv_7=(Token)match(input,35,FOLLOW_34); if (state.failed) return current; + otherlv_7=(Token)match(input,37,FOLLOW_34); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_3_1_0()); @@ -3429,7 +3465,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { int alt22=2; int LA22_0 = input.LA(1); - if ( (LA22_0==38) ) { + if ( (LA22_0==40) ) { alt22=1; } switch (alt22) { @@ -3439,7 +3475,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { // InternalScope.g:1206:6: (lv_recursivePrefix_8_0= 'recursive' ) // InternalScope.g:1207:7: lv_recursivePrefix_8_0= 'recursive' { - lv_recursivePrefix_8_0=(Token)match(input,38,FOLLOW_35); if (state.failed) return current; + lv_recursivePrefix_8_0=(Token)match(input,40,FOLLOW_35); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_recursivePrefix_8_0, grammarAccess.getGlobalScopeExpressionAccess().getRecursivePrefixRecursiveKeyword_3_1_1_0()); @@ -3462,13 +3498,13 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { } - otherlv_9=(Token)match(input,39,FOLLOW_16); if (state.failed) return current; + otherlv_9=(Token)match(input,41,FOLLOW_16); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_9, grammarAccess.getGlobalScopeExpressionAccess().getPrefixKeyword_3_1_2()); } - otherlv_10=(Token)match(input,22,FOLLOW_17); if (state.failed) return current; + otherlv_10=(Token)match(input,24,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_10, grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_3_1_3()); @@ -3522,10 +3558,10 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { int alt25=2; int LA25_0 = input.LA(1); - if ( (LA25_0==35) ) { + if ( (LA25_0==37) ) { int LA25_1 = input.LA(2); - if ( (LA25_1==40) ) { + if ( (LA25_1==42) ) { alt25=1; } } @@ -3533,25 +3569,25 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { case 1 : // InternalScope.g:1249:4: otherlv_12= ',' otherlv_13= 'data' otherlv_14= '=' otherlv_15= '(' ( (lv_data_16_0= ruleDataExpression ) ) (otherlv_17= ',' ( (lv_data_18_0= ruleDataExpression ) ) )* otherlv_19= ')' { - otherlv_12=(Token)match(input,35,FOLLOW_36); if (state.failed) return current; + otherlv_12=(Token)match(input,37,FOLLOW_36); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_12, grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_0()); } - otherlv_13=(Token)match(input,40,FOLLOW_16); if (state.failed) return current; + otherlv_13=(Token)match(input,42,FOLLOW_16); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_13, grammarAccess.getGlobalScopeExpressionAccess().getDataKeyword_4_1()); } - otherlv_14=(Token)match(input,22,FOLLOW_29); if (state.failed) return current; + otherlv_14=(Token)match(input,24,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_14, grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_4_2()); } - otherlv_15=(Token)match(input,25,FOLLOW_37); if (state.failed) return current; + otherlv_15=(Token)match(input,27,FOLLOW_37); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_15, grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_4_3()); @@ -3598,7 +3634,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { int alt24=2; int LA24_0 = input.LA(1); - if ( (LA24_0==35) ) { + if ( (LA24_0==37) ) { alt24=1; } @@ -3607,7 +3643,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { case 1 : // InternalScope.g:1285:5: otherlv_17= ',' ( (lv_data_18_0= ruleDataExpression ) ) { - otherlv_17=(Token)match(input,35,FOLLOW_37); if (state.failed) return current; + otherlv_17=(Token)match(input,37,FOLLOW_37); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_17, grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_4_5_0()); @@ -3657,7 +3693,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { } } while (true); - otherlv_19=(Token)match(input,26,FOLLOW_31); if (state.failed) return current; + otherlv_19=(Token)match(input,28,FOLLOW_31); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_19, grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_4_6()); @@ -3673,26 +3709,26 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { int alt28=2; int LA28_0 = input.LA(1); - if ( (LA28_0==35) ) { + if ( (LA28_0==37) ) { alt28=1; } switch (alt28) { case 1 : // InternalScope.g:1315:4: otherlv_20= ',' otherlv_21= 'domains' otherlv_22= '=' ( ( (lv_domains_23_0= '*' ) ) | ( (lv_domains_24_0= ruleIdentifier ) ) | (otherlv_25= '(' ( (lv_domains_26_0= ruleIdentifier ) ) (otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) )* otherlv_29= ')' ) ) { - otherlv_20=(Token)match(input,35,FOLLOW_38); if (state.failed) return current; + otherlv_20=(Token)match(input,37,FOLLOW_38); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_20, grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_0()); } - otherlv_21=(Token)match(input,41,FOLLOW_16); if (state.failed) return current; + otherlv_21=(Token)match(input,43,FOLLOW_16); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_21, grammarAccess.getGlobalScopeExpressionAccess().getDomainsKeyword_5_1()); } - otherlv_22=(Token)match(input,22,FOLLOW_39); if (state.failed) return current; + otherlv_22=(Token)match(input,24,FOLLOW_39); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_22, grammarAccess.getGlobalScopeExpressionAccess().getEqualsSignKeyword_5_2()); @@ -3701,7 +3737,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { // InternalScope.g:1327:4: ( ( (lv_domains_23_0= '*' ) ) | ( (lv_domains_24_0= ruleIdentifier ) ) | (otherlv_25= '(' ( (lv_domains_26_0= ruleIdentifier ) ) (otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) )* otherlv_29= ')' ) ) int alt27=3; switch ( input.LA(1) ) { - case 30: + case 32: { alt27=1; } @@ -3711,7 +3747,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { alt27=2; } break; - case 25: + case 27: { alt27=3; } @@ -3734,7 +3770,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { // InternalScope.g:1329:6: (lv_domains_23_0= '*' ) // InternalScope.g:1330:7: lv_domains_23_0= '*' { - lv_domains_23_0=(Token)match(input,30,FOLLOW_20); if (state.failed) return current; + lv_domains_23_0=(Token)match(input,32,FOLLOW_20); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_domains_23_0, grammarAccess.getGlobalScopeExpressionAccess().getDomainsAsteriskKeyword_5_3_0_0()); @@ -3804,7 +3840,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { // InternalScope.g:1363:5: (otherlv_25= '(' ( (lv_domains_26_0= ruleIdentifier ) ) (otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) )* otherlv_29= ')' ) // InternalScope.g:1364:6: otherlv_25= '(' ( (lv_domains_26_0= ruleIdentifier ) ) (otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) )* otherlv_29= ')' { - otherlv_25=(Token)match(input,25,FOLLOW_3); if (state.failed) return current; + otherlv_25=(Token)match(input,27,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_25, grammarAccess.getGlobalScopeExpressionAccess().getLeftParenthesisKeyword_5_3_2_0()); @@ -3851,7 +3887,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { int alt26=2; int LA26_0 = input.LA(1); - if ( (LA26_0==35) ) { + if ( (LA26_0==37) ) { alt26=1; } @@ -3860,7 +3896,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { case 1 : // InternalScope.g:1388:7: otherlv_27= ',' ( (lv_domains_28_0= ruleIdentifier ) ) { - otherlv_27=(Token)match(input,35,FOLLOW_3); if (state.failed) return current; + otherlv_27=(Token)match(input,37,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_27, grammarAccess.getGlobalScopeExpressionAccess().getCommaKeyword_5_3_2_2_0()); @@ -3910,7 +3946,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { } } while (true); - otherlv_29=(Token)match(input,26,FOLLOW_20); if (state.failed) return current; + otherlv_29=(Token)match(input,28,FOLLOW_20); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_29, grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_5_3_2_3()); @@ -3931,7 +3967,7 @@ else if ( ((LA23_1>=38 && LA23_1<=39)) ) { } - otherlv_30=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_30=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_30, grammarAccess.getGlobalScopeExpressionAccess().getRightParenthesisKeyword_6()); @@ -4025,7 +4061,7 @@ public final EObject ruleDataExpression() throws RecognitionException { if ( (LA29_0==RULE_ID) ) { alt29=1; } - else if ( (LA29_0==31) ) { + else if ( (LA29_0==33) ) { alt29=2; } else { @@ -4200,7 +4236,7 @@ public final EObject ruleMatchDataExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,22,FOLLOW_17); if (state.failed) return current; + otherlv_1=(Token)match(input,24,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getMatchDataExpressionAccess().getEqualsSignKeyword_1()); @@ -4328,7 +4364,7 @@ public final EObject ruleLambdaDataExpression() throws RecognitionException { // InternalScope.g:1538:2: (otherlv_0= '[' ( (lv_desc_1_0= ruleIdentifier ) ) otherlv_2= '|' ( (lv_value_3_0= ruleExpression ) ) otherlv_4= ']' ) // InternalScope.g:1539:3: otherlv_0= '[' ( (lv_desc_1_0= ruleIdentifier ) ) otherlv_2= '|' ( (lv_value_3_0= ruleExpression ) ) otherlv_4= ']' { - otherlv_0=(Token)match(input,31,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,33,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getLambdaDataExpressionAccess().getLeftSquareBracketKeyword_0()); @@ -4369,7 +4405,7 @@ public final EObject ruleLambdaDataExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,42,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,44,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getLambdaDataExpressionAccess().getVerticalLineKeyword_2()); @@ -4410,7 +4446,7 @@ public final EObject ruleLambdaDataExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,32,FOLLOW_2); if (state.failed) return current; + otherlv_4=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getLambdaDataExpressionAccess().getRightSquareBracketKeyword_4()); @@ -4626,7 +4662,7 @@ public final EObject ruleNaming() throws RecognitionException { // InternalScope.g:1646:4: (otherlv_0= '(' ( (lv_names_1_0= ruleNamingExpression ) ) (otherlv_2= ',' ( (lv_names_3_0= ruleNamingExpression ) ) )* otherlv_4= ')' ) // InternalScope.g:1647:5: otherlv_0= '(' ( (lv_names_1_0= ruleNamingExpression ) ) (otherlv_2= ',' ( (lv_names_3_0= ruleNamingExpression ) ) )* otherlv_4= ')' { - otherlv_0=(Token)match(input,25,FOLLOW_17); if (state.failed) return current; + otherlv_0=(Token)match(input,27,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getNamingAccess().getLeftParenthesisKeyword_0_0_0()); @@ -4673,7 +4709,7 @@ public final EObject ruleNaming() throws RecognitionException { int alt30=2; int LA30_0 = input.LA(1); - if ( (LA30_0==35) ) { + if ( (LA30_0==37) ) { alt30=1; } @@ -4682,7 +4718,7 @@ public final EObject ruleNaming() throws RecognitionException { case 1 : // InternalScope.g:1671:6: otherlv_2= ',' ( (lv_names_3_0= ruleNamingExpression ) ) { - otherlv_2=(Token)match(input,35,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,37,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getNamingAccess().getCommaKeyword_0_0_2_0()); @@ -4732,7 +4768,7 @@ public final EObject ruleNaming() throws RecognitionException { } } while (true); - otherlv_4=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_4=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getNamingAccess().getRightParenthesisKeyword_0_0_3()); @@ -4873,10 +4909,10 @@ public final EObject ruleNamingExpression() throws RecognitionException { int alt33=2; int LA33_0 = input.LA(1); - if ( (LA33_0==43) ) { + if ( (LA33_0==45) ) { alt33=1; } - else if ( ((LA33_0>=RULE_STRING && LA33_0<=RULE_ID)||LA33_0==20||LA33_0==25||LA33_0==33||LA33_0==46||LA33_0==50||LA33_0==53||LA33_0==65||(LA33_0>=67 && LA33_0<=84)) ) { + else if ( ((LA33_0>=RULE_STRING && LA33_0<=RULE_ID)||LA33_0==22||LA33_0==27||LA33_0==35||LA33_0==48||LA33_0==52||LA33_0==55||LA33_0==67||(LA33_0>=69 && LA33_0<=86)) ) { alt33=2; } else { @@ -4896,7 +4932,7 @@ else if ( ((LA33_0>=RULE_STRING && LA33_0<=RULE_ID)||LA33_0==20||LA33_0==25||LA3 // InternalScope.g:1741:4: (lv_export_0_0= 'export' ) // InternalScope.g:1742:5: lv_export_0_0= 'export' { - lv_export_0_0=(Token)match(input,43,FOLLOW_2); if (state.failed) return current; + lv_export_0_0=(Token)match(input,45,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_export_0_0, grammarAccess.getNamingExpressionAccess().getExportExportKeyword_0_0()); @@ -4929,7 +4965,7 @@ else if ( ((LA33_0>=RULE_STRING && LA33_0<=RULE_ID)||LA33_0==20||LA33_0==25||LA3 int alt32=2; int LA32_0 = input.LA(1); - if ( (LA32_0==33) ) { + if ( (LA32_0==35) ) { alt32=1; } switch (alt32) { @@ -4939,7 +4975,7 @@ else if ( ((LA33_0>=RULE_STRING && LA33_0<=RULE_ID)||LA33_0==20||LA33_0==25||LA3 // InternalScope.g:1757:5: (lv_factory_1_0= 'factory' ) // InternalScope.g:1758:6: lv_factory_1_0= 'factory' { - lv_factory_1_0=(Token)match(input,33,FOLLOW_17); if (state.failed) return current; + lv_factory_1_0=(Token)match(input,35,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_factory_1_0, grammarAccess.getNamingExpressionAccess().getFactoryFactoryKeyword_1_0_0()); @@ -5114,7 +5150,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedID() throws RecognitionExceptio int alt34=2; int LA34_0 = input.LA(1); - if ( (LA34_0==44) ) { + if ( (LA34_0==46) ) { alt34=1; } @@ -5123,7 +5159,7 @@ public final AntlrDatatypeRuleToken ruleQualifiedID() throws RecognitionExceptio case 1 : // InternalScope.g:1820:4: kw= '::' this_Identifier_2= ruleIdentifier { - kw=(Token)match(input,44,FOLLOW_3); if (state.failed) return current; + kw=(Token)match(input,46,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -5270,7 +5306,7 @@ public final AntlrDatatypeRuleToken ruleDottedID() throws RecognitionException { int alt35=2; int LA35_0 = input.LA(1); - if ( (LA35_0==45) ) { + if ( (LA35_0==47) ) { alt35=1; } @@ -5279,7 +5315,7 @@ public final AntlrDatatypeRuleToken ruleDottedID() throws RecognitionException { case 1 : // InternalScope.g:1866:4: kw= '.' this_Identifier_2= ruleIdentifier { - kw=(Token)match(input,45,FOLLOW_3); if (state.failed) return current; + kw=(Token)match(input,47,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { current.merge(kw); @@ -5563,7 +5599,7 @@ public final EObject ruleLetExpression() throws RecognitionException { // InternalScope.g:1948:2: (otherlv_0= 'let' ( (lv_identifier_1_0= ruleIdentifier ) ) otherlv_2= '=' ( (lv_varExpr_3_0= ruleExpression ) ) otherlv_4= ':' ( (lv_target_5_0= ruleExpression ) ) ) // InternalScope.g:1949:3: otherlv_0= 'let' ( (lv_identifier_1_0= ruleIdentifier ) ) otherlv_2= '=' ( (lv_varExpr_3_0= ruleExpression ) ) otherlv_4= ':' ( (lv_target_5_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,46,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,48,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getLetExpressionAccess().getLetKeyword_0()); @@ -5604,7 +5640,7 @@ public final EObject ruleLetExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,22,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,24,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getLetExpressionAccess().getEqualsSignKeyword_2()); @@ -5645,7 +5681,7 @@ public final EObject ruleLetExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,47,FOLLOW_17); if (state.failed) return current; + otherlv_4=(Token)match(input,49,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getLetExpressionAccess().getColonKeyword_4()); @@ -5772,7 +5808,7 @@ public final EObject ruleCastedExpression() throws RecognitionException { // InternalScope.g:2036:2: (otherlv_0= '(' ( (lv_type_1_0= ruleType ) ) otherlv_2= ')' ( (lv_target_3_0= ruleExpression ) ) ) // InternalScope.g:2037:3: otherlv_0= '(' ( (lv_type_1_0= ruleType ) ) otherlv_2= ')' ( (lv_target_3_0= ruleExpression ) ) { - otherlv_0=(Token)match(input,25,FOLLOW_44); if (state.failed) return current; + otherlv_0=(Token)match(input,27,FOLLOW_44); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getCastedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -5813,7 +5849,7 @@ public final EObject ruleCastedExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,26,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,28,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getCastedExpressionAccess().getRightParenthesisKeyword_2()); @@ -5961,7 +5997,7 @@ public final EObject ruleChainExpression() throws RecognitionException { int alt37=2; int LA37_0 = input.LA(1); - if ( (LA37_0==48) ) { + if ( (LA37_0==50) ) { alt37=1; } @@ -5983,7 +6019,7 @@ public final EObject ruleChainExpression() throws RecognitionException { } - otherlv_2=(Token)match(input,48,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,50,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getChainExpressionAccess().getHyphenMinusGreaterThanSignKeyword_1_1()); @@ -6119,7 +6155,7 @@ public final EObject ruleChainedExpression() throws RecognitionException { // InternalScope.g:2160:2: (this_IfExpressionKw_0= ruleIfExpressionKw | this_IfExpressionTri_1= ruleIfExpressionTri | this_SwitchExpression_2= ruleSwitchExpression ) int alt38=3; switch ( input.LA(1) ) { - case 50: + case 52: { alt38=1; } @@ -6128,11 +6164,9 @@ public final EObject ruleChainedExpression() throws RecognitionException { case RULE_INT: case RULE_REAL: case RULE_ID: - case 20: - case 25: - case 65: + case 22: + case 27: case 67: - case 68: case 69: case 70: case 71: @@ -6149,11 +6183,13 @@ public final EObject ruleChainedExpression() throws RecognitionException { case 82: case 83: case 84: + case 85: + case 86: { alt38=2; } break; - case 53: + case 55: { alt38=3; } @@ -6341,7 +6377,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { int alt39=2; int LA39_0 = input.LA(1); - if ( (LA39_0==49) ) { + if ( (LA39_0==51) ) { alt39=1; } switch (alt39) { @@ -6361,7 +6397,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { } - otherlv_2=(Token)match(input,49,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,51,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getIfExpressionTriAccess().getQuestionMarkKeyword_1_1()); @@ -6402,7 +6438,7 @@ public final EObject ruleIfExpressionTri() throws RecognitionException { } - otherlv_4=(Token)match(input,47,FOLLOW_17); if (state.failed) return current; + otherlv_4=(Token)match(input,49,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getIfExpressionTriAccess().getColonKeyword_1_3()); @@ -6538,7 +6574,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { // InternalScope.g:2287:2: (otherlv_0= 'if' ( (lv_condition_1_0= ruleChainedExpression ) ) otherlv_2= 'then' ( (lv_thenPart_3_0= ruleChainedExpression ) ) ( ( 'else' )=> (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) )? ) // InternalScope.g:2288:3: otherlv_0= 'if' ( (lv_condition_1_0= ruleChainedExpression ) ) otherlv_2= 'then' ( (lv_thenPart_3_0= ruleChainedExpression ) ) ( ( 'else' )=> (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) )? { - otherlv_0=(Token)match(input,50,FOLLOW_17); if (state.failed) return current; + otherlv_0=(Token)match(input,52,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getIfExpressionKwAccess().getIfKeyword_0()); @@ -6579,7 +6615,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { } - otherlv_2=(Token)match(input,51,FOLLOW_17); if (state.failed) return current; + otherlv_2=(Token)match(input,53,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getIfExpressionKwAccess().getThenKeyword_2()); @@ -6624,7 +6660,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { int alt40=2; int LA40_0 = input.LA(1); - if ( (LA40_0==52) ) { + if ( (LA40_0==54) ) { int LA40_1 = input.LA(2); if ( (synpred3_InternalScope()) ) { @@ -6638,7 +6674,7 @@ public final EObject ruleIfExpressionKw() throws RecognitionException { // InternalScope.g:2336:4: (otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) ) // InternalScope.g:2337:5: otherlv_4= 'else' ( (lv_elsePart_5_0= ruleChainedExpression ) ) { - otherlv_4=(Token)match(input,52,FOLLOW_17); if (state.failed) return current; + otherlv_4=(Token)match(input,54,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getIfExpressionKwAccess().getElseKeyword_4_0_0()); @@ -6781,7 +6817,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { // InternalScope.g:2380:2: (otherlv_0= 'switch' (otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' )? otherlv_4= '{' ( (lv_case_5_0= ruleCase ) )* otherlv_6= 'default' otherlv_7= ':' ( (lv_defaultExpr_8_0= ruleOrExpression ) ) otherlv_9= '}' ) // InternalScope.g:2381:3: otherlv_0= 'switch' (otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' )? otherlv_4= '{' ( (lv_case_5_0= ruleCase ) )* otherlv_6= 'default' otherlv_7= ':' ( (lv_defaultExpr_8_0= ruleOrExpression ) ) otherlv_9= '}' { - otherlv_0=(Token)match(input,53,FOLLOW_49); if (state.failed) return current; + otherlv_0=(Token)match(input,55,FOLLOW_49); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getSwitchExpressionAccess().getSwitchKeyword_0()); @@ -6791,14 +6827,14 @@ public final EObject ruleSwitchExpression() throws RecognitionException { int alt41=2; int LA41_0 = input.LA(1); - if ( (LA41_0==25) ) { + if ( (LA41_0==27) ) { alt41=1; } switch (alt41) { case 1 : // InternalScope.g:2386:4: otherlv_1= '(' ( (lv_switchExpr_2_0= ruleOrExpression ) ) otherlv_3= ')' { - otherlv_1=(Token)match(input,25,FOLLOW_50); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getSwitchExpressionAccess().getLeftParenthesisKeyword_1_0()); @@ -6839,7 +6875,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_14); if (state.failed) return current; + otherlv_3=(Token)match(input,28,FOLLOW_14); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getSwitchExpressionAccess().getRightParenthesisKeyword_1_2()); @@ -6851,7 +6887,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_4=(Token)match(input,20,FOLLOW_51); if (state.failed) return current; + otherlv_4=(Token)match(input,22,FOLLOW_51); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getSwitchExpressionAccess().getLeftCurlyBracketKeyword_2()); @@ -6863,7 +6899,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { int alt42=2; int LA42_0 = input.LA(1); - if ( (LA42_0==18) ) { + if ( (LA42_0==20) ) { alt42=1; } @@ -6910,13 +6946,13 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } } while (true); - otherlv_6=(Token)match(input,54,FOLLOW_43); if (state.failed) return current; + otherlv_6=(Token)match(input,56,FOLLOW_43); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getSwitchExpressionAccess().getDefaultKeyword_4()); } - otherlv_7=(Token)match(input,47,FOLLOW_50); if (state.failed) return current; + otherlv_7=(Token)match(input,49,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_7, grammarAccess.getSwitchExpressionAccess().getColonKeyword_5()); @@ -6957,7 +6993,7 @@ public final EObject ruleSwitchExpression() throws RecognitionException { } - otherlv_9=(Token)match(input,21,FOLLOW_2); if (state.failed) return current; + otherlv_9=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_9, grammarAccess.getSwitchExpressionAccess().getRightCurlyBracketKeyword_7()); @@ -7049,7 +7085,7 @@ public final EObject ruleCase() throws RecognitionException { // InternalScope.g:2486:2: (otherlv_0= 'case' ( (lv_condition_1_0= ruleOrExpression ) ) otherlv_2= ':' ( (lv_thenPar_3_0= ruleOrExpression ) ) ) // InternalScope.g:2487:3: otherlv_0= 'case' ( (lv_condition_1_0= ruleOrExpression ) ) otherlv_2= ':' ( (lv_thenPar_3_0= ruleOrExpression ) ) { - otherlv_0=(Token)match(input,18,FOLLOW_50); if (state.failed) return current; + otherlv_0=(Token)match(input,20,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getCaseAccess().getCaseKeyword_0()); @@ -7090,7 +7126,7 @@ public final EObject ruleCase() throws RecognitionException { } - otherlv_2=(Token)match(input,47,FOLLOW_50); if (state.failed) return current; + otherlv_2=(Token)match(input,49,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getCaseAccess().getColonKeyword_2()); @@ -7238,7 +7274,7 @@ public final EObject ruleOrExpression() throws RecognitionException { int alt43=2; int LA43_0 = input.LA(1); - if ( (LA43_0==55) ) { + if ( (LA43_0==57) ) { alt43=1; } @@ -7266,7 +7302,7 @@ public final EObject ruleOrExpression() throws RecognitionException { // InternalScope.g:2569:5: (lv_operator_2_0= '||' ) // InternalScope.g:2570:6: lv_operator_2_0= '||' { - lv_operator_2_0=(Token)match(input,55,FOLLOW_50); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,57,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getOrExpressionAccess().getOperatorVerticalLineVerticalLineKeyword_1_1_0()); @@ -7437,7 +7473,7 @@ public final EObject ruleAndExpression() throws RecognitionException { int alt44=2; int LA44_0 = input.LA(1); - if ( (LA44_0==56) ) { + if ( (LA44_0==58) ) { alt44=1; } @@ -7465,7 +7501,7 @@ public final EObject ruleAndExpression() throws RecognitionException { // InternalScope.g:2638:5: (lv_operator_2_0= '&&' ) // InternalScope.g:2639:6: lv_operator_2_0= '&&' { - lv_operator_2_0=(Token)match(input,56,FOLLOW_50); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,58,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getAndExpressionAccess().getOperatorAmpersandAmpersandKeyword_1_1_0()); @@ -7636,7 +7672,7 @@ public final EObject ruleImpliesExpression() throws RecognitionException { int alt45=2; int LA45_0 = input.LA(1); - if ( (LA45_0==57) ) { + if ( (LA45_0==59) ) { alt45=1; } @@ -7664,7 +7700,7 @@ public final EObject ruleImpliesExpression() throws RecognitionException { // InternalScope.g:2707:5: (lv_operator_2_0= 'implies' ) // InternalScope.g:2708:6: lv_operator_2_0= 'implies' { - lv_operator_2_0=(Token)match(input,57,FOLLOW_50); if (state.failed) return current; + lv_operator_2_0=(Token)match(input,59,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_0, grammarAccess.getImpliesExpressionAccess().getOperatorImpliesKeyword_1_1_0()); @@ -7840,7 +7876,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { int alt47=2; int LA47_0 = input.LA(1); - if ( ((LA47_0>=58 && LA47_0<=63)) ) { + if ( ((LA47_0>=60 && LA47_0<=65)) ) { alt47=1; } @@ -7871,32 +7907,32 @@ public final EObject ruleRelationalExpression() throws RecognitionException { // InternalScope.g:2777:6: (lv_operator_2_1= '==' | lv_operator_2_2= '!=' | lv_operator_2_3= '>=' | lv_operator_2_4= '<=' | lv_operator_2_5= '>' | lv_operator_2_6= '<' ) int alt46=6; switch ( input.LA(1) ) { - case 58: + case 60: { alt46=1; } break; - case 59: + case 61: { alt46=2; } break; - case 60: + case 62: { alt46=3; } break; - case 61: + case 63: { alt46=4; } break; - case 62: + case 64: { alt46=5; } break; - case 63: + case 65: { alt46=6; } @@ -7913,7 +7949,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 1 : // InternalScope.g:2778:7: lv_operator_2_1= '==' { - lv_operator_2_1=(Token)match(input,58,FOLLOW_50); if (state.failed) return current; + lv_operator_2_1=(Token)match(input,60,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_1, grammarAccess.getRelationalExpressionAccess().getOperatorEqualsSignEqualsSignKeyword_1_1_0_0()); @@ -7933,7 +7969,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 2 : // InternalScope.g:2789:7: lv_operator_2_2= '!=' { - lv_operator_2_2=(Token)match(input,59,FOLLOW_50); if (state.failed) return current; + lv_operator_2_2=(Token)match(input,61,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_2, grammarAccess.getRelationalExpressionAccess().getOperatorExclamationMarkEqualsSignKeyword_1_1_0_1()); @@ -7953,7 +7989,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 3 : // InternalScope.g:2800:7: lv_operator_2_3= '>=' { - lv_operator_2_3=(Token)match(input,60,FOLLOW_50); if (state.failed) return current; + lv_operator_2_3=(Token)match(input,62,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_3, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignEqualsSignKeyword_1_1_0_2()); @@ -7973,7 +8009,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 4 : // InternalScope.g:2811:7: lv_operator_2_4= '<=' { - lv_operator_2_4=(Token)match(input,61,FOLLOW_50); if (state.failed) return current; + lv_operator_2_4=(Token)match(input,63,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_4, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignEqualsSignKeyword_1_1_0_3()); @@ -7993,7 +8029,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 5 : // InternalScope.g:2822:7: lv_operator_2_5= '>' { - lv_operator_2_5=(Token)match(input,62,FOLLOW_50); if (state.failed) return current; + lv_operator_2_5=(Token)match(input,64,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_5, grammarAccess.getRelationalExpressionAccess().getOperatorGreaterThanSignKeyword_1_1_0_4()); @@ -8013,7 +8049,7 @@ public final EObject ruleRelationalExpression() throws RecognitionException { case 6 : // InternalScope.g:2833:7: lv_operator_2_6= '<' { - lv_operator_2_6=(Token)match(input,63,FOLLOW_50); if (state.failed) return current; + lv_operator_2_6=(Token)match(input,65,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_operator_2_6, grammarAccess.getRelationalExpressionAccess().getOperatorLessThanSignKeyword_1_1_0_5()); @@ -8191,7 +8227,7 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { int alt49=2; int LA49_0 = input.LA(1); - if ( ((LA49_0>=64 && LA49_0<=65)) ) { + if ( ((LA49_0>=66 && LA49_0<=67)) ) { alt49=1; } @@ -8223,10 +8259,10 @@ public final EObject ruleAdditiveExpression() throws RecognitionException { int alt48=2; int LA48_0 = input.LA(1); - if ( (LA48_0==64) ) { + if ( (LA48_0==66) ) { alt48=1; } - else if ( (LA48_0==65) ) { + else if ( (LA48_0==67) ) { alt48=2; } else { @@ -8240,7 +8276,7 @@ else if ( (LA48_0==65) ) { case 1 : // InternalScope.g:2904:7: lv_name_2_1= '+' { - lv_name_2_1=(Token)match(input,64,FOLLOW_50); if (state.failed) return current; + lv_name_2_1=(Token)match(input,66,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_1, grammarAccess.getAdditiveExpressionAccess().getNamePlusSignKeyword_1_1_0_0()); @@ -8260,7 +8296,7 @@ else if ( (LA48_0==65) ) { case 2 : // InternalScope.g:2915:7: lv_name_2_2= '-' { - lv_name_2_2=(Token)match(input,65,FOLLOW_50); if (state.failed) return current; + lv_name_2_2=(Token)match(input,67,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_2, grammarAccess.getAdditiveExpressionAccess().getNameHyphenMinusKeyword_1_1_0_1()); @@ -8438,7 +8474,7 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException int alt51=2; int LA51_0 = input.LA(1); - if ( (LA51_0==30||LA51_0==66) ) { + if ( (LA51_0==32||LA51_0==68) ) { alt51=1; } @@ -8470,10 +8506,10 @@ public final EObject ruleMultiplicativeExpression() throws RecognitionException int alt50=2; int LA50_0 = input.LA(1); - if ( (LA50_0==30) ) { + if ( (LA50_0==32) ) { alt50=1; } - else if ( (LA50_0==66) ) { + else if ( (LA50_0==68) ) { alt50=2; } else { @@ -8487,7 +8523,7 @@ else if ( (LA50_0==66) ) { case 1 : // InternalScope.g:2986:7: lv_name_2_1= '*' { - lv_name_2_1=(Token)match(input,30,FOLLOW_50); if (state.failed) return current; + lv_name_2_1=(Token)match(input,32,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_1, grammarAccess.getMultiplicativeExpressionAccess().getNameAsteriskKeyword_1_1_0_0()); @@ -8507,7 +8543,7 @@ else if ( (LA50_0==66) ) { case 2 : // InternalScope.g:2997:7: lv_name_2_2= '/' { - lv_name_2_2=(Token)match(input,66,FOLLOW_50); if (state.failed) return current; + lv_name_2_2=(Token)match(input,68,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_2_2, grammarAccess.getMultiplicativeExpressionAccess().getNameSolidusKeyword_1_1_0_1()); @@ -8662,10 +8698,10 @@ public final EObject ruleUnaryOrInfixExpression() throws RecognitionException { int alt52=2; int LA52_0 = input.LA(1); - if ( (LA52_0==65||LA52_0==67) ) { + if ( (LA52_0==67||LA52_0==69) ) { alt52=1; } - else if ( ((LA52_0>=RULE_STRING && LA52_0<=RULE_ID)||LA52_0==20||LA52_0==25||(LA52_0>=68 && LA52_0<=84)) ) { + else if ( ((LA52_0>=RULE_STRING && LA52_0<=RULE_ID)||LA52_0==22||LA52_0==27||(LA52_0>=70 && LA52_0<=86)) ) { alt52=2; } else { @@ -8814,10 +8850,10 @@ public final EObject ruleUnaryExpression() throws RecognitionException { int alt53=2; int LA53_0 = input.LA(1); - if ( (LA53_0==67) ) { + if ( (LA53_0==69) ) { alt53=1; } - else if ( (LA53_0==65) ) { + else if ( (LA53_0==67) ) { alt53=2; } else { @@ -8831,7 +8867,7 @@ else if ( (LA53_0==65) ) { case 1 : // InternalScope.g:3088:6: lv_name_0_1= '!' { - lv_name_0_1=(Token)match(input,67,FOLLOW_50); if (state.failed) return current; + lv_name_0_1=(Token)match(input,69,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_1, grammarAccess.getUnaryExpressionAccess().getNameExclamationMarkKeyword_0_0_0()); @@ -8851,7 +8887,7 @@ else if ( (LA53_0==65) ) { case 2 : // InternalScope.g:3099:6: lv_name_0_2= '-' { - lv_name_0_2=(Token)match(input,65,FOLLOW_50); if (state.failed) return current; + lv_name_0_2=(Token)match(input,67,FOLLOW_50); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_2, grammarAccess.getUnaryExpressionAccess().getNameHyphenMinusKeyword_0_0_1()); @@ -9051,44 +9087,44 @@ public final EObject ruleInfixExpression() throws RecognitionException { int alt58=5; int LA58_0 = input.LA(1); - if ( (LA58_0==45) ) { + if ( (LA58_0==47) ) { switch ( input.LA(2) ) { - case 82: - case 83: - case 84: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: { - alt58=2; + alt58=4; } break; case RULE_ID: { int LA58_4 = input.LA(3); - if ( (LA58_4==EOF||LA58_4==15||LA58_4==18||LA58_4==21||LA58_4==23||LA58_4==26||(LA58_4>=29 && LA58_4<=30)||LA58_4==32||LA58_4==35||(LA58_4>=44 && LA58_4<=45)||(LA58_4>=47 && LA58_4<=49)||(LA58_4>=51 && LA58_4<=52)||(LA58_4>=54 && LA58_4<=66)) ) { + if ( (LA58_4==EOF||LA58_4==17||LA58_4==20||LA58_4==23||LA58_4==25||LA58_4==28||(LA58_4>=31 && LA58_4<=32)||LA58_4==34||LA58_4==37||(LA58_4>=46 && LA58_4<=47)||(LA58_4>=49 && LA58_4<=51)||(LA58_4>=53 && LA58_4<=54)||(LA58_4>=56 && LA58_4<=68)) ) { alt58=2; } - else if ( (LA58_4==25) ) { + else if ( (LA58_4==27) ) { alt58=1; } } break; - case 68: + case 84: + case 85: + case 86: { - alt58=3; + alt58=2; } break; - case 69: case 70: - case 71: - case 72: - case 73: - case 74: - case 75: - case 76: { - alt58=4; + alt58=3; } break; @@ -9117,7 +9153,7 @@ else if ( (LA58_4==25) ) { } - otherlv_2=(Token)match(input,45,FOLLOW_3); if (state.failed) return current; + otherlv_2=(Token)match(input,47,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_0_1()); @@ -9158,7 +9194,7 @@ else if ( (LA58_4==25) ) { } - otherlv_4=(Token)match(input,25,FOLLOW_59); if (state.failed) return current; + otherlv_4=(Token)match(input,27,FOLLOW_59); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_4, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_0_3()); @@ -9168,7 +9204,7 @@ else if ( (LA58_4==25) ) { int alt55=2; int LA55_0 = input.LA(1); - if ( ((LA55_0>=RULE_STRING && LA55_0<=RULE_ID)||LA55_0==20||LA55_0==25||LA55_0==46||LA55_0==50||LA55_0==53||LA55_0==65||(LA55_0>=67 && LA55_0<=84)) ) { + if ( ((LA55_0>=RULE_STRING && LA55_0<=RULE_ID)||LA55_0==22||LA55_0==27||LA55_0==48||LA55_0==52||LA55_0==55||LA55_0==67||(LA55_0>=69 && LA55_0<=86)) ) { alt55=1; } switch (alt55) { @@ -9216,7 +9252,7 @@ else if ( (LA58_4==25) ) { int alt54=2; int LA54_0 = input.LA(1); - if ( (LA54_0==35) ) { + if ( (LA54_0==37) ) { alt54=1; } @@ -9225,7 +9261,7 @@ else if ( (LA58_4==25) ) { case 1 : // InternalScope.g:3215:7: otherlv_6= ',' ( (lv_params_7_0= ruleExpression ) ) { - otherlv_6=(Token)match(input,35,FOLLOW_17); if (state.failed) return current; + otherlv_6=(Token)match(input,37,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_6, grammarAccess.getInfixExpressionAccess().getCommaKeyword_1_0_4_1_0()); @@ -9281,7 +9317,7 @@ else if ( (LA58_4==25) ) { } - otherlv_8=(Token)match(input,26,FOLLOW_42); if (state.failed) return current; + otherlv_8=(Token)match(input,28,FOLLOW_42); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_8, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_0_5()); @@ -9312,7 +9348,7 @@ else if ( (LA58_4==25) ) { } - otherlv_10=(Token)match(input,45,FOLLOW_44); if (state.failed) return current; + otherlv_10=(Token)match(input,47,FOLLOW_44); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_10, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_1_1()); @@ -9378,7 +9414,7 @@ else if ( (LA58_4==25) ) { } - otherlv_13=(Token)match(input,45,FOLLOW_60); if (state.failed) return current; + otherlv_13=(Token)match(input,47,FOLLOW_60); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_13, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_2_1()); @@ -9390,7 +9426,7 @@ else if ( (LA58_4==25) ) { // InternalScope.g:3292:6: (lv_name_14_0= 'typeSelect' ) // InternalScope.g:3293:7: lv_name_14_0= 'typeSelect' { - lv_name_14_0=(Token)match(input,68,FOLLOW_29); if (state.failed) return current; + lv_name_14_0=(Token)match(input,70,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_14_0, grammarAccess.getInfixExpressionAccess().getNameTypeSelectKeyword_1_2_2_0()); @@ -9410,7 +9446,7 @@ else if ( (LA58_4==25) ) { } - otherlv_15=(Token)match(input,25,FOLLOW_44); if (state.failed) return current; + otherlv_15=(Token)match(input,27,FOLLOW_44); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_15, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_2_3()); @@ -9451,7 +9487,7 @@ else if ( (LA58_4==25) ) { } - otherlv_17=(Token)match(input,26,FOLLOW_42); if (state.failed) return current; + otherlv_17=(Token)match(input,28,FOLLOW_42); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_17, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_2_5()); @@ -9482,7 +9518,7 @@ else if ( (LA58_4==25) ) { } - otherlv_19=(Token)match(input,45,FOLLOW_61); if (state.failed) return current; + otherlv_19=(Token)match(input,47,FOLLOW_61); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_19, grammarAccess.getInfixExpressionAccess().getFullStopKeyword_1_3_1()); @@ -9497,42 +9533,42 @@ else if ( (LA58_4==25) ) { // InternalScope.g:3348:7: (lv_name_20_1= 'collect' | lv_name_20_2= 'select' | lv_name_20_3= 'selectFirst' | lv_name_20_4= 'reject' | lv_name_20_5= 'exists' | lv_name_20_6= 'notExists' | lv_name_20_7= 'sortBy' | lv_name_20_8= 'forAll' ) int alt56=8; switch ( input.LA(1) ) { - case 69: + case 71: { alt56=1; } break; - case 70: + case 72: { alt56=2; } break; - case 71: + case 73: { alt56=3; } break; - case 72: + case 74: { alt56=4; } break; - case 73: + case 75: { alt56=5; } break; - case 74: + case 76: { alt56=6; } break; - case 75: + case 77: { alt56=7; } break; - case 76: + case 78: { alt56=8; } @@ -9549,7 +9585,7 @@ else if ( (LA58_4==25) ) { case 1 : // InternalScope.g:3349:8: lv_name_20_1= 'collect' { - lv_name_20_1=(Token)match(input,69,FOLLOW_29); if (state.failed) return current; + lv_name_20_1=(Token)match(input,71,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_1, grammarAccess.getInfixExpressionAccess().getNameCollectKeyword_1_3_2_0_0()); @@ -9569,7 +9605,7 @@ else if ( (LA58_4==25) ) { case 2 : // InternalScope.g:3360:8: lv_name_20_2= 'select' { - lv_name_20_2=(Token)match(input,70,FOLLOW_29); if (state.failed) return current; + lv_name_20_2=(Token)match(input,72,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_2, grammarAccess.getInfixExpressionAccess().getNameSelectKeyword_1_3_2_0_1()); @@ -9589,7 +9625,7 @@ else if ( (LA58_4==25) ) { case 3 : // InternalScope.g:3371:8: lv_name_20_3= 'selectFirst' { - lv_name_20_3=(Token)match(input,71,FOLLOW_29); if (state.failed) return current; + lv_name_20_3=(Token)match(input,73,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_3, grammarAccess.getInfixExpressionAccess().getNameSelectFirstKeyword_1_3_2_0_2()); @@ -9609,7 +9645,7 @@ else if ( (LA58_4==25) ) { case 4 : // InternalScope.g:3382:8: lv_name_20_4= 'reject' { - lv_name_20_4=(Token)match(input,72,FOLLOW_29); if (state.failed) return current; + lv_name_20_4=(Token)match(input,74,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_4, grammarAccess.getInfixExpressionAccess().getNameRejectKeyword_1_3_2_0_3()); @@ -9629,7 +9665,7 @@ else if ( (LA58_4==25) ) { case 5 : // InternalScope.g:3393:8: lv_name_20_5= 'exists' { - lv_name_20_5=(Token)match(input,73,FOLLOW_29); if (state.failed) return current; + lv_name_20_5=(Token)match(input,75,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_5, grammarAccess.getInfixExpressionAccess().getNameExistsKeyword_1_3_2_0_4()); @@ -9649,7 +9685,7 @@ else if ( (LA58_4==25) ) { case 6 : // InternalScope.g:3404:8: lv_name_20_6= 'notExists' { - lv_name_20_6=(Token)match(input,74,FOLLOW_29); if (state.failed) return current; + lv_name_20_6=(Token)match(input,76,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_6, grammarAccess.getInfixExpressionAccess().getNameNotExistsKeyword_1_3_2_0_5()); @@ -9669,7 +9705,7 @@ else if ( (LA58_4==25) ) { case 7 : // InternalScope.g:3415:8: lv_name_20_7= 'sortBy' { - lv_name_20_7=(Token)match(input,75,FOLLOW_29); if (state.failed) return current; + lv_name_20_7=(Token)match(input,77,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_7, grammarAccess.getInfixExpressionAccess().getNameSortByKeyword_1_3_2_0_6()); @@ -9689,7 +9725,7 @@ else if ( (LA58_4==25) ) { case 8 : // InternalScope.g:3426:8: lv_name_20_8= 'forAll' { - lv_name_20_8=(Token)match(input,76,FOLLOW_29); if (state.failed) return current; + lv_name_20_8=(Token)match(input,78,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_20_8, grammarAccess.getInfixExpressionAccess().getNameForAllKeyword_1_3_2_0_7()); @@ -9715,7 +9751,7 @@ else if ( (LA58_4==25) ) { } - otherlv_21=(Token)match(input,25,FOLLOW_17); if (state.failed) return current; + otherlv_21=(Token)match(input,27,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_21, grammarAccess.getInfixExpressionAccess().getLeftParenthesisKeyword_1_3_3()); @@ -9728,7 +9764,7 @@ else if ( (LA58_4==25) ) { if ( (LA57_0==RULE_ID) ) { int LA57_1 = input.LA(2); - if ( (LA57_1==42) ) { + if ( (LA57_1==44) ) { alt57=1; } } @@ -9771,7 +9807,7 @@ else if ( (LA58_4==25) ) { } - otherlv_23=(Token)match(input,42,FOLLOW_17); if (state.failed) return current; + otherlv_23=(Token)match(input,44,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_23, grammarAccess.getInfixExpressionAccess().getVerticalLineKeyword_1_3_4_1()); @@ -9818,7 +9854,7 @@ else if ( (LA58_4==25) ) { } - otherlv_25=(Token)match(input,26,FOLLOW_42); if (state.failed) return current; + otherlv_25=(Token)match(input,28,FOLLOW_42); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_25, grammarAccess.getInfixExpressionAccess().getRightParenthesisKeyword_1_3_6()); @@ -9931,16 +9967,14 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case RULE_STRING: case RULE_INT: case RULE_REAL: - case 77: - case 78: case 79: + case 80: + case 81: { alt59=1; } break; case RULE_ID: - case 68: - case 69: case 70: case 71: case 72: @@ -9948,29 +9982,31 @@ public final EObject rulePrimaryExpression() throws RecognitionException { case 74: case 75: case 76: - case 82: - case 83: + case 77: + case 78: case 84: + case 85: + case 86: { alt59=2; } break; - case 20: + case 22: { alt59=3; } break; - case 81: + case 83: { alt59=4; } break; - case 80: + case 82: { alt59=5; } break; - case 25: + case 27: { alt59=6; } @@ -10206,8 +10242,8 @@ public final EObject ruleLiteral() throws RecognitionException { // InternalScope.g:3583:2: (this_BooleanLiteral_0= ruleBooleanLiteral | this_IntegerLiteral_1= ruleIntegerLiteral | this_NullLiteral_2= ruleNullLiteral | this_RealLiteral_3= ruleRealLiteral | this_StringLiteral_4= ruleStringLiteral ) int alt60=5; switch ( input.LA(1) ) { - case 77: - case 78: + case 79: + case 80: { alt60=1; } @@ -10217,7 +10253,7 @@ public final EObject ruleLiteral() throws RecognitionException { alt60=2; } break; - case 79: + case 81: { alt60=3; } @@ -10440,10 +10476,10 @@ public final EObject ruleBooleanLiteral() throws RecognitionException { int alt61=2; int LA61_0 = input.LA(1); - if ( (LA61_0==77) ) { + if ( (LA61_0==79) ) { alt61=1; } - else if ( (LA61_0==78) ) { + else if ( (LA61_0==80) ) { alt61=2; } else { @@ -10457,7 +10493,7 @@ else if ( (LA61_0==78) ) { case 1 : // InternalScope.g:3649:5: lv_val_0_1= 'true' { - lv_val_0_1=(Token)match(input,77,FOLLOW_2); if (state.failed) return current; + lv_val_0_1=(Token)match(input,79,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_1, grammarAccess.getBooleanLiteralAccess().getValTrueKeyword_0_0()); @@ -10477,7 +10513,7 @@ else if ( (LA61_0==78) ) { case 2 : // InternalScope.g:3660:5: lv_val_0_2= 'false' { - lv_val_0_2=(Token)match(input,78,FOLLOW_2); if (state.failed) return current; + lv_val_0_2=(Token)match(input,80,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_2, grammarAccess.getBooleanLiteralAccess().getValFalseKeyword_0_1()); @@ -10599,7 +10635,7 @@ public final EObject ruleIntegerLiteral() throws RecognitionException { current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.INT"); + "org.eclipse.xtext.xbase.Xbase.INT"); } @@ -10689,7 +10725,7 @@ public final EObject ruleNullLiteral() throws RecognitionException { // InternalScope.g:3726:3: (lv_val_0_0= 'null' ) // InternalScope.g:3727:4: lv_val_0_0= 'null' { - lv_val_0_0=(Token)match(input,79,FOLLOW_2); if (state.failed) return current; + lv_val_0_0=(Token)match(input,81,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_val_0_0, grammarAccess.getNullLiteralAccess().getValNullKeyword_0()); @@ -10910,7 +10946,7 @@ public final EObject ruleStringLiteral() throws RecognitionException { current, "val", lv_val_0_0, - "org.eclipse.xtext.common.Terminals.STRING"); + "org.eclipse.xtext.xbase.Xtype.STRING"); } @@ -11000,7 +11036,7 @@ public final EObject ruleParanthesizedExpression() throws RecognitionException { // InternalScope.g:3826:2: (otherlv_0= '(' this_Expression_1= ruleExpression otherlv_2= ')' ) // InternalScope.g:3827:3: otherlv_0= '(' this_Expression_1= ruleExpression otherlv_2= ')' { - otherlv_0=(Token)match(input,25,FOLLOW_17); if (state.failed) return current; + otherlv_0=(Token)match(input,27,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); @@ -11022,7 +11058,7 @@ public final EObject ruleParanthesizedExpression() throws RecognitionException { afterParserOrEnumRuleCall(); } - otherlv_2=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_2=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_2, grammarAccess.getParanthesizedExpressionAccess().getRightParenthesisKeyword_2()); @@ -11111,7 +11147,7 @@ public final EObject ruleGlobalVarExpression() throws RecognitionException { // InternalScope.g:3861:2: (otherlv_0= 'GLOBALVAR' ( (lv_name_1_0= ruleIdentifier ) ) ) // InternalScope.g:3862:3: otherlv_0= 'GLOBALVAR' ( (lv_name_1_0= ruleIdentifier ) ) { - otherlv_0=(Token)match(input,80,FOLLOW_3); if (state.failed) return current; + otherlv_0=(Token)match(input,82,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getGlobalVarExpressionAccess().getGLOBALVARKeyword_0()); @@ -11244,12 +11280,12 @@ public final EObject ruleFeatureCall() throws RecognitionException { { int LA62_1 = input.LA(2); - if ( (LA62_1==EOF||LA62_1==15||LA62_1==18||LA62_1==21||LA62_1==23||LA62_1==26||(LA62_1>=29 && LA62_1<=30)||LA62_1==32||LA62_1==35||(LA62_1>=44 && LA62_1<=45)||(LA62_1>=47 && LA62_1<=49)||(LA62_1>=51 && LA62_1<=52)||(LA62_1>=54 && LA62_1<=66)) ) { - alt62=2; - } - else if ( (LA62_1==25) ) { + if ( (LA62_1==27) ) { alt62=1; } + else if ( (LA62_1==EOF||LA62_1==17||LA62_1==20||LA62_1==23||LA62_1==25||LA62_1==28||(LA62_1>=31 && LA62_1<=32)||LA62_1==34||LA62_1==37||(LA62_1>=46 && LA62_1<=47)||(LA62_1>=49 && LA62_1<=51)||(LA62_1>=53 && LA62_1<=54)||(LA62_1>=56 && LA62_1<=68)) ) { + alt62=2; + } else { if (state.backtracking>0) {state.failed=true; return current;} NoViableAltException nvae = @@ -11259,26 +11295,26 @@ else if ( (LA62_1==25) ) { } } break; - case 82: - case 83: case 84: + case 85: + case 86: { alt62=2; } break; - case 69: - case 70: case 71: case 72: case 73: case 74: case 75: case 76: + case 77: + case 78: { alt62=3; } break; - case 68: + case 70: { alt62=4; } @@ -11523,7 +11559,7 @@ public final EObject ruleOperationCall() throws RecognitionException { } - otherlv_1=(Token)match(input,25,FOLLOW_59); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_59); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getOperationCallAccess().getLeftParenthesisKeyword_1()); @@ -11533,7 +11569,7 @@ public final EObject ruleOperationCall() throws RecognitionException { int alt64=2; int LA64_0 = input.LA(1); - if ( ((LA64_0>=RULE_STRING && LA64_0<=RULE_ID)||LA64_0==20||LA64_0==25||LA64_0==46||LA64_0==50||LA64_0==53||LA64_0==65||(LA64_0>=67 && LA64_0<=84)) ) { + if ( ((LA64_0>=RULE_STRING && LA64_0<=RULE_ID)||LA64_0==22||LA64_0==27||LA64_0==48||LA64_0==52||LA64_0==55||LA64_0==67||(LA64_0>=69 && LA64_0<=86)) ) { alt64=1; } switch (alt64) { @@ -11581,7 +11617,7 @@ public final EObject ruleOperationCall() throws RecognitionException { int alt63=2; int LA63_0 = input.LA(1); - if ( (LA63_0==35) ) { + if ( (LA63_0==37) ) { alt63=1; } @@ -11590,7 +11626,7 @@ public final EObject ruleOperationCall() throws RecognitionException { case 1 : // InternalScope.g:4013:5: otherlv_3= ',' ( (lv_params_4_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,35,FOLLOW_17); if (state.failed) return current; + otherlv_3=(Token)match(input,37,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getOperationCallAccess().getCommaKeyword_2_1_0()); @@ -11646,7 +11682,7 @@ public final EObject ruleOperationCall() throws RecognitionException { } - otherlv_5=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getOperationCallAccess().getRightParenthesisKeyword_3()); @@ -11752,7 +11788,7 @@ public final EObject ruleListLiteral() throws RecognitionException { } - otherlv_1=(Token)match(input,20,FOLLOW_62); if (state.failed) return current; + otherlv_1=(Token)match(input,22,FOLLOW_62); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getListLiteralAccess().getLeftCurlyBracketKeyword_1()); @@ -11762,7 +11798,7 @@ public final EObject ruleListLiteral() throws RecognitionException { int alt66=2; int LA66_0 = input.LA(1); - if ( ((LA66_0>=RULE_STRING && LA66_0<=RULE_ID)||LA66_0==20||LA66_0==25||LA66_0==46||LA66_0==50||LA66_0==53||LA66_0==65||(LA66_0>=67 && LA66_0<=84)) ) { + if ( ((LA66_0>=RULE_STRING && LA66_0<=RULE_ID)||LA66_0==22||LA66_0==27||LA66_0==48||LA66_0==52||LA66_0==55||LA66_0==67||(LA66_0>=69 && LA66_0<=86)) ) { alt66=1; } switch (alt66) { @@ -11810,7 +11846,7 @@ public final EObject ruleListLiteral() throws RecognitionException { int alt65=2; int LA65_0 = input.LA(1); - if ( (LA65_0==35) ) { + if ( (LA65_0==37) ) { alt65=1; } @@ -11819,7 +11855,7 @@ public final EObject ruleListLiteral() throws RecognitionException { case 1 : // InternalScope.g:4093:5: otherlv_3= ',' ( (lv_elements_4_0= ruleExpression ) ) { - otherlv_3=(Token)match(input,35,FOLLOW_17); if (state.failed) return current; + otherlv_3=(Token)match(input,37,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getListLiteralAccess().getCommaKeyword_2_1_0()); @@ -11875,7 +11911,7 @@ public final EObject ruleListLiteral() throws RecognitionException { } - otherlv_5=(Token)match(input,21,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getListLiteralAccess().getRightCurlyBracketKeyword_3()); @@ -11964,7 +12000,7 @@ public final EObject ruleConstructorCallExpression() throws RecognitionException // InternalScope.g:4140:2: (otherlv_0= 'new' ( (lv_type_1_0= ruleSimpleType ) ) ) // InternalScope.g:4141:3: otherlv_0= 'new' ( (lv_type_1_0= ruleSimpleType ) ) { - otherlv_0=(Token)match(input,81,FOLLOW_44); if (state.failed) return current; + otherlv_0=(Token)match(input,83,FOLLOW_44); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_0, grammarAccess.getConstructorCallExpressionAccess().getNewKeyword_0()); @@ -12096,7 +12132,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { // InternalScope.g:4184:4: (lv_name_0_0= 'typeSelect' ) // InternalScope.g:4185:5: lv_name_0_0= 'typeSelect' { - lv_name_0_0=(Token)match(input,68,FOLLOW_29); if (state.failed) return current; + lv_name_0_0=(Token)match(input,70,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_0, grammarAccess.getTypeSelectExpressionAccess().getNameTypeSelectKeyword_0_0()); @@ -12116,7 +12152,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,25,FOLLOW_44); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_44); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getTypeSelectExpressionAccess().getLeftParenthesisKeyword_1()); @@ -12157,7 +12193,7 @@ public final EObject ruleTypeSelectExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getTypeSelectExpressionAccess().getRightParenthesisKeyword_3()); @@ -12267,42 +12303,42 @@ public final EObject ruleCollectionExpression() throws RecognitionException { // InternalScope.g:4245:5: (lv_name_0_1= 'collect' | lv_name_0_2= 'select' | lv_name_0_3= 'selectFirst' | lv_name_0_4= 'reject' | lv_name_0_5= 'exists' | lv_name_0_6= 'notExists' | lv_name_0_7= 'sortBy' | lv_name_0_8= 'forAll' ) int alt67=8; switch ( input.LA(1) ) { - case 69: + case 71: { alt67=1; } break; - case 70: + case 72: { alt67=2; } break; - case 71: + case 73: { alt67=3; } break; - case 72: + case 74: { alt67=4; } break; - case 73: + case 75: { alt67=5; } break; - case 74: + case 76: { alt67=6; } break; - case 75: + case 77: { alt67=7; } break; - case 76: + case 78: { alt67=8; } @@ -12319,7 +12355,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 1 : // InternalScope.g:4246:6: lv_name_0_1= 'collect' { - lv_name_0_1=(Token)match(input,69,FOLLOW_29); if (state.failed) return current; + lv_name_0_1=(Token)match(input,71,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_1, grammarAccess.getCollectionExpressionAccess().getNameCollectKeyword_0_0_0()); @@ -12339,7 +12375,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 2 : // InternalScope.g:4257:6: lv_name_0_2= 'select' { - lv_name_0_2=(Token)match(input,70,FOLLOW_29); if (state.failed) return current; + lv_name_0_2=(Token)match(input,72,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_2, grammarAccess.getCollectionExpressionAccess().getNameSelectKeyword_0_0_1()); @@ -12359,7 +12395,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 3 : // InternalScope.g:4268:6: lv_name_0_3= 'selectFirst' { - lv_name_0_3=(Token)match(input,71,FOLLOW_29); if (state.failed) return current; + lv_name_0_3=(Token)match(input,73,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_3, grammarAccess.getCollectionExpressionAccess().getNameSelectFirstKeyword_0_0_2()); @@ -12379,7 +12415,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 4 : // InternalScope.g:4279:6: lv_name_0_4= 'reject' { - lv_name_0_4=(Token)match(input,72,FOLLOW_29); if (state.failed) return current; + lv_name_0_4=(Token)match(input,74,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_4, grammarAccess.getCollectionExpressionAccess().getNameRejectKeyword_0_0_3()); @@ -12399,7 +12435,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 5 : // InternalScope.g:4290:6: lv_name_0_5= 'exists' { - lv_name_0_5=(Token)match(input,73,FOLLOW_29); if (state.failed) return current; + lv_name_0_5=(Token)match(input,75,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_5, grammarAccess.getCollectionExpressionAccess().getNameExistsKeyword_0_0_4()); @@ -12419,7 +12455,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 6 : // InternalScope.g:4301:6: lv_name_0_6= 'notExists' { - lv_name_0_6=(Token)match(input,74,FOLLOW_29); if (state.failed) return current; + lv_name_0_6=(Token)match(input,76,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_6, grammarAccess.getCollectionExpressionAccess().getNameNotExistsKeyword_0_0_5()); @@ -12439,7 +12475,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 7 : // InternalScope.g:4312:6: lv_name_0_7= 'sortBy' { - lv_name_0_7=(Token)match(input,75,FOLLOW_29); if (state.failed) return current; + lv_name_0_7=(Token)match(input,77,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_7, grammarAccess.getCollectionExpressionAccess().getNameSortByKeyword_0_0_6()); @@ -12459,7 +12495,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { case 8 : // InternalScope.g:4323:6: lv_name_0_8= 'forAll' { - lv_name_0_8=(Token)match(input,76,FOLLOW_29); if (state.failed) return current; + lv_name_0_8=(Token)match(input,78,FOLLOW_29); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_name_0_8, grammarAccess.getCollectionExpressionAccess().getNameForAllKeyword_0_0_7()); @@ -12485,7 +12521,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_1=(Token)match(input,25,FOLLOW_17); if (state.failed) return current; + otherlv_1=(Token)match(input,27,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getCollectionExpressionAccess().getLeftParenthesisKeyword_1()); @@ -12498,7 +12534,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { if ( (LA68_0==RULE_ID) ) { int LA68_1 = input.LA(2); - if ( (LA68_1==42) ) { + if ( (LA68_1==44) ) { alt68=1; } } @@ -12541,7 +12577,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_3=(Token)match(input,42,FOLLOW_17); if (state.failed) return current; + otherlv_3=(Token)match(input,44,FOLLOW_17); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getCollectionExpressionAccess().getVerticalLineKeyword_2_1()); @@ -12588,7 +12624,7 @@ public final EObject ruleCollectionExpression() throws RecognitionException { } - otherlv_5=(Token)match(input,26,FOLLOW_2); if (state.failed) return current; + otherlv_5=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_5, grammarAccess.getCollectionExpressionAccess().getRightParenthesisKeyword_4()); @@ -12679,7 +12715,7 @@ public final EObject ruleType() throws RecognitionException { int alt69=2; int LA69_0 = input.LA(1); - if ( ((LA69_0>=82 && LA69_0<=84)) ) { + if ( ((LA69_0>=84 && LA69_0<=86)) ) { alt69=1; } else if ( (LA69_0==RULE_ID) ) { @@ -12833,17 +12869,17 @@ public final EObject ruleCollectionType() throws RecognitionException { // InternalScope.g:4445:5: (lv_cl_0_1= 'Collection' | lv_cl_0_2= 'List' | lv_cl_0_3= 'Set' ) int alt70=3; switch ( input.LA(1) ) { - case 82: + case 84: { alt70=1; } break; - case 83: + case 85: { alt70=2; } break; - case 84: + case 86: { alt70=3; } @@ -12860,7 +12896,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 1 : // InternalScope.g:4446:6: lv_cl_0_1= 'Collection' { - lv_cl_0_1=(Token)match(input,82,FOLLOW_64); if (state.failed) return current; + lv_cl_0_1=(Token)match(input,84,FOLLOW_64); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_1, grammarAccess.getCollectionTypeAccess().getClCollectionKeyword_0_0_0()); @@ -12880,7 +12916,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 2 : // InternalScope.g:4457:6: lv_cl_0_2= 'List' { - lv_cl_0_2=(Token)match(input,83,FOLLOW_64); if (state.failed) return current; + lv_cl_0_2=(Token)match(input,85,FOLLOW_64); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_2, grammarAccess.getCollectionTypeAccess().getClListKeyword_0_0_1()); @@ -12900,7 +12936,7 @@ public final EObject ruleCollectionType() throws RecognitionException { case 3 : // InternalScope.g:4468:6: lv_cl_0_3= 'Set' { - lv_cl_0_3=(Token)match(input,84,FOLLOW_64); if (state.failed) return current; + lv_cl_0_3=(Token)match(input,86,FOLLOW_64); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(lv_cl_0_3, grammarAccess.getCollectionTypeAccess().getClSetKeyword_0_0_2()); @@ -12926,7 +12962,7 @@ public final EObject ruleCollectionType() throws RecognitionException { } - otherlv_1=(Token)match(input,31,FOLLOW_44); if (state.failed) return current; + otherlv_1=(Token)match(input,33,FOLLOW_44); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getCollectionTypeAccess().getLeftSquareBracketKeyword_1()); @@ -12967,7 +13003,7 @@ public final EObject ruleCollectionType() throws RecognitionException { } - otherlv_3=(Token)match(input,32,FOLLOW_2); if (state.failed) return current; + otherlv_3=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_3, grammarAccess.getCollectionTypeAccess().getRightSquareBracketKeyword_3()); @@ -13099,7 +13135,7 @@ public final EObject ruleSimpleType() throws RecognitionException { int alt71=2; int LA71_0 = input.LA(1); - if ( (LA71_0==44) ) { + if ( (LA71_0==46) ) { alt71=1; } @@ -13108,7 +13144,7 @@ public final EObject ruleSimpleType() throws RecognitionException { case 1 : // InternalScope.g:4547:4: otherlv_1= '::' ( (lv_id_2_0= ruleIdentifier ) ) { - otherlv_1=(Token)match(input,44,FOLLOW_3); if (state.failed) return current; + otherlv_1=(Token)match(input,46,FOLLOW_3); if (state.failed) return current; if ( state.backtracking==0 ) { newLeafNode(otherlv_1, grammarAccess.getSimpleTypeAccess().getColonColonKeyword_1_0()); @@ -13268,80 +13304,77 @@ public final AntlrDatatypeRuleToken ruleIdentifier() throws RecognitionException // $ANTLR end "ruleIdentifier" - // $ANTLR start "ruleCasing" - // InternalScope.g:4599:1: ruleCasing returns [Enumerator current=null] : ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) ; - public final Enumerator ruleCasing() throws RecognitionException { - Enumerator current = null; - - Token enumLiteral_0=null; - Token enumLiteral_1=null; + // $ANTLR start "entryRuleXExpression" + // InternalScope.g:4599:1: entryRuleXExpression returns [EObject current=null] : iv_ruleXExpression= ruleXExpression EOF ; + public final EObject entryRuleXExpression() throws RecognitionException { + EObject current = null; + EObject iv_ruleXExpression = null; - enterRule(); try { - // InternalScope.g:4605:2: ( ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) ) - // InternalScope.g:4606:2: ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) + // InternalScope.g:4599:52: (iv_ruleXExpression= ruleXExpression EOF ) + // InternalScope.g:4600:2: iv_ruleXExpression= ruleXExpression EOF { - // InternalScope.g:4606:2: ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) - int alt72=2; - int LA72_0 = input.LA(1); - - if ( (LA72_0==85) ) { - alt72=1; + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionRule()); } - else if ( (LA72_0==86) ) { - alt72=2; + pushFollow(FOLLOW_1); + iv_ruleXExpression=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpression; } - else { - if (state.backtracking>0) {state.failed=true; return current;} - NoViableAltException nvae = - new NoViableAltException("", 72, 0, input); + match(input,EOF,FOLLOW_2); if (state.failed) return current; - throw nvae; } - switch (alt72) { - case 1 : - // InternalScope.g:4607:3: (enumLiteral_0= 'sensitive' ) - { - // InternalScope.g:4607:3: (enumLiteral_0= 'sensitive' ) - // InternalScope.g:4608:4: enumLiteral_0= 'sensitive' - { - enumLiteral_0=(Token)match(input,85,FOLLOW_2); if (state.failed) return current; - if ( state.backtracking==0 ) { - current = grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); - newLeafNode(enumLiteral_0, grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); - - } + } - } + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpression" - } - break; - case 2 : - // InternalScope.g:4615:3: (enumLiteral_1= 'insensitive' ) - { - // InternalScope.g:4615:3: (enumLiteral_1= 'insensitive' ) - // InternalScope.g:4616:4: enumLiteral_1= 'insensitive' - { - enumLiteral_1=(Token)match(input,86,FOLLOW_2); if (state.failed) return current; - if ( state.backtracking==0 ) { + // $ANTLR start "ruleXExpression" + // InternalScope.g:4606:1: ruleXExpression returns [EObject current=null] : this_XAssignment_0= ruleXAssignment ; + public final EObject ruleXExpression() throws RecognitionException { + EObject current = null; - current = grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); - newLeafNode(enumLiteral_1, grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); - - } + EObject this_XAssignment_0 = null; - } - } - break; + enterRule(); + + try { + // InternalScope.g:4612:2: (this_XAssignment_0= ruleXAssignment ) + // InternalScope.g:4613:2: this_XAssignment_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); + } + pushFollow(FOLLOW_2); + this_XAssignment_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current = this_XAssignment_0; + afterParserOrEnumRuleCall(); + + } } @@ -13360,139 +13393,22196 @@ else if ( (LA72_0==86) ) { } return current; } - // $ANTLR end "ruleCasing" + // $ANTLR end "ruleXExpression" - // $ANTLR start synpred1_InternalScope - public final void synpred1_InternalScope_fragment() throws RecognitionException { - // InternalScope.g:1645:4: ( '(' ) - // InternalScope.g:1645:5: '(' - { - match(input,25,FOLLOW_2); if (state.failed) return ; - } - } - // $ANTLR end synpred1_InternalScope + // $ANTLR start "entryRuleXAssignment" + // InternalScope.g:4624:1: entryRuleXAssignment returns [EObject current=null] : iv_ruleXAssignment= ruleXAssignment EOF ; + public final EObject entryRuleXAssignment() throws RecognitionException { + EObject current = null; - // $ANTLR start synpred2_InternalScope - public final void synpred2_InternalScope_fragment() throws RecognitionException { - // InternalScope.g:1911:4: ( ruleCastedExpression ) - // InternalScope.g:1911:5: ruleCastedExpression - { - pushFollow(FOLLOW_2); - ruleCastedExpression(); + EObject iv_ruleXAssignment = null; - state._fsp--; - if (state.failed) return ; + try { + // InternalScope.g:4624:52: (iv_ruleXAssignment= ruleXAssignment EOF ) + // InternalScope.g:4625:2: iv_ruleXAssignment= ruleXAssignment EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAssignmentRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAssignment=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAssignment; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { } + return current; } - // $ANTLR end synpred2_InternalScope + // $ANTLR end "entryRuleXAssignment" + + + // $ANTLR start "ruleXAssignment" + // InternalScope.g:4631:1: ruleXAssignment returns [EObject current=null] : ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ; + public final EObject ruleXAssignment() throws RecognitionException { + EObject current = null; + + EObject lv_value_3_0 = null; + + EObject this_XOrExpression_4 = null; + + EObject lv_rightOperand_7_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:4637:2: ( ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ) + // InternalScope.g:4638:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) + { + // InternalScope.g:4638:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) + int alt73=2; + switch ( input.LA(1) ) { + case RULE_ID: + { + int LA73_1 = input.LA(2); + + if ( (LA73_1==24) ) { + alt73=1; + } + else if ( (LA73_1==EOF||(LA73_1>=RULE_STRING && LA73_1<=RULE_INT)||(LA73_1>=RULE_ID && LA73_1<=RULE_DECIMAL)||(LA73_1>=16 && LA73_1<=18)||LA73_1==20||(LA73_1>=22 && LA73_1<=23)||LA73_1==25||(LA73_1>=27 && LA73_1<=29)||(LA73_1>=32 && LA73_1<=34)||LA73_1==37||(LA73_1>=46 && LA73_1<=47)||(LA73_1>=49 && LA73_1<=50)||LA73_1==52||(LA73_1>=54 && LA73_1<=58)||(LA73_1>=60 && LA73_1<=62)||(LA73_1>=64 && LA73_1<=69)||(LA73_1>=79 && LA73_1<=81)||LA73_1==83||(LA73_1>=87 && LA73_1<=119)) ) { + alt73=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 1, input); + + throw nvae; + } + } + break; + case 110: + { + int LA73_2 = input.LA(2); + + if ( (LA73_2==EOF||(LA73_2>=RULE_STRING && LA73_2<=RULE_INT)||(LA73_2>=RULE_ID && LA73_2<=RULE_DECIMAL)||(LA73_2>=16 && LA73_2<=18)||LA73_2==20||(LA73_2>=22 && LA73_2<=23)||LA73_2==25||(LA73_2>=27 && LA73_2<=29)||(LA73_2>=32 && LA73_2<=34)||LA73_2==37||(LA73_2>=46 && LA73_2<=47)||(LA73_2>=49 && LA73_2<=50)||LA73_2==52||(LA73_2>=54 && LA73_2<=58)||(LA73_2>=60 && LA73_2<=62)||(LA73_2>=64 && LA73_2<=69)||(LA73_2>=79 && LA73_2<=81)||LA73_2==83||(LA73_2>=87 && LA73_2<=119)) ) { + alt73=2; + } + else if ( (LA73_2==24) ) { + alt73=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 2, input); + + throw nvae; + } + } + break; + case 111: + { + int LA73_3 = input.LA(2); + + if ( (LA73_3==24) ) { + alt73=1; + } + else if ( (LA73_3==EOF||(LA73_3>=RULE_STRING && LA73_3<=RULE_INT)||(LA73_3>=RULE_ID && LA73_3<=RULE_DECIMAL)||(LA73_3>=16 && LA73_3<=18)||LA73_3==20||(LA73_3>=22 && LA73_3<=23)||LA73_3==25||(LA73_3>=27 && LA73_3<=29)||(LA73_3>=32 && LA73_3<=34)||LA73_3==37||(LA73_3>=46 && LA73_3<=47)||(LA73_3>=49 && LA73_3<=50)||LA73_3==52||(LA73_3>=54 && LA73_3<=58)||(LA73_3>=60 && LA73_3<=62)||(LA73_3>=64 && LA73_3<=69)||(LA73_3>=79 && LA73_3<=81)||LA73_3==83||(LA73_3>=87 && LA73_3<=119)) ) { + alt73=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 3, input); + + throw nvae; + } + } + break; + case 16: + { + int LA73_4 = input.LA(2); + + if ( (LA73_4==24) ) { + alt73=1; + } + else if ( (LA73_4==EOF||(LA73_4>=RULE_STRING && LA73_4<=RULE_INT)||(LA73_4>=RULE_ID && LA73_4<=RULE_DECIMAL)||(LA73_4>=16 && LA73_4<=18)||LA73_4==20||(LA73_4>=22 && LA73_4<=23)||LA73_4==25||(LA73_4>=27 && LA73_4<=29)||(LA73_4>=32 && LA73_4<=34)||LA73_4==37||(LA73_4>=46 && LA73_4<=47)||(LA73_4>=49 && LA73_4<=50)||LA73_4==52||(LA73_4>=54 && LA73_4<=58)||(LA73_4>=60 && LA73_4<=62)||(LA73_4>=64 && LA73_4<=69)||(LA73_4>=79 && LA73_4<=81)||LA73_4==83||(LA73_4>=87 && LA73_4<=119)) ) { + alt73=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 4, input); + + throw nvae; + } + } + break; + case 18: + { + int LA73_5 = input.LA(2); + + if ( (LA73_5==24) ) { + alt73=1; + } + else if ( (LA73_5==EOF||(LA73_5>=RULE_STRING && LA73_5<=RULE_INT)||(LA73_5>=RULE_ID && LA73_5<=RULE_DECIMAL)||(LA73_5>=16 && LA73_5<=18)||LA73_5==20||(LA73_5>=22 && LA73_5<=23)||LA73_5==25||(LA73_5>=27 && LA73_5<=29)||(LA73_5>=32 && LA73_5<=34)||LA73_5==37||(LA73_5>=46 && LA73_5<=47)||(LA73_5>=49 && LA73_5<=50)||LA73_5==52||(LA73_5>=54 && LA73_5<=58)||(LA73_5>=60 && LA73_5<=62)||(LA73_5>=64 && LA73_5<=69)||(LA73_5>=79 && LA73_5<=81)||LA73_5==83||(LA73_5>=87 && LA73_5<=119)) ) { + alt73=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 5, input); + + throw nvae; + } + } + break; + case RULE_STRING: + case RULE_INT: + case RULE_HEX: + case RULE_DECIMAL: + case 22: + case 27: + case 29: + case 33: + case 52: + case 55: + case 65: + case 66: + case 67: + case 69: + case 79: + case 80: + case 81: + case 83: + case 105: + case 106: + case 107: + case 112: + case 113: + case 114: + case 115: + case 116: + case 118: + { + alt73=2; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 73, 0, input); + + throw nvae; + } + + switch (alt73) { + case 1 : + // InternalScope.g:4639:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) + { + // InternalScope.g:4639:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) + // InternalScope.g:4640:4: () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) + { + // InternalScope.g:4640:4: () + // InternalScope.g:4641:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(), + current); + + } + + } + + // InternalScope.g:4647:4: ( ( ruleFeatureCallID ) ) + // InternalScope.g:4648:5: ( ruleFeatureCallID ) + { + // InternalScope.g:4648:5: ( ruleFeatureCallID ) + // InternalScope.g:4649:6: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAssignmentRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + + } + pushFollow(FOLLOW_16); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); + + } + pushFollow(FOLLOW_65); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:4670:4: ( (lv_value_3_0= ruleXAssignment ) ) + // InternalScope.g:4671:5: (lv_value_3_0= ruleXAssignment ) + { + // InternalScope.g:4671:5: (lv_value_3_0= ruleXAssignment ) + // InternalScope.g:4672:6: lv_value_3_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); + + } + pushFollow(FOLLOW_2); + lv_value_3_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + current, + "value", + lv_value_3_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:4691:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) + { + // InternalScope.g:4691:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) + // InternalScope.g:4692:4: this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_66); + this_XOrExpression_4=ruleXOrExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XOrExpression_4; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:4700:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? + int alt72=2; + alt72 = dfa72.predict(input); + switch (alt72) { + case 1 : + // InternalScope.g:4701:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) + { + // InternalScope.g:4701:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) + // InternalScope.g:4702:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) + { + // InternalScope.g:4712:6: ( () ( ( ruleOpMultiAssign ) ) ) + // InternalScope.g:4713:7: () ( ( ruleOpMultiAssign ) ) + { + // InternalScope.g:4713:7: () + // InternalScope.g:4714:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:4720:7: ( ( ruleOpMultiAssign ) ) + // InternalScope.g:4721:8: ( ruleOpMultiAssign ) + { + // InternalScope.g:4721:8: ( ruleOpMultiAssign ) + // InternalScope.g:4722:9: ruleOpMultiAssign + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAssignmentRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:4738:5: ( (lv_rightOperand_7_0= ruleXAssignment ) ) + // InternalScope.g:4739:6: (lv_rightOperand_7_0= ruleXAssignment ) + { + // InternalScope.g:4739:6: (lv_rightOperand_7_0= ruleXAssignment ) + // InternalScope.g:4740:7: lv_rightOperand_7_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_rightOperand_7_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAssignmentRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_7_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAssignment" + + + // $ANTLR start "entryRuleOpSingleAssign" + // InternalScope.g:4763:1: entryRuleOpSingleAssign returns [String current=null] : iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ; + public final String entryRuleOpSingleAssign() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpSingleAssign = null; + + + try { + // InternalScope.g:4763:54: (iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ) + // InternalScope.g:4764:2: iv_ruleOpSingleAssign= ruleOpSingleAssign EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpSingleAssignRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpSingleAssign=ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpSingleAssign.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpSingleAssign" + + + // $ANTLR start "ruleOpSingleAssign" + // InternalScope.g:4770:1: ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '=' ; + public final AntlrDatatypeRuleToken ruleOpSingleAssign() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:4776:2: (kw= '=' ) + // InternalScope.g:4777:2: kw= '=' + { + kw=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpSingleAssign" + + + // $ANTLR start "entryRuleOpMultiAssign" + // InternalScope.g:4785:1: entryRuleOpMultiAssign returns [String current=null] : iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ; + public final String entryRuleOpMultiAssign() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpMultiAssign = null; + + + try { + // InternalScope.g:4785:53: (iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ) + // InternalScope.g:4786:2: iv_ruleOpMultiAssign= ruleOpMultiAssign EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpMultiAssignRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpMultiAssign=ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpMultiAssign.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpMultiAssign" + + + // $ANTLR start "ruleOpMultiAssign" + // InternalScope.g:4792:1: ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ; + public final AntlrDatatypeRuleToken ruleOpMultiAssign() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:4798:2: ( (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ) + // InternalScope.g:4799:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) + { + // InternalScope.g:4799:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) + int alt75=7; + switch ( input.LA(1) ) { + case 87: + { + alt75=1; + } + break; + case 88: + { + alt75=2; + } + break; + case 89: + { + alt75=3; + } + break; + case 90: + { + alt75=4; + } + break; + case 91: + { + alt75=5; + } + break; + case 65: + { + alt75=6; + } + break; + case 64: + { + alt75=7; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 75, 0, input); + + throw nvae; + } + + switch (alt75) { + case 1 : + // InternalScope.g:4800:3: kw= '+=' + { + kw=(Token)match(input,87,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:4806:3: kw= '-=' + { + kw=(Token)match(input,88,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalScope.g:4812:3: kw= '*=' + { + kw=(Token)match(input,89,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalScope.g:4818:3: kw= '/=' + { + kw=(Token)match(input,90,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); + + } + + } + break; + case 5 : + // InternalScope.g:4824:3: kw= '%=' + { + kw=(Token)match(input,91,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); + + } + + } + break; + case 6 : + // InternalScope.g:4830:3: (kw= '<' kw= '<' kw= '=' ) + { + // InternalScope.g:4830:3: (kw= '<' kw= '<' kw= '=' ) + // InternalScope.g:4831:4: kw= '<' kw= '<' kw= '=' + { + kw=(Token)match(input,65,FOLLOW_67); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); + + } + kw=(Token)match(input,65,FOLLOW_16); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); + + } + kw=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); + + } + + } + + + } + break; + case 7 : + // InternalScope.g:4848:3: (kw= '>' (kw= '>' )? kw= '>=' ) + { + // InternalScope.g:4848:3: (kw= '>' (kw= '>' )? kw= '>=' ) + // InternalScope.g:4849:4: kw= '>' (kw= '>' )? kw= '>=' + { + kw=(Token)match(input,64,FOLLOW_68); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); + + } + // InternalScope.g:4854:4: (kw= '>' )? + int alt74=2; + int LA74_0 = input.LA(1); + + if ( (LA74_0==64) ) { + alt74=1; + } + switch (alt74) { + case 1 : + // InternalScope.g:4855:5: kw= '>' + { + kw=(Token)match(input,64,FOLLOW_69); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); + + } + + } + break; + + } + + kw=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); + + } + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpMultiAssign" + + + // $ANTLR start "entryRuleXOrExpression" + // InternalScope.g:4871:1: entryRuleXOrExpression returns [EObject current=null] : iv_ruleXOrExpression= ruleXOrExpression EOF ; + public final EObject entryRuleXOrExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXOrExpression = null; + + + try { + // InternalScope.g:4871:54: (iv_ruleXOrExpression= ruleXOrExpression EOF ) + // InternalScope.g:4872:2: iv_ruleXOrExpression= ruleXOrExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXOrExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXOrExpression=ruleXOrExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXOrExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXOrExpression" + + + // $ANTLR start "ruleXOrExpression" + // InternalScope.g:4878:1: ruleXOrExpression returns [EObject current=null] : (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ; + public final EObject ruleXOrExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAndExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:4884:2: ( (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ) + // InternalScope.g:4885:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) + { + // InternalScope.g:4885:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) + // InternalScope.g:4886:3: this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_53); + this_XAndExpression_0=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAndExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:4894:3: ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* + loop76: + do { + int alt76=2; + int LA76_0 = input.LA(1); + + if ( (LA76_0==57) ) { + int LA76_2 = input.LA(2); + + if ( (synpred5_InternalScope()) ) { + alt76=1; + } + + + } + + + switch (alt76) { + case 1 : + // InternalScope.g:4895:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) + { + // InternalScope.g:4895:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) + // InternalScope.g:4896:5: ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) + { + // InternalScope.g:4906:5: ( () ( ( ruleOpOr ) ) ) + // InternalScope.g:4907:6: () ( ( ruleOpOr ) ) + { + // InternalScope.g:4907:6: () + // InternalScope.g:4908:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:4914:6: ( ( ruleOpOr ) ) + // InternalScope.g:4915:7: ( ruleOpOr ) + { + // InternalScope.g:4915:7: ( ruleOpOr ) + // InternalScope.g:4916:8: ruleOpOr + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXOrExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpOr(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:4932:4: ( (lv_rightOperand_3_0= ruleXAndExpression ) ) + // InternalScope.g:4933:5: (lv_rightOperand_3_0= ruleXAndExpression ) + { + // InternalScope.g:4933:5: (lv_rightOperand_3_0= ruleXAndExpression ) + // InternalScope.g:4934:6: lv_rightOperand_3_0= ruleXAndExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_53); + lv_rightOperand_3_0=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXOrExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAndExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop76; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXOrExpression" + + + // $ANTLR start "entryRuleOpOr" + // InternalScope.g:4956:1: entryRuleOpOr returns [String current=null] : iv_ruleOpOr= ruleOpOr EOF ; + public final String entryRuleOpOr() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpOr = null; + + + try { + // InternalScope.g:4956:44: (iv_ruleOpOr= ruleOpOr EOF ) + // InternalScope.g:4957:2: iv_ruleOpOr= ruleOpOr EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpOrRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpOr=ruleOpOr(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpOr.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpOr" + + + // $ANTLR start "ruleOpOr" + // InternalScope.g:4963:1: ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '||' ; + public final AntlrDatatypeRuleToken ruleOpOr() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:4969:2: (kw= '||' ) + // InternalScope.g:4970:2: kw= '||' + { + kw=(Token)match(input,57,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpOr" + + + // $ANTLR start "entryRuleXAndExpression" + // InternalScope.g:4978:1: entryRuleXAndExpression returns [EObject current=null] : iv_ruleXAndExpression= ruleXAndExpression EOF ; + public final EObject entryRuleXAndExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAndExpression = null; + + + try { + // InternalScope.g:4978:55: (iv_ruleXAndExpression= ruleXAndExpression EOF ) + // InternalScope.g:4979:2: iv_ruleXAndExpression= ruleXAndExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAndExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAndExpression=ruleXAndExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAndExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAndExpression" + + + // $ANTLR start "ruleXAndExpression" + // InternalScope.g:4985:1: ruleXAndExpression returns [EObject current=null] : (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ; + public final EObject ruleXAndExpression() throws RecognitionException { + EObject current = null; + + EObject this_XEqualityExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:4991:2: ( (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ) + // InternalScope.g:4992:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) + { + // InternalScope.g:4992:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) + // InternalScope.g:4993:3: this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_54); + this_XEqualityExpression_0=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XEqualityExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5001:3: ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* + loop77: + do { + int alt77=2; + int LA77_0 = input.LA(1); + + if ( (LA77_0==58) ) { + int LA77_2 = input.LA(2); + + if ( (synpred6_InternalScope()) ) { + alt77=1; + } + + + } + + + switch (alt77) { + case 1 : + // InternalScope.g:5002:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) + { + // InternalScope.g:5002:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) + // InternalScope.g:5003:5: ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) + { + // InternalScope.g:5013:5: ( () ( ( ruleOpAnd ) ) ) + // InternalScope.g:5014:6: () ( ( ruleOpAnd ) ) + { + // InternalScope.g:5014:6: () + // InternalScope.g:5015:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:5021:6: ( ( ruleOpAnd ) ) + // InternalScope.g:5022:7: ( ruleOpAnd ) + { + // InternalScope.g:5022:7: ( ruleOpAnd ) + // InternalScope.g:5023:8: ruleOpAnd + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAndExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:5039:4: ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) + // InternalScope.g:5040:5: (lv_rightOperand_3_0= ruleXEqualityExpression ) + { + // InternalScope.g:5040:5: (lv_rightOperand_3_0= ruleXEqualityExpression ) + // InternalScope.g:5041:6: lv_rightOperand_3_0= ruleXEqualityExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_54); + lv_rightOperand_3_0=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAndExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XEqualityExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop77; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAndExpression" + + + // $ANTLR start "entryRuleOpAnd" + // InternalScope.g:5063:1: entryRuleOpAnd returns [String current=null] : iv_ruleOpAnd= ruleOpAnd EOF ; + public final String entryRuleOpAnd() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpAnd = null; + + + try { + // InternalScope.g:5063:45: (iv_ruleOpAnd= ruleOpAnd EOF ) + // InternalScope.g:5064:2: iv_ruleOpAnd= ruleOpAnd EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpAndRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpAnd=ruleOpAnd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpAnd.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpAnd" + + + // $ANTLR start "ruleOpAnd" + // InternalScope.g:5070:1: ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '&&' ; + public final AntlrDatatypeRuleToken ruleOpAnd() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5076:2: (kw= '&&' ) + // InternalScope.g:5077:2: kw= '&&' + { + kw=(Token)match(input,58,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpAnd" + + + // $ANTLR start "entryRuleXEqualityExpression" + // InternalScope.g:5085:1: entryRuleXEqualityExpression returns [EObject current=null] : iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ; + public final EObject entryRuleXEqualityExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXEqualityExpression = null; + + + try { + // InternalScope.g:5085:60: (iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ) + // InternalScope.g:5086:2: iv_ruleXEqualityExpression= ruleXEqualityExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXEqualityExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXEqualityExpression=ruleXEqualityExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXEqualityExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXEqualityExpression" + + + // $ANTLR start "ruleXEqualityExpression" + // InternalScope.g:5092:1: ruleXEqualityExpression returns [EObject current=null] : (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ; + public final EObject ruleXEqualityExpression() throws RecognitionException { + EObject current = null; + + EObject this_XRelationalExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:5098:2: ( (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ) + // InternalScope.g:5099:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) + { + // InternalScope.g:5099:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) + // InternalScope.g:5100:3: this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_70); + this_XRelationalExpression_0=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XRelationalExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5108:3: ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* + loop78: + do { + int alt78=2; + switch ( input.LA(1) ) { + case 60: + { + int LA78_2 = input.LA(2); + + if ( (synpred7_InternalScope()) ) { + alt78=1; + } + + + } + break; + case 61: + { + int LA78_3 = input.LA(2); + + if ( (synpred7_InternalScope()) ) { + alt78=1; + } + + + } + break; + case 92: + { + int LA78_4 = input.LA(2); + + if ( (synpred7_InternalScope()) ) { + alt78=1; + } + + + } + break; + case 93: + { + int LA78_5 = input.LA(2); + + if ( (synpred7_InternalScope()) ) { + alt78=1; + } + + + } + break; + + } + + switch (alt78) { + case 1 : + // InternalScope.g:5109:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) + { + // InternalScope.g:5109:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) + // InternalScope.g:5110:5: ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) + { + // InternalScope.g:5120:5: ( () ( ( ruleOpEquality ) ) ) + // InternalScope.g:5121:6: () ( ( ruleOpEquality ) ) + { + // InternalScope.g:5121:6: () + // InternalScope.g:5122:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:5128:6: ( ( ruleOpEquality ) ) + // InternalScope.g:5129:7: ( ruleOpEquality ) + { + // InternalScope.g:5129:7: ( ruleOpEquality ) + // InternalScope.g:5130:8: ruleOpEquality + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXEqualityExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:5146:4: ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) + // InternalScope.g:5147:5: (lv_rightOperand_3_0= ruleXRelationalExpression ) + { + // InternalScope.g:5147:5: (lv_rightOperand_3_0= ruleXRelationalExpression ) + // InternalScope.g:5148:6: lv_rightOperand_3_0= ruleXRelationalExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_70); + lv_rightOperand_3_0=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XRelationalExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop78; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXEqualityExpression" + + + // $ANTLR start "entryRuleOpEquality" + // InternalScope.g:5170:1: entryRuleOpEquality returns [String current=null] : iv_ruleOpEquality= ruleOpEquality EOF ; + public final String entryRuleOpEquality() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpEquality = null; + + + try { + // InternalScope.g:5170:50: (iv_ruleOpEquality= ruleOpEquality EOF ) + // InternalScope.g:5171:2: iv_ruleOpEquality= ruleOpEquality EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpEqualityRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpEquality=ruleOpEquality(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpEquality.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpEquality" + + + // $ANTLR start "ruleOpEquality" + // InternalScope.g:5177:1: ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ; + public final AntlrDatatypeRuleToken ruleOpEquality() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5183:2: ( (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ) + // InternalScope.g:5184:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) + { + // InternalScope.g:5184:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) + int alt79=4; + switch ( input.LA(1) ) { + case 60: + { + alt79=1; + } + break; + case 61: + { + alt79=2; + } + break; + case 92: + { + alt79=3; + } + break; + case 93: + { + alt79=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 79, 0, input); + + throw nvae; + } + + switch (alt79) { + case 1 : + // InternalScope.g:5185:3: kw= '==' + { + kw=(Token)match(input,60,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:5191:3: kw= '!=' + { + kw=(Token)match(input,61,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalScope.g:5197:3: kw= '===' + { + kw=(Token)match(input,92,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalScope.g:5203:3: kw= '!==' + { + kw=(Token)match(input,93,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpEquality" + + + // $ANTLR start "entryRuleXRelationalExpression" + // InternalScope.g:5212:1: entryRuleXRelationalExpression returns [EObject current=null] : iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ; + public final EObject entryRuleXRelationalExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXRelationalExpression = null; + + + try { + // InternalScope.g:5212:62: (iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ) + // InternalScope.g:5213:2: iv_ruleXRelationalExpression= ruleXRelationalExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXRelationalExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXRelationalExpression=ruleXRelationalExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXRelationalExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXRelationalExpression" + + + // $ANTLR start "ruleXRelationalExpression" + // InternalScope.g:5219:1: ruleXRelationalExpression returns [EObject current=null] : (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ; + public final EObject ruleXRelationalExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject this_XOtherOperatorExpression_0 = null; + + EObject lv_type_3_0 = null; + + EObject lv_rightOperand_6_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:5225:2: ( (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ) + // InternalScope.g:5226:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) + { + // InternalScope.g:5226:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) + // InternalScope.g:5227:3: this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_71); + this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XOtherOperatorExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5235:3: ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* + loop80: + do { + int alt80=3; + switch ( input.LA(1) ) { + case 65: + { + int LA80_2 = input.LA(2); + + if ( (synpred9_InternalScope()) ) { + alt80=2; + } + + + } + break; + case 64: + { + int LA80_3 = input.LA(2); + + if ( (synpred9_InternalScope()) ) { + alt80=2; + } + + + } + break; + case 94: + { + int LA80_4 = input.LA(2); + + if ( (synpred8_InternalScope()) ) { + alt80=1; + } + + + } + break; + case 62: + { + int LA80_5 = input.LA(2); + + if ( (synpred9_InternalScope()) ) { + alt80=2; + } + + + } + break; + + } + + switch (alt80) { + case 1 : + // InternalScope.g:5236:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) + { + // InternalScope.g:5236:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) + // InternalScope.g:5237:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) + { + // InternalScope.g:5237:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) + // InternalScope.g:5238:6: ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) + { + // InternalScope.g:5244:6: ( () otherlv_2= 'instanceof' ) + // InternalScope.g:5245:7: () otherlv_2= 'instanceof' + { + // InternalScope.g:5245:7: () + // InternalScope.g:5246:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(), + current); + + } + + } + + otherlv_2=(Token)match(input,94,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); + + } + + } + + + } + + // InternalScope.g:5258:5: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalScope.g:5259:6: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalScope.g:5259:6: (lv_type_3_0= ruleJvmTypeReference ) + // InternalScope.g:5260:7: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); + + } + pushFollow(FOLLOW_71); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:5279:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) + { + // InternalScope.g:5279:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) + // InternalScope.g:5280:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) + { + // InternalScope.g:5280:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) + // InternalScope.g:5281:6: ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) + { + // InternalScope.g:5291:6: ( () ( ( ruleOpCompare ) ) ) + // InternalScope.g:5292:7: () ( ( ruleOpCompare ) ) + { + // InternalScope.g:5292:7: () + // InternalScope.g:5293:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:5299:7: ( ( ruleOpCompare ) ) + // InternalScope.g:5300:8: ( ruleOpCompare ) + { + // InternalScope.g:5300:8: ( ruleOpCompare ) + // InternalScope.g:5301:9: ruleOpCompare + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXRelationalExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:5317:5: ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) + // InternalScope.g:5318:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) + { + // InternalScope.g:5318:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) + // InternalScope.g:5319:7: lv_rightOperand_6_0= ruleXOtherOperatorExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); + + } + pushFollow(FOLLOW_71); + lv_rightOperand_6_0=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_6_0, + "org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + default : + break loop80; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXRelationalExpression" + + + // $ANTLR start "entryRuleOpCompare" + // InternalScope.g:5342:1: entryRuleOpCompare returns [String current=null] : iv_ruleOpCompare= ruleOpCompare EOF ; + public final String entryRuleOpCompare() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpCompare = null; + + + try { + // InternalScope.g:5342:49: (iv_ruleOpCompare= ruleOpCompare EOF ) + // InternalScope.g:5343:2: iv_ruleOpCompare= ruleOpCompare EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpCompareRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpCompare=ruleOpCompare(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpCompare.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpCompare" + + + // $ANTLR start "ruleOpCompare" + // InternalScope.g:5349:1: ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ; + public final AntlrDatatypeRuleToken ruleOpCompare() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5355:2: ( (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ) + // InternalScope.g:5356:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) + { + // InternalScope.g:5356:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) + int alt81=4; + switch ( input.LA(1) ) { + case 62: + { + alt81=1; + } + break; + case 65: + { + int LA81_2 = input.LA(2); + + if ( (LA81_2==EOF||(LA81_2>=RULE_STRING && LA81_2<=RULE_INT)||(LA81_2>=RULE_ID && LA81_2<=RULE_DECIMAL)||LA81_2==16||LA81_2==18||LA81_2==22||LA81_2==27||LA81_2==29||LA81_2==33||LA81_2==52||LA81_2==55||(LA81_2>=65 && LA81_2<=67)||LA81_2==69||(LA81_2>=79 && LA81_2<=81)||LA81_2==83||(LA81_2>=105 && LA81_2<=107)||(LA81_2>=110 && LA81_2<=116)||LA81_2==118) ) { + alt81=4; + } + else if ( (LA81_2==24) ) { + alt81=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 81, 2, input); + + throw nvae; + } + } + break; + case 64: + { + alt81=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 81, 0, input); + + throw nvae; + } + + switch (alt81) { + case 1 : + // InternalScope.g:5357:3: kw= '>=' + { + kw=(Token)match(input,62,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:5363:3: (kw= '<' kw= '=' ) + { + // InternalScope.g:5363:3: (kw= '<' kw= '=' ) + // InternalScope.g:5364:4: kw= '<' kw= '=' + { + kw=(Token)match(input,65,FOLLOW_16); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); + + } + kw=(Token)match(input,24,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); + + } + + } + + + } + break; + case 3 : + // InternalScope.g:5376:3: kw= '>' + { + kw=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); + + } + + } + break; + case 4 : + // InternalScope.g:5382:3: kw= '<' + { + kw=(Token)match(input,65,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpCompare" + + + // $ANTLR start "entryRuleXOtherOperatorExpression" + // InternalScope.g:5391:1: entryRuleXOtherOperatorExpression returns [EObject current=null] : iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ; + public final EObject entryRuleXOtherOperatorExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXOtherOperatorExpression = null; + + + try { + // InternalScope.g:5391:65: (iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ) + // InternalScope.g:5392:2: iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXOtherOperatorExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXOtherOperatorExpression" + + + // $ANTLR start "ruleXOtherOperatorExpression" + // InternalScope.g:5398:1: ruleXOtherOperatorExpression returns [EObject current=null] : (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ; + public final EObject ruleXOtherOperatorExpression() throws RecognitionException { + EObject current = null; + + EObject this_XAdditiveExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:5404:2: ( (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ) + // InternalScope.g:5405:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) + { + // InternalScope.g:5405:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) + // InternalScope.g:5406:3: this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_73); + this_XAdditiveExpression_0=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XAdditiveExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5414:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* + loop82: + do { + int alt82=2; + alt82 = dfa82.predict(input); + switch (alt82) { + case 1 : + // InternalScope.g:5415:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) + { + // InternalScope.g:5415:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) + // InternalScope.g:5416:5: ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) + { + // InternalScope.g:5426:5: ( () ( ( ruleOpOther ) ) ) + // InternalScope.g:5427:6: () ( ( ruleOpOther ) ) + { + // InternalScope.g:5427:6: () + // InternalScope.g:5428:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:5434:6: ( ( ruleOpOther ) ) + // InternalScope.g:5435:7: ( ruleOpOther ) + { + // InternalScope.g:5435:7: ( ruleOpOther ) + // InternalScope.g:5436:8: ruleOpOther + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpOther(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:5452:4: ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) + // InternalScope.g:5453:5: (lv_rightOperand_3_0= ruleXAdditiveExpression ) + { + // InternalScope.g:5453:5: (lv_rightOperand_3_0= ruleXAdditiveExpression ) + // InternalScope.g:5454:6: lv_rightOperand_3_0= ruleXAdditiveExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_73); + lv_rightOperand_3_0=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XAdditiveExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop82; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXOtherOperatorExpression" + + + // $ANTLR start "entryRuleOpOther" + // InternalScope.g:5476:1: entryRuleOpOther returns [String current=null] : iv_ruleOpOther= ruleOpOther EOF ; + public final String entryRuleOpOther() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpOther = null; + + + try { + // InternalScope.g:5476:47: (iv_ruleOpOther= ruleOpOther EOF ) + // InternalScope.g:5477:2: iv_ruleOpOther= ruleOpOther EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpOtherRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpOther=ruleOpOther(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpOther.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpOther" + + + // $ANTLR start "ruleOpOther" + // InternalScope.g:5483:1: ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ; + public final AntlrDatatypeRuleToken ruleOpOther() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5489:2: ( (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ) + // InternalScope.g:5490:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) + { + // InternalScope.g:5490:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) + int alt85=9; + alt85 = dfa85.predict(input); + switch (alt85) { + case 1 : + // InternalScope.g:5491:3: kw= '->' + { + kw=(Token)match(input,50,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:5497:3: kw= '..<' + { + kw=(Token)match(input,95,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); + + } + + } + break; + case 3 : + // InternalScope.g:5503:3: (kw= '>' kw= '..' ) + { + // InternalScope.g:5503:3: (kw= '>' kw= '..' ) + // InternalScope.g:5504:4: kw= '>' kw= '..' + { + kw=(Token)match(input,64,FOLLOW_74); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); + + } + kw=(Token)match(input,96,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); + + } + + } + + + } + break; + case 4 : + // InternalScope.g:5516:3: kw= '..' + { + kw=(Token)match(input,96,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); + + } + + } + break; + case 5 : + // InternalScope.g:5522:3: kw= '=>' + { + kw=(Token)match(input,97,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); + + } + + } + break; + case 6 : + // InternalScope.g:5528:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) + { + // InternalScope.g:5528:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) + // InternalScope.g:5529:4: kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) + { + kw=(Token)match(input,64,FOLLOW_75); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); + + } + // InternalScope.g:5534:4: ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) + int alt83=2; + int LA83_0 = input.LA(1); + + if ( (LA83_0==64) ) { + int LA83_1 = input.LA(2); + + if ( (LA83_1==64) && (synpred11_InternalScope())) { + alt83=1; + } + else if ( (LA83_1==EOF||(LA83_1>=RULE_STRING && LA83_1<=RULE_INT)||(LA83_1>=RULE_ID && LA83_1<=RULE_DECIMAL)||LA83_1==16||LA83_1==18||LA83_1==22||LA83_1==27||LA83_1==29||LA83_1==33||LA83_1==52||LA83_1==55||(LA83_1>=65 && LA83_1<=67)||LA83_1==69||(LA83_1>=79 && LA83_1<=81)||LA83_1==83||(LA83_1>=105 && LA83_1<=107)||(LA83_1>=110 && LA83_1<=116)||LA83_1==118) ) { + alt83=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 83, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 83, 0, input); + + throw nvae; + } + switch (alt83) { + case 1 : + // InternalScope.g:5535:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) + { + // InternalScope.g:5535:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) + // InternalScope.g:5536:6: ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) + { + // InternalScope.g:5541:6: (kw= '>' kw= '>' ) + // InternalScope.g:5542:7: kw= '>' kw= '>' + { + kw=(Token)match(input,64,FOLLOW_75); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); + + } + kw=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:5555:5: kw= '>' + { + kw=(Token)match(input,64,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); + + } + + } + break; + + } + + + } + + + } + break; + case 7 : + // InternalScope.g:5563:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) + { + // InternalScope.g:5563:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) + // InternalScope.g:5564:4: kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) + { + kw=(Token)match(input,65,FOLLOW_76); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); + + } + // InternalScope.g:5569:4: ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) + int alt84=3; + int LA84_0 = input.LA(1); + + if ( (LA84_0==65) ) { + int LA84_1 = input.LA(2); + + if ( (synpred12_InternalScope()) ) { + alt84=1; + } + else if ( (true) ) { + alt84=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 84, 1, input); + + throw nvae; + } + } + else if ( (LA84_0==97) ) { + alt84=3; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 84, 0, input); + + throw nvae; + } + switch (alt84) { + case 1 : + // InternalScope.g:5570:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) + { + // InternalScope.g:5570:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) + // InternalScope.g:5571:6: ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) + { + // InternalScope.g:5576:6: (kw= '<' kw= '<' ) + // InternalScope.g:5577:7: kw= '<' kw= '<' + { + kw=(Token)match(input,65,FOLLOW_67); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); + + } + kw=(Token)match(input,65,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:5590:5: kw= '<' + { + kw=(Token)match(input,65,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); + + } + + } + break; + case 3 : + // InternalScope.g:5596:5: kw= '=>' + { + kw=(Token)match(input,97,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); + + } + + } + break; + + } + + + } + + + } + break; + case 8 : + // InternalScope.g:5604:3: kw= '<>' + { + kw=(Token)match(input,98,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); + + } + + } + break; + case 9 : + // InternalScope.g:5610:3: kw= '?:' + { + kw=(Token)match(input,99,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpOther" + + + // $ANTLR start "entryRuleXAdditiveExpression" + // InternalScope.g:5619:1: entryRuleXAdditiveExpression returns [EObject current=null] : iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ; + public final EObject entryRuleXAdditiveExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXAdditiveExpression = null; + + + try { + // InternalScope.g:5619:60: (iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ) + // InternalScope.g:5620:2: iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXAdditiveExpression=ruleXAdditiveExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXAdditiveExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXAdditiveExpression" + + + // $ANTLR start "ruleXAdditiveExpression" + // InternalScope.g:5626:1: ruleXAdditiveExpression returns [EObject current=null] : (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ; + public final EObject ruleXAdditiveExpression() throws RecognitionException { + EObject current = null; + + EObject this_XMultiplicativeExpression_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:5632:2: ( (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ) + // InternalScope.g:5633:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) + { + // InternalScope.g:5633:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) + // InternalScope.g:5634:3: this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_57); + this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XMultiplicativeExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5642:3: ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* + loop86: + do { + int alt86=2; + int LA86_0 = input.LA(1); + + if ( (LA86_0==66) ) { + int LA86_2 = input.LA(2); + + if ( (synpred13_InternalScope()) ) { + alt86=1; + } + + + } + else if ( (LA86_0==67) ) { + int LA86_3 = input.LA(2); + + if ( (synpred13_InternalScope()) ) { + alt86=1; + } + + + } + + + switch (alt86) { + case 1 : + // InternalScope.g:5643:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) + { + // InternalScope.g:5643:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) + // InternalScope.g:5644:5: ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) + { + // InternalScope.g:5654:5: ( () ( ( ruleOpAdd ) ) ) + // InternalScope.g:5655:6: () ( ( ruleOpAdd ) ) + { + // InternalScope.g:5655:6: () + // InternalScope.g:5656:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:5662:6: ( ( ruleOpAdd ) ) + // InternalScope.g:5663:7: ( ruleOpAdd ) + { + // InternalScope.g:5663:7: ( ruleOpAdd ) + // InternalScope.g:5664:8: ruleOpAdd + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXAdditiveExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:5680:4: ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) + // InternalScope.g:5681:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) + { + // InternalScope.g:5681:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) + // InternalScope.g:5682:6: lv_rightOperand_3_0= ruleXMultiplicativeExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_57); + lv_rightOperand_3_0=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop86; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXAdditiveExpression" + + + // $ANTLR start "entryRuleOpAdd" + // InternalScope.g:5704:1: entryRuleOpAdd returns [String current=null] : iv_ruleOpAdd= ruleOpAdd EOF ; + public final String entryRuleOpAdd() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpAdd = null; + + + try { + // InternalScope.g:5704:45: (iv_ruleOpAdd= ruleOpAdd EOF ) + // InternalScope.g:5705:2: iv_ruleOpAdd= ruleOpAdd EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpAddRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpAdd=ruleOpAdd(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpAdd.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpAdd" + + + // $ANTLR start "ruleOpAdd" + // InternalScope.g:5711:1: ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+' | kw= '-' ) ; + public final AntlrDatatypeRuleToken ruleOpAdd() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5717:2: ( (kw= '+' | kw= '-' ) ) + // InternalScope.g:5718:2: (kw= '+' | kw= '-' ) + { + // InternalScope.g:5718:2: (kw= '+' | kw= '-' ) + int alt87=2; + int LA87_0 = input.LA(1); + + if ( (LA87_0==66) ) { + alt87=1; + } + else if ( (LA87_0==67) ) { + alt87=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 87, 0, input); + + throw nvae; + } + switch (alt87) { + case 1 : + // InternalScope.g:5719:3: kw= '+' + { + kw=(Token)match(input,66,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:5725:3: kw= '-' + { + kw=(Token)match(input,67,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpAdd" + + + // $ANTLR start "entryRuleXMultiplicativeExpression" + // InternalScope.g:5734:1: entryRuleXMultiplicativeExpression returns [EObject current=null] : iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ; + public final EObject entryRuleXMultiplicativeExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXMultiplicativeExpression = null; + + + try { + // InternalScope.g:5734:66: (iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ) + // InternalScope.g:5735:2: iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXMultiplicativeExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXMultiplicativeExpression" + + + // $ANTLR start "ruleXMultiplicativeExpression" + // InternalScope.g:5741:1: ruleXMultiplicativeExpression returns [EObject current=null] : (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ; + public final EObject ruleXMultiplicativeExpression() throws RecognitionException { + EObject current = null; + + EObject this_XUnaryOperation_0 = null; + + EObject lv_rightOperand_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:5747:2: ( (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ) + // InternalScope.g:5748:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) + { + // InternalScope.g:5748:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) + // InternalScope.g:5749:3: this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); + + } + pushFollow(FOLLOW_77); + this_XUnaryOperation_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XUnaryOperation_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5757:3: ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* + loop88: + do { + int alt88=2; + switch ( input.LA(1) ) { + case 32: + { + int LA88_2 = input.LA(2); + + if ( (synpred14_InternalScope()) ) { + alt88=1; + } + + + } + break; + case 100: + { + int LA88_3 = input.LA(2); + + if ( (synpred14_InternalScope()) ) { + alt88=1; + } + + + } + break; + case 68: + { + int LA88_4 = input.LA(2); + + if ( (synpred14_InternalScope()) ) { + alt88=1; + } + + + } + break; + case 101: + { + int LA88_5 = input.LA(2); + + if ( (synpred14_InternalScope()) ) { + alt88=1; + } + + + } + break; + + } + + switch (alt88) { + case 1 : + // InternalScope.g:5758:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) + { + // InternalScope.g:5758:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) + // InternalScope.g:5759:5: ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) + { + // InternalScope.g:5769:5: ( () ( ( ruleOpMulti ) ) ) + // InternalScope.g:5770:6: () ( ( ruleOpMulti ) ) + { + // InternalScope.g:5770:6: () + // InternalScope.g:5771:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:5777:6: ( ( ruleOpMulti ) ) + // InternalScope.g:5778:7: ( ruleOpMulti ) + { + // InternalScope.g:5778:7: ( ruleOpMulti ) + // InternalScope.g:5779:8: ruleOpMulti + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:5795:4: ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) + // InternalScope.g:5796:5: (lv_rightOperand_3_0= ruleXUnaryOperation ) + { + // InternalScope.g:5796:5: (lv_rightOperand_3_0= ruleXUnaryOperation ) + // InternalScope.g:5797:6: lv_rightOperand_3_0= ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_77); + lv_rightOperand_3_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule()); + } + set( + current, + "rightOperand", + lv_rightOperand_3_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop88; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXMultiplicativeExpression" + + + // $ANTLR start "entryRuleOpMulti" + // InternalScope.g:5819:1: entryRuleOpMulti returns [String current=null] : iv_ruleOpMulti= ruleOpMulti EOF ; + public final String entryRuleOpMulti() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpMulti = null; + + + try { + // InternalScope.g:5819:47: (iv_ruleOpMulti= ruleOpMulti EOF ) + // InternalScope.g:5820:2: iv_ruleOpMulti= ruleOpMulti EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpMultiRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpMulti=ruleOpMulti(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpMulti.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpMulti" + + + // $ANTLR start "ruleOpMulti" + // InternalScope.g:5826:1: ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ; + public final AntlrDatatypeRuleToken ruleOpMulti() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5832:2: ( (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ) + // InternalScope.g:5833:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) + { + // InternalScope.g:5833:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) + int alt89=4; + switch ( input.LA(1) ) { + case 32: + { + alt89=1; + } + break; + case 100: + { + alt89=2; + } + break; + case 68: + { + alt89=3; + } + break; + case 101: + { + alt89=4; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 89, 0, input); + + throw nvae; + } + + switch (alt89) { + case 1 : + // InternalScope.g:5834:3: kw= '*' + { + kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:5840:3: kw= '**' + { + kw=(Token)match(input,100,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); + + } + + } + break; + case 3 : + // InternalScope.g:5846:3: kw= '/' + { + kw=(Token)match(input,68,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); + + } + + } + break; + case 4 : + // InternalScope.g:5852:3: kw= '%' + { + kw=(Token)match(input,101,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpMulti" + + + // $ANTLR start "entryRuleXUnaryOperation" + // InternalScope.g:5861:1: entryRuleXUnaryOperation returns [EObject current=null] : iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ; + public final EObject entryRuleXUnaryOperation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXUnaryOperation = null; + + + try { + // InternalScope.g:5861:56: (iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ) + // InternalScope.g:5862:2: iv_ruleXUnaryOperation= ruleXUnaryOperation EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXUnaryOperationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXUnaryOperation=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXUnaryOperation; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXUnaryOperation" + + + // $ANTLR start "ruleXUnaryOperation" + // InternalScope.g:5868:1: ruleXUnaryOperation returns [EObject current=null] : ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ; + public final EObject ruleXUnaryOperation() throws RecognitionException { + EObject current = null; + + EObject lv_operand_2_0 = null; + + EObject this_XCastedExpression_3 = null; + + + + enterRule(); + + try { + // InternalScope.g:5874:2: ( ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ) + // InternalScope.g:5875:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) + { + // InternalScope.g:5875:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) + int alt90=2; + int LA90_0 = input.LA(1); + + if ( ((LA90_0>=66 && LA90_0<=67)||LA90_0==69) ) { + alt90=1; + } + else if ( ((LA90_0>=RULE_STRING && LA90_0<=RULE_INT)||(LA90_0>=RULE_ID && LA90_0<=RULE_DECIMAL)||LA90_0==16||LA90_0==18||LA90_0==22||LA90_0==27||LA90_0==29||LA90_0==33||LA90_0==52||LA90_0==55||LA90_0==65||(LA90_0>=79 && LA90_0<=81)||LA90_0==83||(LA90_0>=105 && LA90_0<=107)||(LA90_0>=110 && LA90_0<=116)||LA90_0==118) ) { + alt90=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 90, 0, input); + + throw nvae; + } + switch (alt90) { + case 1 : + // InternalScope.g:5876:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) + { + // InternalScope.g:5876:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) + // InternalScope.g:5877:4: () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) + { + // InternalScope.g:5877:4: () + // InternalScope.g:5878:5: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(), + current); + + } + + } + + // InternalScope.g:5884:4: ( ( ruleOpUnary ) ) + // InternalScope.g:5885:5: ( ruleOpUnary ) + { + // InternalScope.g:5885:5: ( ruleOpUnary ) + // InternalScope.g:5886:6: ruleOpUnary + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXUnaryOperationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); + + } + pushFollow(FOLLOW_65); + ruleOpUnary(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:5900:4: ( (lv_operand_2_0= ruleXUnaryOperation ) ) + // InternalScope.g:5901:5: (lv_operand_2_0= ruleXUnaryOperation ) + { + // InternalScope.g:5901:5: (lv_operand_2_0= ruleXUnaryOperation ) + // InternalScope.g:5902:6: lv_operand_2_0= ruleXUnaryOperation + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); + + } + pushFollow(FOLLOW_2); + lv_operand_2_0=ruleXUnaryOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXUnaryOperationRule()); + } + set( + current, + "operand", + lv_operand_2_0, + "org.eclipse.xtext.xbase.Xbase.XUnaryOperation"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:5921:3: this_XCastedExpression_3= ruleXCastedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XCastedExpression_3=ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XCastedExpression_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXUnaryOperation" + + + // $ANTLR start "entryRuleOpUnary" + // InternalScope.g:5933:1: entryRuleOpUnary returns [String current=null] : iv_ruleOpUnary= ruleOpUnary EOF ; + public final String entryRuleOpUnary() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpUnary = null; + + + try { + // InternalScope.g:5933:47: (iv_ruleOpUnary= ruleOpUnary EOF ) + // InternalScope.g:5934:2: iv_ruleOpUnary= ruleOpUnary EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpUnaryRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpUnary=ruleOpUnary(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpUnary.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpUnary" + + + // $ANTLR start "ruleOpUnary" + // InternalScope.g:5940:1: ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '!' | kw= '-' | kw= '+' ) ; + public final AntlrDatatypeRuleToken ruleOpUnary() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:5946:2: ( (kw= '!' | kw= '-' | kw= '+' ) ) + // InternalScope.g:5947:2: (kw= '!' | kw= '-' | kw= '+' ) + { + // InternalScope.g:5947:2: (kw= '!' | kw= '-' | kw= '+' ) + int alt91=3; + switch ( input.LA(1) ) { + case 69: + { + alt91=1; + } + break; + case 67: + { + alt91=2; + } + break; + case 66: + { + alt91=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 91, 0, input); + + throw nvae; + } + + switch (alt91) { + case 1 : + // InternalScope.g:5948:3: kw= '!' + { + kw=(Token)match(input,69,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:5954:3: kw= '-' + { + kw=(Token)match(input,67,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); + + } + + } + break; + case 3 : + // InternalScope.g:5960:3: kw= '+' + { + kw=(Token)match(input,66,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpUnary" + + + // $ANTLR start "entryRuleXCastedExpression" + // InternalScope.g:5969:1: entryRuleXCastedExpression returns [EObject current=null] : iv_ruleXCastedExpression= ruleXCastedExpression EOF ; + public final EObject entryRuleXCastedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCastedExpression = null; + + + try { + // InternalScope.g:5969:58: (iv_ruleXCastedExpression= ruleXCastedExpression EOF ) + // InternalScope.g:5970:2: iv_ruleXCastedExpression= ruleXCastedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCastedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCastedExpression=ruleXCastedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCastedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCastedExpression" + + + // $ANTLR start "ruleXCastedExpression" + // InternalScope.g:5976:1: ruleXCastedExpression returns [EObject current=null] : (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ; + public final EObject ruleXCastedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject this_XPostfixOperation_0 = null; + + EObject lv_type_3_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:5982:2: ( (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ) + // InternalScope.g:5983:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) + { + // InternalScope.g:5983:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) + // InternalScope.g:5984:3: this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); + + } + pushFollow(FOLLOW_10); + this_XPostfixOperation_0=ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XPostfixOperation_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:5992:3: ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* + loop92: + do { + int alt92=2; + int LA92_0 = input.LA(1); + + if ( (LA92_0==17) ) { + int LA92_2 = input.LA(2); + + if ( (synpred15_InternalScope()) ) { + alt92=1; + } + + + } + + + switch (alt92) { + case 1 : + // InternalScope.g:5993:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) + { + // InternalScope.g:5993:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) + // InternalScope.g:5994:5: ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) + { + // InternalScope.g:6000:5: ( () otherlv_2= 'as' ) + // InternalScope.g:6001:6: () otherlv_2= 'as' + { + // InternalScope.g:6001:6: () + // InternalScope.g:6002:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(), + current); + + } + + } + + otherlv_2=(Token)match(input,17,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); + + } + + } + + + } + + // InternalScope.g:6014:4: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalScope.g:6015:5: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalScope.g:6015:5: (lv_type_3_0= ruleJvmTypeReference ) + // InternalScope.g:6016:6: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_10); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCastedExpressionRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop92; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCastedExpression" + + + // $ANTLR start "entryRuleXPostfixOperation" + // InternalScope.g:6038:1: entryRuleXPostfixOperation returns [EObject current=null] : iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ; + public final EObject entryRuleXPostfixOperation() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXPostfixOperation = null; + + + try { + // InternalScope.g:6038:58: (iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ) + // InternalScope.g:6039:2: iv_ruleXPostfixOperation= ruleXPostfixOperation EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXPostfixOperationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXPostfixOperation=ruleXPostfixOperation(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXPostfixOperation; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXPostfixOperation" + + + // $ANTLR start "ruleXPostfixOperation" + // InternalScope.g:6045:1: ruleXPostfixOperation returns [EObject current=null] : (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ; + public final EObject ruleXPostfixOperation() throws RecognitionException { + EObject current = null; + + EObject this_XMemberFeatureCall_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:6051:2: ( (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ) + // InternalScope.g:6052:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) + { + // InternalScope.g:6052:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) + // InternalScope.g:6053:3: this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); + + } + pushFollow(FOLLOW_78); + this_XMemberFeatureCall_0=ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XMemberFeatureCall_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:6061:3: ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? + int alt93=2; + int LA93_0 = input.LA(1); + + if ( (LA93_0==102) ) { + int LA93_1 = input.LA(2); + + if ( (synpred16_InternalScope()) ) { + alt93=1; + } + } + else if ( (LA93_0==103) ) { + int LA93_2 = input.LA(2); + + if ( (synpred16_InternalScope()) ) { + alt93=1; + } + } + switch (alt93) { + case 1 : + // InternalScope.g:6062:4: ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) + { + // InternalScope.g:6072:4: ( () ( ( ruleOpPostfix ) ) ) + // InternalScope.g:6073:5: () ( ( ruleOpPostfix ) ) + { + // InternalScope.g:6073:5: () + // InternalScope.g:6074:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(), + current); + + } + + } + + // InternalScope.g:6080:5: ( ( ruleOpPostfix ) ) + // InternalScope.g:6081:6: ( ruleOpPostfix ) + { + // InternalScope.g:6081:6: ( ruleOpPostfix ) + // InternalScope.g:6082:7: ruleOpPostfix + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXPostfixOperationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); + + } + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXPostfixOperation" + + + // $ANTLR start "entryRuleOpPostfix" + // InternalScope.g:6102:1: entryRuleOpPostfix returns [String current=null] : iv_ruleOpPostfix= ruleOpPostfix EOF ; + public final String entryRuleOpPostfix() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleOpPostfix = null; + + + try { + // InternalScope.g:6102:49: (iv_ruleOpPostfix= ruleOpPostfix EOF ) + // InternalScope.g:6103:2: iv_ruleOpPostfix= ruleOpPostfix EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getOpPostfixRule()); + } + pushFollow(FOLLOW_1); + iv_ruleOpPostfix=ruleOpPostfix(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleOpPostfix.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleOpPostfix" + + + // $ANTLR start "ruleOpPostfix" + // InternalScope.g:6109:1: ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '++' | kw= '--' ) ; + public final AntlrDatatypeRuleToken ruleOpPostfix() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:6115:2: ( (kw= '++' | kw= '--' ) ) + // InternalScope.g:6116:2: (kw= '++' | kw= '--' ) + { + // InternalScope.g:6116:2: (kw= '++' | kw= '--' ) + int alt94=2; + int LA94_0 = input.LA(1); + + if ( (LA94_0==102) ) { + alt94=1; + } + else if ( (LA94_0==103) ) { + alt94=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 94, 0, input); + + throw nvae; + } + switch (alt94) { + case 1 : + // InternalScope.g:6117:3: kw= '++' + { + kw=(Token)match(input,102,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); + + } + + } + break; + case 2 : + // InternalScope.g:6123:3: kw= '--' + { + kw=(Token)match(input,103,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleOpPostfix" + + + // $ANTLR start "entryRuleXMemberFeatureCall" + // InternalScope.g:6132:1: entryRuleXMemberFeatureCall returns [EObject current=null] : iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ; + public final EObject entryRuleXMemberFeatureCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXMemberFeatureCall = null; + + + try { + // InternalScope.g:6132:59: (iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ) + // InternalScope.g:6133:2: iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXMemberFeatureCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXMemberFeatureCall" + + + // $ANTLR start "ruleXMemberFeatureCall" + // InternalScope.g:6139:1: ruleXMemberFeatureCall returns [EObject current=null] : (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ; + public final EObject ruleXMemberFeatureCall() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_explicitStatic_3_0=null; + Token otherlv_8=null; + Token lv_nullSafe_9_0=null; + Token lv_explicitStatic_10_0=null; + Token otherlv_11=null; + Token otherlv_13=null; + Token otherlv_15=null; + Token lv_explicitOperationCall_17_0=null; + Token otherlv_20=null; + Token otherlv_22=null; + EObject this_XPrimaryExpression_0 = null; + + EObject lv_value_6_0 = null; + + EObject lv_typeArguments_12_0 = null; + + EObject lv_typeArguments_14_0 = null; + + EObject lv_memberCallArguments_18_0 = null; + + EObject lv_memberCallArguments_19_0 = null; + + EObject lv_memberCallArguments_21_0 = null; + + EObject lv_memberCallArguments_23_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:6145:2: ( (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ) + // InternalScope.g:6146:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) + { + // InternalScope.g:6146:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) + // InternalScope.g:6147:3: this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); + + } + pushFollow(FOLLOW_79); + this_XPrimaryExpression_0=ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XPrimaryExpression_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:6155:3: ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* + loop103: + do { + int alt103=3; + switch ( input.LA(1) ) { + case 47: + { + int LA103_2 = input.LA(2); + + if ( (synpred17_InternalScope()) ) { + alt103=1; + } + else if ( (synpred18_InternalScope()) ) { + alt103=2; + } + + + } + break; + case 46: + { + int LA103_3 = input.LA(2); + + if ( (synpred17_InternalScope()) ) { + alt103=1; + } + else if ( (synpred18_InternalScope()) ) { + alt103=2; + } + + + } + break; + case 104: + { + int LA103_4 = input.LA(2); + + if ( (synpred18_InternalScope()) ) { + alt103=2; + } + + + } + break; + + } + + switch (alt103) { + case 1 : + // InternalScope.g:6156:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) + { + // InternalScope.g:6156:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) + // InternalScope.g:6157:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) + { + // InternalScope.g:6157:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) + // InternalScope.g:6158:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + { + // InternalScope.g:6178:6: ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + // InternalScope.g:6179:7: () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign + { + // InternalScope.g:6179:7: () + // InternalScope.g:6180:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(), + current); + + } + + } + + // InternalScope.g:6186:7: (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) + int alt95=2; + int LA95_0 = input.LA(1); + + if ( (LA95_0==47) ) { + alt95=1; + } + else if ( (LA95_0==46) ) { + alt95=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 95, 0, input); + + throw nvae; + } + switch (alt95) { + case 1 : + // InternalScope.g:6187:8: otherlv_2= '.' + { + otherlv_2=(Token)match(input,47,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); + + } + + } + break; + case 2 : + // InternalScope.g:6192:8: ( (lv_explicitStatic_3_0= '::' ) ) + { + // InternalScope.g:6192:8: ( (lv_explicitStatic_3_0= '::' ) ) + // InternalScope.g:6193:9: (lv_explicitStatic_3_0= '::' ) + { + // InternalScope.g:6193:9: (lv_explicitStatic_3_0= '::' ) + // InternalScope.g:6194:10: lv_explicitStatic_3_0= '::' + { + lv_explicitStatic_3_0=(Token)match(input,46,FOLLOW_80); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitStatic", lv_explicitStatic_3_0 != null, "::"); + + } + + } + + + } + + + } + break; + + } + + // InternalScope.g:6207:7: ( ( ruleFeatureCallID ) ) + // InternalScope.g:6208:8: ( ruleFeatureCallID ) + { + // InternalScope.g:6208:8: ( ruleFeatureCallID ) + // InternalScope.g:6209:9: ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); + + } + pushFollow(FOLLOW_16); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); + + } + pushFollow(FOLLOW_65); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:6232:5: ( (lv_value_6_0= ruleXAssignment ) ) + // InternalScope.g:6233:6: (lv_value_6_0= ruleXAssignment ) + { + // InternalScope.g:6233:6: (lv_value_6_0= ruleXAssignment ) + // InternalScope.g:6234:7: lv_value_6_0= ruleXAssignment + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); + + } + pushFollow(FOLLOW_79); + lv_value_6_0=ruleXAssignment(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + set( + current, + "value", + lv_value_6_0, + "org.eclipse.xtext.xbase.Xbase.XAssignment"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:6253:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) + { + // InternalScope.g:6253:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) + // InternalScope.g:6254:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? + { + // InternalScope.g:6254:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) + // InternalScope.g:6255:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) + { + // InternalScope.g:6275:6: ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) + // InternalScope.g:6276:7: () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) + { + // InternalScope.g:6276:7: () + // InternalScope.g:6277:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(), + current); + + } + + } + + // InternalScope.g:6283:7: (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) + int alt96=3; + switch ( input.LA(1) ) { + case 47: + { + alt96=1; + } + break; + case 104: + { + alt96=2; + } + break; + case 46: + { + alt96=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 96, 0, input); + + throw nvae; + } + + switch (alt96) { + case 1 : + // InternalScope.g:6284:8: otherlv_8= '.' + { + otherlv_8=(Token)match(input,47,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); + + } + + } + break; + case 2 : + // InternalScope.g:6289:8: ( (lv_nullSafe_9_0= '?.' ) ) + { + // InternalScope.g:6289:8: ( (lv_nullSafe_9_0= '?.' ) ) + // InternalScope.g:6290:9: (lv_nullSafe_9_0= '?.' ) + { + // InternalScope.g:6290:9: (lv_nullSafe_9_0= '?.' ) + // InternalScope.g:6291:10: lv_nullSafe_9_0= '?.' + { + lv_nullSafe_9_0=(Token)match(input,104,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "nullSafe", lv_nullSafe_9_0 != null, "?."); + + } + + } + + + } + + + } + break; + case 3 : + // InternalScope.g:6304:8: ( (lv_explicitStatic_10_0= '::' ) ) + { + // InternalScope.g:6304:8: ( (lv_explicitStatic_10_0= '::' ) ) + // InternalScope.g:6305:9: (lv_explicitStatic_10_0= '::' ) + { + // InternalScope.g:6305:9: (lv_explicitStatic_10_0= '::' ) + // InternalScope.g:6306:10: lv_explicitStatic_10_0= '::' + { + lv_explicitStatic_10_0=(Token)match(input,46,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitStatic", lv_explicitStatic_10_0 != null, "::"); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + // InternalScope.g:6321:5: (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? + int alt98=2; + int LA98_0 = input.LA(1); + + if ( (LA98_0==65) ) { + alt98=1; + } + switch (alt98) { + case 1 : + // InternalScope.g:6322:6: otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' + { + otherlv_11=(Token)match(input,65,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); + + } + // InternalScope.g:6326:6: ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:6327:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:6327:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:6328:8: lv_typeArguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); + + } + pushFollow(FOLLOW_83); + lv_typeArguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:6345:6: (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* + loop97: + do { + int alt97=2; + int LA97_0 = input.LA(1); + + if ( (LA97_0==37) ) { + alt97=1; + } + + + switch (alt97) { + case 1 : + // InternalScope.g:6346:7: otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_13=(Token)match(input,37,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); + + } + // InternalScope.g:6350:7: ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:6351:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:6351:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:6352:9: lv_typeArguments_14_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); + + } + pushFollow(FOLLOW_83); + lv_typeArguments_14_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_14_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop97; + } + } while (true); + + otherlv_15=(Token)match(input,64,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); + + } + + } + break; + + } + + // InternalScope.g:6375:5: ( ( ruleIdOrSuper ) ) + // InternalScope.g:6376:6: ( ruleIdOrSuper ) + { + // InternalScope.g:6376:6: ( ruleIdOrSuper ) + // InternalScope.g:6377:7: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); + + } + pushFollow(FOLLOW_84); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:6391:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? + int alt101=2; + alt101 = dfa101.predict(input); + switch (alt101) { + case 1 : + // InternalScope.g:6392:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' + { + // InternalScope.g:6392:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) + // InternalScope.g:6393:7: ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) + { + // InternalScope.g:6397:7: (lv_explicitOperationCall_17_0= '(' ) + // InternalScope.g:6398:8: lv_explicitOperationCall_17_0= '(' + { + lv_explicitOperationCall_17_0=(Token)match(input,27,FOLLOW_85); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXMemberFeatureCallRule()); + } + setWithLastConsumed(current, "explicitOperationCall", lv_explicitOperationCall_17_0 != null, "("); + + } + + } + + + } + + // InternalScope.g:6410:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? + int alt100=3; + alt100 = dfa100.predict(input); + switch (alt100) { + case 1 : + // InternalScope.g:6411:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) + { + // InternalScope.g:6411:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) + // InternalScope.g:6412:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) + { + // InternalScope.g:6437:8: (lv_memberCallArguments_18_0= ruleXShortClosure ) + // InternalScope.g:6438:9: lv_memberCallArguments_18_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); + + } + pushFollow(FOLLOW_20); + lv_memberCallArguments_18_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_18_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:6456:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) + { + // InternalScope.g:6456:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) + // InternalScope.g:6457:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* + { + // InternalScope.g:6457:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) + // InternalScope.g:6458:9: (lv_memberCallArguments_19_0= ruleXExpression ) + { + // InternalScope.g:6458:9: (lv_memberCallArguments_19_0= ruleXExpression ) + // InternalScope.g:6459:10: lv_memberCallArguments_19_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); + + } + pushFollow(FOLLOW_31); + lv_memberCallArguments_19_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_19_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:6476:8: (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* + loop99: + do { + int alt99=2; + int LA99_0 = input.LA(1); + + if ( (LA99_0==37) ) { + alt99=1; + } + + + switch (alt99) { + case 1 : + // InternalScope.g:6477:9: otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) + { + otherlv_20=(Token)match(input,37,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); + + } + // InternalScope.g:6481:9: ( (lv_memberCallArguments_21_0= ruleXExpression ) ) + // InternalScope.g:6482:10: (lv_memberCallArguments_21_0= ruleXExpression ) + { + // InternalScope.g:6482:10: (lv_memberCallArguments_21_0= ruleXExpression ) + // InternalScope.g:6483:11: lv_memberCallArguments_21_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); + + } + pushFollow(FOLLOW_31); + lv_memberCallArguments_21_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_21_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop99; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_22=(Token)match(input,28,FOLLOW_86); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); + + } + + } + break; + + } + + // InternalScope.g:6508:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? + int alt102=2; + alt102 = dfa102.predict(input); + switch (alt102) { + case 1 : + // InternalScope.g:6509:6: ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) + { + // InternalScope.g:6515:6: (lv_memberCallArguments_23_0= ruleXClosure ) + // InternalScope.g:6516:7: lv_memberCallArguments_23_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); + + } + pushFollow(FOLLOW_79); + lv_memberCallArguments_23_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule()); + } + add( + current, + "memberCallArguments", + lv_memberCallArguments_23_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + break; + + default : + break loop103; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXMemberFeatureCall" + + + // $ANTLR start "entryRuleXPrimaryExpression" + // InternalScope.g:6539:1: entryRuleXPrimaryExpression returns [EObject current=null] : iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ; + public final EObject entryRuleXPrimaryExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXPrimaryExpression = null; + + + try { + // InternalScope.g:6539:59: (iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ) + // InternalScope.g:6540:2: iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXPrimaryExpression=ruleXPrimaryExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXPrimaryExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXPrimaryExpression" + + + // $ANTLR start "ruleXPrimaryExpression" + // InternalScope.g:6546:1: ruleXPrimaryExpression returns [EObject current=null] : (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ; + public final EObject ruleXPrimaryExpression() throws RecognitionException { + EObject current = null; + + EObject this_XConstructorCall_0 = null; + + EObject this_XBlockExpression_1 = null; + + EObject this_XSwitchExpression_2 = null; + + EObject this_XSynchronizedExpression_3 = null; + + EObject this_XFeatureCall_4 = null; + + EObject this_XLiteral_5 = null; + + EObject this_XIfExpression_6 = null; + + EObject this_XForLoopExpression_7 = null; + + EObject this_XBasicForLoopExpression_8 = null; + + EObject this_XWhileExpression_9 = null; + + EObject this_XDoWhileExpression_10 = null; + + EObject this_XThrowExpression_11 = null; + + EObject this_XReturnExpression_12 = null; + + EObject this_XTryCatchFinallyExpression_13 = null; + + EObject this_XParenthesizedExpression_14 = null; + + + + enterRule(); + + try { + // InternalScope.g:6552:2: ( (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ) + // InternalScope.g:6553:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) + { + // InternalScope.g:6553:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) + int alt104=15; + alt104 = dfa104.predict(input); + switch (alt104) { + case 1 : + // InternalScope.g:6554:3: this_XConstructorCall_0= ruleXConstructorCall + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XConstructorCall_0=ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XConstructorCall_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:6563:3: this_XBlockExpression_1= ruleXBlockExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XBlockExpression_1=ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBlockExpression_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 3 : + // InternalScope.g:6572:3: this_XSwitchExpression_2= ruleXSwitchExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); + + } + pushFollow(FOLLOW_2); + this_XSwitchExpression_2=ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSwitchExpression_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 4 : + // InternalScope.g:6581:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) + { + // InternalScope.g:6581:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) + // InternalScope.g:6582:4: ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); + + } + pushFollow(FOLLOW_2); + this_XSynchronizedExpression_3=ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSynchronizedExpression_3; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 5 : + // InternalScope.g:6599:3: this_XFeatureCall_4= ruleXFeatureCall + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); + + } + pushFollow(FOLLOW_2); + this_XFeatureCall_4=ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFeatureCall_4; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 6 : + // InternalScope.g:6608:3: this_XLiteral_5= ruleXLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); + + } + pushFollow(FOLLOW_2); + this_XLiteral_5=ruleXLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XLiteral_5; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 7 : + // InternalScope.g:6617:3: this_XIfExpression_6= ruleXIfExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); + + } + pushFollow(FOLLOW_2); + this_XIfExpression_6=ruleXIfExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XIfExpression_6; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 8 : + // InternalScope.g:6626:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) + { + // InternalScope.g:6626:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) + // InternalScope.g:6627:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); + + } + pushFollow(FOLLOW_2); + this_XForLoopExpression_7=ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XForLoopExpression_7; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 9 : + // InternalScope.g:6650:3: this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); + + } + pushFollow(FOLLOW_2); + this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBasicForLoopExpression_8; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 10 : + // InternalScope.g:6659:3: this_XWhileExpression_9= ruleXWhileExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); + + } + pushFollow(FOLLOW_2); + this_XWhileExpression_9=ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XWhileExpression_9; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 11 : + // InternalScope.g:6668:3: this_XDoWhileExpression_10= ruleXDoWhileExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); + + } + pushFollow(FOLLOW_2); + this_XDoWhileExpression_10=ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XDoWhileExpression_10; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 12 : + // InternalScope.g:6677:3: this_XThrowExpression_11= ruleXThrowExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); + + } + pushFollow(FOLLOW_2); + this_XThrowExpression_11=ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XThrowExpression_11; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 13 : + // InternalScope.g:6686:3: this_XReturnExpression_12= ruleXReturnExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); + + } + pushFollow(FOLLOW_2); + this_XReturnExpression_12=ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XReturnExpression_12; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 14 : + // InternalScope.g:6695:3: this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); + + } + pushFollow(FOLLOW_2); + this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XTryCatchFinallyExpression_13; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 15 : + // InternalScope.g:6704:3: this_XParenthesizedExpression_14= ruleXParenthesizedExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); + + } + pushFollow(FOLLOW_2); + this_XParenthesizedExpression_14=ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XParenthesizedExpression_14; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXPrimaryExpression" + + + // $ANTLR start "entryRuleXLiteral" + // InternalScope.g:6716:1: entryRuleXLiteral returns [EObject current=null] : iv_ruleXLiteral= ruleXLiteral EOF ; + public final EObject entryRuleXLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXLiteral = null; + + + try { + // InternalScope.g:6716:49: (iv_ruleXLiteral= ruleXLiteral EOF ) + // InternalScope.g:6717:2: iv_ruleXLiteral= ruleXLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXLiteral=ruleXLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXLiteral" + + + // $ANTLR start "ruleXLiteral" + // InternalScope.g:6723:1: ruleXLiteral returns [EObject current=null] : (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ; + public final EObject ruleXLiteral() throws RecognitionException { + EObject current = null; + + EObject this_XCollectionLiteral_0 = null; + + EObject this_XClosure_1 = null; + + EObject this_XBooleanLiteral_2 = null; + + EObject this_XNumberLiteral_3 = null; + + EObject this_XNullLiteral_4 = null; + + EObject this_XStringLiteral_5 = null; + + EObject this_XTypeLiteral_6 = null; + + + + enterRule(); + + try { + // InternalScope.g:6729:2: ( (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ) + // InternalScope.g:6730:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) + { + // InternalScope.g:6730:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) + int alt105=7; + int LA105_0 = input.LA(1); + + if ( (LA105_0==29) ) { + alt105=1; + } + else if ( (LA105_0==33) && (synpred24_InternalScope())) { + alt105=2; + } + else if ( ((LA105_0>=79 && LA105_0<=80)) ) { + alt105=3; + } + else if ( (LA105_0==RULE_INT||(LA105_0>=RULE_HEX && LA105_0<=RULE_DECIMAL)) ) { + alt105=4; + } + else if ( (LA105_0==81) ) { + alt105=5; + } + else if ( (LA105_0==RULE_STRING) ) { + alt105=6; + } + else if ( (LA105_0==113) ) { + alt105=7; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 105, 0, input); + + throw nvae; + } + switch (alt105) { + case 1 : + // InternalScope.g:6731:3: this_XCollectionLiteral_0= ruleXCollectionLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XCollectionLiteral_0=ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XCollectionLiteral_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:6740:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) + { + // InternalScope.g:6740:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) + // InternalScope.g:6741:4: ( ( () '[' ) )=>this_XClosure_1= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XClosure_1=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XClosure_1; + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + case 3 : + // InternalScope.g:6757:3: this_XBooleanLiteral_2= ruleXBooleanLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); + + } + pushFollow(FOLLOW_2); + this_XBooleanLiteral_2=ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XBooleanLiteral_2; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 4 : + // InternalScope.g:6766:3: this_XNumberLiteral_3= ruleXNumberLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); + + } + pushFollow(FOLLOW_2); + this_XNumberLiteral_3=ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XNumberLiteral_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 5 : + // InternalScope.g:6775:3: this_XNullLiteral_4= ruleXNullLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); + + } + pushFollow(FOLLOW_2); + this_XNullLiteral_4=ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XNullLiteral_4; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 6 : + // InternalScope.g:6784:3: this_XStringLiteral_5= ruleXStringLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); + + } + pushFollow(FOLLOW_2); + this_XStringLiteral_5=ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XStringLiteral_5; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 7 : + // InternalScope.g:6793:3: this_XTypeLiteral_6= ruleXTypeLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); + + } + pushFollow(FOLLOW_2); + this_XTypeLiteral_6=ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XTypeLiteral_6; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXLiteral" + + + // $ANTLR start "entryRuleXCollectionLiteral" + // InternalScope.g:6805:1: entryRuleXCollectionLiteral returns [EObject current=null] : iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ; + public final EObject entryRuleXCollectionLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCollectionLiteral = null; + + + try { + // InternalScope.g:6805:59: (iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ) + // InternalScope.g:6806:2: iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCollectionLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCollectionLiteral=ruleXCollectionLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCollectionLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCollectionLiteral" + + + // $ANTLR start "ruleXCollectionLiteral" + // InternalScope.g:6812:1: ruleXCollectionLiteral returns [EObject current=null] : (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ; + public final EObject ruleXCollectionLiteral() throws RecognitionException { + EObject current = null; + + EObject this_XSetLiteral_0 = null; + + EObject this_XListLiteral_1 = null; + + + + enterRule(); + + try { + // InternalScope.g:6818:2: ( (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ) + // InternalScope.g:6819:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) + { + // InternalScope.g:6819:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) + int alt106=2; + int LA106_0 = input.LA(1); + + if ( (LA106_0==29) ) { + int LA106_1 = input.LA(2); + + if ( (LA106_1==22) ) { + alt106=1; + } + else if ( (LA106_1==33) ) { + alt106=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 106, 1, input); + + throw nvae; + } + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 106, 0, input); + + throw nvae; + } + switch (alt106) { + case 1 : + // InternalScope.g:6820:3: this_XSetLiteral_0= ruleXSetLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XSetLiteral_0=ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XSetLiteral_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:6829:3: this_XListLiteral_1= ruleXListLiteral + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XListLiteral_1=ruleXListLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XListLiteral_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCollectionLiteral" + + + // $ANTLR start "entryRuleXSetLiteral" + // InternalScope.g:6841:1: entryRuleXSetLiteral returns [EObject current=null] : iv_ruleXSetLiteral= ruleXSetLiteral EOF ; + public final EObject entryRuleXSetLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSetLiteral = null; + + + try { + // InternalScope.g:6841:52: (iv_ruleXSetLiteral= ruleXSetLiteral EOF ) + // InternalScope.g:6842:2: iv_ruleXSetLiteral= ruleXSetLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSetLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSetLiteral=ruleXSetLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSetLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSetLiteral" + + + // $ANTLR start "ruleXSetLiteral" + // InternalScope.g:6848:1: ruleXSetLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ; + public final EObject ruleXSetLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_elements_3_0 = null; + + EObject lv_elements_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:6854:2: ( ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ) + // InternalScope.g:6855:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) + { + // InternalScope.g:6855:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) + // InternalScope.g:6856:3: () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' + { + // InternalScope.g:6856:3: () + // InternalScope.g:6857:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,29,FOLLOW_14); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); + + } + otherlv_2=(Token)match(input,22,FOLLOW_87); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); + + } + // InternalScope.g:6871:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? + int alt108=2; + int LA108_0 = input.LA(1); + + if ( ((LA108_0>=RULE_STRING && LA108_0<=RULE_INT)||(LA108_0>=RULE_ID && LA108_0<=RULE_DECIMAL)||LA108_0==16||LA108_0==18||LA108_0==22||LA108_0==27||LA108_0==29||LA108_0==33||LA108_0==52||LA108_0==55||(LA108_0>=65 && LA108_0<=67)||LA108_0==69||(LA108_0>=79 && LA108_0<=81)||LA108_0==83||(LA108_0>=105 && LA108_0<=107)||(LA108_0>=110 && LA108_0<=116)||LA108_0==118) ) { + alt108=1; + } + switch (alt108) { + case 1 : + // InternalScope.g:6872:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + { + // InternalScope.g:6872:4: ( (lv_elements_3_0= ruleXExpression ) ) + // InternalScope.g:6873:5: (lv_elements_3_0= ruleXExpression ) + { + // InternalScope.g:6873:5: (lv_elements_3_0= ruleXExpression ) + // InternalScope.g:6874:6: lv_elements_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_63); + lv_elements_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:6891:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + loop107: + do { + int alt107=2; + int LA107_0 = input.LA(1); + + if ( (LA107_0==37) ) { + alt107=1; + } + + + switch (alt107) { + case 1 : + // InternalScope.g:6892:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,37,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); + + } + // InternalScope.g:6896:5: ( (lv_elements_5_0= ruleXExpression ) ) + // InternalScope.g:6897:6: (lv_elements_5_0= ruleXExpression ) + { + // InternalScope.g:6897:6: (lv_elements_5_0= ruleXExpression ) + // InternalScope.g:6898:7: lv_elements_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_63); + lv_elements_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSetLiteralRule()); + } + add( + current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop107; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSetLiteral" + + + // $ANTLR start "entryRuleXListLiteral" + // InternalScope.g:6925:1: entryRuleXListLiteral returns [EObject current=null] : iv_ruleXListLiteral= ruleXListLiteral EOF ; + public final EObject entryRuleXListLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXListLiteral = null; + + + try { + // InternalScope.g:6925:53: (iv_ruleXListLiteral= ruleXListLiteral EOF ) + // InternalScope.g:6926:2: iv_ruleXListLiteral= ruleXListLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXListLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXListLiteral=ruleXListLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXListLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXListLiteral" + + + // $ANTLR start "ruleXListLiteral" + // InternalScope.g:6932:1: ruleXListLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ; + public final EObject ruleXListLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_elements_3_0 = null; + + EObject lv_elements_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:6938:2: ( ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ) + // InternalScope.g:6939:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) + { + // InternalScope.g:6939:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) + // InternalScope.g:6940:3: () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' + { + // InternalScope.g:6940:3: () + // InternalScope.g:6941:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,29,FOLLOW_64); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); + + } + otherlv_2=(Token)match(input,33,FOLLOW_88); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); + + } + // InternalScope.g:6955:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? + int alt110=2; + int LA110_0 = input.LA(1); + + if ( ((LA110_0>=RULE_STRING && LA110_0<=RULE_INT)||(LA110_0>=RULE_ID && LA110_0<=RULE_DECIMAL)||LA110_0==16||LA110_0==18||LA110_0==22||LA110_0==27||LA110_0==29||LA110_0==33||LA110_0==52||LA110_0==55||(LA110_0>=65 && LA110_0<=67)||LA110_0==69||(LA110_0>=79 && LA110_0<=81)||LA110_0==83||(LA110_0>=105 && LA110_0<=107)||(LA110_0>=110 && LA110_0<=116)||LA110_0==118) ) { + alt110=1; + } + switch (alt110) { + case 1 : + // InternalScope.g:6956:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + { + // InternalScope.g:6956:4: ( (lv_elements_3_0= ruleXExpression ) ) + // InternalScope.g:6957:5: (lv_elements_3_0= ruleXExpression ) + { + // InternalScope.g:6957:5: (lv_elements_3_0= ruleXExpression ) + // InternalScope.g:6958:6: lv_elements_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_89); + lv_elements_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + current, + "elements", + lv_elements_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:6975:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* + loop109: + do { + int alt109=2; + int LA109_0 = input.LA(1); + + if ( (LA109_0==37) ) { + alt109=1; + } + + + switch (alt109) { + case 1 : + // InternalScope.g:6976:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,37,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); + + } + // InternalScope.g:6980:5: ( (lv_elements_5_0= ruleXExpression ) ) + // InternalScope.g:6981:6: (lv_elements_5_0= ruleXExpression ) + { + // InternalScope.g:6981:6: (lv_elements_5_0= ruleXExpression ) + // InternalScope.g:6982:7: lv_elements_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_89); + lv_elements_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXListLiteralRule()); + } + add( + current, + "elements", + lv_elements_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop109; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXListLiteral" + + + // $ANTLR start "entryRuleXClosure" + // InternalScope.g:7009:1: entryRuleXClosure returns [EObject current=null] : iv_ruleXClosure= ruleXClosure EOF ; + public final EObject entryRuleXClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXClosure = null; + + + try { + // InternalScope.g:7009:49: (iv_ruleXClosure= ruleXClosure EOF ) + // InternalScope.g:7010:2: iv_ruleXClosure= ruleXClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXClosure=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXClosure" + + + // $ANTLR start "ruleXClosure" + // InternalScope.g:7016:1: ruleXClosure returns [EObject current=null] : ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ; + public final EObject ruleXClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token lv_explicitSyntax_5_0=null; + Token otherlv_7=null; + EObject lv_declaredFormalParameters_2_0 = null; + + EObject lv_declaredFormalParameters_4_0 = null; + + EObject lv_expression_6_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7022:2: ( ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ) + // InternalScope.g:7023:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) + { + // InternalScope.g:7023:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) + // InternalScope.g:7024:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' + { + // InternalScope.g:7024:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) + // InternalScope.g:7025:4: ( ( () '[' ) )=> ( () otherlv_1= '[' ) + { + // InternalScope.g:7031:4: ( () otherlv_1= '[' ) + // InternalScope.g:7032:5: () otherlv_1= '[' + { + // InternalScope.g:7032:5: () + // InternalScope.g:7033:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,33,FOLLOW_90); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); + + } + + } + + + } + + // InternalScope.g:7045:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? + int alt113=2; + alt113 = dfa113.predict(input); + switch (alt113) { + case 1 : + // InternalScope.g:7046:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) + { + // InternalScope.g:7069:4: ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) + // InternalScope.g:7070:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) + { + // InternalScope.g:7070:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? + int alt112=2; + int LA112_0 = input.LA(1); + + if ( (LA112_0==RULE_ID||LA112_0==27||LA112_0==97) ) { + alt112=1; + } + switch (alt112) { + case 1 : + // InternalScope.g:7071:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* + { + // InternalScope.g:7071:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7072:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7072:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) + // InternalScope.g:7073:8: lv_declaredFormalParameters_2_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); + + } + pushFollow(FOLLOW_91); + lv_declaredFormalParameters_2_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_2_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:7090:6: (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* + loop111: + do { + int alt111=2; + int LA111_0 = input.LA(1); + + if ( (LA111_0==37) ) { + alt111=1; + } + + + switch (alt111) { + case 1 : + // InternalScope.g:7091:7: otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) + { + otherlv_3=(Token)match(input,37,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); + + } + // InternalScope.g:7095:7: ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7096:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7096:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) + // InternalScope.g:7097:9: lv_declaredFormalParameters_4_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); + + } + pushFollow(FOLLOW_91); + lv_declaredFormalParameters_4_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_4_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop111; + } + } while (true); + + + } + break; + + } + + // InternalScope.g:7116:5: ( (lv_explicitSyntax_5_0= '|' ) ) + // InternalScope.g:7117:6: (lv_explicitSyntax_5_0= '|' ) + { + // InternalScope.g:7117:6: (lv_explicitSyntax_5_0= '|' ) + // InternalScope.g:7118:7: lv_explicitSyntax_5_0= '|' + { + lv_explicitSyntax_5_0=(Token)match(input,44,FOLLOW_92); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXClosureRule()); + } + setWithLastConsumed(current, "explicitSyntax", lv_explicitSyntax_5_0 != null, "|"); + + } + + } + + + } + + + } + + + } + break; + + } + + // InternalScope.g:7132:3: ( (lv_expression_6_0= ruleXExpressionInClosure ) ) + // InternalScope.g:7133:4: (lv_expression_6_0= ruleXExpressionInClosure ) + { + // InternalScope.g:7133:4: (lv_expression_6_0= ruleXExpressionInClosure ) + // InternalScope.g:7134:5: lv_expression_6_0= ruleXExpressionInClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_28); + lv_expression_6_0=ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXClosureRule()); + } + set( + current, + "expression", + lv_expression_6_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionInClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_7=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXClosure" + + + // $ANTLR start "entryRuleXExpressionInClosure" + // InternalScope.g:7159:1: entryRuleXExpressionInClosure returns [EObject current=null] : iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ; + public final EObject entryRuleXExpressionInClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXExpressionInClosure = null; + + + try { + // InternalScope.g:7159:61: (iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ) + // InternalScope.g:7160:2: iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionInClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpressionInClosure=ruleXExpressionInClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpressionInClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpressionInClosure" + + + // $ANTLR start "ruleXExpressionInClosure" + // InternalScope.g:7166:1: ruleXExpressionInClosure returns [EObject current=null] : ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ; + public final EObject ruleXExpressionInClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + EObject lv_expressions_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7172:2: ( ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ) + // InternalScope.g:7173:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) + { + // InternalScope.g:7173:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) + // InternalScope.g:7174:3: () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* + { + // InternalScope.g:7174:3: () + // InternalScope.g:7175:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(), + current); + + } + + } + + // InternalScope.g:7181:3: ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* + loop115: + do { + int alt115=2; + int LA115_0 = input.LA(1); + + if ( ((LA115_0>=RULE_STRING && LA115_0<=RULE_INT)||(LA115_0>=RULE_ID && LA115_0<=RULE_DECIMAL)||LA115_0==16||LA115_0==18||LA115_0==22||LA115_0==27||LA115_0==29||LA115_0==33||LA115_0==52||LA115_0==55||(LA115_0>=65 && LA115_0<=67)||LA115_0==69||(LA115_0>=79 && LA115_0<=81)||LA115_0==83||(LA115_0>=105 && LA115_0<=116)||LA115_0==118) ) { + alt115=1; + } + + + switch (alt115) { + case 1 : + // InternalScope.g:7182:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? + { + // InternalScope.g:7182:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:7183:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:7183:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) + // InternalScope.g:7184:6: lv_expressions_1_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); + + } + pushFollow(FOLLOW_93); + lv_expressions_1_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule()); + } + add( + current, + "expressions", + lv_expressions_1_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:7201:4: (otherlv_2= ';' )? + int alt114=2; + int LA114_0 = input.LA(1); + + if ( (LA114_0==25) ) { + alt114=1; + } + switch (alt114) { + case 1 : + // InternalScope.g:7202:5: otherlv_2= ';' + { + otherlv_2=(Token)match(input,25,FOLLOW_94); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + + } + + } + break; + + } + + + } + break; + + default : + break loop115; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpressionInClosure" + + + // $ANTLR start "entryRuleXShortClosure" + // InternalScope.g:7212:1: entryRuleXShortClosure returns [EObject current=null] : iv_ruleXShortClosure= ruleXShortClosure EOF ; + public final EObject entryRuleXShortClosure() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXShortClosure = null; + + + try { + // InternalScope.g:7212:54: (iv_ruleXShortClosure= ruleXShortClosure EOF ) + // InternalScope.g:7213:2: iv_ruleXShortClosure= ruleXShortClosure EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXShortClosureRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXShortClosure=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXShortClosure; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXShortClosure" + + + // $ANTLR start "ruleXShortClosure" + // InternalScope.g:7219:1: ruleXShortClosure returns [EObject current=null] : ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXShortClosure() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token lv_explicitSyntax_4_0=null; + EObject lv_declaredFormalParameters_1_0 = null; + + EObject lv_declaredFormalParameters_3_0 = null; + + EObject lv_expression_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7225:2: ( ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ) + // InternalScope.g:7226:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) + { + // InternalScope.g:7226:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) + // InternalScope.g:7227:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) + { + // InternalScope.g:7227:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) + // InternalScope.g:7228:4: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) + { + // InternalScope.g:7253:4: ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) + // InternalScope.g:7254:5: () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) + { + // InternalScope.g:7254:5: () + // InternalScope.g:7255:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(), + current); + + } + + } + + // InternalScope.g:7261:5: ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? + int alt117=2; + int LA117_0 = input.LA(1); + + if ( (LA117_0==RULE_ID||LA117_0==27||LA117_0==97) ) { + alt117=1; + } + switch (alt117) { + case 1 : + // InternalScope.g:7262:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* + { + // InternalScope.g:7262:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7263:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7263:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) + // InternalScope.g:7264:8: lv_declaredFormalParameters_1_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); + + } + pushFollow(FOLLOW_91); + lv_declaredFormalParameters_1_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_1_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:7281:6: (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* + loop116: + do { + int alt116=2; + int LA116_0 = input.LA(1); + + if ( (LA116_0==37) ) { + alt116=1; + } + + + switch (alt116) { + case 1 : + // InternalScope.g:7282:7: otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) + { + otherlv_2=(Token)match(input,37,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); + + } + // InternalScope.g:7286:7: ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7287:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7287:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) + // InternalScope.g:7288:9: lv_declaredFormalParameters_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); + + } + pushFollow(FOLLOW_91); + lv_declaredFormalParameters_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + add( + current, + "declaredFormalParameters", + lv_declaredFormalParameters_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop116; + } + } while (true); + + + } + break; + + } + + // InternalScope.g:7307:5: ( (lv_explicitSyntax_4_0= '|' ) ) + // InternalScope.g:7308:6: (lv_explicitSyntax_4_0= '|' ) + { + // InternalScope.g:7308:6: (lv_explicitSyntax_4_0= '|' ) + // InternalScope.g:7309:7: lv_explicitSyntax_4_0= '|' + { + lv_explicitSyntax_4_0=(Token)match(input,44,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXShortClosureRule()); + } + setWithLastConsumed(current, "explicitSyntax", lv_explicitSyntax_4_0 != null, "|"); + + } + + } + + + } + + + } + + + } + + // InternalScope.g:7323:3: ( (lv_expression_5_0= ruleXExpression ) ) + // InternalScope.g:7324:4: (lv_expression_5_0= ruleXExpression ) + { + // InternalScope.g:7324:4: (lv_expression_5_0= ruleXExpression ) + // InternalScope.g:7325:5: lv_expression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXShortClosureRule()); + } + set( + current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXShortClosure" + + + // $ANTLR start "entryRuleXParenthesizedExpression" + // InternalScope.g:7346:1: entryRuleXParenthesizedExpression returns [EObject current=null] : iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ; + public final EObject entryRuleXParenthesizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXParenthesizedExpression = null; + + + try { + // InternalScope.g:7346:65: (iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ) + // InternalScope.g:7347:2: iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXParenthesizedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXParenthesizedExpression" + + + // $ANTLR start "ruleXParenthesizedExpression" + // InternalScope.g:7353:1: ruleXParenthesizedExpression returns [EObject current=null] : (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ; + public final EObject ruleXParenthesizedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + EObject this_XExpression_1 = null; + + + + enterRule(); + + try { + // InternalScope.g:7359:2: ( (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ) + // InternalScope.g:7360:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) + { + // InternalScope.g:7360:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) + // InternalScope.g:7361:3: otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' + { + otherlv_0=(Token)match(input,27,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_20); + this_XExpression_1=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XExpression_1; + afterParserOrEnumRuleCall(); + + } + otherlv_2=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXParenthesizedExpression" + + + // $ANTLR start "entryRuleXIfExpression" + // InternalScope.g:7381:1: entryRuleXIfExpression returns [EObject current=null] : iv_ruleXIfExpression= ruleXIfExpression EOF ; + public final EObject entryRuleXIfExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXIfExpression = null; + + + try { + // InternalScope.g:7381:54: (iv_ruleXIfExpression= ruleXIfExpression EOF ) + // InternalScope.g:7382:2: iv_ruleXIfExpression= ruleXIfExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXIfExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXIfExpression=ruleXIfExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXIfExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXIfExpression" + + + // $ANTLR start "ruleXIfExpression" + // InternalScope.g:7388:1: ruleXIfExpression returns [EObject current=null] : ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ; + public final EObject ruleXIfExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_if_3_0 = null; + + EObject lv_then_5_0 = null; + + EObject lv_else_7_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7394:2: ( ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ) + // InternalScope.g:7395:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) + { + // InternalScope.g:7395:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) + // InternalScope.g:7396:3: () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? + { + // InternalScope.g:7396:3: () + // InternalScope.g:7397:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,52,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); + + } + otherlv_2=(Token)match(input,27,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalScope.g:7411:3: ( (lv_if_3_0= ruleXExpression ) ) + // InternalScope.g:7412:4: (lv_if_3_0= ruleXExpression ) + { + // InternalScope.g:7412:4: (lv_if_3_0= ruleXExpression ) + // InternalScope.g:7413:5: lv_if_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_20); + lv_if_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "if", + lv_if_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,28,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); + + } + // InternalScope.g:7434:3: ( (lv_then_5_0= ruleXExpression ) ) + // InternalScope.g:7435:4: (lv_then_5_0= ruleXExpression ) + { + // InternalScope.g:7435:4: (lv_then_5_0= ruleXExpression ) + // InternalScope.g:7436:5: lv_then_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_48); + lv_then_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:7453:3: ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? + int alt118=2; + int LA118_0 = input.LA(1); + + if ( (LA118_0==54) ) { + int LA118_1 = input.LA(2); + + if ( (synpred28_InternalScope()) ) { + alt118=1; + } + } + switch (alt118) { + case 1 : + // InternalScope.g:7454:4: ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) + { + // InternalScope.g:7454:4: ( ( 'else' )=>otherlv_6= 'else' ) + // InternalScope.g:7455:5: ( 'else' )=>otherlv_6= 'else' + { + otherlv_6=(Token)match(input,54,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); + + } + + } + + // InternalScope.g:7461:4: ( (lv_else_7_0= ruleXExpression ) ) + // InternalScope.g:7462:5: (lv_else_7_0= ruleXExpression ) + { + // InternalScope.g:7462:5: (lv_else_7_0= ruleXExpression ) + // InternalScope.g:7463:6: lv_else_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); + + } + pushFollow(FOLLOW_2); + lv_else_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXIfExpressionRule()); + } + set( + current, + "else", + lv_else_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXIfExpression" + + + // $ANTLR start "entryRuleXSwitchExpression" + // InternalScope.g:7485:1: entryRuleXSwitchExpression returns [EObject current=null] : iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ; + public final EObject entryRuleXSwitchExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSwitchExpression = null; + + + try { + // InternalScope.g:7485:58: (iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ) + // InternalScope.g:7486:2: iv_ruleXSwitchExpression= ruleXSwitchExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSwitchExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSwitchExpression=ruleXSwitchExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSwitchExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSwitchExpression" + + + // $ANTLR start "ruleXSwitchExpression" + // InternalScope.g:7492:1: ruleXSwitchExpression returns [EObject current=null] : ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ; + public final EObject ruleXSwitchExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + Token otherlv_12=null; + Token otherlv_13=null; + Token otherlv_15=null; + EObject lv_declaredParam_3_0 = null; + + EObject lv_switch_5_0 = null; + + EObject lv_declaredParam_7_0 = null; + + EObject lv_switch_9_0 = null; + + EObject lv_cases_11_0 = null; + + EObject lv_default_14_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7498:2: ( ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ) + // InternalScope.g:7499:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) + { + // InternalScope.g:7499:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) + // InternalScope.g:7500:3: () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' + { + // InternalScope.g:7500:3: () + // InternalScope.g:7501:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,55,FOLLOW_95); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); + + } + // InternalScope.g:7511:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) + int alt120=2; + alt120 = dfa120.predict(input); + switch (alt120) { + case 1 : + // InternalScope.g:7512:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) + { + // InternalScope.g:7512:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) + // InternalScope.g:7513:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' + { + // InternalScope.g:7513:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) + // InternalScope.g:7514:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + { + // InternalScope.g:7524:6: (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + // InternalScope.g:7525:7: otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' + { + otherlv_2=(Token)match(input,27,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); + + } + // InternalScope.g:7529:7: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7530:8: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7530:8: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + // InternalScope.g:7531:9: lv_declaredParam_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); + + } + pushFollow(FOLLOW_43); + lv_declaredParam_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,49,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); + + } + + } + + + } + + // InternalScope.g:7554:5: ( (lv_switch_5_0= ruleXExpression ) ) + // InternalScope.g:7555:6: (lv_switch_5_0= ruleXExpression ) + { + // InternalScope.g:7555:6: (lv_switch_5_0= ruleXExpression ) + // InternalScope.g:7556:7: lv_switch_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_20); + lv_switch_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "switch", + lv_switch_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,28,FOLLOW_14); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); + + } + + } + + + } + break; + case 2 : + // InternalScope.g:7579:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) + { + // InternalScope.g:7579:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) + // InternalScope.g:7580:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) + { + // InternalScope.g:7580:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? + int alt119=2; + alt119 = dfa119.predict(input); + switch (alt119) { + case 1 : + // InternalScope.g:7581:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) + { + // InternalScope.g:7590:6: ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) + // InternalScope.g:7591:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' + { + // InternalScope.g:7591:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7592:8: (lv_declaredParam_7_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7592:8: (lv_declaredParam_7_0= ruleJvmFormalParameter ) + // InternalScope.g:7593:9: lv_declaredParam_7_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); + + } + pushFollow(FOLLOW_43); + lv_declaredParam_7_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_7_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_8=(Token)match(input,49,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); + + } + + } + + + } + break; + + } + + // InternalScope.g:7616:5: ( (lv_switch_9_0= ruleXExpression ) ) + // InternalScope.g:7617:6: (lv_switch_9_0= ruleXExpression ) + { + // InternalScope.g:7617:6: (lv_switch_9_0= ruleXExpression ) + // InternalScope.g:7618:7: lv_switch_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_14); + lv_switch_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "switch", + lv_switch_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + otherlv_10=(Token)match(input,22,FOLLOW_96); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); + + } + // InternalScope.g:7641:3: ( (lv_cases_11_0= ruleXCasePart ) )* + loop121: + do { + int alt121=2; + int LA121_0 = input.LA(1); + + if ( (LA121_0==RULE_ID||LA121_0==20||LA121_0==27||LA121_0==37||LA121_0==49||LA121_0==97) ) { + alt121=1; + } + + + switch (alt121) { + case 1 : + // InternalScope.g:7642:4: (lv_cases_11_0= ruleXCasePart ) + { + // InternalScope.g:7642:4: (lv_cases_11_0= ruleXCasePart ) + // InternalScope.g:7643:5: lv_cases_11_0= ruleXCasePart + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_96); + lv_cases_11_0=ruleXCasePart(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + add( + current, + "cases", + lv_cases_11_0, + "org.eclipse.xtext.xbase.Xbase.XCasePart"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop121; + } + } while (true); + + // InternalScope.g:7660:3: (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? + int alt122=2; + int LA122_0 = input.LA(1); + + if ( (LA122_0==56) ) { + alt122=1; + } + switch (alt122) { + case 1 : + // InternalScope.g:7661:4: otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) + { + otherlv_12=(Token)match(input,56,FOLLOW_43); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); + + } + otherlv_13=(Token)match(input,49,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); + + } + // InternalScope.g:7669:4: ( (lv_default_14_0= ruleXExpression ) ) + // InternalScope.g:7670:5: (lv_default_14_0= ruleXExpression ) + { + // InternalScope.g:7670:5: (lv_default_14_0= ruleXExpression ) + // InternalScope.g:7671:6: lv_default_14_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); + + } + pushFollow(FOLLOW_52); + lv_default_14_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule()); + } + set( + current, + "default", + lv_default_14_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + otherlv_15=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSwitchExpression" + + + // $ANTLR start "entryRuleXCasePart" + // InternalScope.g:7697:1: entryRuleXCasePart returns [EObject current=null] : iv_ruleXCasePart= ruleXCasePart EOF ; + public final EObject entryRuleXCasePart() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCasePart = null; + + + try { + // InternalScope.g:7697:50: (iv_ruleXCasePart= ruleXCasePart EOF ) + // InternalScope.g:7698:2: iv_ruleXCasePart= ruleXCasePart EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCasePartRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCasePart=ruleXCasePart(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCasePart; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCasePart" + + + // $ANTLR start "ruleXCasePart" + // InternalScope.g:7704:1: ruleXCasePart returns [EObject current=null] : ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ; + public final EObject ruleXCasePart() throws RecognitionException { + EObject current = null; + + Token otherlv_2=null; + Token otherlv_4=null; + Token lv_fallThrough_6_0=null; + EObject lv_typeGuard_1_0 = null; + + EObject lv_case_3_0 = null; + + EObject lv_then_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7710:2: ( ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ) + // InternalScope.g:7711:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) + { + // InternalScope.g:7711:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) + // InternalScope.g:7712:3: () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) + { + // InternalScope.g:7712:3: () + // InternalScope.g:7713:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXCasePartAccess().getXCasePartAction_0(), + current); + + } + + } + + // InternalScope.g:7719:3: ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? + int alt123=2; + int LA123_0 = input.LA(1); + + if ( (LA123_0==RULE_ID||LA123_0==27||LA123_0==97) ) { + alt123=1; + } + switch (alt123) { + case 1 : + // InternalScope.g:7720:4: (lv_typeGuard_1_0= ruleJvmTypeReference ) + { + // InternalScope.g:7720:4: (lv_typeGuard_1_0= ruleJvmTypeReference ) + // InternalScope.g:7721:5: lv_typeGuard_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_97); + lv_typeGuard_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "typeGuard", + lv_typeGuard_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + // InternalScope.g:7738:3: (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? + int alt124=2; + int LA124_0 = input.LA(1); + + if ( (LA124_0==20) ) { + alt124=1; + } + switch (alt124) { + case 1 : + // InternalScope.g:7739:4: otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) + { + otherlv_2=(Token)match(input,20,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); + + } + // InternalScope.g:7743:4: ( (lv_case_3_0= ruleXExpression ) ) + // InternalScope.g:7744:5: (lv_case_3_0= ruleXExpression ) + { + // InternalScope.g:7744:5: (lv_case_3_0= ruleXExpression ) + // InternalScope.g:7745:6: lv_case_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_98); + lv_case_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "case", + lv_case_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalScope.g:7763:3: ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) + int alt125=2; + int LA125_0 = input.LA(1); + + if ( (LA125_0==49) ) { + alt125=1; + } + else if ( (LA125_0==37) ) { + alt125=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 125, 0, input); + + throw nvae; + } + switch (alt125) { + case 1 : + // InternalScope.g:7764:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) + { + // InternalScope.g:7764:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) + // InternalScope.g:7765:5: otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) + { + otherlv_4=(Token)match(input,49,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); + + } + // InternalScope.g:7769:5: ( (lv_then_5_0= ruleXExpression ) ) + // InternalScope.g:7770:6: (lv_then_5_0= ruleXExpression ) + { + // InternalScope.g:7770:6: (lv_then_5_0= ruleXExpression ) + // InternalScope.g:7771:7: lv_then_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); + + } + pushFollow(FOLLOW_2); + lv_then_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCasePartRule()); + } + set( + current, + "then", + lv_then_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:7790:4: ( (lv_fallThrough_6_0= ',' ) ) + { + // InternalScope.g:7790:4: ( (lv_fallThrough_6_0= ',' ) ) + // InternalScope.g:7791:5: (lv_fallThrough_6_0= ',' ) + { + // InternalScope.g:7791:5: (lv_fallThrough_6_0= ',' ) + // InternalScope.g:7792:6: lv_fallThrough_6_0= ',' + { + lv_fallThrough_6_0=(Token)match(input,37,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXCasePartRule()); + } + setWithLastConsumed(current, "fallThrough", lv_fallThrough_6_0 != null, ","); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCasePart" + + + // $ANTLR start "entryRuleXForLoopExpression" + // InternalScope.g:7809:1: entryRuleXForLoopExpression returns [EObject current=null] : iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ; + public final EObject entryRuleXForLoopExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXForLoopExpression = null; + + + try { + // InternalScope.g:7809:59: (iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ) + // InternalScope.g:7810:2: iv_ruleXForLoopExpression= ruleXForLoopExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXForLoopExpression=ruleXForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXForLoopExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXForLoopExpression" + + + // $ANTLR start "ruleXForLoopExpression" + // InternalScope.g:7816:1: ruleXForLoopExpression returns [EObject current=null] : ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ; + public final EObject ruleXForLoopExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_declaredParam_3_0 = null; + + EObject lv_forExpression_5_0 = null; + + EObject lv_eachExpression_7_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7822:2: ( ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ) + // InternalScope.g:7823:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) + { + // InternalScope.g:7823:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) + // InternalScope.g:7824:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) + { + // InternalScope.g:7824:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) + // InternalScope.g:7825:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + { + // InternalScope.g:7838:4: ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) + // InternalScope.g:7839:5: () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' + { + // InternalScope.g:7839:5: () + // InternalScope.g:7840:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,105,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); + + } + otherlv_2=(Token)match(input,27,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + + } + // InternalScope.g:7854:5: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) + // InternalScope.g:7855:6: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + { + // InternalScope.g:7855:6: (lv_declaredParam_3_0= ruleJvmFormalParameter ) + // InternalScope.g:7856:7: lv_declaredParam_3_0= ruleJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); + + } + pushFollow(FOLLOW_43); + lv_declaredParam_3_0=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_3_0, + "org.eclipse.xtext.xbase.Xbase.JvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,49,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); + + } + + } + + + } + + // InternalScope.g:7879:3: ( (lv_forExpression_5_0= ruleXExpression ) ) + // InternalScope.g:7880:4: (lv_forExpression_5_0= ruleXExpression ) + { + // InternalScope.g:7880:4: (lv_forExpression_5_0= ruleXExpression ) + // InternalScope.g:7881:5: lv_forExpression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_20); + lv_forExpression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "forExpression", + lv_forExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,28,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); + + } + // InternalScope.g:7902:3: ( (lv_eachExpression_7_0= ruleXExpression ) ) + // InternalScope.g:7903:4: (lv_eachExpression_7_0= ruleXExpression ) + { + // InternalScope.g:7903:4: (lv_eachExpression_7_0= ruleXExpression ) + // InternalScope.g:7904:5: lv_eachExpression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_eachExpression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule()); + } + set( + current, + "eachExpression", + lv_eachExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXForLoopExpression" + + + // $ANTLR start "entryRuleXBasicForLoopExpression" + // InternalScope.g:7925:1: entryRuleXBasicForLoopExpression returns [EObject current=null] : iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ; + public final EObject entryRuleXBasicForLoopExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBasicForLoopExpression = null; + + + try { + // InternalScope.g:7925:64: (iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ) + // InternalScope.g:7926:2: iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBasicForLoopExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBasicForLoopExpression" + + + // $ANTLR start "ruleXBasicForLoopExpression" + // InternalScope.g:7932:1: ruleXBasicForLoopExpression returns [EObject current=null] : ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ; + public final EObject ruleXBasicForLoopExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_6=null; + Token otherlv_8=null; + Token otherlv_10=null; + Token otherlv_12=null; + EObject lv_initExpressions_3_0 = null; + + EObject lv_initExpressions_5_0 = null; + + EObject lv_expression_7_0 = null; + + EObject lv_updateExpressions_9_0 = null; + + EObject lv_updateExpressions_11_0 = null; + + EObject lv_eachExpression_13_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:7938:2: ( ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ) + // InternalScope.g:7939:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) + { + // InternalScope.g:7939:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) + // InternalScope.g:7940:3: () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) + { + // InternalScope.g:7940:3: () + // InternalScope.g:7941:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,105,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); + + } + otherlv_2=(Token)match(input,27,FOLLOW_99); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalScope.g:7955:3: ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? + int alt127=2; + int LA127_0 = input.LA(1); + + if ( ((LA127_0>=RULE_STRING && LA127_0<=RULE_INT)||(LA127_0>=RULE_ID && LA127_0<=RULE_DECIMAL)||LA127_0==16||LA127_0==18||LA127_0==22||LA127_0==27||LA127_0==29||LA127_0==33||LA127_0==52||LA127_0==55||(LA127_0>=65 && LA127_0<=67)||LA127_0==69||(LA127_0>=79 && LA127_0<=81)||LA127_0==83||(LA127_0>=105 && LA127_0<=116)||LA127_0==118) ) { + alt127=1; + } + switch (alt127) { + case 1 : + // InternalScope.g:7956:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* + { + // InternalScope.g:7956:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:7957:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:7957:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) + // InternalScope.g:7958:6: lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); + + } + pushFollow(FOLLOW_100); + lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "initExpressions", + lv_initExpressions_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:7975:4: (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* + loop126: + do { + int alt126=2; + int LA126_0 = input.LA(1); + + if ( (LA126_0==37) ) { + alt126=1; + } + + + switch (alt126) { + case 1 : + // InternalScope.g:7976:5: otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) + { + otherlv_4=(Token)match(input,37,FOLLOW_101); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); + + } + // InternalScope.g:7980:5: ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:7981:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:7981:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) + // InternalScope.g:7982:7: lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_100); + lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "initExpressions", + lv_initExpressions_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop126; + } + } while (true); + + + } + break; + + } + + otherlv_6=(Token)match(input,25,FOLLOW_102); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); + + } + // InternalScope.g:8005:3: ( (lv_expression_7_0= ruleXExpression ) )? + int alt128=2; + int LA128_0 = input.LA(1); + + if ( ((LA128_0>=RULE_STRING && LA128_0<=RULE_INT)||(LA128_0>=RULE_ID && LA128_0<=RULE_DECIMAL)||LA128_0==16||LA128_0==18||LA128_0==22||LA128_0==27||LA128_0==29||LA128_0==33||LA128_0==52||LA128_0==55||(LA128_0>=65 && LA128_0<=67)||LA128_0==69||(LA128_0>=79 && LA128_0<=81)||LA128_0==83||(LA128_0>=105 && LA128_0<=107)||(LA128_0>=110 && LA128_0<=116)||LA128_0==118) ) { + alt128=1; + } + switch (alt128) { + case 1 : + // InternalScope.g:8006:4: (lv_expression_7_0= ruleXExpression ) + { + // InternalScope.g:8006:4: (lv_expression_7_0= ruleXExpression ) + // InternalScope.g:8007:5: lv_expression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_18); + lv_expression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + current, + "expression", + lv_expression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + otherlv_8=(Token)match(input,25,FOLLOW_103); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); + + } + // InternalScope.g:8028:3: ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? + int alt130=2; + int LA130_0 = input.LA(1); + + if ( ((LA130_0>=RULE_STRING && LA130_0<=RULE_INT)||(LA130_0>=RULE_ID && LA130_0<=RULE_DECIMAL)||LA130_0==16||LA130_0==18||LA130_0==22||LA130_0==27||LA130_0==29||LA130_0==33||LA130_0==52||LA130_0==55||(LA130_0>=65 && LA130_0<=67)||LA130_0==69||(LA130_0>=79 && LA130_0<=81)||LA130_0==83||(LA130_0>=105 && LA130_0<=107)||(LA130_0>=110 && LA130_0<=116)||LA130_0==118) ) { + alt130=1; + } + switch (alt130) { + case 1 : + // InternalScope.g:8029:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* + { + // InternalScope.g:8029:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) + // InternalScope.g:8030:5: (lv_updateExpressions_9_0= ruleXExpression ) + { + // InternalScope.g:8030:5: (lv_updateExpressions_9_0= ruleXExpression ) + // InternalScope.g:8031:6: lv_updateExpressions_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); + + } + pushFollow(FOLLOW_31); + lv_updateExpressions_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "updateExpressions", + lv_updateExpressions_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8048:4: (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* + loop129: + do { + int alt129=2; + int LA129_0 = input.LA(1); + + if ( (LA129_0==37) ) { + alt129=1; + } + + + switch (alt129) { + case 1 : + // InternalScope.g:8049:5: otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) + { + otherlv_10=(Token)match(input,37,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); + + } + // InternalScope.g:8053:5: ( (lv_updateExpressions_11_0= ruleXExpression ) ) + // InternalScope.g:8054:6: (lv_updateExpressions_11_0= ruleXExpression ) + { + // InternalScope.g:8054:6: (lv_updateExpressions_11_0= ruleXExpression ) + // InternalScope.g:8055:7: lv_updateExpressions_11_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); + + } + pushFollow(FOLLOW_31); + lv_updateExpressions_11_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + add( + current, + "updateExpressions", + lv_updateExpressions_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop129; + } + } while (true); + + + } + break; + + } + + otherlv_12=(Token)match(input,28,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); + + } + // InternalScope.g:8078:3: ( (lv_eachExpression_13_0= ruleXExpression ) ) + // InternalScope.g:8079:4: (lv_eachExpression_13_0= ruleXExpression ) + { + // InternalScope.g:8079:4: (lv_eachExpression_13_0= ruleXExpression ) + // InternalScope.g:8080:5: lv_eachExpression_13_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); + + } + pushFollow(FOLLOW_2); + lv_eachExpression_13_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule()); + } + set( + current, + "eachExpression", + lv_eachExpression_13_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBasicForLoopExpression" + + + // $ANTLR start "entryRuleXWhileExpression" + // InternalScope.g:8101:1: entryRuleXWhileExpression returns [EObject current=null] : iv_ruleXWhileExpression= ruleXWhileExpression EOF ; + public final EObject entryRuleXWhileExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXWhileExpression = null; + + + try { + // InternalScope.g:8101:57: (iv_ruleXWhileExpression= ruleXWhileExpression EOF ) + // InternalScope.g:8102:2: iv_ruleXWhileExpression= ruleXWhileExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXWhileExpression=ruleXWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXWhileExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXWhileExpression" + + + // $ANTLR start "ruleXWhileExpression" + // InternalScope.g:8108:1: ruleXWhileExpression returns [EObject current=null] : ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXWhileExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_predicate_3_0 = null; + + EObject lv_body_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8114:2: ( ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ) + // InternalScope.g:8115:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) + { + // InternalScope.g:8115:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) + // InternalScope.g:8116:3: () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) + { + // InternalScope.g:8116:3: () + // InternalScope.g:8117:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,106,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); + + } + otherlv_2=(Token)match(input,27,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); + + } + // InternalScope.g:8131:3: ( (lv_predicate_3_0= ruleXExpression ) ) + // InternalScope.g:8132:4: (lv_predicate_3_0= ruleXExpression ) + { + // InternalScope.g:8132:4: (lv_predicate_3_0= ruleXExpression ) + // InternalScope.g:8133:5: lv_predicate_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_20); + lv_predicate_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + current, + "predicate", + lv_predicate_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,28,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); + + } + // InternalScope.g:8154:3: ( (lv_body_5_0= ruleXExpression ) ) + // InternalScope.g:8155:4: (lv_body_5_0= ruleXExpression ) + { + // InternalScope.g:8155:4: (lv_body_5_0= ruleXExpression ) + // InternalScope.g:8156:5: lv_body_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_2); + lv_body_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXWhileExpressionRule()); + } + set( + current, + "body", + lv_body_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXWhileExpression" + + + // $ANTLR start "entryRuleXDoWhileExpression" + // InternalScope.g:8177:1: entryRuleXDoWhileExpression returns [EObject current=null] : iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ; + public final EObject entryRuleXDoWhileExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXDoWhileExpression = null; + + + try { + // InternalScope.g:8177:59: (iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ) + // InternalScope.g:8178:2: iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXDoWhileExpression=ruleXDoWhileExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXDoWhileExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXDoWhileExpression" + + + // $ANTLR start "ruleXDoWhileExpression" + // InternalScope.g:8184:1: ruleXDoWhileExpression returns [EObject current=null] : ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ; + public final EObject ruleXDoWhileExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_body_2_0 = null; + + EObject lv_predicate_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8190:2: ( ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ) + // InternalScope.g:8191:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) + { + // InternalScope.g:8191:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) + // InternalScope.g:8192:3: () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' + { + // InternalScope.g:8192:3: () + // InternalScope.g:8193:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,107,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); + + } + // InternalScope.g:8203:3: ( (lv_body_2_0= ruleXExpression ) ) + // InternalScope.g:8204:4: (lv_body_2_0= ruleXExpression ) + { + // InternalScope.g:8204:4: (lv_body_2_0= ruleXExpression ) + // InternalScope.g:8205:5: lv_body_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_104); + lv_body_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + current, + "body", + lv_body_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_3=(Token)match(input,106,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); + + } + otherlv_4=(Token)match(input,27,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); + + } + // InternalScope.g:8230:3: ( (lv_predicate_5_0= ruleXExpression ) ) + // InternalScope.g:8231:4: (lv_predicate_5_0= ruleXExpression ) + { + // InternalScope.g:8231:4: (lv_predicate_5_0= ruleXExpression ) + // InternalScope.g:8232:5: lv_predicate_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_20); + lv_predicate_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule()); + } + set( + current, + "predicate", + lv_predicate_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_6=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXDoWhileExpression" + + + // $ANTLR start "entryRuleXBlockExpression" + // InternalScope.g:8257:1: entryRuleXBlockExpression returns [EObject current=null] : iv_ruleXBlockExpression= ruleXBlockExpression EOF ; + public final EObject entryRuleXBlockExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBlockExpression = null; + + + try { + // InternalScope.g:8257:57: (iv_ruleXBlockExpression= ruleXBlockExpression EOF ) + // InternalScope.g:8258:2: iv_ruleXBlockExpression= ruleXBlockExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBlockExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBlockExpression=ruleXBlockExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBlockExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBlockExpression" + + + // $ANTLR start "ruleXBlockExpression" + // InternalScope.g:8264:1: ruleXBlockExpression returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ; + public final EObject ruleXBlockExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_4=null; + EObject lv_expressions_2_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8270:2: ( ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ) + // InternalScope.g:8271:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) + { + // InternalScope.g:8271:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) + // InternalScope.g:8272:3: () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' + { + // InternalScope.g:8272:3: () + // InternalScope.g:8273:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,22,FOLLOW_105); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); + + } + // InternalScope.g:8283:3: ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* + loop132: + do { + int alt132=2; + int LA132_0 = input.LA(1); + + if ( ((LA132_0>=RULE_STRING && LA132_0<=RULE_INT)||(LA132_0>=RULE_ID && LA132_0<=RULE_DECIMAL)||LA132_0==16||LA132_0==18||LA132_0==22||LA132_0==27||LA132_0==29||LA132_0==33||LA132_0==52||LA132_0==55||(LA132_0>=65 && LA132_0<=67)||LA132_0==69||(LA132_0>=79 && LA132_0<=81)||LA132_0==83||(LA132_0>=105 && LA132_0<=116)||LA132_0==118) ) { + alt132=1; + } + + + switch (alt132) { + case 1 : + // InternalScope.g:8284:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? + { + // InternalScope.g:8284:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) + // InternalScope.g:8285:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) + { + // InternalScope.g:8285:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) + // InternalScope.g:8286:6: lv_expressions_2_0= ruleXExpressionOrVarDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); + + } + pushFollow(FOLLOW_106); + lv_expressions_2_0=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXBlockExpressionRule()); + } + add( + current, + "expressions", + lv_expressions_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8303:4: (otherlv_3= ';' )? + int alt131=2; + int LA131_0 = input.LA(1); + + if ( (LA131_0==25) ) { + alt131=1; + } + switch (alt131) { + case 1 : + // InternalScope.g:8304:5: otherlv_3= ';' + { + otherlv_3=(Token)match(input,25,FOLLOW_105); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + + } + + } + break; + + } + + + } + break; + + default : + break loop132; + } + } while (true); + + otherlv_4=(Token)match(input,23,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBlockExpression" + + + // $ANTLR start "entryRuleXExpressionOrVarDeclaration" + // InternalScope.g:8318:1: entryRuleXExpressionOrVarDeclaration returns [EObject current=null] : iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ; + public final EObject entryRuleXExpressionOrVarDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXExpressionOrVarDeclaration = null; + + + try { + // InternalScope.g:8318:68: (iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ) + // InternalScope.g:8319:2: iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXExpressionOrVarDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXExpressionOrVarDeclaration" + + + // $ANTLR start "ruleXExpressionOrVarDeclaration" + // InternalScope.g:8325:1: ruleXExpressionOrVarDeclaration returns [EObject current=null] : (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ; + public final EObject ruleXExpressionOrVarDeclaration() throws RecognitionException { + EObject current = null; + + EObject this_XVariableDeclaration_0 = null; + + EObject this_XExpression_1 = null; + + + + enterRule(); + + try { + // InternalScope.g:8331:2: ( (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ) + // InternalScope.g:8332:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) + { + // InternalScope.g:8332:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) + int alt133=2; + int LA133_0 = input.LA(1); + + if ( ((LA133_0>=108 && LA133_0<=109)) ) { + alt133=1; + } + else if ( ((LA133_0>=RULE_STRING && LA133_0<=RULE_INT)||(LA133_0>=RULE_ID && LA133_0<=RULE_DECIMAL)||LA133_0==16||LA133_0==18||LA133_0==22||LA133_0==27||LA133_0==29||LA133_0==33||LA133_0==52||LA133_0==55||(LA133_0>=65 && LA133_0<=67)||LA133_0==69||(LA133_0>=79 && LA133_0<=81)||LA133_0==83||(LA133_0>=105 && LA133_0<=107)||(LA133_0>=110 && LA133_0<=116)||LA133_0==118) ) { + alt133=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 133, 0, input); + + throw nvae; + } + switch (alt133) { + case 1 : + // InternalScope.g:8333:3: this_XVariableDeclaration_0= ruleXVariableDeclaration + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_XVariableDeclaration_0=ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XVariableDeclaration_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:8342:3: this_XExpression_1= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XExpression_1=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XExpression_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXExpressionOrVarDeclaration" + + + // $ANTLR start "entryRuleXVariableDeclaration" + // InternalScope.g:8354:1: entryRuleXVariableDeclaration returns [EObject current=null] : iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ; + public final EObject entryRuleXVariableDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXVariableDeclaration = null; + + + try { + // InternalScope.g:8354:61: (iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ) + // InternalScope.g:8355:2: iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXVariableDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXVariableDeclaration=ruleXVariableDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXVariableDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXVariableDeclaration" + + + // $ANTLR start "ruleXVariableDeclaration" + // InternalScope.g:8361:1: ruleXVariableDeclaration returns [EObject current=null] : ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ; + public final EObject ruleXVariableDeclaration() throws RecognitionException { + EObject current = null; + + Token lv_writeable_1_0=null; + Token otherlv_2=null; + Token otherlv_6=null; + EObject lv_type_3_0 = null; + + AntlrDatatypeRuleToken lv_name_4_0 = null; + + AntlrDatatypeRuleToken lv_name_5_0 = null; + + EObject lv_right_7_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8367:2: ( ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ) + // InternalScope.g:8368:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) + { + // InternalScope.g:8368:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) + // InternalScope.g:8369:3: () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? + { + // InternalScope.g:8369:3: () + // InternalScope.g:8370:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(), + current); + + } + + } + + // InternalScope.g:8376:3: ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) + int alt134=2; + int LA134_0 = input.LA(1); + + if ( (LA134_0==108) ) { + alt134=1; + } + else if ( (LA134_0==109) ) { + alt134=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 134, 0, input); + + throw nvae; + } + switch (alt134) { + case 1 : + // InternalScope.g:8377:4: ( (lv_writeable_1_0= 'var' ) ) + { + // InternalScope.g:8377:4: ( (lv_writeable_1_0= 'var' ) ) + // InternalScope.g:8378:5: (lv_writeable_1_0= 'var' ) + { + // InternalScope.g:8378:5: (lv_writeable_1_0= 'var' ) + // InternalScope.g:8379:6: lv_writeable_1_0= 'var' + { + lv_writeable_1_0=(Token)match(input,108,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXVariableDeclarationRule()); + } + setWithLastConsumed(current, "writeable", lv_writeable_1_0 != null, "var"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:8392:4: otherlv_2= 'val' + { + otherlv_2=(Token)match(input,109,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); + + } + + } + break; + + } + + // InternalScope.g:8397:3: ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) + int alt135=2; + int LA135_0 = input.LA(1); + + if ( (LA135_0==RULE_ID) ) { + int LA135_1 = input.LA(2); + + if ( (synpred32_InternalScope()) ) { + alt135=1; + } + else if ( (true) ) { + alt135=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 135, 1, input); + + throw nvae; + } + } + else if ( (LA135_0==27) && (synpred32_InternalScope())) { + alt135=1; + } + else if ( (LA135_0==97) && (synpred32_InternalScope())) { + alt135=1; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 135, 0, input); + + throw nvae; + } + switch (alt135) { + case 1 : + // InternalScope.g:8398:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) + { + // InternalScope.g:8398:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) + // InternalScope.g:8399:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) + { + // InternalScope.g:8412:5: ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) + // InternalScope.g:8413:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) + { + // InternalScope.g:8413:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) + // InternalScope.g:8414:7: (lv_type_3_0= ruleJvmTypeReference ) + { + // InternalScope.g:8414:7: (lv_type_3_0= ruleJvmTypeReference ) + // InternalScope.g:8415:8: lv_type_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); + + } + pushFollow(FOLLOW_3); + lv_type_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "type", + lv_type_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8432:6: ( (lv_name_4_0= ruleValidID ) ) + // InternalScope.g:8433:7: (lv_name_4_0= ruleValidID ) + { + // InternalScope.g:8433:7: (lv_name_4_0= ruleValidID ) + // InternalScope.g:8434:8: lv_name_4_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); + + } + pushFollow(FOLLOW_107); + lv_name_4_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "name", + lv_name_4_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:8454:4: ( (lv_name_5_0= ruleValidID ) ) + { + // InternalScope.g:8454:4: ( (lv_name_5_0= ruleValidID ) ) + // InternalScope.g:8455:5: (lv_name_5_0= ruleValidID ) + { + // InternalScope.g:8455:5: (lv_name_5_0= ruleValidID ) + // InternalScope.g:8456:6: lv_name_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); + + } + pushFollow(FOLLOW_107); + lv_name_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "name", + lv_name_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalScope.g:8474:3: (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? + int alt136=2; + int LA136_0 = input.LA(1); + + if ( (LA136_0==24) ) { + alt136=1; + } + switch (alt136) { + case 1 : + // InternalScope.g:8475:4: otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) + { + otherlv_6=(Token)match(input,24,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); + + } + // InternalScope.g:8479:4: ( (lv_right_7_0= ruleXExpression ) ) + // InternalScope.g:8480:5: (lv_right_7_0= ruleXExpression ) + { + // InternalScope.g:8480:5: (lv_right_7_0= ruleXExpression ) + // InternalScope.g:8481:6: lv_right_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_2); + lv_right_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule()); + } + set( + current, + "right", + lv_right_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXVariableDeclaration" + + + // $ANTLR start "entryRuleJvmFormalParameter" + // InternalScope.g:8503:1: entryRuleJvmFormalParameter returns [EObject current=null] : iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ; + public final EObject entryRuleJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmFormalParameter = null; + + + try { + // InternalScope.g:8503:59: (iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ) + // InternalScope.g:8504:2: iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmFormalParameter=ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmFormalParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmFormalParameter" + + + // $ANTLR start "ruleJvmFormalParameter" + // InternalScope.g:8510:1: ruleJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ; + public final EObject ruleJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject lv_parameterType_0_0 = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8516:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ) + // InternalScope.g:8517:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) + { + // InternalScope.g:8517:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) + // InternalScope.g:8518:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) + { + // InternalScope.g:8518:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? + int alt137=2; + int LA137_0 = input.LA(1); + + if ( (LA137_0==RULE_ID) ) { + int LA137_1 = input.LA(2); + + if ( (LA137_1==RULE_ID||LA137_1==33||LA137_1==47||LA137_1==65) ) { + alt137=1; + } + } + else if ( (LA137_0==27||LA137_0==97) ) { + alt137=1; + } + switch (alt137) { + case 1 : + // InternalScope.g:8519:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + { + // InternalScope.g:8519:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + // InternalScope.g:8520:5: lv_parameterType_0_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_3); + lv_parameterType_0_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + // InternalScope.g:8537:3: ( (lv_name_1_0= ruleValidID ) ) + // InternalScope.g:8538:4: (lv_name_1_0= ruleValidID ) + { + // InternalScope.g:8538:4: (lv_name_1_0= ruleValidID ) + // InternalScope.g:8539:5: lv_name_1_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_name_1_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmFormalParameter" + + + // $ANTLR start "entryRuleFullJvmFormalParameter" + // InternalScope.g:8560:1: entryRuleFullJvmFormalParameter returns [EObject current=null] : iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ; + public final EObject entryRuleFullJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject iv_ruleFullJvmFormalParameter = null; + + + try { + // InternalScope.g:8560:63: (iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ) + // InternalScope.g:8561:2: iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); + } + pushFollow(FOLLOW_1); + iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleFullJvmFormalParameter; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFullJvmFormalParameter" + + + // $ANTLR start "ruleFullJvmFormalParameter" + // InternalScope.g:8567:1: ruleFullJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ; + public final EObject ruleFullJvmFormalParameter() throws RecognitionException { + EObject current = null; + + EObject lv_parameterType_0_0 = null; + + AntlrDatatypeRuleToken lv_name_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8573:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ) + // InternalScope.g:8574:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) + { + // InternalScope.g:8574:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) + // InternalScope.g:8575:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) + { + // InternalScope.g:8575:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) + // InternalScope.g:8576:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + { + // InternalScope.g:8576:4: (lv_parameterType_0_0= ruleJvmTypeReference ) + // InternalScope.g:8577:5: lv_parameterType_0_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_3); + lv_parameterType_0_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + current, + "parameterType", + lv_parameterType_0_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8594:3: ( (lv_name_1_0= ruleValidID ) ) + // InternalScope.g:8595:4: (lv_name_1_0= ruleValidID ) + { + // InternalScope.g:8595:4: (lv_name_1_0= ruleValidID ) + // InternalScope.g:8596:5: lv_name_1_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_name_1_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule()); + } + set( + current, + "name", + lv_name_1_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFullJvmFormalParameter" + + + // $ANTLR start "entryRuleXFeatureCall" + // InternalScope.g:8617:1: entryRuleXFeatureCall returns [EObject current=null] : iv_ruleXFeatureCall= ruleXFeatureCall EOF ; + public final EObject entryRuleXFeatureCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFeatureCall = null; + + + try { + // InternalScope.g:8617:53: (iv_ruleXFeatureCall= ruleXFeatureCall EOF ) + // InternalScope.g:8618:2: iv_ruleXFeatureCall= ruleXFeatureCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFeatureCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFeatureCall=ruleXFeatureCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFeatureCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFeatureCall" + + + // $ANTLR start "ruleXFeatureCall" + // InternalScope.g:8624:1: ruleXFeatureCall returns [EObject current=null] : ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ; + public final EObject ruleXFeatureCall() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token lv_explicitOperationCall_7_0=null; + Token otherlv_10=null; + Token otherlv_12=null; + EObject lv_typeArguments_2_0 = null; + + EObject lv_typeArguments_4_0 = null; + + EObject lv_featureCallArguments_8_0 = null; + + EObject lv_featureCallArguments_9_0 = null; + + EObject lv_featureCallArguments_11_0 = null; + + EObject lv_featureCallArguments_13_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8630:2: ( ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ) + // InternalScope.g:8631:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) + { + // InternalScope.g:8631:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) + // InternalScope.g:8632:3: () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? + { + // InternalScope.g:8632:3: () + // InternalScope.g:8633:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(), + current); + + } + + } + + // InternalScope.g:8639:3: (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? + int alt139=2; + int LA139_0 = input.LA(1); + + if ( (LA139_0==65) ) { + alt139=1; + } + switch (alt139) { + case 1 : + // InternalScope.g:8640:4: otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' + { + otherlv_1=(Token)match(input,65,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); + + } + // InternalScope.g:8644:4: ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:8645:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:8645:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:8646:6: lv_typeArguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_83); + lv_typeArguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8663:4: (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop138: + do { + int alt138=2; + int LA138_0 = input.LA(1); + + if ( (LA138_0==37) ) { + alt138=1; + } + + + switch (alt138) { + case 1 : + // InternalScope.g:8664:5: otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,37,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); + + } + // InternalScope.g:8668:5: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:8669:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:8669:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:8670:7: lv_typeArguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_83); + lv_typeArguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop138; + } + } while (true); + + otherlv_5=(Token)match(input,64,FOLLOW_81); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); + + } + + } + break; + + } + + // InternalScope.g:8693:3: ( ( ruleIdOrSuper ) ) + // InternalScope.g:8694:4: ( ruleIdOrSuper ) + { + // InternalScope.g:8694:4: ( ruleIdOrSuper ) + // InternalScope.g:8695:5: ruleIdOrSuper + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); + + } + pushFollow(FOLLOW_108); + ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8709:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? + int alt142=2; + alt142 = dfa142.predict(input); + switch (alt142) { + case 1 : + // InternalScope.g:8710:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' + { + // InternalScope.g:8710:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) + // InternalScope.g:8711:5: ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) + { + // InternalScope.g:8715:5: (lv_explicitOperationCall_7_0= '(' ) + // InternalScope.g:8716:6: lv_explicitOperationCall_7_0= '(' + { + lv_explicitOperationCall_7_0=(Token)match(input,27,FOLLOW_85); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXFeatureCallRule()); + } + setWithLastConsumed(current, "explicitOperationCall", lv_explicitOperationCall_7_0 != null, "("); + + } + + } + + + } + + // InternalScope.g:8728:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? + int alt141=3; + alt141 = dfa141.predict(input); + switch (alt141) { + case 1 : + // InternalScope.g:8729:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) + { + // InternalScope.g:8729:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) + // InternalScope.g:8730:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) + { + // InternalScope.g:8755:6: (lv_featureCallArguments_8_0= ruleXShortClosure ) + // InternalScope.g:8756:7: lv_featureCallArguments_8_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); + + } + pushFollow(FOLLOW_20); + lv_featureCallArguments_8_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_8_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:8774:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) + { + // InternalScope.g:8774:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) + // InternalScope.g:8775:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* + { + // InternalScope.g:8775:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) + // InternalScope.g:8776:7: (lv_featureCallArguments_9_0= ruleXExpression ) + { + // InternalScope.g:8776:7: (lv_featureCallArguments_9_0= ruleXExpression ) + // InternalScope.g:8777:8: lv_featureCallArguments_9_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); + + } + pushFollow(FOLLOW_31); + lv_featureCallArguments_9_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8794:6: (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* + loop140: + do { + int alt140=2; + int LA140_0 = input.LA(1); + + if ( (LA140_0==37) ) { + alt140=1; + } + + + switch (alt140) { + case 1 : + // InternalScope.g:8795:7: otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) + { + otherlv_10=(Token)match(input,37,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); + + } + // InternalScope.g:8799:7: ( (lv_featureCallArguments_11_0= ruleXExpression ) ) + // InternalScope.g:8800:8: (lv_featureCallArguments_11_0= ruleXExpression ) + { + // InternalScope.g:8800:8: (lv_featureCallArguments_11_0= ruleXExpression ) + // InternalScope.g:8801:9: lv_featureCallArguments_11_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); + + } + pushFollow(FOLLOW_31); + lv_featureCallArguments_11_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_11_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop140; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_12=(Token)match(input,28,FOLLOW_27); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); + + } + + } + break; + + } + + // InternalScope.g:8826:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? + int alt143=2; + alt143 = dfa143.predict(input); + switch (alt143) { + case 1 : + // InternalScope.g:8827:4: ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) + { + // InternalScope.g:8833:4: (lv_featureCallArguments_13_0= ruleXClosure ) + // InternalScope.g:8834:5: lv_featureCallArguments_13_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_2); + lv_featureCallArguments_13_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFeatureCallRule()); + } + add( + current, + "featureCallArguments", + lv_featureCallArguments_13_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFeatureCall" + + + // $ANTLR start "entryRuleFeatureCallID" + // InternalScope.g:8855:1: entryRuleFeatureCallID returns [String current=null] : iv_ruleFeatureCallID= ruleFeatureCallID EOF ; + public final String entryRuleFeatureCallID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleFeatureCallID = null; + + + try { + // InternalScope.g:8855:53: (iv_ruleFeatureCallID= ruleFeatureCallID EOF ) + // InternalScope.g:8856:2: iv_ruleFeatureCallID= ruleFeatureCallID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getFeatureCallIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleFeatureCallID=ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleFeatureCallID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleFeatureCallID" + + + // $ANTLR start "ruleFeatureCallID" + // InternalScope.g:8862:1: ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ; + public final AntlrDatatypeRuleToken ruleFeatureCallID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8868:2: ( (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ) + // InternalScope.g:8869:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) + { + // InternalScope.g:8869:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) + int alt144=5; + switch ( input.LA(1) ) { + case RULE_ID: + { + alt144=1; + } + break; + case 110: + { + alt144=2; + } + break; + case 111: + { + alt144=3; + } + break; + case 16: + { + alt144=4; + } + break; + case 18: + { + alt144=5; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 144, 0, input); + + throw nvae; + } + + switch (alt144) { + case 1 : + // InternalScope.g:8870:3: this_ValidID_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:8881:3: kw= 'extends' + { + kw=(Token)match(input,110,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); + + } + + } + break; + case 3 : + // InternalScope.g:8887:3: kw= 'static' + { + kw=(Token)match(input,111,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); + + } + + } + break; + case 4 : + // InternalScope.g:8893:3: kw= 'import' + { + kw=(Token)match(input,16,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); + + } + + } + break; + case 5 : + // InternalScope.g:8899:3: kw= 'extension' + { + kw=(Token)match(input,18,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleFeatureCallID" + + + // $ANTLR start "entryRuleIdOrSuper" + // InternalScope.g:8908:1: entryRuleIdOrSuper returns [String current=null] : iv_ruleIdOrSuper= ruleIdOrSuper EOF ; + public final String entryRuleIdOrSuper() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleIdOrSuper = null; + + + try { + // InternalScope.g:8908:49: (iv_ruleIdOrSuper= ruleIdOrSuper EOF ) + // InternalScope.g:8909:2: iv_ruleIdOrSuper= ruleIdOrSuper EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getIdOrSuperRule()); + } + pushFollow(FOLLOW_1); + iv_ruleIdOrSuper=ruleIdOrSuper(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleIdOrSuper.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleIdOrSuper" + + + // $ANTLR start "ruleIdOrSuper" + // InternalScope.g:8915:1: ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ; + public final AntlrDatatypeRuleToken ruleIdOrSuper() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_FeatureCallID_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8921:2: ( (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ) + // InternalScope.g:8922:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) + { + // InternalScope.g:8922:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) + int alt145=2; + int LA145_0 = input.LA(1); + + if ( (LA145_0==RULE_ID||LA145_0==16||LA145_0==18||(LA145_0>=110 && LA145_0<=111)) ) { + alt145=1; + } + else if ( (LA145_0==112) ) { + alt145=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 145, 0, input); + + throw nvae; + } + switch (alt145) { + case 1 : + // InternalScope.g:8923:3: this_FeatureCallID_0= ruleFeatureCallID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_FeatureCallID_0=ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_FeatureCallID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:8934:3: kw= 'super' + { + kw=(Token)match(input,112,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleIdOrSuper" + + + // $ANTLR start "entryRuleXConstructorCall" + // InternalScope.g:8943:1: entryRuleXConstructorCall returns [EObject current=null] : iv_ruleXConstructorCall= ruleXConstructorCall EOF ; + public final EObject entryRuleXConstructorCall() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXConstructorCall = null; + + + try { + // InternalScope.g:8943:57: (iv_ruleXConstructorCall= ruleXConstructorCall EOF ) + // InternalScope.g:8944:2: iv_ruleXConstructorCall= ruleXConstructorCall EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXConstructorCallRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXConstructorCall=ruleXConstructorCall(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXConstructorCall; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXConstructorCall" + + + // $ANTLR start "ruleXConstructorCall" + // InternalScope.g:8950:1: ruleXConstructorCall returns [EObject current=null] : ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ; + public final EObject ruleXConstructorCall() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token lv_explicitConstructorCall_8_0=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_typeArguments_4_0 = null; + + EObject lv_typeArguments_6_0 = null; + + EObject lv_arguments_9_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + EObject lv_arguments_14_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:8956:2: ( ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ) + // InternalScope.g:8957:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) + { + // InternalScope.g:8957:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) + // InternalScope.g:8958:3: () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? + { + // InternalScope.g:8958:3: () + // InternalScope.g:8959:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,83,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); + + } + // InternalScope.g:8969:3: ( ( ruleQualifiedName ) ) + // InternalScope.g:8970:4: ( ruleQualifiedName ) + { + // InternalScope.g:8970:4: ( ruleQualifiedName ) + // InternalScope.g:8971:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); + + } + pushFollow(FOLLOW_109); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:8985:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? + int alt147=2; + alt147 = dfa147.predict(input); + switch (alt147) { + case 1 : + // InternalScope.g:8986:4: ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' + { + // InternalScope.g:8986:4: ( ( '<' )=>otherlv_3= '<' ) + // InternalScope.g:8987:5: ( '<' )=>otherlv_3= '<' + { + otherlv_3=(Token)match(input,65,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); + + } + + } + + // InternalScope.g:8993:4: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:8994:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:8994:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:8995:6: lv_typeArguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); + + } + pushFollow(FOLLOW_83); + lv_typeArguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:9012:4: (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* + loop146: + do { + int alt146=2; + int LA146_0 = input.LA(1); + + if ( (LA146_0==37) ) { + alt146=1; + } + + + switch (alt146) { + case 1 : + // InternalScope.g:9013:5: otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_5=(Token)match(input,37,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); + + } + // InternalScope.g:9017:5: ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:9018:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:9018:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:9019:7: lv_typeArguments_6_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); + + } + pushFollow(FOLLOW_83); + lv_typeArguments_6_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "typeArguments", + lv_typeArguments_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop146; + } + } while (true); + + otherlv_7=(Token)match(input,64,FOLLOW_108); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); + + } + + } + break; + + } + + // InternalScope.g:9042:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? + int alt150=2; + alt150 = dfa150.predict(input); + switch (alt150) { + case 1 : + // InternalScope.g:9043:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' + { + // InternalScope.g:9043:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) + // InternalScope.g:9044:5: ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) + { + // InternalScope.g:9048:5: (lv_explicitConstructorCall_8_0= '(' ) + // InternalScope.g:9049:6: lv_explicitConstructorCall_8_0= '(' + { + lv_explicitConstructorCall_8_0=(Token)match(input,27,FOLLOW_85); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXConstructorCallRule()); + } + setWithLastConsumed(current, "explicitConstructorCall", lv_explicitConstructorCall_8_0 != null, "("); + + } + + } + + + } + + // InternalScope.g:9061:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? + int alt149=3; + alt149 = dfa149.predict(input); + switch (alt149) { + case 1 : + // InternalScope.g:9062:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) + { + // InternalScope.g:9062:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) + // InternalScope.g:9063:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) + { + // InternalScope.g:9088:6: (lv_arguments_9_0= ruleXShortClosure ) + // InternalScope.g:9089:7: lv_arguments_9_0= ruleXShortClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); + + } + pushFollow(FOLLOW_20); + lv_arguments_9_0=ruleXShortClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_9_0, + "org.eclipse.xtext.xbase.Xbase.XShortClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:9107:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) + { + // InternalScope.g:9107:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) + // InternalScope.g:9108:6: ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* + { + // InternalScope.g:9108:6: ( (lv_arguments_10_0= ruleXExpression ) ) + // InternalScope.g:9109:7: (lv_arguments_10_0= ruleXExpression ) + { + // InternalScope.g:9109:7: (lv_arguments_10_0= ruleXExpression ) + // InternalScope.g:9110:8: lv_arguments_10_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); + + } + pushFollow(FOLLOW_31); + lv_arguments_10_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:9127:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* + loop148: + do { + int alt148=2; + int LA148_0 = input.LA(1); + + if ( (LA148_0==37) ) { + alt148=1; + } + + + switch (alt148) { + case 1 : + // InternalScope.g:9128:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) + { + otherlv_11=(Token)match(input,37,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); + + } + // InternalScope.g:9132:7: ( (lv_arguments_12_0= ruleXExpression ) ) + // InternalScope.g:9133:8: (lv_arguments_12_0= ruleXExpression ) + { + // InternalScope.g:9133:8: (lv_arguments_12_0= ruleXExpression ) + // InternalScope.g:9134:9: lv_arguments_12_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); + + } + pushFollow(FOLLOW_31); + lv_arguments_12_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop148; + } + } while (true); + + + } + + + } + break; + + } + + otherlv_13=(Token)match(input,28,FOLLOW_27); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); + + } + + } + break; + + } + + // InternalScope.g:9159:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? + int alt151=2; + alt151 = dfa151.predict(input); + switch (alt151) { + case 1 : + // InternalScope.g:9160:4: ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) + { + // InternalScope.g:9166:4: (lv_arguments_14_0= ruleXClosure ) + // InternalScope.g:9167:5: lv_arguments_14_0= ruleXClosure + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); + + } + pushFollow(FOLLOW_2); + lv_arguments_14_0=ruleXClosure(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXConstructorCallRule()); + } + add( + current, + "arguments", + lv_arguments_14_0, + "org.eclipse.xtext.xbase.Xbase.XClosure"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXConstructorCall" + + + // $ANTLR start "entryRuleXBooleanLiteral" + // InternalScope.g:9188:1: entryRuleXBooleanLiteral returns [EObject current=null] : iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ; + public final EObject entryRuleXBooleanLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXBooleanLiteral = null; + + + try { + // InternalScope.g:9188:56: (iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ) + // InternalScope.g:9189:2: iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXBooleanLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXBooleanLiteral=ruleXBooleanLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXBooleanLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXBooleanLiteral" + + + // $ANTLR start "ruleXBooleanLiteral" + // InternalScope.g:9195:1: ruleXBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ; + public final EObject ruleXBooleanLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token lv_isTrue_2_0=null; + + + enterRule(); + + try { + // InternalScope.g:9201:2: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ) + // InternalScope.g:9202:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) + { + // InternalScope.g:9202:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) + // InternalScope.g:9203:3: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) + { + // InternalScope.g:9203:3: () + // InternalScope.g:9204:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(), + current); + + } + + } + + // InternalScope.g:9210:3: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) + int alt152=2; + int LA152_0 = input.LA(1); + + if ( (LA152_0==80) ) { + alt152=1; + } + else if ( (LA152_0==79) ) { + alt152=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 152, 0, input); + + throw nvae; + } + switch (alt152) { + case 1 : + // InternalScope.g:9211:4: otherlv_1= 'false' + { + otherlv_1=(Token)match(input,80,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); + + } + + } + break; + case 2 : + // InternalScope.g:9216:4: ( (lv_isTrue_2_0= 'true' ) ) + { + // InternalScope.g:9216:4: ( (lv_isTrue_2_0= 'true' ) ) + // InternalScope.g:9217:5: (lv_isTrue_2_0= 'true' ) + { + // InternalScope.g:9217:5: (lv_isTrue_2_0= 'true' ) + // InternalScope.g:9218:6: lv_isTrue_2_0= 'true' + { + lv_isTrue_2_0=(Token)match(input,79,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXBooleanLiteralRule()); + } + setWithLastConsumed(current, "isTrue", lv_isTrue_2_0 != null, "true"); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXBooleanLiteral" + + + // $ANTLR start "entryRuleXNullLiteral" + // InternalScope.g:9235:1: entryRuleXNullLiteral returns [EObject current=null] : iv_ruleXNullLiteral= ruleXNullLiteral EOF ; + public final EObject entryRuleXNullLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXNullLiteral = null; + + + try { + // InternalScope.g:9235:53: (iv_ruleXNullLiteral= ruleXNullLiteral EOF ) + // InternalScope.g:9236:2: iv_ruleXNullLiteral= ruleXNullLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXNullLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXNullLiteral=ruleXNullLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXNullLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXNullLiteral" + + + // $ANTLR start "ruleXNullLiteral" + // InternalScope.g:9242:1: ruleXNullLiteral returns [EObject current=null] : ( () otherlv_1= 'null' ) ; + public final EObject ruleXNullLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + + + enterRule(); + + try { + // InternalScope.g:9248:2: ( ( () otherlv_1= 'null' ) ) + // InternalScope.g:9249:2: ( () otherlv_1= 'null' ) + { + // InternalScope.g:9249:2: ( () otherlv_1= 'null' ) + // InternalScope.g:9250:3: () otherlv_1= 'null' + { + // InternalScope.g:9250:3: () + // InternalScope.g:9251:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,81,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXNullLiteral" + + + // $ANTLR start "entryRuleXNumberLiteral" + // InternalScope.g:9265:1: entryRuleXNumberLiteral returns [EObject current=null] : iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ; + public final EObject entryRuleXNumberLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXNumberLiteral = null; + + + try { + // InternalScope.g:9265:55: (iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ) + // InternalScope.g:9266:2: iv_ruleXNumberLiteral= ruleXNumberLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXNumberLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXNumberLiteral=ruleXNumberLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXNumberLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXNumberLiteral" + + + // $ANTLR start "ruleXNumberLiteral" + // InternalScope.g:9272:1: ruleXNumberLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleNumber ) ) ) ; + public final EObject ruleXNumberLiteral() throws RecognitionException { + EObject current = null; + + AntlrDatatypeRuleToken lv_value_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9278:2: ( ( () ( (lv_value_1_0= ruleNumber ) ) ) ) + // InternalScope.g:9279:2: ( () ( (lv_value_1_0= ruleNumber ) ) ) + { + // InternalScope.g:9279:2: ( () ( (lv_value_1_0= ruleNumber ) ) ) + // InternalScope.g:9280:3: () ( (lv_value_1_0= ruleNumber ) ) + { + // InternalScope.g:9280:3: () + // InternalScope.g:9281:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(), + current); + + } + + } + + // InternalScope.g:9287:3: ( (lv_value_1_0= ruleNumber ) ) + // InternalScope.g:9288:4: (lv_value_1_0= ruleNumber ) + { + // InternalScope.g:9288:4: (lv_value_1_0= ruleNumber ) + // InternalScope.g:9289:5: lv_value_1_0= ruleNumber + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_value_1_0=ruleNumber(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXNumberLiteralRule()); + } + set( + current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xbase.Number"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXNumberLiteral" + + + // $ANTLR start "entryRuleXStringLiteral" + // InternalScope.g:9310:1: entryRuleXStringLiteral returns [EObject current=null] : iv_ruleXStringLiteral= ruleXStringLiteral EOF ; + public final EObject entryRuleXStringLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXStringLiteral = null; + + + try { + // InternalScope.g:9310:55: (iv_ruleXStringLiteral= ruleXStringLiteral EOF ) + // InternalScope.g:9311:2: iv_ruleXStringLiteral= ruleXStringLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXStringLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXStringLiteral=ruleXStringLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXStringLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXStringLiteral" + + + // $ANTLR start "ruleXStringLiteral" + // InternalScope.g:9317:1: ruleXStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ; + public final EObject ruleXStringLiteral() throws RecognitionException { + EObject current = null; + + Token lv_value_1_0=null; + + + enterRule(); + + try { + // InternalScope.g:9323:2: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) ) + // InternalScope.g:9324:2: ( () ( (lv_value_1_0= RULE_STRING ) ) ) + { + // InternalScope.g:9324:2: ( () ( (lv_value_1_0= RULE_STRING ) ) ) + // InternalScope.g:9325:3: () ( (lv_value_1_0= RULE_STRING ) ) + { + // InternalScope.g:9325:3: () + // InternalScope.g:9326:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(), + current); + + } + + } + + // InternalScope.g:9332:3: ( (lv_value_1_0= RULE_STRING ) ) + // InternalScope.g:9333:4: (lv_value_1_0= RULE_STRING ) + { + // InternalScope.g:9333:4: (lv_value_1_0= RULE_STRING ) + // InternalScope.g:9334:5: lv_value_1_0= RULE_STRING + { + lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXStringLiteralRule()); + } + setWithLastConsumed( + current, + "value", + lv_value_1_0, + "org.eclipse.xtext.xbase.Xtype.STRING"); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXStringLiteral" + + + // $ANTLR start "entryRuleXTypeLiteral" + // InternalScope.g:9354:1: entryRuleXTypeLiteral returns [EObject current=null] : iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ; + public final EObject entryRuleXTypeLiteral() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXTypeLiteral = null; + + + try { + // InternalScope.g:9354:53: (iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ) + // InternalScope.g:9355:2: iv_ruleXTypeLiteral= ruleXTypeLiteral EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXTypeLiteralRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXTypeLiteral=ruleXTypeLiteral(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXTypeLiteral; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXTypeLiteral" + + + // $ANTLR start "ruleXTypeLiteral" + // InternalScope.g:9361:1: ruleXTypeLiteral returns [EObject current=null] : ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ; + public final EObject ruleXTypeLiteral() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_5=null; + AntlrDatatypeRuleToken lv_arrayDimensions_4_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9367:2: ( ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ) + // InternalScope.g:9368:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) + { + // InternalScope.g:9368:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) + // InternalScope.g:9369:3: () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' + { + // InternalScope.g:9369:3: () + // InternalScope.g:9370:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,113,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); + + } + otherlv_2=(Token)match(input,27,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); + + } + // InternalScope.g:9384:3: ( ( ruleQualifiedName ) ) + // InternalScope.g:9385:4: ( ruleQualifiedName ) + { + // InternalScope.g:9385:4: ( ruleQualifiedName ) + // InternalScope.g:9386:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXTypeLiteralRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); + + } + pushFollow(FOLLOW_110); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:9400:3: ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* + loop153: + do { + int alt153=2; + int LA153_0 = input.LA(1); + + if ( (LA153_0==33) ) { + alt153=1; + } + + + switch (alt153) { + case 1 : + // InternalScope.g:9401:4: (lv_arrayDimensions_4_0= ruleArrayBrackets ) + { + // InternalScope.g:9401:4: (lv_arrayDimensions_4_0= ruleArrayBrackets ) + // InternalScope.g:9402:5: lv_arrayDimensions_4_0= ruleArrayBrackets + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_110); + lv_arrayDimensions_4_0=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTypeLiteralRule()); + } + add( + current, + "arrayDimensions", + lv_arrayDimensions_4_0, + "org.eclipse.xtext.xbase.Xtype.ArrayBrackets"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop153; + } + } while (true); + + otherlv_5=(Token)match(input,28,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXTypeLiteral" + + + // $ANTLR start "entryRuleXThrowExpression" + // InternalScope.g:9427:1: entryRuleXThrowExpression returns [EObject current=null] : iv_ruleXThrowExpression= ruleXThrowExpression EOF ; + public final EObject entryRuleXThrowExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXThrowExpression = null; + + + try { + // InternalScope.g:9427:57: (iv_ruleXThrowExpression= ruleXThrowExpression EOF ) + // InternalScope.g:9428:2: iv_ruleXThrowExpression= ruleXThrowExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXThrowExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXThrowExpression=ruleXThrowExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXThrowExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXThrowExpression" + + + // $ANTLR start "ruleXThrowExpression" + // InternalScope.g:9434:1: ruleXThrowExpression returns [EObject current=null] : ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ; + public final EObject ruleXThrowExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_expression_2_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9440:2: ( ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ) + // InternalScope.g:9441:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) + { + // InternalScope.g:9441:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) + // InternalScope.g:9442:3: () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) + { + // InternalScope.g:9442:3: () + // InternalScope.g:9443:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,114,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); + + } + // InternalScope.g:9453:3: ( (lv_expression_2_0= ruleXExpression ) ) + // InternalScope.g:9454:4: (lv_expression_2_0= ruleXExpression ) + { + // InternalScope.g:9454:4: (lv_expression_2_0= ruleXExpression ) + // InternalScope.g:9455:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXThrowExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXThrowExpression" + + + // $ANTLR start "entryRuleXReturnExpression" + // InternalScope.g:9476:1: entryRuleXReturnExpression returns [EObject current=null] : iv_ruleXReturnExpression= ruleXReturnExpression EOF ; + public final EObject entryRuleXReturnExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXReturnExpression = null; + + + try { + // InternalScope.g:9476:58: (iv_ruleXReturnExpression= ruleXReturnExpression EOF ) + // InternalScope.g:9477:2: iv_ruleXReturnExpression= ruleXReturnExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXReturnExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXReturnExpression=ruleXReturnExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXReturnExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXReturnExpression" + + + // $ANTLR start "ruleXReturnExpression" + // InternalScope.g:9483:1: ruleXReturnExpression returns [EObject current=null] : ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ; + public final EObject ruleXReturnExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_expression_2_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9489:2: ( ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ) + // InternalScope.g:9490:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) + { + // InternalScope.g:9490:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) + // InternalScope.g:9491:3: () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? + { + // InternalScope.g:9491:3: () + // InternalScope.g:9492:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,115,FOLLOW_111); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); + + } + // InternalScope.g:9502:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? + int alt154=2; + alt154 = dfa154.predict(input); + switch (alt154) { + case 1 : + // InternalScope.g:9503:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) + { + // InternalScope.g:9504:4: (lv_expression_2_0= ruleXExpression ) + // InternalScope.g:9505:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXReturnExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXReturnExpression" + + + // $ANTLR start "entryRuleXTryCatchFinallyExpression" + // InternalScope.g:9526:1: entryRuleXTryCatchFinallyExpression returns [EObject current=null] : iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ; + public final EObject entryRuleXTryCatchFinallyExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXTryCatchFinallyExpression = null; + + + try { + // InternalScope.g:9526:67: (iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ) + // InternalScope.g:9527:2: iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXTryCatchFinallyExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXTryCatchFinallyExpression" + + + // $ANTLR start "ruleXTryCatchFinallyExpression" + // InternalScope.g:9533:1: ruleXTryCatchFinallyExpression returns [EObject current=null] : ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ; + public final EObject ruleXTryCatchFinallyExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_4=null; + Token otherlv_6=null; + EObject lv_expression_2_0 = null; + + EObject lv_catchClauses_3_0 = null; + + EObject lv_finallyExpression_5_0 = null; + + EObject lv_finallyExpression_7_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9539:2: ( ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ) + // InternalScope.g:9540:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) + { + // InternalScope.g:9540:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) + // InternalScope.g:9541:3: () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) + { + // InternalScope.g:9541:3: () + // InternalScope.g:9542:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,116,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); + + } + // InternalScope.g:9552:3: ( (lv_expression_2_0= ruleXExpression ) ) + // InternalScope.g:9553:4: (lv_expression_2_0= ruleXExpression ) + { + // InternalScope.g:9553:4: (lv_expression_2_0= ruleXExpression ) + // InternalScope.g:9554:5: lv_expression_2_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_112); + lv_expression_2_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "expression", + lv_expression_2_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:9571:3: ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) + int alt157=2; + int LA157_0 = input.LA(1); + + if ( (LA157_0==119) ) { + alt157=1; + } + else if ( (LA157_0==117) ) { + alt157=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 157, 0, input); + + throw nvae; + } + switch (alt157) { + case 1 : + // InternalScope.g:9572:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) + { + // InternalScope.g:9572:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) + // InternalScope.g:9573:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? + { + // InternalScope.g:9573:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ + int cnt155=0; + loop155: + do { + int alt155=2; + int LA155_0 = input.LA(1); + + if ( (LA155_0==119) ) { + int LA155_2 = input.LA(2); + + if ( (synpred41_InternalScope()) ) { + alt155=1; + } + + + } + + + switch (alt155) { + case 1 : + // InternalScope.g:9574:6: ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) + { + // InternalScope.g:9575:6: (lv_catchClauses_3_0= ruleXCatchClause ) + // InternalScope.g:9576:7: lv_catchClauses_3_0= ruleXCatchClause + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); + + } + pushFollow(FOLLOW_113); + lv_catchClauses_3_0=ruleXCatchClause(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + add( + current, + "catchClauses", + lv_catchClauses_3_0, + "org.eclipse.xtext.xbase.Xbase.XCatchClause"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + if ( cnt155 >= 1 ) break loop155; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(155, input); + throw eee; + } + cnt155++; + } while (true); + + // InternalScope.g:9593:5: ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? + int alt156=2; + int LA156_0 = input.LA(1); + + if ( (LA156_0==117) ) { + int LA156_1 = input.LA(2); + + if ( (synpred42_InternalScope()) ) { + alt156=1; + } + } + switch (alt156) { + case 1 : + // InternalScope.g:9594:6: ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) + { + // InternalScope.g:9594:6: ( ( 'finally' )=>otherlv_4= 'finally' ) + // InternalScope.g:9595:7: ( 'finally' )=>otherlv_4= 'finally' + { + otherlv_4=(Token)match(input,117,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); + + } + + } + + // InternalScope.g:9601:6: ( (lv_finallyExpression_5_0= ruleXExpression ) ) + // InternalScope.g:9602:7: (lv_finallyExpression_5_0= ruleXExpression ) + { + // InternalScope.g:9602:7: (lv_finallyExpression_5_0= ruleXExpression ) + // InternalScope.g:9603:8: lv_finallyExpression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_finallyExpression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "finallyExpression", + lv_finallyExpression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:9623:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) + { + // InternalScope.g:9623:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) + // InternalScope.g:9624:5: otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) + { + otherlv_6=(Token)match(input,117,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); + + } + // InternalScope.g:9628:5: ( (lv_finallyExpression_7_0= ruleXExpression ) ) + // InternalScope.g:9629:6: (lv_finallyExpression_7_0= ruleXExpression ) + { + // InternalScope.g:9629:6: (lv_finallyExpression_7_0= ruleXExpression ) + // InternalScope.g:9630:7: lv_finallyExpression_7_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); + + } + pushFollow(FOLLOW_2); + lv_finallyExpression_7_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule()); + } + set( + current, + "finallyExpression", + lv_finallyExpression_7_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXTryCatchFinallyExpression" + + + // $ANTLR start "entryRuleXSynchronizedExpression" + // InternalScope.g:9653:1: entryRuleXSynchronizedExpression returns [EObject current=null] : iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ; + public final EObject entryRuleXSynchronizedExpression() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXSynchronizedExpression = null; + + + try { + // InternalScope.g:9653:64: (iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ) + // InternalScope.g:9654:2: iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXSynchronizedExpression; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXSynchronizedExpression" + + + // $ANTLR start "ruleXSynchronizedExpression" + // InternalScope.g:9660:1: ruleXSynchronizedExpression returns [EObject current=null] : ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ; + public final EObject ruleXSynchronizedExpression() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_2=null; + Token otherlv_4=null; + EObject lv_param_3_0 = null; + + EObject lv_expression_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9666:2: ( ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ) + // InternalScope.g:9667:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) + { + // InternalScope.g:9667:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) + // InternalScope.g:9668:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) + { + // InternalScope.g:9668:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) + // InternalScope.g:9669:4: ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) + { + // InternalScope.g:9676:4: ( () otherlv_1= 'synchronized' otherlv_2= '(' ) + // InternalScope.g:9677:5: () otherlv_1= 'synchronized' otherlv_2= '(' + { + // InternalScope.g:9677:5: () + // InternalScope.g:9678:6: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,118,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); + + } + otherlv_2=(Token)match(input,27,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); + + } + + } + + + } + + // InternalScope.g:9694:3: ( (lv_param_3_0= ruleXExpression ) ) + // InternalScope.g:9695:4: (lv_param_3_0= ruleXExpression ) + { + // InternalScope.g:9695:4: (lv_param_3_0= ruleXExpression ) + // InternalScope.g:9696:5: lv_param_3_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_20); + lv_param_3_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + current, + "param", + lv_param_3_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_4=(Token)match(input,28,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); + + } + // InternalScope.g:9717:3: ( (lv_expression_5_0= ruleXExpression ) ) + // InternalScope.g:9718:4: (lv_expression_5_0= ruleXExpression ) + { + // InternalScope.g:9718:4: (lv_expression_5_0= ruleXExpression ) + // InternalScope.g:9719:5: lv_expression_5_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_5_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule()); + } + set( + current, + "expression", + lv_expression_5_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXSynchronizedExpression" + + + // $ANTLR start "entryRuleXCatchClause" + // InternalScope.g:9740:1: entryRuleXCatchClause returns [EObject current=null] : iv_ruleXCatchClause= ruleXCatchClause EOF ; + public final EObject entryRuleXCatchClause() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXCatchClause = null; + + + try { + // InternalScope.g:9740:53: (iv_ruleXCatchClause= ruleXCatchClause EOF ) + // InternalScope.g:9741:2: iv_ruleXCatchClause= ruleXCatchClause EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXCatchClauseRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXCatchClause=ruleXCatchClause(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXCatchClause; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXCatchClause" + + + // $ANTLR start "ruleXCatchClause" + // InternalScope.g:9747:1: ruleXCatchClause returns [EObject current=null] : ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ; + public final EObject ruleXCatchClause() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_1=null; + Token otherlv_3=null; + EObject lv_declaredParam_2_0 = null; + + EObject lv_expression_4_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:9753:2: ( ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ) + // InternalScope.g:9754:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) + { + // InternalScope.g:9754:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) + // InternalScope.g:9755:3: ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) + { + // InternalScope.g:9755:3: ( ( 'catch' )=>otherlv_0= 'catch' ) + // InternalScope.g:9756:4: ( 'catch' )=>otherlv_0= 'catch' + { + otherlv_0=(Token)match(input,119,FOLLOW_29); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); + + } + + } + + otherlv_1=(Token)match(input,27,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); + + } + // InternalScope.g:9766:3: ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) + // InternalScope.g:9767:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) + { + // InternalScope.g:9767:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) + // InternalScope.g:9768:5: lv_declaredParam_2_0= ruleFullJvmFormalParameter + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_20); + lv_declaredParam_2_0=ruleFullJvmFormalParameter(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + current, + "declaredParam", + lv_declaredParam_2_0, + "org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + otherlv_3=(Token)match(input,28,FOLLOW_65); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); + + } + // InternalScope.g:9789:3: ( (lv_expression_4_0= ruleXExpression ) ) + // InternalScope.g:9790:4: (lv_expression_4_0= ruleXExpression ) + { + // InternalScope.g:9790:4: (lv_expression_4_0= ruleXExpression ) + // InternalScope.g:9791:5: lv_expression_4_0= ruleXExpression + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); + + } + pushFollow(FOLLOW_2); + lv_expression_4_0=ruleXExpression(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXCatchClauseRule()); + } + set( + current, + "expression", + lv_expression_4_0, + "org.eclipse.xtext.xbase.Xbase.XExpression"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXCatchClause" + + + // $ANTLR start "entryRuleQualifiedName" + // InternalScope.g:9812:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ; + public final String entryRuleQualifiedName() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedName = null; + + + try { + // InternalScope.g:9812:53: (iv_ruleQualifiedName= ruleQualifiedName EOF ) + // InternalScope.g:9813:2: iv_ruleQualifiedName= ruleQualifiedName EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedName=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedName.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedName" + + + // $ANTLR start "ruleQualifiedName" + // InternalScope.g:9819:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ; + public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + AntlrDatatypeRuleToken this_ValidID_2 = null; + + + + enterRule(); + + try { + // InternalScope.g:9825:2: ( (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ) + // InternalScope.g:9826:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) + { + // InternalScope.g:9826:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) + // InternalScope.g:9827:3: this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_42); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:9837:3: ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* + loop158: + do { + int alt158=2; + int LA158_0 = input.LA(1); + + if ( (LA158_0==47) ) { + int LA158_2 = input.LA(2); + + if ( (LA158_2==RULE_ID) ) { + int LA158_3 = input.LA(3); + + if ( (synpred45_InternalScope()) ) { + alt158=1; + } + + + } + + + } + + + switch (alt158) { + case 1 : + // InternalScope.g:9838:4: ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID + { + // InternalScope.g:9838:4: ( ( '.' )=>kw= '.' ) + // InternalScope.g:9839:5: ( '.' )=>kw= '.' + { + kw=(Token)match(input,47,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); + + } + pushFollow(FOLLOW_42); + this_ValidID_2=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_2); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + break; + + default : + break loop158; + } + } while (true); + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedName" + + + // $ANTLR start "entryRuleNumber" + // InternalScope.g:9861:1: entryRuleNumber returns [String current=null] : iv_ruleNumber= ruleNumber EOF ; + public final String entryRuleNumber() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleNumber = null; + + + + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // InternalScope.g:9863:2: (iv_ruleNumber= ruleNumber EOF ) + // InternalScope.g:9864:2: iv_ruleNumber= ruleNumber EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getNumberRule()); + } + pushFollow(FOLLOW_1); + iv_ruleNumber=ruleNumber(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleNumber.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + + myHiddenTokenState.restore(); + + } + return current; + } + // $ANTLR end "entryRuleNumber" + + + // $ANTLR start "ruleNumber" + // InternalScope.g:9873:1: ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ; + public final AntlrDatatypeRuleToken ruleNumber() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_HEX_0=null; + Token this_INT_1=null; + Token this_DECIMAL_2=null; + Token kw=null; + Token this_INT_4=null; + Token this_DECIMAL_5=null; + + + enterRule(); + HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens(); + + try { + // InternalScope.g:9880:2: ( (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ) + // InternalScope.g:9881:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) + { + // InternalScope.g:9881:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) + int alt162=2; + int LA162_0 = input.LA(1); + + if ( (LA162_0==RULE_HEX) ) { + alt162=1; + } + else if ( (LA162_0==RULE_INT||LA162_0==RULE_DECIMAL) ) { + alt162=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 162, 0, input); + + throw nvae; + } + switch (alt162) { + case 1 : + // InternalScope.g:9882:3: this_HEX_0= RULE_HEX + { + this_HEX_0=(Token)match(input,RULE_HEX,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_HEX_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); + + } + + } + break; + case 2 : + // InternalScope.g:9890:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) + { + // InternalScope.g:9890:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) + // InternalScope.g:9891:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? + { + // InternalScope.g:9891:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) + int alt159=2; + int LA159_0 = input.LA(1); + + if ( (LA159_0==RULE_INT) ) { + alt159=1; + } + else if ( (LA159_0==RULE_DECIMAL) ) { + alt159=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 159, 0, input); + + throw nvae; + } + switch (alt159) { + case 1 : + // InternalScope.g:9892:5: this_INT_1= RULE_INT + { + this_INT_1=(Token)match(input,RULE_INT,FOLLOW_42); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_INT_1); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); + + } + + } + break; + case 2 : + // InternalScope.g:9900:5: this_DECIMAL_2= RULE_DECIMAL + { + this_DECIMAL_2=(Token)match(input,RULE_DECIMAL,FOLLOW_42); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_DECIMAL_2); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); + + } + + } + break; + + } + + // InternalScope.g:9908:4: (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? + int alt161=2; + int LA161_0 = input.LA(1); + + if ( (LA161_0==47) ) { + int LA161_1 = input.LA(2); + + if ( (LA161_1==RULE_INT||LA161_1==RULE_DECIMAL) ) { + alt161=1; + } + } + switch (alt161) { + case 1 : + // InternalScope.g:9909:5: kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) + { + kw=(Token)match(input,47,FOLLOW_114); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); + + } + // InternalScope.g:9914:5: (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) + int alt160=2; + int LA160_0 = input.LA(1); + + if ( (LA160_0==RULE_INT) ) { + alt160=1; + } + else if ( (LA160_0==RULE_DECIMAL) ) { + alt160=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 160, 0, input); + + throw nvae; + } + switch (alt160) { + case 1 : + // InternalScope.g:9915:6: this_INT_4= RULE_INT + { + this_INT_4=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_INT_4); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); + + } + + } + break; + case 2 : + // InternalScope.g:9923:6: this_DECIMAL_5= RULE_DECIMAL + { + this_DECIMAL_5=(Token)match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_DECIMAL_5); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); + + } + + } + break; + + } + + + } + break; + + } + + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + + myHiddenTokenState.restore(); + + } + return current; + } + // $ANTLR end "ruleNumber" + + + // $ANTLR start "entryRuleJvmTypeReference" + // InternalScope.g:9940:1: entryRuleJvmTypeReference returns [EObject current=null] : iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ; + public final EObject entryRuleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmTypeReference = null; + + + try { + // InternalScope.g:9940:57: (iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ) + // InternalScope.g:9941:2: iv_ruleJvmTypeReference= ruleJvmTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmTypeReference=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmTypeReference" + + + // $ANTLR start "ruleJvmTypeReference" + // InternalScope.g:9947:1: ruleJvmTypeReference returns [EObject current=null] : ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ; + public final EObject ruleJvmTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmParameterizedTypeReference_0 = null; + + EObject this_XFunctionTypeRef_3 = null; + + + + enterRule(); + + try { + // InternalScope.g:9953:2: ( ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ) + // InternalScope.g:9954:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + { + // InternalScope.g:9954:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) + int alt164=2; + int LA164_0 = input.LA(1); + + if ( (LA164_0==RULE_ID) ) { + alt164=1; + } + else if ( (LA164_0==27||LA164_0==97) ) { + alt164=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 164, 0, input); + + throw nvae; + } + switch (alt164) { + case 1 : + // InternalScope.g:9955:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + { + // InternalScope.g:9955:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) + // InternalScope.g:9956:4: this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); + + } + pushFollow(FOLLOW_27); + this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmParameterizedTypeReference_0; + afterParserOrEnumRuleCall(); + + } + // InternalScope.g:9964:4: ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* + loop163: + do { + int alt163=2; + int LA163_0 = input.LA(1); + + if ( (LA163_0==33) ) { + int LA163_2 = input.LA(2); + + if ( (LA163_2==34) ) { + int LA163_3 = input.LA(3); + + if ( (synpred46_InternalScope()) ) { + alt163=1; + } + + + } + + + } + + + switch (alt163) { + case 1 : + // InternalScope.g:9965:5: ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) + { + // InternalScope.g:9971:5: ( () ruleArrayBrackets ) + // InternalScope.g:9972:6: () ruleArrayBrackets + { + // InternalScope.g:9972:6: () + // InternalScope.g:9973:7: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(), + current); + + } + + } + + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); + + } + pushFollow(FOLLOW_27); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop163; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalScope.g:9990:3: this_XFunctionTypeRef_3= ruleXFunctionTypeRef + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_XFunctionTypeRef_3=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_XFunctionTypeRef_3; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmTypeReference" + + + // $ANTLR start "entryRuleArrayBrackets" + // InternalScope.g:10002:1: entryRuleArrayBrackets returns [String current=null] : iv_ruleArrayBrackets= ruleArrayBrackets EOF ; + public final String entryRuleArrayBrackets() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleArrayBrackets = null; + + + try { + // InternalScope.g:10002:53: (iv_ruleArrayBrackets= ruleArrayBrackets EOF ) + // InternalScope.g:10003:2: iv_ruleArrayBrackets= ruleArrayBrackets EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getArrayBracketsRule()); + } + pushFollow(FOLLOW_1); + iv_ruleArrayBrackets=ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleArrayBrackets.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleArrayBrackets" + + + // $ANTLR start "ruleArrayBrackets" + // InternalScope.g:10009:1: ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' kw= ']' ) ; + public final AntlrDatatypeRuleToken ruleArrayBrackets() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + + + enterRule(); + + try { + // InternalScope.g:10015:2: ( (kw= '[' kw= ']' ) ) + // InternalScope.g:10016:2: (kw= '[' kw= ']' ) + { + // InternalScope.g:10016:2: (kw= '[' kw= ']' ) + // InternalScope.g:10017:3: kw= '[' kw= ']' + { + kw=(Token)match(input,33,FOLLOW_28); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); + + } + kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleArrayBrackets" + + + // $ANTLR start "entryRuleXFunctionTypeRef" + // InternalScope.g:10031:1: entryRuleXFunctionTypeRef returns [EObject current=null] : iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ; + public final EObject entryRuleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXFunctionTypeRef = null; + + + try { + // InternalScope.g:10031:57: (iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ) + // InternalScope.g:10032:2: iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXFunctionTypeRef; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXFunctionTypeRef" + + + // $ANTLR start "ruleXFunctionTypeRef" + // InternalScope.g:10038:1: ruleXFunctionTypeRef returns [EObject current=null] : ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleXFunctionTypeRef() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token otherlv_2=null; + Token otherlv_4=null; + Token otherlv_5=null; + EObject lv_paramTypes_1_0 = null; + + EObject lv_paramTypes_3_0 = null; + + EObject lv_returnType_6_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10044:2: ( ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ) + // InternalScope.g:10045:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + { + // InternalScope.g:10045:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) + // InternalScope.g:10046:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + { + // InternalScope.g:10046:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? + int alt167=2; + int LA167_0 = input.LA(1); + + if ( (LA167_0==27) ) { + alt167=1; + } + switch (alt167) { + case 1 : + // InternalScope.g:10047:4: otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' + { + otherlv_0=(Token)match(input,27,FOLLOW_115); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); + + } + // InternalScope.g:10051:4: ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? + int alt166=2; + int LA166_0 = input.LA(1); + + if ( (LA166_0==RULE_ID||LA166_0==27||LA166_0==97) ) { + alt166=1; + } + switch (alt166) { + case 1 : + // InternalScope.g:10052:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + { + // InternalScope.g:10052:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) + // InternalScope.g:10053:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + { + // InternalScope.g:10053:6: (lv_paramTypes_1_0= ruleJvmTypeReference ) + // InternalScope.g:10054:7: lv_paramTypes_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); + + } + pushFollow(FOLLOW_31); + lv_paramTypes_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10071:5: (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* + loop165: + do { + int alt165=2; + int LA165_0 = input.LA(1); + + if ( (LA165_0==37) ) { + alt165=1; + } + + + switch (alt165) { + case 1 : + // InternalScope.g:10072:6: otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + { + otherlv_2=(Token)match(input,37,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); + + } + // InternalScope.g:10076:6: ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) + // InternalScope.g:10077:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + { + // InternalScope.g:10077:7: (lv_paramTypes_3_0= ruleJvmTypeReference ) + // InternalScope.g:10078:8: lv_paramTypes_3_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); + + } + pushFollow(FOLLOW_31); + lv_paramTypes_3_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + add( + current, + "paramTypes", + lv_paramTypes_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop165; + } + } while (true); + + + } + break; + + } + + otherlv_4=(Token)match(input,28,FOLLOW_116); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); + + } + + } + break; + + } + + otherlv_5=(Token)match(input,97,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); + + } + // InternalScope.g:10106:3: ( (lv_returnType_6_0= ruleJvmTypeReference ) ) + // InternalScope.g:10107:4: (lv_returnType_6_0= ruleJvmTypeReference ) + { + // InternalScope.g:10107:4: (lv_returnType_6_0= ruleJvmTypeReference ) + // InternalScope.g:10108:5: lv_returnType_6_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); + + } + pushFollow(FOLLOW_2); + lv_returnType_6_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule()); + } + set( + current, + "returnType", + lv_returnType_6_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXFunctionTypeRef" + + + // $ANTLR start "entryRuleJvmParameterizedTypeReference" + // InternalScope.g:10129:1: entryRuleJvmParameterizedTypeReference returns [EObject current=null] : iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ; + public final EObject entryRuleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmParameterizedTypeReference = null; + + + try { + // InternalScope.g:10129:70: (iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ) + // InternalScope.g:10130:2: iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmParameterizedTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmParameterizedTypeReference" + + + // $ANTLR start "ruleJvmParameterizedTypeReference" + // InternalScope.g:10136:1: ruleJvmParameterizedTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ; + public final EObject ruleJvmParameterizedTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + Token otherlv_3=null; + Token otherlv_5=null; + Token otherlv_7=null; + Token otherlv_9=null; + Token otherlv_11=null; + Token otherlv_13=null; + EObject lv_arguments_2_0 = null; + + EObject lv_arguments_4_0 = null; + + EObject lv_arguments_10_0 = null; + + EObject lv_arguments_12_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10142:2: ( ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ) + // InternalScope.g:10143:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + { + // InternalScope.g:10143:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) + // InternalScope.g:10144:3: ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + { + // InternalScope.g:10144:3: ( ( ruleQualifiedName ) ) + // InternalScope.g:10145:4: ( ruleQualifiedName ) + { + // InternalScope.g:10145:4: ( ruleQualifiedName ) + // InternalScope.g:10146:5: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); + + } + pushFollow(FOLLOW_117); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10160:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? + int alt172=2; + alt172 = dfa172.predict(input); + switch (alt172) { + case 1 : + // InternalScope.g:10161:4: ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + { + // InternalScope.g:10161:4: ( ( '<' )=>otherlv_1= '<' ) + // InternalScope.g:10162:5: ( '<' )=>otherlv_1= '<' + { + otherlv_1=(Token)match(input,65,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); + + } + + } + + // InternalScope.g:10168:4: ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:10169:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:10169:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:10170:6: lv_arguments_2_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); + + } + pushFollow(FOLLOW_83); + lv_arguments_2_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10187:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* + loop168: + do { + int alt168=2; + int LA168_0 = input.LA(1); + + if ( (LA168_0==37) ) { + alt168=1; + } + + + switch (alt168) { + case 1 : + // InternalScope.g:10188:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_3=(Token)match(input,37,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); + + } + // InternalScope.g:10192:5: ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:10193:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:10193:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:10194:7: lv_arguments_4_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); + + } + pushFollow(FOLLOW_83); + lv_arguments_4_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop168; + } + } while (true); + + otherlv_5=(Token)match(input,64,FOLLOW_42); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); + + } + // InternalScope.g:10216:4: ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* + loop171: + do { + int alt171=2; + int LA171_0 = input.LA(1); + + if ( (LA171_0==47) ) { + int LA171_2 = input.LA(2); + + if ( (LA171_2==RULE_ID) ) { + int LA171_3 = input.LA(3); + + if ( (synpred48_InternalScope()) ) { + alt171=1; + } + + + } + + + } + + + switch (alt171) { + case 1 : + // InternalScope.g:10217:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + { + // InternalScope.g:10217:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) + // InternalScope.g:10218:6: ( ( () '.' ) )=> ( () otherlv_7= '.' ) + { + // InternalScope.g:10224:6: ( () otherlv_7= '.' ) + // InternalScope.g:10225:7: () otherlv_7= '.' + { + // InternalScope.g:10225:7: () + // InternalScope.g:10226:8: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElementAndSet( + grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(), + current); + + } + + } + + otherlv_7=(Token)match(input,47,FOLLOW_3); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); + + } + + } + + + } + + // InternalScope.g:10238:5: ( ( ruleValidID ) ) + // InternalScope.g:10239:6: ( ruleValidID ) + { + // InternalScope.g:10239:6: ( ruleValidID ) + // InternalScope.g:10240:7: ruleValidID + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); + + } + pushFollow(FOLLOW_118); + ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10254:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? + int alt170=2; + alt170 = dfa170.predict(input); + switch (alt170) { + case 1 : + // InternalScope.g:10255:6: ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' + { + // InternalScope.g:10255:6: ( ( '<' )=>otherlv_9= '<' ) + // InternalScope.g:10256:7: ( '<' )=>otherlv_9= '<' + { + otherlv_9=(Token)match(input,65,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); + + } + + } + + // InternalScope.g:10262:6: ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:10263:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:10263:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:10264:8: lv_arguments_10_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); + + } + pushFollow(FOLLOW_83); + lv_arguments_10_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_10_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10281:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* + loop169: + do { + int alt169=2; + int LA169_0 = input.LA(1); + + if ( (LA169_0==37) ) { + alt169=1; + } + + + switch (alt169) { + case 1 : + // InternalScope.g:10282:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + { + otherlv_11=(Token)match(input,37,FOLLOW_82); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); + + } + // InternalScope.g:10286:7: ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) + // InternalScope.g:10287:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + { + // InternalScope.g:10287:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference ) + // InternalScope.g:10288:9: lv_arguments_12_0= ruleJvmArgumentTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); + + } + pushFollow(FOLLOW_83); + lv_arguments_12_0=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule()); + } + add( + current, + "arguments", + lv_arguments_12_0, + "org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + default : + break loop169; + } + } while (true); + + otherlv_13=(Token)match(input,64,FOLLOW_42); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); + + } + + } + break; + + } + + + } + break; + + default : + break loop171; + } + } while (true); + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmParameterizedTypeReference" + + + // $ANTLR start "entryRuleJvmArgumentTypeReference" + // InternalScope.g:10317:1: entryRuleJvmArgumentTypeReference returns [EObject current=null] : iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ; + public final EObject entryRuleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmArgumentTypeReference = null; + + + try { + // InternalScope.g:10317:65: (iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ) + // InternalScope.g:10318:2: iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmArgumentTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmArgumentTypeReference" + + + // $ANTLR start "ruleJvmArgumentTypeReference" + // InternalScope.g:10324:1: ruleJvmArgumentTypeReference returns [EObject current=null] : (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ; + public final EObject ruleJvmArgumentTypeReference() throws RecognitionException { + EObject current = null; + + EObject this_JvmTypeReference_0 = null; + + EObject this_JvmWildcardTypeReference_1 = null; + + + + enterRule(); + + try { + // InternalScope.g:10330:2: ( (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ) + // InternalScope.g:10331:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + { + // InternalScope.g:10331:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) + int alt173=2; + int LA173_0 = input.LA(1); + + if ( (LA173_0==RULE_ID||LA173_0==27||LA173_0==97) ) { + alt173=1; + } + else if ( (LA173_0==51) ) { + alt173=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 173, 0, input); + + throw nvae; + } + switch (alt173) { + case 1 : + // InternalScope.g:10332:3: this_JvmTypeReference_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); + + } + pushFollow(FOLLOW_2); + this_JvmTypeReference_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmTypeReference_0; + afterParserOrEnumRuleCall(); + + } + + } + break; + case 2 : + // InternalScope.g:10341:3: this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); + + } + pushFollow(FOLLOW_2); + this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = this_JvmWildcardTypeReference_1; + afterParserOrEnumRuleCall(); + + } + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmArgumentTypeReference" + + + // $ANTLR start "entryRuleJvmWildcardTypeReference" + // InternalScope.g:10353:1: entryRuleJvmWildcardTypeReference returns [EObject current=null] : iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ; + public final EObject entryRuleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmWildcardTypeReference = null; + + + try { + // InternalScope.g:10353:65: (iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ) + // InternalScope.g:10354:2: iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmWildcardTypeReference; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmWildcardTypeReference" + + + // $ANTLR start "ruleJvmWildcardTypeReference" + // InternalScope.g:10360:1: ruleJvmWildcardTypeReference returns [EObject current=null] : ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ; + public final EObject ruleJvmWildcardTypeReference() throws RecognitionException { + EObject current = null; + + Token otherlv_1=null; + EObject lv_constraints_2_0 = null; + + EObject lv_constraints_3_0 = null; + + EObject lv_constraints_4_0 = null; + + EObject lv_constraints_5_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10366:2: ( ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ) + // InternalScope.g:10367:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + { + // InternalScope.g:10367:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) + // InternalScope.g:10368:3: () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + { + // InternalScope.g:10368:3: () + // InternalScope.g:10369:4: + { + if ( state.backtracking==0 ) { + + current = forceCreateModelElement( + grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(), + current); + + } + + } + + otherlv_1=(Token)match(input,51,FOLLOW_119); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); + + } + // InternalScope.g:10379:3: ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? + int alt176=3; + int LA176_0 = input.LA(1); + + if ( (LA176_0==110) ) { + alt176=1; + } + else if ( (LA176_0==112) ) { + alt176=2; + } + switch (alt176) { + case 1 : + // InternalScope.g:10380:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + { + // InternalScope.g:10380:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) + // InternalScope.g:10381:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + { + // InternalScope.g:10381:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) + // InternalScope.g:10382:6: (lv_constraints_2_0= ruleJvmUpperBound ) + { + // InternalScope.g:10382:6: (lv_constraints_2_0= ruleJvmUpperBound ) + // InternalScope.g:10383:7: lv_constraints_2_0= ruleJvmUpperBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); + + } + pushFollow(FOLLOW_120); + lv_constraints_2_0=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_2_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10400:5: ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* + loop174: + do { + int alt174=2; + int LA174_0 = input.LA(1); + + if ( (LA174_0==120) ) { + alt174=1; + } + + + switch (alt174) { + case 1 : + // InternalScope.g:10401:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + { + // InternalScope.g:10401:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded ) + // InternalScope.g:10402:7: lv_constraints_3_0= ruleJvmUpperBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); + + } + pushFollow(FOLLOW_120); + lv_constraints_3_0=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_3_0, + "org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop174; + } + } while (true); + + + } + + + } + break; + case 2 : + // InternalScope.g:10421:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + { + // InternalScope.g:10421:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) + // InternalScope.g:10422:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + { + // InternalScope.g:10422:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) + // InternalScope.g:10423:6: (lv_constraints_4_0= ruleJvmLowerBound ) + { + // InternalScope.g:10423:6: (lv_constraints_4_0= ruleJvmLowerBound ) + // InternalScope.g:10424:7: lv_constraints_4_0= ruleJvmLowerBound + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); + + } + pushFollow(FOLLOW_120); + lv_constraints_4_0=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_4_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBound"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10441:5: ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* + loop175: + do { + int alt175=2; + int LA175_0 = input.LA(1); + + if ( (LA175_0==120) ) { + alt175=1; + } + + + switch (alt175) { + case 1 : + // InternalScope.g:10442:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + { + // InternalScope.g:10442:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded ) + // InternalScope.g:10443:7: lv_constraints_5_0= ruleJvmLowerBoundAnded + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); + + } + pushFollow(FOLLOW_120); + lv_constraints_5_0=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule()); + } + add( + current, + "constraints", + lv_constraints_5_0, + "org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + break; + + default : + break loop175; + } + } while (true); + + + } + + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmWildcardTypeReference" + + + // $ANTLR start "entryRuleJvmUpperBound" + // InternalScope.g:10466:1: entryRuleJvmUpperBound returns [EObject current=null] : iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ; + public final EObject entryRuleJvmUpperBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBound = null; + + + try { + // InternalScope.g:10466:54: (iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ) + // InternalScope.g:10467:2: iv_ruleJvmUpperBound= ruleJvmUpperBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBound=ruleJvmUpperBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBound" + + + // $ANTLR start "ruleJvmUpperBound" + // InternalScope.g:10473:1: ruleJvmUpperBound returns [EObject current=null] : (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10479:2: ( (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalScope.g:10480:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalScope.g:10480:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalScope.g:10481:3: otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,110,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); + + } + // InternalScope.g:10485:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalScope.g:10486:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalScope.g:10486:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalScope.g:10487:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBound" + + + // $ANTLR start "entryRuleJvmUpperBoundAnded" + // InternalScope.g:10508:1: entryRuleJvmUpperBoundAnded returns [EObject current=null] : iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ; + public final EObject entryRuleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmUpperBoundAnded = null; + + + try { + // InternalScope.g:10508:59: (iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ) + // InternalScope.g:10509:2: iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmUpperBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmUpperBoundAnded" + + + // $ANTLR start "ruleJvmUpperBoundAnded" + // InternalScope.g:10515:1: ruleJvmUpperBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmUpperBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10521:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalScope.g:10522:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalScope.g:10522:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalScope.g:10523:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,120,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalScope.g:10527:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalScope.g:10528:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalScope.g:10528:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalScope.g:10529:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmUpperBoundAnded" + + + // $ANTLR start "entryRuleJvmLowerBound" + // InternalScope.g:10550:1: entryRuleJvmLowerBound returns [EObject current=null] : iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ; + public final EObject entryRuleJvmLowerBound() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBound = null; + + + try { + // InternalScope.g:10550:54: (iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ) + // InternalScope.g:10551:2: iv_ruleJvmLowerBound= ruleJvmLowerBound EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBound=ruleJvmLowerBound(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBound; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBound" + + + // $ANTLR start "ruleJvmLowerBound" + // InternalScope.g:10557:1: ruleJvmLowerBound returns [EObject current=null] : (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBound() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10563:2: ( (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalScope.g:10564:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalScope.g:10564:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalScope.g:10565:3: otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,112,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); + + } + // InternalScope.g:10569:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalScope.g:10570:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalScope.g:10570:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalScope.g:10571:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBound" + + + // $ANTLR start "entryRuleJvmLowerBoundAnded" + // InternalScope.g:10592:1: entryRuleJvmLowerBoundAnded returns [EObject current=null] : iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ; + public final EObject entryRuleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + EObject iv_ruleJvmLowerBoundAnded = null; + + + try { + // InternalScope.g:10592:59: (iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ) + // InternalScope.g:10593:2: iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); + } + pushFollow(FOLLOW_1); + iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleJvmLowerBoundAnded; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleJvmLowerBoundAnded" + + + // $ANTLR start "ruleJvmLowerBoundAnded" + // InternalScope.g:10599:1: ruleJvmLowerBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ; + public final EObject ruleJvmLowerBoundAnded() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + EObject lv_typeReference_1_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10605:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ) + // InternalScope.g:10606:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + { + // InternalScope.g:10606:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) + // InternalScope.g:10607:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + { + otherlv_0=(Token)match(input,120,FOLLOW_72); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); + + } + // InternalScope.g:10611:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) + // InternalScope.g:10612:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + { + // InternalScope.g:10612:4: (lv_typeReference_1_0= ruleJvmTypeReference ) + // InternalScope.g:10613:5: lv_typeReference_1_0= ruleJvmTypeReference + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); + + } + pushFollow(FOLLOW_2); + lv_typeReference_1_0=ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule()); + } + set( + current, + "typeReference", + lv_typeReference_1_0, + "org.eclipse.xtext.xbase.Xtype.JvmTypeReference"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleJvmLowerBoundAnded" + + + // $ANTLR start "entryRuleQualifiedNameWithWildcard" + // InternalScope.g:10634:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ; + public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null; + + + try { + // InternalScope.g:10634:65: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ) + // InternalScope.g:10635:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameWithWildcard.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameWithWildcard" + + + // $ANTLR start "ruleQualifiedNameWithWildcard" + // InternalScope.g:10641:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ; + public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_QualifiedName_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10647:2: ( (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ) + // InternalScope.g:10648:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + { + // InternalScope.g:10648:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) + // InternalScope.g:10649:3: this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); + + } + pushFollow(FOLLOW_121); + this_QualifiedName_0=ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_QualifiedName_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,47,FOLLOW_122); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); + + } + kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); + + } + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameWithWildcard" + + + // $ANTLR start "entryRuleValidID" + // InternalScope.g:10673:1: entryRuleValidID returns [String current=null] : iv_ruleValidID= ruleValidID EOF ; + public final String entryRuleValidID() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleValidID = null; + + + try { + // InternalScope.g:10673:47: (iv_ruleValidID= ruleValidID EOF ) + // InternalScope.g:10674:2: iv_ruleValidID= ruleValidID EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getValidIDRule()); + } + pushFollow(FOLLOW_1); + iv_ruleValidID=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleValidID.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleValidID" + + + // $ANTLR start "ruleValidID" + // InternalScope.g:10680:1: ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ; + public final AntlrDatatypeRuleToken ruleValidID() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token this_ID_0=null; + + + enterRule(); + + try { + // InternalScope.g:10686:2: (this_ID_0= RULE_ID ) + // InternalScope.g:10687:2: this_ID_0= RULE_ID + { + this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ID_0); + + } + if ( state.backtracking==0 ) { + + newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); + + } + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleValidID" + + + // $ANTLR start "entryRuleXImportDeclaration" + // InternalScope.g:10697:1: entryRuleXImportDeclaration returns [EObject current=null] : iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ; + public final EObject entryRuleXImportDeclaration() throws RecognitionException { + EObject current = null; + + EObject iv_ruleXImportDeclaration = null; + + + try { + // InternalScope.g:10697:59: (iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ) + // InternalScope.g:10698:2: iv_ruleXImportDeclaration= ruleXImportDeclaration EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getXImportDeclarationRule()); + } + pushFollow(FOLLOW_1); + iv_ruleXImportDeclaration=ruleXImportDeclaration(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleXImportDeclaration; + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleXImportDeclaration" + + + // $ANTLR start "ruleXImportDeclaration" + // InternalScope.g:10704:1: ruleXImportDeclaration returns [EObject current=null] : (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ; + public final EObject ruleXImportDeclaration() throws RecognitionException { + EObject current = null; + + Token otherlv_0=null; + Token lv_static_1_0=null; + Token lv_extension_2_0=null; + Token lv_wildcard_4_0=null; + Token otherlv_8=null; + AntlrDatatypeRuleToken lv_memberName_5_0 = null; + + AntlrDatatypeRuleToken lv_importedNamespace_7_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10710:2: ( (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) ) + // InternalScope.g:10711:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + { + // InternalScope.g:10711:2: (otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? ) + // InternalScope.g:10712:3: otherlv_0= 'import' ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) (otherlv_8= ';' )? + { + otherlv_0=(Token)match(input,16,FOLLOW_123); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_0, grammarAccess.getXImportDeclarationAccess().getImportKeyword_0()); + + } + // InternalScope.g:10716:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) ) + int alt179=3; + alt179 = dfa179.predict(input); + switch (alt179) { + case 1 : + // InternalScope.g:10717:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + { + // InternalScope.g:10717:4: ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) + // InternalScope.g:10718:5: ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + { + // InternalScope.g:10718:5: ( (lv_static_1_0= 'static' ) ) + // InternalScope.g:10719:6: (lv_static_1_0= 'static' ) + { + // InternalScope.g:10719:6: (lv_static_1_0= 'static' ) + // InternalScope.g:10720:7: lv_static_1_0= 'static' + { + lv_static_1_0=(Token)match(input,111,FOLLOW_124); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_static_1_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_1_0_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "static", lv_static_1_0 != null, "static"); + + } + + } + + + } + + // InternalScope.g:10732:5: ( (lv_extension_2_0= 'extension' ) )? + int alt177=2; + int LA177_0 = input.LA(1); + + if ( (LA177_0==18) ) { + alt177=1; + } + switch (alt177) { + case 1 : + // InternalScope.g:10733:6: (lv_extension_2_0= 'extension' ) + { + // InternalScope.g:10733:6: (lv_extension_2_0= 'extension' ) + // InternalScope.g:10734:7: lv_extension_2_0= 'extension' + { + lv_extension_2_0=(Token)match(input,18,FOLLOW_124); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_extension_2_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_1_0_1_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "extension", lv_extension_2_0 != null, "extension"); + + } + + } + + + } + break; + + } + + // InternalScope.g:10746:5: ( ( ruleQualifiedNameInStaticImport ) ) + // InternalScope.g:10747:6: ( ruleQualifiedNameInStaticImport ) + { + // InternalScope.g:10747:6: ( ruleQualifiedNameInStaticImport ) + // InternalScope.g:10748:7: ruleQualifiedNameInStaticImport + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_0_2_0()); + + } + pushFollow(FOLLOW_24); + ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + // InternalScope.g:10762:5: ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) + int alt178=2; + int LA178_0 = input.LA(1); + + if ( (LA178_0==32) ) { + alt178=1; + } + else if ( (LA178_0==RULE_ID) ) { + alt178=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 178, 0, input); + + throw nvae; + } + switch (alt178) { + case 1 : + // InternalScope.g:10763:6: ( (lv_wildcard_4_0= '*' ) ) + { + // InternalScope.g:10763:6: ( (lv_wildcard_4_0= '*' ) ) + // InternalScope.g:10764:7: (lv_wildcard_4_0= '*' ) + { + // InternalScope.g:10764:7: (lv_wildcard_4_0= '*' ) + // InternalScope.g:10765:8: lv_wildcard_4_0= '*' + { + lv_wildcard_4_0=(Token)match(input,32,FOLLOW_125); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(lv_wildcard_4_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_1_0_3_0_0()); + + } + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + setWithLastConsumed(current, "wildcard", lv_wildcard_4_0 != null, "*"); + + } + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:10778:6: ( (lv_memberName_5_0= ruleValidID ) ) + { + // InternalScope.g:10778:6: ( (lv_memberName_5_0= ruleValidID ) ) + // InternalScope.g:10779:7: (lv_memberName_5_0= ruleValidID ) + { + // InternalScope.g:10779:7: (lv_memberName_5_0= ruleValidID ) + // InternalScope.g:10780:8: lv_memberName_5_0= ruleValidID + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_1_0_3_1_0()); + + } + pushFollow(FOLLOW_125); + lv_memberName_5_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "memberName", + lv_memberName_5_0, + "org.eclipse.xtext.xbase.Xtype.ValidID"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + + } + + + } + break; + case 2 : + // InternalScope.g:10800:4: ( ( ruleQualifiedName ) ) + { + // InternalScope.g:10800:4: ( ( ruleQualifiedName ) ) + // InternalScope.g:10801:5: ( ruleQualifiedName ) + { + // InternalScope.g:10801:5: ( ruleQualifiedName ) + // InternalScope.g:10802:6: ruleQualifiedName + { + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElement(grammarAccess.getXImportDeclarationRule()); + } + + } + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_1_1_0()); + + } + pushFollow(FOLLOW_125); + ruleQualifiedName(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + case 3 : + // InternalScope.g:10817:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + { + // InternalScope.g:10817:4: ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) + // InternalScope.g:10818:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + { + // InternalScope.g:10818:5: (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) + // InternalScope.g:10819:6: lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_1_2_0()); + + } + pushFollow(FOLLOW_125); + lv_importedNamespace_7_0=ruleQualifiedNameWithWildcard(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + if (current==null) { + current = createModelElementForParent(grammarAccess.getXImportDeclarationRule()); + } + set( + current, + "importedNamespace", + lv_importedNamespace_7_0, + "org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard"); + afterParserOrEnumRuleCall(); + + } + + } + + + } + + + } + break; + + } + + // InternalScope.g:10837:3: (otherlv_8= ';' )? + int alt180=2; + int LA180_0 = input.LA(1); + + if ( (LA180_0==25) ) { + alt180=1; + } + switch (alt180) { + case 1 : + // InternalScope.g:10838:4: otherlv_8= ';' + { + otherlv_8=(Token)match(input,25,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + newLeafNode(otherlv_8, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + + } + + } + break; + + } + + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleXImportDeclaration" + + + // $ANTLR start "entryRuleQualifiedNameInStaticImport" + // InternalScope.g:10847:1: entryRuleQualifiedNameInStaticImport returns [String current=null] : iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ; + public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException { + String current = null; + + AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null; + + + try { + // InternalScope.g:10847:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ) + // InternalScope.g:10848:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF + { + if ( state.backtracking==0 ) { + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); + } + pushFollow(FOLLOW_1); + iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + current =iv_ruleQualifiedNameInStaticImport.getText(); + } + match(input,EOF,FOLLOW_2); if (state.failed) return current; + + } + + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "entryRuleQualifiedNameInStaticImport" + + + // $ANTLR start "ruleQualifiedNameInStaticImport" + // InternalScope.g:10854:1: ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID kw= '.' )+ ; + public final AntlrDatatypeRuleToken ruleQualifiedNameInStaticImport() throws RecognitionException { + AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken(); + + Token kw=null; + AntlrDatatypeRuleToken this_ValidID_0 = null; + + + + enterRule(); + + try { + // InternalScope.g:10860:2: ( (this_ValidID_0= ruleValidID kw= '.' )+ ) + // InternalScope.g:10861:2: (this_ValidID_0= ruleValidID kw= '.' )+ + { + // InternalScope.g:10861:2: (this_ValidID_0= ruleValidID kw= '.' )+ + int cnt181=0; + loop181: + do { + int alt181=2; + int LA181_0 = input.LA(1); + + if ( (LA181_0==RULE_ID) ) { + int LA181_2 = input.LA(2); + + if ( (LA181_2==47) ) { + alt181=1; + } + + + } + + + switch (alt181) { + case 1 : + // InternalScope.g:10862:3: this_ValidID_0= ruleValidID kw= '.' + { + if ( state.backtracking==0 ) { + + newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); + + } + pushFollow(FOLLOW_121); + this_ValidID_0=ruleValidID(); + + state._fsp--; + if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(this_ValidID_0); + + } + if ( state.backtracking==0 ) { + + afterParserOrEnumRuleCall(); + + } + kw=(Token)match(input,47,FOLLOW_126); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current.merge(kw); + newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); + + } + + } + break; + + default : + if ( cnt181 >= 1 ) break loop181; + if (state.backtracking>0) {state.failed=true; return current;} + EarlyExitException eee = + new EarlyExitException(181, input); + throw eee; + } + cnt181++; + } while (true); + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleQualifiedNameInStaticImport" + + + // $ANTLR start "ruleCasing" + // InternalScope.g:10881:1: ruleCasing returns [Enumerator current=null] : ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) ; + public final Enumerator ruleCasing() throws RecognitionException { + Enumerator current = null; + + Token enumLiteral_0=null; + Token enumLiteral_1=null; + + + enterRule(); + + try { + // InternalScope.g:10887:2: ( ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) ) + // InternalScope.g:10888:2: ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) + { + // InternalScope.g:10888:2: ( (enumLiteral_0= 'sensitive' ) | (enumLiteral_1= 'insensitive' ) ) + int alt182=2; + int LA182_0 = input.LA(1); + + if ( (LA182_0==121) ) { + alt182=1; + } + else if ( (LA182_0==122) ) { + alt182=2; + } + else { + if (state.backtracking>0) {state.failed=true; return current;} + NoViableAltException nvae = + new NoViableAltException("", 182, 0, input); + + throw nvae; + } + switch (alt182) { + case 1 : + // InternalScope.g:10889:3: (enumLiteral_0= 'sensitive' ) + { + // InternalScope.g:10889:3: (enumLiteral_0= 'sensitive' ) + // InternalScope.g:10890:4: enumLiteral_0= 'sensitive' + { + enumLiteral_0=(Token)match(input,121,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_0, grammarAccess.getCasingAccess().getSENSITIVEEnumLiteralDeclaration_0()); + + } + + } + + + } + break; + case 2 : + // InternalScope.g:10897:3: (enumLiteral_1= 'insensitive' ) + { + // InternalScope.g:10897:3: (enumLiteral_1= 'insensitive' ) + // InternalScope.g:10898:4: enumLiteral_1= 'insensitive' + { + enumLiteral_1=(Token)match(input,122,FOLLOW_2); if (state.failed) return current; + if ( state.backtracking==0 ) { + + current = grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1().getEnumLiteral().getInstance(); + newLeafNode(enumLiteral_1, grammarAccess.getCasingAccess().getINSENSITIVEEnumLiteralDeclaration_1()); + + } + + } + + + } + break; + + } + + + } + + if ( state.backtracking==0 ) { + + leaveRule(); + + } + } + + catch (RecognitionException re) { + recover(input,re); + appendSkippedTokens(); + } + finally { + } + return current; + } + // $ANTLR end "ruleCasing" + + // $ANTLR start synpred1_InternalScope + public final void synpred1_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:1645:4: ( '(' ) + // InternalScope.g:1645:5: '(' + { + match(input,27,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred1_InternalScope + + // $ANTLR start synpred2_InternalScope + public final void synpred2_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:1911:4: ( ruleCastedExpression ) + // InternalScope.g:1911:5: ruleCastedExpression + { + pushFollow(FOLLOW_2); + ruleCastedExpression(); + + state._fsp--; + if (state.failed) return ; + + } + } + // $ANTLR end synpred2_InternalScope + + // $ANTLR start synpred3_InternalScope + public final void synpred3_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:2335:4: ( 'else' ) + // InternalScope.g:2335:5: 'else' + { + match(input,54,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred3_InternalScope + + // $ANTLR start synpred4_InternalScope + public final void synpred4_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4702:6: ( ( () ( ( ruleOpMultiAssign ) ) ) ) + // InternalScope.g:4702:7: ( () ( ( ruleOpMultiAssign ) ) ) + { + // InternalScope.g:4702:7: ( () ( ( ruleOpMultiAssign ) ) ) + // InternalScope.g:4703:7: () ( ( ruleOpMultiAssign ) ) + { + // InternalScope.g:4703:7: () + // InternalScope.g:4704:7: + { + } + + // InternalScope.g:4705:7: ( ( ruleOpMultiAssign ) ) + // InternalScope.g:4706:8: ( ruleOpMultiAssign ) + { + // InternalScope.g:4706:8: ( ruleOpMultiAssign ) + // InternalScope.g:4707:9: ruleOpMultiAssign + { + pushFollow(FOLLOW_2); + ruleOpMultiAssign(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred4_InternalScope + + // $ANTLR start synpred5_InternalScope + public final void synpred5_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:4896:5: ( ( () ( ( ruleOpOr ) ) ) ) + // InternalScope.g:4896:6: ( () ( ( ruleOpOr ) ) ) + { + // InternalScope.g:4896:6: ( () ( ( ruleOpOr ) ) ) + // InternalScope.g:4897:6: () ( ( ruleOpOr ) ) + { + // InternalScope.g:4897:6: () + // InternalScope.g:4898:6: + { + } + + // InternalScope.g:4899:6: ( ( ruleOpOr ) ) + // InternalScope.g:4900:7: ( ruleOpOr ) + { + // InternalScope.g:4900:7: ( ruleOpOr ) + // InternalScope.g:4901:8: ruleOpOr + { + pushFollow(FOLLOW_2); + ruleOpOr(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred5_InternalScope + + // $ANTLR start synpred6_InternalScope + public final void synpred6_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5003:5: ( ( () ( ( ruleOpAnd ) ) ) ) + // InternalScope.g:5003:6: ( () ( ( ruleOpAnd ) ) ) + { + // InternalScope.g:5003:6: ( () ( ( ruleOpAnd ) ) ) + // InternalScope.g:5004:6: () ( ( ruleOpAnd ) ) + { + // InternalScope.g:5004:6: () + // InternalScope.g:5005:6: + { + } + + // InternalScope.g:5006:6: ( ( ruleOpAnd ) ) + // InternalScope.g:5007:7: ( ruleOpAnd ) + { + // InternalScope.g:5007:7: ( ruleOpAnd ) + // InternalScope.g:5008:8: ruleOpAnd + { + pushFollow(FOLLOW_2); + ruleOpAnd(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred6_InternalScope + + // $ANTLR start synpred7_InternalScope + public final void synpred7_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5110:5: ( ( () ( ( ruleOpEquality ) ) ) ) + // InternalScope.g:5110:6: ( () ( ( ruleOpEquality ) ) ) + { + // InternalScope.g:5110:6: ( () ( ( ruleOpEquality ) ) ) + // InternalScope.g:5111:6: () ( ( ruleOpEquality ) ) + { + // InternalScope.g:5111:6: () + // InternalScope.g:5112:6: + { + } + + // InternalScope.g:5113:6: ( ( ruleOpEquality ) ) + // InternalScope.g:5114:7: ( ruleOpEquality ) + { + // InternalScope.g:5114:7: ( ruleOpEquality ) + // InternalScope.g:5115:8: ruleOpEquality + { + pushFollow(FOLLOW_2); + ruleOpEquality(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred7_InternalScope + + // $ANTLR start synpred8_InternalScope + public final void synpred8_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5238:6: ( ( () 'instanceof' ) ) + // InternalScope.g:5238:7: ( () 'instanceof' ) + { + // InternalScope.g:5238:7: ( () 'instanceof' ) + // InternalScope.g:5239:7: () 'instanceof' + { + // InternalScope.g:5239:7: () + // InternalScope.g:5240:7: + { + } + + match(input,94,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred8_InternalScope + + // $ANTLR start synpred9_InternalScope + public final void synpred9_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5281:6: ( ( () ( ( ruleOpCompare ) ) ) ) + // InternalScope.g:5281:7: ( () ( ( ruleOpCompare ) ) ) + { + // InternalScope.g:5281:7: ( () ( ( ruleOpCompare ) ) ) + // InternalScope.g:5282:7: () ( ( ruleOpCompare ) ) + { + // InternalScope.g:5282:7: () + // InternalScope.g:5283:7: + { + } + + // InternalScope.g:5284:7: ( ( ruleOpCompare ) ) + // InternalScope.g:5285:8: ( ruleOpCompare ) + { + // InternalScope.g:5285:8: ( ruleOpCompare ) + // InternalScope.g:5286:9: ruleOpCompare + { + pushFollow(FOLLOW_2); + ruleOpCompare(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred9_InternalScope + + // $ANTLR start synpred10_InternalScope + public final void synpred10_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5416:5: ( ( () ( ( ruleOpOther ) ) ) ) + // InternalScope.g:5416:6: ( () ( ( ruleOpOther ) ) ) + { + // InternalScope.g:5416:6: ( () ( ( ruleOpOther ) ) ) + // InternalScope.g:5417:6: () ( ( ruleOpOther ) ) + { + // InternalScope.g:5417:6: () + // InternalScope.g:5418:6: + { + } + + // InternalScope.g:5419:6: ( ( ruleOpOther ) ) + // InternalScope.g:5420:7: ( ruleOpOther ) + { + // InternalScope.g:5420:7: ( ruleOpOther ) + // InternalScope.g:5421:8: ruleOpOther + { + pushFollow(FOLLOW_2); + ruleOpOther(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred10_InternalScope + + // $ANTLR start synpred11_InternalScope + public final void synpred11_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5536:6: ( ( '>' '>' ) ) + // InternalScope.g:5536:7: ( '>' '>' ) + { + // InternalScope.g:5536:7: ( '>' '>' ) + // InternalScope.g:5537:7: '>' '>' + { + match(input,64,FOLLOW_75); if (state.failed) return ; + match(input,64,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred11_InternalScope + + // $ANTLR start synpred12_InternalScope + public final void synpred12_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5571:6: ( ( '<' '<' ) ) + // InternalScope.g:5571:7: ( '<' '<' ) + { + // InternalScope.g:5571:7: ( '<' '<' ) + // InternalScope.g:5572:7: '<' '<' + { + match(input,65,FOLLOW_67); if (state.failed) return ; + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred12_InternalScope + + // $ANTLR start synpred13_InternalScope + public final void synpred13_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5644:5: ( ( () ( ( ruleOpAdd ) ) ) ) + // InternalScope.g:5644:6: ( () ( ( ruleOpAdd ) ) ) + { + // InternalScope.g:5644:6: ( () ( ( ruleOpAdd ) ) ) + // InternalScope.g:5645:6: () ( ( ruleOpAdd ) ) + { + // InternalScope.g:5645:6: () + // InternalScope.g:5646:6: + { + } + + // InternalScope.g:5647:6: ( ( ruleOpAdd ) ) + // InternalScope.g:5648:7: ( ruleOpAdd ) + { + // InternalScope.g:5648:7: ( ruleOpAdd ) + // InternalScope.g:5649:8: ruleOpAdd + { + pushFollow(FOLLOW_2); + ruleOpAdd(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred13_InternalScope + + // $ANTLR start synpred14_InternalScope + public final void synpred14_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5759:5: ( ( () ( ( ruleOpMulti ) ) ) ) + // InternalScope.g:5759:6: ( () ( ( ruleOpMulti ) ) ) + { + // InternalScope.g:5759:6: ( () ( ( ruleOpMulti ) ) ) + // InternalScope.g:5760:6: () ( ( ruleOpMulti ) ) + { + // InternalScope.g:5760:6: () + // InternalScope.g:5761:6: + { + } + + // InternalScope.g:5762:6: ( ( ruleOpMulti ) ) + // InternalScope.g:5763:7: ( ruleOpMulti ) + { + // InternalScope.g:5763:7: ( ruleOpMulti ) + // InternalScope.g:5764:8: ruleOpMulti + { + pushFollow(FOLLOW_2); + ruleOpMulti(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred14_InternalScope + + // $ANTLR start synpred15_InternalScope + public final void synpred15_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:5994:5: ( ( () 'as' ) ) + // InternalScope.g:5994:6: ( () 'as' ) + { + // InternalScope.g:5994:6: ( () 'as' ) + // InternalScope.g:5995:6: () 'as' + { + // InternalScope.g:5995:6: () + // InternalScope.g:5996:6: + { + } + + match(input,17,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred15_InternalScope + + // $ANTLR start synpred16_InternalScope + public final void synpred16_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6062:4: ( ( () ( ( ruleOpPostfix ) ) ) ) + // InternalScope.g:6062:5: ( () ( ( ruleOpPostfix ) ) ) + { + // InternalScope.g:6062:5: ( () ( ( ruleOpPostfix ) ) ) + // InternalScope.g:6063:5: () ( ( ruleOpPostfix ) ) + { + // InternalScope.g:6063:5: () + // InternalScope.g:6064:5: + { + } + + // InternalScope.g:6065:5: ( ( ruleOpPostfix ) ) + // InternalScope.g:6066:6: ( ruleOpPostfix ) + { + // InternalScope.g:6066:6: ( ruleOpPostfix ) + // InternalScope.g:6067:7: ruleOpPostfix + { + pushFollow(FOLLOW_2); + ruleOpPostfix(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred16_InternalScope + + // $ANTLR start synpred17_InternalScope + public final void synpred17_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6158:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) + // InternalScope.g:6158:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + { + // InternalScope.g:6158:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) + // InternalScope.g:6159:7: () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign + { + // InternalScope.g:6159:7: () + // InternalScope.g:6160:7: + { + } + + // InternalScope.g:6161:7: ( '.' | ( ( '::' ) ) ) + int alt183=2; + int LA183_0 = input.LA(1); + + if ( (LA183_0==47) ) { + alt183=1; + } + else if ( (LA183_0==46) ) { + alt183=2; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 183, 0, input); + + throw nvae; + } + switch (alt183) { + case 1 : + // InternalScope.g:6162:8: '.' + { + match(input,47,FOLLOW_80); if (state.failed) return ; + + } + break; + case 2 : + // InternalScope.g:6164:8: ( ( '::' ) ) + { + // InternalScope.g:6164:8: ( ( '::' ) ) + // InternalScope.g:6165:9: ( '::' ) + { + // InternalScope.g:6165:9: ( '::' ) + // InternalScope.g:6166:10: '::' + { + match(input,46,FOLLOW_80); if (state.failed) return ; + + } + + + } + + + } + break; + + } + + // InternalScope.g:6170:7: ( ( ruleFeatureCallID ) ) + // InternalScope.g:6171:8: ( ruleFeatureCallID ) + { + // InternalScope.g:6171:8: ( ruleFeatureCallID ) + // InternalScope.g:6172:9: ruleFeatureCallID + { + pushFollow(FOLLOW_16); + ruleFeatureCallID(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + pushFollow(FOLLOW_2); + ruleOpSingleAssign(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred17_InternalScope + + // $ANTLR start synpred18_InternalScope + public final void synpred18_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6255:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) ) + // InternalScope.g:6255:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) + { + // InternalScope.g:6255:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) + // InternalScope.g:6256:7: () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) + { + // InternalScope.g:6256:7: () + // InternalScope.g:6257:7: + { + } + + // InternalScope.g:6258:7: ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) + int alt184=3; + switch ( input.LA(1) ) { + case 47: + { + alt184=1; + } + break; + case 104: + { + alt184=2; + } + break; + case 46: + { + alt184=3; + } + break; + default: + if (state.backtracking>0) {state.failed=true; return ;} + NoViableAltException nvae = + new NoViableAltException("", 184, 0, input); + + throw nvae; + } + + switch (alt184) { + case 1 : + // InternalScope.g:6259:8: '.' + { + match(input,47,FOLLOW_2); if (state.failed) return ; + + } + break; + case 2 : + // InternalScope.g:6261:8: ( ( '?.' ) ) + { + // InternalScope.g:6261:8: ( ( '?.' ) ) + // InternalScope.g:6262:9: ( '?.' ) + { + // InternalScope.g:6262:9: ( '?.' ) + // InternalScope.g:6263:10: '?.' + { + match(input,104,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + break; + case 3 : + // InternalScope.g:6267:8: ( ( '::' ) ) + { + // InternalScope.g:6267:8: ( ( '::' ) ) + // InternalScope.g:6268:9: ( '::' ) + { + // InternalScope.g:6268:9: ( '::' ) + // InternalScope.g:6269:10: '::' + { + match(input,46,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + break; + + } + + + } + + + } + } + // $ANTLR end synpred18_InternalScope + + // $ANTLR start synpred19_InternalScope + public final void synpred19_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6393:7: ( ( '(' ) ) + // InternalScope.g:6393:8: ( '(' ) + { + // InternalScope.g:6393:8: ( '(' ) + // InternalScope.g:6394:8: '(' + { + match(input,27,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred19_InternalScope + + // $ANTLR start synpred20_InternalScope + public final void synpred20_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6412:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalScope.g:6412:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalScope.g:6412:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalScope.g:6413:9: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalScope.g:6413:9: () + // InternalScope.g:6414:9: + { + } + + // InternalScope.g:6415:9: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt186=2; + int LA186_0 = input.LA(1); + + if ( (LA186_0==RULE_ID||LA186_0==27||LA186_0==97) ) { + alt186=1; + } + switch (alt186) { + case 1 : + // InternalScope.g:6416:10: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalScope.g:6416:10: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:6417:11: ( ruleJvmFormalParameter ) + { + // InternalScope.g:6417:11: ( ruleJvmFormalParameter ) + // InternalScope.g:6418:12: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalScope.g:6421:10: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop185: + do { + int alt185=2; + int LA185_0 = input.LA(1); + + if ( (LA185_0==37) ) { + alt185=1; + } + + + switch (alt185) { + case 1 : + // InternalScope.g:6422:11: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,37,FOLLOW_72); if (state.failed) return ; + // InternalScope.g:6423:11: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:6424:12: ( ruleJvmFormalParameter ) + { + // InternalScope.g:6424:12: ( ruleJvmFormalParameter ) + // InternalScope.g:6425:13: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop185; + } + } while (true); + + + } + break; + + } + + // InternalScope.g:6430:9: ( ( '|' ) ) + // InternalScope.g:6431:10: ( '|' ) + { + // InternalScope.g:6431:10: ( '|' ) + // InternalScope.g:6432:11: '|' + { + match(input,44,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred20_InternalScope + + // $ANTLR start synpred21_InternalScope + public final void synpred21_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6509:6: ( ( () '[' ) ) + // InternalScope.g:6509:7: ( () '[' ) + { + // InternalScope.g:6509:7: ( () '[' ) + // InternalScope.g:6510:7: () '[' + { + // InternalScope.g:6510:7: () + // InternalScope.g:6511:7: + { + } + + match(input,33,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred21_InternalScope + + // $ANTLR start synpred22_InternalScope + public final void synpred22_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6582:4: ( ( () 'synchronized' '(' ) ) + // InternalScope.g:6582:5: ( () 'synchronized' '(' ) + { + // InternalScope.g:6582:5: ( () 'synchronized' '(' ) + // InternalScope.g:6583:5: () 'synchronized' '(' + { + // InternalScope.g:6583:5: () + // InternalScope.g:6584:5: + { + } + + match(input,118,FOLLOW_29); if (state.failed) return ; + match(input,27,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred22_InternalScope + + // $ANTLR start synpred23_InternalScope + public final void synpred23_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6627:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalScope.g:6627:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalScope.g:6627:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalScope.g:6628:5: () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' + { + // InternalScope.g:6628:5: () + // InternalScope.g:6629:5: + { + } + + match(input,105,FOLLOW_29); if (state.failed) return ; + match(input,27,FOLLOW_72); if (state.failed) return ; + // InternalScope.g:6632:5: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:6633:6: ( ruleJvmFormalParameter ) + { + // InternalScope.g:6633:6: ( ruleJvmFormalParameter ) + // InternalScope.g:6634:7: ruleJvmFormalParameter + { + pushFollow(FOLLOW_43); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,49,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred23_InternalScope + + // $ANTLR start synpred24_InternalScope + public final void synpred24_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:6741:4: ( ( () '[' ) ) + // InternalScope.g:6741:5: ( () '[' ) + { + // InternalScope.g:6741:5: ( () '[' ) + // InternalScope.g:6742:5: () '[' + { + // InternalScope.g:6742:5: () + // InternalScope.g:6743:5: + { + } + + match(input,33,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred24_InternalScope + + // $ANTLR start synpred26_InternalScope + public final void synpred26_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:7046:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalScope.g:7046:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalScope.g:7046:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalScope.g:7047:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalScope.g:7047:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt188=2; + int LA188_0 = input.LA(1); + + if ( (LA188_0==RULE_ID||LA188_0==27||LA188_0==97) ) { + alt188=1; + } + switch (alt188) { + case 1 : + // InternalScope.g:7048:6: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalScope.g:7048:6: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:7049:7: ( ruleJvmFormalParameter ) + { + // InternalScope.g:7049:7: ( ruleJvmFormalParameter ) + // InternalScope.g:7050:8: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalScope.g:7053:6: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop187: + do { + int alt187=2; + int LA187_0 = input.LA(1); + + if ( (LA187_0==37) ) { + alt187=1; + } + + + switch (alt187) { + case 1 : + // InternalScope.g:7054:7: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,37,FOLLOW_72); if (state.failed) return ; + // InternalScope.g:7055:7: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:7056:8: ( ruleJvmFormalParameter ) + { + // InternalScope.g:7056:8: ( ruleJvmFormalParameter ) + // InternalScope.g:7057:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop187; + } + } while (true); + + + } + break; + + } + + // InternalScope.g:7062:5: ( ( '|' ) ) + // InternalScope.g:7063:6: ( '|' ) + { + // InternalScope.g:7063:6: ( '|' ) + // InternalScope.g:7064:7: '|' + { + match(input,44,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred26_InternalScope + + // $ANTLR start synpred28_InternalScope + public final void synpred28_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:7455:5: ( 'else' ) + // InternalScope.g:7455:6: 'else' + { + match(input,54,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred28_InternalScope + + // $ANTLR start synpred29_InternalScope + public final void synpred29_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:7514:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalScope.g:7514:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalScope.g:7514:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalScope.g:7515:7: '(' ( ( ruleJvmFormalParameter ) ) ':' + { + match(input,27,FOLLOW_72); if (state.failed) return ; + // InternalScope.g:7516:7: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:7517:8: ( ruleJvmFormalParameter ) + { + // InternalScope.g:7517:8: ( ruleJvmFormalParameter ) + // InternalScope.g:7518:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_43); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,49,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred29_InternalScope + + // $ANTLR start synpred30_InternalScope + public final void synpred30_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:7581:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) ) + // InternalScope.g:7581:7: ( ( ( ruleJvmFormalParameter ) ) ':' ) + { + // InternalScope.g:7581:7: ( ( ( ruleJvmFormalParameter ) ) ':' ) + // InternalScope.g:7582:7: ( ( ruleJvmFormalParameter ) ) ':' + { + // InternalScope.g:7582:7: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:7583:8: ( ruleJvmFormalParameter ) + { + // InternalScope.g:7583:8: ( ruleJvmFormalParameter ) + // InternalScope.g:7584:9: ruleJvmFormalParameter + { + pushFollow(FOLLOW_43); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + match(input,49,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred30_InternalScope + + // $ANTLR start synpred32_InternalScope + public final void synpred32_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:8399:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) ) + // InternalScope.g:8399:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) + { + // InternalScope.g:8399:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) + // InternalScope.g:8400:6: ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) + { + // InternalScope.g:8400:6: ( ( ruleJvmTypeReference ) ) + // InternalScope.g:8401:7: ( ruleJvmTypeReference ) + { + // InternalScope.g:8401:7: ( ruleJvmTypeReference ) + // InternalScope.g:8402:8: ruleJvmTypeReference + { + pushFollow(FOLLOW_3); + ruleJvmTypeReference(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalScope.g:8405:6: ( ( ruleValidID ) ) + // InternalScope.g:8406:7: ( ruleValidID ) + { + // InternalScope.g:8406:7: ( ruleValidID ) + // InternalScope.g:8407:8: ruleValidID + { + pushFollow(FOLLOW_2); + ruleValidID(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred32_InternalScope + + // $ANTLR start synpred33_InternalScope + public final void synpred33_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:8711:5: ( ( '(' ) ) + // InternalScope.g:8711:6: ( '(' ) + { + // InternalScope.g:8711:6: ( '(' ) + // InternalScope.g:8712:6: '(' + { + match(input,27,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred33_InternalScope + + // $ANTLR start synpred34_InternalScope + public final void synpred34_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:8730:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalScope.g:8730:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalScope.g:8730:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalScope.g:8731:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalScope.g:8731:7: () + // InternalScope.g:8732:7: + { + } + + // InternalScope.g:8733:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt192=2; + int LA192_0 = input.LA(1); + + if ( (LA192_0==RULE_ID||LA192_0==27||LA192_0==97) ) { + alt192=1; + } + switch (alt192) { + case 1 : + // InternalScope.g:8734:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalScope.g:8734:8: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:8735:9: ( ruleJvmFormalParameter ) + { + // InternalScope.g:8735:9: ( ruleJvmFormalParameter ) + // InternalScope.g:8736:10: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalScope.g:8739:8: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop191: + do { + int alt191=2; + int LA191_0 = input.LA(1); + + if ( (LA191_0==37) ) { + alt191=1; + } + + + switch (alt191) { + case 1 : + // InternalScope.g:8740:9: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,37,FOLLOW_72); if (state.failed) return ; + // InternalScope.g:8741:9: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:8742:10: ( ruleJvmFormalParameter ) + { + // InternalScope.g:8742:10: ( ruleJvmFormalParameter ) + // InternalScope.g:8743:11: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop191; + } + } while (true); + + + } + break; + + } + + // InternalScope.g:8748:7: ( ( '|' ) ) + // InternalScope.g:8749:8: ( '|' ) + { + // InternalScope.g:8749:8: ( '|' ) + // InternalScope.g:8750:9: '|' + { + match(input,44,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred34_InternalScope + + // $ANTLR start synpred35_InternalScope + public final void synpred35_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:8827:4: ( ( () '[' ) ) + // InternalScope.g:8827:5: ( () '[' ) + { + // InternalScope.g:8827:5: ( () '[' ) + // InternalScope.g:8828:5: () '[' + { + // InternalScope.g:8828:5: () + // InternalScope.g:8829:5: + { + } + + match(input,33,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred35_InternalScope + + // $ANTLR start synpred36_InternalScope + public final void synpred36_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:8987:5: ( '<' ) + // InternalScope.g:8987:6: '<' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred36_InternalScope + + // $ANTLR start synpred37_InternalScope + public final void synpred37_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9044:5: ( ( '(' ) ) + // InternalScope.g:9044:6: ( '(' ) + { + // InternalScope.g:9044:6: ( '(' ) + // InternalScope.g:9045:6: '(' + { + match(input,27,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred37_InternalScope + + // $ANTLR start synpred38_InternalScope + public final void synpred38_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9063:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) ) + // InternalScope.g:9063:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + { + // InternalScope.g:9063:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) + // InternalScope.g:9064:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) + { + // InternalScope.g:9064:7: () + // InternalScope.g:9065:7: + { + } + + // InternalScope.g:9066:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? + int alt194=2; + int LA194_0 = input.LA(1); + + if ( (LA194_0==RULE_ID||LA194_0==27||LA194_0==97) ) { + alt194=1; + } + switch (alt194) { + case 1 : + // InternalScope.g:9067:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* + { + // InternalScope.g:9067:8: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:9068:9: ( ruleJvmFormalParameter ) + { + // InternalScope.g:9068:9: ( ruleJvmFormalParameter ) + // InternalScope.g:9069:10: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + // InternalScope.g:9072:8: ( ',' ( ( ruleJvmFormalParameter ) ) )* + loop193: + do { + int alt193=2; + int LA193_0 = input.LA(1); + + if ( (LA193_0==37) ) { + alt193=1; + } + + + switch (alt193) { + case 1 : + // InternalScope.g:9073:9: ',' ( ( ruleJvmFormalParameter ) ) + { + match(input,37,FOLLOW_72); if (state.failed) return ; + // InternalScope.g:9074:9: ( ( ruleJvmFormalParameter ) ) + // InternalScope.g:9075:10: ( ruleJvmFormalParameter ) + { + // InternalScope.g:9075:10: ( ruleJvmFormalParameter ) + // InternalScope.g:9076:11: ruleJvmFormalParameter + { + pushFollow(FOLLOW_91); + ruleJvmFormalParameter(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + + + } + break; + + default : + break loop193; + } + } while (true); + + + } + break; + + } + + // InternalScope.g:9081:7: ( ( '|' ) ) + // InternalScope.g:9082:8: ( '|' ) + { + // InternalScope.g:9082:8: ( '|' ) + // InternalScope.g:9083:9: '|' + { + match(input,44,FOLLOW_2); if (state.failed) return ; + + } + + + } + + + } + + + } + } + // $ANTLR end synpred38_InternalScope + + // $ANTLR start synpred39_InternalScope + public final void synpred39_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9160:4: ( ( () '[' ) ) + // InternalScope.g:9160:5: ( () '[' ) + { + // InternalScope.g:9160:5: ( () '[' ) + // InternalScope.g:9161:5: () '[' + { + // InternalScope.g:9161:5: () + // InternalScope.g:9162:5: + { + } + + match(input,33,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred39_InternalScope + + // $ANTLR start synpred40_InternalScope + public final void synpred40_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9503:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING ) + // InternalScope.g: + { + if ( (input.LA(1)>=RULE_STRING && input.LA(1)<=RULE_INT)||(input.LA(1)>=RULE_ID && input.LA(1)<=RULE_DECIMAL)||input.LA(1)==16||input.LA(1)==18||input.LA(1)==22||input.LA(1)==27||input.LA(1)==29||input.LA(1)==33||input.LA(1)==52||input.LA(1)==55||(input.LA(1)>=65 && input.LA(1)<=67)||input.LA(1)==69||(input.LA(1)>=79 && input.LA(1)<=81)||input.LA(1)==83||(input.LA(1)>=105 && input.LA(1)<=107)||(input.LA(1)>=110 && input.LA(1)<=116)||input.LA(1)==118 ) { + input.consume(); + state.errorRecovery=false;state.failed=false; + } + else { + if (state.backtracking>0) {state.failed=true; return ;} + MismatchedSetException mse = new MismatchedSetException(null,input); + throw mse; + } + + + } + } + // $ANTLR end synpred40_InternalScope + + // $ANTLR start synpred41_InternalScope + public final void synpred41_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9574:6: ( 'catch' ) + // InternalScope.g:9574:7: 'catch' + { + match(input,119,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred41_InternalScope + + // $ANTLR start synpred42_InternalScope + public final void synpred42_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9595:7: ( 'finally' ) + // InternalScope.g:9595:8: 'finally' + { + match(input,117,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred42_InternalScope + + // $ANTLR start synpred45_InternalScope + public final void synpred45_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9839:5: ( '.' ) + // InternalScope.g:9839:6: '.' + { + match(input,47,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred45_InternalScope + + // $ANTLR start synpred46_InternalScope + public final void synpred46_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:9965:5: ( ( () ruleArrayBrackets ) ) + // InternalScope.g:9965:6: ( () ruleArrayBrackets ) + { + // InternalScope.g:9965:6: ( () ruleArrayBrackets ) + // InternalScope.g:9966:6: () ruleArrayBrackets + { + // InternalScope.g:9966:6: () + // InternalScope.g:9967:6: + { + } + + pushFollow(FOLLOW_2); + ruleArrayBrackets(); + + state._fsp--; + if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred46_InternalScope + + // $ANTLR start synpred47_InternalScope + public final void synpred47_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:10162:5: ( '<' ) + // InternalScope.g:10162:6: '<' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred47_InternalScope + + // $ANTLR start synpred48_InternalScope + public final void synpred48_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:10218:6: ( ( () '.' ) ) + // InternalScope.g:10218:7: ( () '.' ) + { + // InternalScope.g:10218:7: ( () '.' ) + // InternalScope.g:10219:7: () '.' + { + // InternalScope.g:10219:7: () + // InternalScope.g:10220:7: + { + } + + match(input,47,FOLLOW_2); if (state.failed) return ; + + } + + + } + } + // $ANTLR end synpred48_InternalScope + + // $ANTLR start synpred49_InternalScope + public final void synpred49_InternalScope_fragment() throws RecognitionException { + // InternalScope.g:10256:7: ( '<' ) + // InternalScope.g:10256:8: '<' + { + match(input,65,FOLLOW_2); if (state.failed) return ; + + } + } + // $ANTLR end synpred49_InternalScope + + // Delegated rules + + public final boolean synpred2_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred2_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred28_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred28_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred49_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred49_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred36_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred36_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred21_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred21_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred15_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred15_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred13_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred13_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred34_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred34_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred9_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred9_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred26_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred26_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred47_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred47_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred7_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred7_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred32_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred32_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred20_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred20_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred39_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred39_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred41_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred41_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred11_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred11_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred5_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred5_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred37_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred37_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred45_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred45_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred16_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred16_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred24_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred24_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred18_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred18_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred3_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred3_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred8_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred8_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred14_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred14_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred22_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred22_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred30_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred30_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred35_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred35_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred1_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred1_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred6_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred6_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred29_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred29_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred33_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred33_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred48_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred48_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred46_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred46_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred12_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred12_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred40_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred40_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred10_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred10_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred19_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred19_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred42_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred42_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred4_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred4_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred17_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred17_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred38_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred38_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + public final boolean synpred23_InternalScope() { + state.backtracking++; + int start = input.mark(); + try { + synpred23_InternalScope_fragment(); // can never throw exception + } catch (RecognitionException re) { + System.err.println("impossible: "+re); + } + boolean success = !state.failed; + input.rewind(start); + state.backtracking--; + state.failed=false; + return success; + } + + + protected DFA11 dfa11 = new DFA11(this); + protected DFA31 dfa31 = new DFA31(this); + protected DFA36 dfa36 = new DFA36(this); + protected DFA72 dfa72 = new DFA72(this); + protected DFA82 dfa82 = new DFA82(this); + protected DFA85 dfa85 = new DFA85(this); + protected DFA101 dfa101 = new DFA101(this); + protected DFA100 dfa100 = new DFA100(this); + protected DFA102 dfa102 = new DFA102(this); + protected DFA104 dfa104 = new DFA104(this); + protected DFA113 dfa113 = new DFA113(this); + protected DFA120 dfa120 = new DFA120(this); + protected DFA119 dfa119 = new DFA119(this); + protected DFA142 dfa142 = new DFA142(this); + protected DFA141 dfa141 = new DFA141(this); + protected DFA143 dfa143 = new DFA143(this); + protected DFA147 dfa147 = new DFA147(this); + protected DFA150 dfa150 = new DFA150(this); + protected DFA149 dfa149 = new DFA149(this); + protected DFA151 dfa151 = new DFA151(this); + protected DFA154 dfa154 = new DFA154(this); + protected DFA172 dfa172 = new DFA172(this); + protected DFA170 dfa170 = new DFA170(this); + protected DFA179 dfa179 = new DFA179(this); + static final String dfa_1s = "\6\uffff"; + static final String dfa_2s = "\1\7\1\26\1\7\2\uffff\1\26"; + static final String dfa_3s = "\1\7\1\56\1\7\2\uffff\1\56"; + static final String dfa_4s = "\3\uffff\1\2\1\1\1\uffff"; + static final String dfa_5s = "\6\uffff}>"; + static final String[] dfa_6s = { + "\1\1", + "\1\4\6\uffff\1\3\20\uffff\1\2", + "\1\5", + "", + "", + "\1\4\6\uffff\1\3\20\uffff\1\2" + }; + + static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); + static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); + static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); + static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); + static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); + static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + + class DFA11 extends DFA { + + public DFA11(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 11; + this.eot = dfa_1; + this.eof = dfa_1; + this.min = dfa_2; + this.max = dfa_3; + this.accept = dfa_4; + this.special = dfa_5; + this.transition = dfa_6; + } + public String getDescription() { + return "584:3: ( ( ( ruleQualifiedID ) ) | ( ( ( ruleQualifiedID ) ) otherlv_6= '#' ( ( ruleIdentifier ) ) ) )"; + } + } + static final String dfa_7s = "\40\uffff"; + static final String dfa_8s = "\1\4\1\0\36\uffff"; + static final String dfa_9s = "\1\126\1\0\36\uffff"; + static final String dfa_10s = "\2\uffff\1\2\34\uffff\1\1"; + static final String dfa_11s = "\1\uffff\1\0\36\uffff}>"; + static final String[] dfa_12s = { + "\4\2\16\uffff\1\2\4\uffff\1\1\7\uffff\1\2\11\uffff\1\2\2\uffff\1\2\3\uffff\1\2\2\uffff\1\2\13\uffff\1\2\1\uffff\22\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); + static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); + static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); + static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); + static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); + static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); + + class DFA31 extends DFA { + + public DFA31(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 31; + this.eot = dfa_7; + this.eof = dfa_7; + this.min = dfa_8; + this.max = dfa_9; + this.accept = dfa_10; + this.special = dfa_11; + this.transition = dfa_12; + } + public String getDescription() { + return "1643:2: ( ( ( '(' )=> (otherlv_0= '(' ( (lv_names_1_0= ruleNamingExpression ) ) (otherlv_2= ',' ( (lv_names_3_0= ruleNamingExpression ) ) )* otherlv_4= ')' ) ) | ( (lv_names_5_0= ruleNamingExpression ) ) )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA31_1 = input.LA(1); + + + int index31_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred1_InternalScope()) ) {s = 31;} + + else if ( (true) ) {s = 2;} + + + input.seek(index31_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 31, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_13s = "\36\uffff"; + static final String dfa_14s = "\1\4\1\uffff\1\0\33\uffff"; + static final String dfa_15s = "\1\126\1\uffff\1\0\33\uffff"; + static final String dfa_16s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; + static final String dfa_17s = "\2\uffff\1\0\33\uffff}>"; + static final String[] dfa_18s = { + "\4\3\16\uffff\1\3\4\uffff\1\2\24\uffff\1\1\3\uffff\1\3\2\uffff\1\3\13\uffff\1\3\1\uffff\22\3", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); + static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s); + static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); + static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s); + static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); + static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); + + class DFA36 extends DFA { + + public DFA36(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 36; + this.eot = dfa_13; + this.eof = dfa_13; + this.min = dfa_14; + this.max = dfa_15; + this.accept = dfa_16; + this.special = dfa_17; + this.transition = dfa_18; + } + public String getDescription() { + return "1900:2: (this_LetExpression_0= ruleLetExpression | ( ( ruleCastedExpression )=>this_CastedExpression_1= ruleCastedExpression ) | this_ChainExpression_2= ruleChainExpression )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA36_2 = input.LA(1); + + + int index36_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred2_InternalScope()) ) {s = 29;} + + else if ( (true) ) {s = 3;} + + + input.seek(index36_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 36, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_19s = "\12\uffff"; + static final String dfa_20s = "\1\10\11\uffff"; + static final String dfa_21s = "\1\4\7\0\2\uffff"; + static final String dfa_22s = "\1\167\7\0\2\uffff"; + static final String dfa_23s = "\10\uffff\1\2\1\1"; + static final String dfa_24s = "\1\uffff\1\2\1\3\1\4\1\5\1\6\1\1\1\0\2\uffff}>"; + static final String[] dfa_25s = { + "\2\10\1\uffff\3\10\6\uffff\3\10\1\uffff\1\10\1\uffff\2\10\1\uffff\1\10\1\uffff\3\10\2\uffff\3\10\2\uffff\1\10\10\uffff\2\10\1\uffff\2\10\1\uffff\1\10\1\uffff\5\10\1\uffff\3\10\1\uffff\1\7\1\6\4\10\11\uffff\3\10\1\uffff\1\10\3\uffff\1\1\1\2\1\3\1\4\1\5\34\10", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "" + }; + + static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s); + static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s); + static final char[] dfa_21 = DFA.unpackEncodedStringToUnsignedChars(dfa_21s); + static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s); + static final short[] dfa_23 = DFA.unpackEncodedString(dfa_23s); + static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s); + static final short[][] dfa_25 = unpackEncodedStringArray(dfa_25s); + + class DFA72 extends DFA { + + public DFA72(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 72; + this.eot = dfa_19; + this.eof = dfa_20; + this.min = dfa_21; + this.max = dfa_22; + this.accept = dfa_23; + this.special = dfa_24; + this.transition = dfa_25; + } + public String getDescription() { + return "4700:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA72_7 = input.LA(1); + + + int index72_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_7); + if ( s>=0 ) return s; + break; + case 1 : + int LA72_6 = input.LA(1); + + + int index72_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_6); + if ( s>=0 ) return s; + break; + case 2 : + int LA72_1 = input.LA(1); + + + int index72_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_1); + if ( s>=0 ) return s; + break; + case 3 : + int LA72_2 = input.LA(1); + + + int index72_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_2); + if ( s>=0 ) return s; + break; + case 4 : + int LA72_3 = input.LA(1); + + + int index72_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_3); + if ( s>=0 ) return s; + break; + case 5 : + int LA72_4 = input.LA(1); + + + int index72_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_4); + if ( s>=0 ) return s; + break; + case 6 : + int LA72_5 = input.LA(1); + + + int index72_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred4_InternalScope()) ) {s = 9;} + + else if ( (true) ) {s = 8;} + + + input.seek(index72_5); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 72, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_26s = "\13\uffff"; + static final String dfa_27s = "\1\1\12\uffff"; + static final String dfa_28s = "\1\4\1\uffff\10\0\1\uffff"; + static final String dfa_29s = "\1\167\1\uffff\10\0\1\uffff"; + static final String dfa_30s = "\1\uffff\1\2\10\uffff\1\1"; + static final String dfa_31s = "\2\uffff\1\6\1\3\1\0\1\1\1\7\1\2\1\4\1\5\1\uffff}>"; + static final String[] dfa_32s = { + "\2\1\1\uffff\3\1\6\uffff\3\1\1\uffff\1\1\1\uffff\2\1\1\uffff\1\1\1\uffff\3\1\2\uffff\3\1\2\uffff\1\1\10\uffff\2\1\1\uffff\1\1\1\4\1\uffff\1\1\1\uffff\5\1\1\uffff\3\1\1\uffff\1\3\1\2\4\1\11\uffff\3\1\1\uffff\1\1\3\uffff\10\1\1\5\1\6\1\7\1\10\1\11\24\1", + "", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "" + }; + + static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s); + static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s); + static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s); + static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s); + static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s); + static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s); + static final short[][] dfa_32 = unpackEncodedStringArray(dfa_32s); + + class DFA82 extends DFA { + + public DFA82(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 82; + this.eot = dfa_26; + this.eof = dfa_27; + this.min = dfa_28; + this.max = dfa_29; + this.accept = dfa_30; + this.special = dfa_31; + this.transition = dfa_32; + } + public String getDescription() { + return "()* loopback of 5414:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA82_4 = input.LA(1); + + + int index82_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_4); + if ( s>=0 ) return s; + break; + case 1 : + int LA82_5 = input.LA(1); + + + int index82_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_5); + if ( s>=0 ) return s; + break; + case 2 : + int LA82_7 = input.LA(1); + + + int index82_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_7); + if ( s>=0 ) return s; + break; + case 3 : + int LA82_3 = input.LA(1); + + + int index82_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_3); + if ( s>=0 ) return s; + break; + case 4 : + int LA82_8 = input.LA(1); + + + int index82_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_8); + if ( s>=0 ) return s; + break; + case 5 : + int LA82_9 = input.LA(1); + + + int index82_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_9); + if ( s>=0 ) return s; + break; + case 6 : + int LA82_2 = input.LA(1); + + + int index82_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_2); + if ( s>=0 ) return s; + break; + case 7 : + int LA82_6 = input.LA(1); + + + int index82_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred10_InternalScope()) ) {s = 10;} + + else if ( (true) ) {s = 1;} + + + input.seek(index82_6); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 82, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_33s = "\1\62\2\uffff\1\100\7\uffff"; + static final String dfa_34s = "\1\143\2\uffff\1\140\7\uffff"; + static final String dfa_35s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\6\1\3"; + static final String dfa_36s = "\13\uffff}>"; + static final String[] dfa_37s = { + "\1\1\15\uffff\1\3\1\6\35\uffff\1\2\1\4\1\5\1\7\1\10", + "", + "", + "\1\11\37\uffff\1\12", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_33 = DFA.unpackEncodedStringToUnsignedChars(dfa_33s); + static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s); + static final short[] dfa_35 = DFA.unpackEncodedString(dfa_35s); + static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s); + static final short[][] dfa_37 = unpackEncodedStringArray(dfa_37s); + + class DFA85 extends DFA { + + public DFA85(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 85; + this.eot = dfa_26; + this.eof = dfa_26; + this.min = dfa_33; + this.max = dfa_34; + this.accept = dfa_35; + this.special = dfa_36; + this.transition = dfa_37; + } + public String getDescription() { + return "5490:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )"; + } + } + static final String dfa_38s = "\116\uffff"; + static final String dfa_39s = "\1\2\115\uffff"; + static final String dfa_40s = "\1\4\1\0\114\uffff"; + static final String dfa_41s = "\1\167\1\0\114\uffff"; + static final String dfa_42s = "\2\uffff\1\2\112\uffff\1\1"; + static final String dfa_43s = "\1\uffff\1\0\114\uffff}>"; + static final String[] dfa_44s = { + "\2\2\1\uffff\3\2\6\uffff\3\2\1\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\1\1\2\2\2\uffff\3\2\2\uffff\1\2\10\uffff\2\2\1\uffff\2\2\1\uffff\1\2\1\uffff\5\2\1\uffff\3\2\1\uffff\6\2\11\uffff\3\2\1\uffff\1\2\3\uffff\41\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_38 = DFA.unpackEncodedString(dfa_38s); + static final short[] dfa_39 = DFA.unpackEncodedString(dfa_39s); + static final char[] dfa_40 = DFA.unpackEncodedStringToUnsignedChars(dfa_40s); + static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s); + static final short[] dfa_42 = DFA.unpackEncodedString(dfa_42s); + static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s); + static final short[][] dfa_44 = unpackEncodedStringArray(dfa_44s); + + class DFA101 extends DFA { + + public DFA101(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 101; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_44; + } + public String getDescription() { + return "6391:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA101_1 = input.LA(1); + + + int index101_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred19_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index101_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 101, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_45s = "\44\uffff"; + static final String dfa_46s = "\1\4\2\0\41\uffff"; + static final String dfa_47s = "\1\166\2\0\41\uffff"; + static final String dfa_48s = "\3\uffff\2\1\1\2\35\uffff\1\3"; + static final String dfa_49s = "\1\0\1\1\1\2\41\uffff}>"; + static final String[] dfa_50s = { + "\2\5\1\uffff\1\1\2\5\6\uffff\1\5\1\uffff\1\5\3\uffff\1\5\4\uffff\1\2\1\43\1\5\3\uffff\1\5\12\uffff\1\4\7\uffff\1\5\2\uffff\1\5\11\uffff\3\5\1\uffff\1\5\11\uffff\3\5\1\uffff\1\5\15\uffff\1\3\7\uffff\3\5\2\uffff\7\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_45 = DFA.unpackEncodedString(dfa_45s); + static final char[] dfa_46 = DFA.unpackEncodedStringToUnsignedChars(dfa_46s); + static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s); + static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s); + static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s); + static final short[][] dfa_50 = unpackEncodedStringArray(dfa_50s); + + class DFA100 extends DFA { + + public DFA100(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 100; + this.eot = dfa_45; + this.eof = dfa_45; + this.min = dfa_46; + this.max = dfa_47; + this.accept = dfa_48; + this.special = dfa_49; + this.transition = dfa_50; + } + public String getDescription() { + return "6410:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA100_0 = input.LA(1); + + + int index100_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA100_0==RULE_ID) ) {s = 1;} + + else if ( (LA100_0==27) ) {s = 2;} + + else if ( (LA100_0==97) && (synpred20_InternalScope())) {s = 3;} + + else if ( (LA100_0==44) && (synpred20_InternalScope())) {s = 4;} + + else if ( ((LA100_0>=RULE_STRING && LA100_0<=RULE_INT)||(LA100_0>=RULE_HEX && LA100_0<=RULE_DECIMAL)||LA100_0==16||LA100_0==18||LA100_0==22||LA100_0==29||LA100_0==33||LA100_0==52||LA100_0==55||(LA100_0>=65 && LA100_0<=67)||LA100_0==69||(LA100_0>=79 && LA100_0<=81)||LA100_0==83||(LA100_0>=105 && LA100_0<=107)||(LA100_0>=110 && LA100_0<=116)||LA100_0==118) ) {s = 5;} + + else if ( (LA100_0==28) ) {s = 35;} + + + input.seek(index100_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA100_1 = input.LA(1); + + + int index100_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred20_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index100_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA100_2 = input.LA(1); + + + int index100_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred20_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index100_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 100, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_51s = { + "\2\2\1\uffff\3\2\6\uffff\3\2\1\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\3\2\2\uffff\1\2\1\1\1\2\2\uffff\1\2\10\uffff\2\2\1\uffff\2\2\1\uffff\1\2\1\uffff\5\2\1\uffff\3\2\1\uffff\6\2\11\uffff\3\2\1\uffff\1\2\3\uffff\41\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s); + + class DFA102 extends DFA { + + public DFA102(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 102; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_51; + } + public String getDescription() { + return "6508:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA102_1 = input.LA(1); + + + int index102_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred21_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index102_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 102, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_52s = "\1\4\26\uffff\1\0\10\uffff"; + static final String dfa_53s = "\1\166\26\uffff\1\0\10\uffff"; + static final String dfa_54s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11"; + static final String dfa_55s = "\1\0\26\uffff\1\1\10\uffff}>"; + static final String[] dfa_56s = { + "\2\14\1\uffff\1\5\2\14\6\uffff\1\5\1\uffff\1\5\3\uffff\1\2\4\uffff\1\35\1\uffff\1\14\3\uffff\1\14\22\uffff\1\26\2\uffff\1\3\11\uffff\1\5\15\uffff\3\14\1\uffff\1\1\25\uffff\1\27\1\30\1\31\2\uffff\3\5\1\14\1\32\1\33\1\34\1\uffff\1\4", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final char[] dfa_52 = DFA.unpackEncodedStringToUnsignedChars(dfa_52s); + static final char[] dfa_53 = DFA.unpackEncodedStringToUnsignedChars(dfa_53s); + static final short[] dfa_54 = DFA.unpackEncodedString(dfa_54s); + static final short[] dfa_55 = DFA.unpackEncodedString(dfa_55s); + static final short[][] dfa_56 = unpackEncodedStringArray(dfa_56s); + + class DFA104 extends DFA { + + public DFA104(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 104; + this.eot = dfa_7; + this.eof = dfa_7; + this.min = dfa_52; + this.max = dfa_53; + this.accept = dfa_54; + this.special = dfa_55; + this.transition = dfa_56; + } + public String getDescription() { + return "6553:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA104_0 = input.LA(1); + + + int index104_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA104_0==83) ) {s = 1;} + + else if ( (LA104_0==22) ) {s = 2;} + + else if ( (LA104_0==55) ) {s = 3;} + + else if ( (LA104_0==118) && (synpred22_InternalScope())) {s = 4;} + + else if ( (LA104_0==RULE_ID||LA104_0==16||LA104_0==18||LA104_0==65||(LA104_0>=110 && LA104_0<=112)) ) {s = 5;} + + else if ( ((LA104_0>=RULE_STRING && LA104_0<=RULE_INT)||(LA104_0>=RULE_HEX && LA104_0<=RULE_DECIMAL)||LA104_0==29||LA104_0==33||(LA104_0>=79 && LA104_0<=81)||LA104_0==113) ) {s = 12;} + + else if ( (LA104_0==52) ) {s = 22;} + + else if ( (LA104_0==105) ) {s = 23;} + + else if ( (LA104_0==106) ) {s = 24;} + + else if ( (LA104_0==107) ) {s = 25;} + + else if ( (LA104_0==114) ) {s = 26;} + + else if ( (LA104_0==115) ) {s = 27;} + + else if ( (LA104_0==116) ) {s = 28;} + + else if ( (LA104_0==27) ) {s = 29;} + + + input.seek(index104_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA104_23 = input.LA(1); + + + int index104_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred23_InternalScope()) ) {s = 30;} + + else if ( (true) ) {s = 31;} + + + input.seek(index104_23); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 104, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_57s = "\46\uffff"; + static final String dfa_58s = "\1\4\2\0\43\uffff"; + static final String dfa_59s = "\1\166\2\0\43\uffff"; + static final String dfa_60s = "\3\uffff\2\1\1\2\40\uffff"; + static final String dfa_61s = "\1\0\1\1\1\2\43\uffff}>"; + static final String[] dfa_62s = { + "\2\5\1\uffff\1\1\2\5\6\uffff\1\5\1\uffff\1\5\3\uffff\1\5\4\uffff\1\2\1\uffff\1\5\3\uffff\2\5\11\uffff\1\4\7\uffff\1\5\2\uffff\1\5\11\uffff\3\5\1\uffff\1\5\11\uffff\3\5\1\uffff\1\5\15\uffff\1\3\7\uffff\14\5\1\uffff\1\5", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_57 = DFA.unpackEncodedString(dfa_57s); + static final char[] dfa_58 = DFA.unpackEncodedStringToUnsignedChars(dfa_58s); + static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s); + static final short[] dfa_60 = DFA.unpackEncodedString(dfa_60s); + static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s); + static final short[][] dfa_62 = unpackEncodedStringArray(dfa_62s); + + class DFA113 extends DFA { + + public DFA113(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 113; + this.eot = dfa_57; + this.eof = dfa_57; + this.min = dfa_58; + this.max = dfa_59; + this.accept = dfa_60; + this.special = dfa_61; + this.transition = dfa_62; + } + public String getDescription() { + return "7045:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA113_0 = input.LA(1); + + + int index113_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA113_0==RULE_ID) ) {s = 1;} + + else if ( (LA113_0==27) ) {s = 2;} + + else if ( (LA113_0==97) && (synpred26_InternalScope())) {s = 3;} + + else if ( (LA113_0==44) && (synpred26_InternalScope())) {s = 4;} + + else if ( ((LA113_0>=RULE_STRING && LA113_0<=RULE_INT)||(LA113_0>=RULE_HEX && LA113_0<=RULE_DECIMAL)||LA113_0==16||LA113_0==18||LA113_0==22||LA113_0==29||(LA113_0>=33 && LA113_0<=34)||LA113_0==52||LA113_0==55||(LA113_0>=65 && LA113_0<=67)||LA113_0==69||(LA113_0>=79 && LA113_0<=81)||LA113_0==83||(LA113_0>=105 && LA113_0<=116)||LA113_0==118) ) {s = 5;} + + + input.seek(index113_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA113_1 = input.LA(1); + + + int index113_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred26_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index113_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA113_2 = input.LA(1); + + + int index113_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred26_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index113_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 113, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_63s = "\43\uffff"; + static final String dfa_64s = "\1\4\1\0\41\uffff"; + static final String dfa_65s = "\1\166\1\0\41\uffff"; + static final String dfa_66s = "\2\uffff\1\2\37\uffff\1\1"; + static final String dfa_67s = "\1\uffff\1\0\41\uffff}>"; + static final String[] dfa_68s = { + "\2\2\1\uffff\3\2\6\uffff\1\2\1\uffff\1\2\3\uffff\1\2\4\uffff\1\1\1\uffff\1\2\3\uffff\1\2\22\uffff\1\2\2\uffff\1\2\11\uffff\3\2\1\uffff\1\2\11\uffff\3\2\1\uffff\1\2\15\uffff\1\2\7\uffff\3\2\2\uffff\7\2\1\uffff\1\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_63 = DFA.unpackEncodedString(dfa_63s); + static final char[] dfa_64 = DFA.unpackEncodedStringToUnsignedChars(dfa_64s); + static final char[] dfa_65 = DFA.unpackEncodedStringToUnsignedChars(dfa_65s); + static final short[] dfa_66 = DFA.unpackEncodedString(dfa_66s); + static final short[] dfa_67 = DFA.unpackEncodedString(dfa_67s); + static final short[][] dfa_68 = unpackEncodedStringArray(dfa_68s); + + class DFA120 extends DFA { + + public DFA120(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 120; + this.eot = dfa_63; + this.eof = dfa_63; + this.min = dfa_64; + this.max = dfa_65; + this.accept = dfa_66; + this.special = dfa_67; + this.transition = dfa_68; + } + public String getDescription() { + return "7511:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA120_1 = input.LA(1); + + + int index120_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred29_InternalScope()) ) {s = 34;} + + else if ( (true) ) {s = 2;} + + + input.seek(index120_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 120, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_69s = "\42\uffff"; + static final String dfa_70s = "\1\4\2\0\37\uffff"; + static final String dfa_71s = "\1\166\2\0\37\uffff"; + static final String dfa_72s = "\3\uffff\1\1\1\2\35\uffff"; + static final String dfa_73s = "\1\0\1\1\1\2\37\uffff}>"; + static final String[] dfa_74s = { + "\2\4\1\uffff\1\1\2\4\6\uffff\1\4\1\uffff\1\4\3\uffff\1\4\4\uffff\1\2\1\uffff\1\4\3\uffff\1\4\22\uffff\1\4\2\uffff\1\4\11\uffff\3\4\1\uffff\1\4\11\uffff\3\4\1\uffff\1\4\15\uffff\1\3\7\uffff\3\4\2\uffff\7\4\1\uffff\1\4", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + + static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s); + static final char[] dfa_70 = DFA.unpackEncodedStringToUnsignedChars(dfa_70s); + static final char[] dfa_71 = DFA.unpackEncodedStringToUnsignedChars(dfa_71s); + static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s); + static final short[] dfa_73 = DFA.unpackEncodedString(dfa_73s); + static final short[][] dfa_74 = unpackEncodedStringArray(dfa_74s); + + class DFA119 extends DFA { + + public DFA119(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 119; + this.eot = dfa_69; + this.eof = dfa_69; + this.min = dfa_70; + this.max = dfa_71; + this.accept = dfa_72; + this.special = dfa_73; + this.transition = dfa_74; + } + public String getDescription() { + return "7580:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA119_0 = input.LA(1); + + + int index119_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA119_0==RULE_ID) ) {s = 1;} + + else if ( (LA119_0==27) ) {s = 2;} + + else if ( (LA119_0==97) && (synpred30_InternalScope())) {s = 3;} + + else if ( ((LA119_0>=RULE_STRING && LA119_0<=RULE_INT)||(LA119_0>=RULE_HEX && LA119_0<=RULE_DECIMAL)||LA119_0==16||LA119_0==18||LA119_0==22||LA119_0==29||LA119_0==33||LA119_0==52||LA119_0==55||(LA119_0>=65 && LA119_0<=67)||LA119_0==69||(LA119_0>=79 && LA119_0<=81)||LA119_0==83||(LA119_0>=105 && LA119_0<=107)||(LA119_0>=110 && LA119_0<=116)||LA119_0==118) ) {s = 4;} + + + input.seek(index119_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA119_1 = input.LA(1); + + + int index119_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred30_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index119_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA119_2 = input.LA(1); + + + int index119_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred30_InternalScope()) ) {s = 3;} + + else if ( (true) ) {s = 4;} + + + input.seek(index119_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 119, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA142 extends DFA { + + public DFA142(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 142; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_44; + } + public String getDescription() { + return "8709:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA142_1 = input.LA(1); + + + int index142_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred33_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index142_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 142, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA141 extends DFA { + + public DFA141(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 141; + this.eot = dfa_45; + this.eof = dfa_45; + this.min = dfa_46; + this.max = dfa_47; + this.accept = dfa_48; + this.special = dfa_49; + this.transition = dfa_50; + } + public String getDescription() { + return "8728:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA141_0 = input.LA(1); + + + int index141_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA141_0==RULE_ID) ) {s = 1;} + + else if ( (LA141_0==27) ) {s = 2;} + + else if ( (LA141_0==97) && (synpred34_InternalScope())) {s = 3;} + + else if ( (LA141_0==44) && (synpred34_InternalScope())) {s = 4;} + + else if ( ((LA141_0>=RULE_STRING && LA141_0<=RULE_INT)||(LA141_0>=RULE_HEX && LA141_0<=RULE_DECIMAL)||LA141_0==16||LA141_0==18||LA141_0==22||LA141_0==29||LA141_0==33||LA141_0==52||LA141_0==55||(LA141_0>=65 && LA141_0<=67)||LA141_0==69||(LA141_0>=79 && LA141_0<=81)||LA141_0==83||(LA141_0>=105 && LA141_0<=107)||(LA141_0>=110 && LA141_0<=116)||LA141_0==118) ) {s = 5;} + + else if ( (LA141_0==28) ) {s = 35;} + + + input.seek(index141_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA141_1 = input.LA(1); + + + int index141_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred34_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index141_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA141_2 = input.LA(1); + + + int index141_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred34_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index141_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 141, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA143 extends DFA { + + public DFA143(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 143; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_51; + } + public String getDescription() { + return "8826:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA143_1 = input.LA(1); + + + int index143_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred35_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index143_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 143, _s, input); + error(nvae); + throw nvae; + } + } + static final String[] dfa_75s = { + "\2\2\1\uffff\3\2\6\uffff\3\2\1\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\3\2\2\uffff\3\2\2\uffff\1\2\10\uffff\2\2\1\uffff\2\2\1\uffff\1\2\1\uffff\5\2\1\uffff\3\2\1\uffff\1\2\1\1\4\2\11\uffff\3\2\1\uffff\1\2\3\uffff\41\2", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[][] dfa_75 = unpackEncodedStringArray(dfa_75s); + + class DFA147 extends DFA { + + public DFA147(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 147; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_75; + } + public String getDescription() { + return "8985:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA147_1 = input.LA(1); + + + int index147_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred36_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index147_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 147, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA150 extends DFA { + + public DFA150(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 150; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_44; + } + public String getDescription() { + return "9042:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA150_1 = input.LA(1); + + + int index150_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred37_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index150_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 150, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA149 extends DFA { + + public DFA149(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 149; + this.eot = dfa_45; + this.eof = dfa_45; + this.min = dfa_46; + this.max = dfa_47; + this.accept = dfa_48; + this.special = dfa_49; + this.transition = dfa_50; + } + public String getDescription() { + return "9061:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA149_0 = input.LA(1); + + + int index149_0 = input.index(); + input.rewind(); + s = -1; + if ( (LA149_0==RULE_ID) ) {s = 1;} + + else if ( (LA149_0==27) ) {s = 2;} + + else if ( (LA149_0==97) && (synpred38_InternalScope())) {s = 3;} + + else if ( (LA149_0==44) && (synpred38_InternalScope())) {s = 4;} + + else if ( ((LA149_0>=RULE_STRING && LA149_0<=RULE_INT)||(LA149_0>=RULE_HEX && LA149_0<=RULE_DECIMAL)||LA149_0==16||LA149_0==18||LA149_0==22||LA149_0==29||LA149_0==33||LA149_0==52||LA149_0==55||(LA149_0>=65 && LA149_0<=67)||LA149_0==69||(LA149_0>=79 && LA149_0<=81)||LA149_0==83||(LA149_0>=105 && LA149_0<=107)||(LA149_0>=110 && LA149_0<=116)||LA149_0==118) ) {s = 5;} + + else if ( (LA149_0==28) ) {s = 35;} + + + input.seek(index149_0); + if ( s>=0 ) return s; + break; + case 1 : + int LA149_1 = input.LA(1); + + + int index149_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred38_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index149_1); + if ( s>=0 ) return s; + break; + case 2 : + int LA149_2 = input.LA(1); + + + int index149_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred38_InternalScope()) ) {s = 4;} + + else if ( (true) ) {s = 5;} + + + input.seek(index149_2); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 149, _s, input); + error(nvae); + throw nvae; + } + } + + class DFA151 extends DFA { + + public DFA151(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 151; + this.eot = dfa_38; + this.eof = dfa_39; + this.min = dfa_40; + this.max = dfa_41; + this.accept = dfa_42; + this.special = dfa_43; + this.transition = dfa_51; + } + public String getDescription() { + return "9159:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA151_1 = input.LA(1); + + + int index151_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred39_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 2;} + + + input.seek(index151_1); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 151, _s, input); + error(nvae); + throw nvae; + } + } + static final String dfa_76s = "\1\41\115\uffff"; + static final String dfa_77s = "\1\4\40\0\55\uffff"; + static final String dfa_78s = "\1\167\40\0\55\uffff"; + static final String dfa_79s = "\41\uffff\1\2\53\uffff\1\1"; + static final String dfa_80s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>"; + static final String[] dfa_81s = { + "\1\27\1\24\1\uffff\1\1\1\23\1\25\6\uffff\1\4\1\41\1\5\1\uffff\1\41\1\uffff\1\12\1\41\1\uffff\1\41\1\uffff\1\40\1\41\1\17\2\uffff\1\41\1\20\1\41\2\uffff\1\41\10\uffff\2\41\1\uffff\2\41\1\uffff\1\31\1\uffff\1\41\1\13\3\41\1\uffff\3\41\1\uffff\1\41\1\15\1\10\1\7\1\41\1\6\11\uffff\1\22\1\21\1\26\1\uffff\1\11\3\uffff\22\41\1\32\1\33\1\34\2\41\1\2\1\3\1\16\1\30\1\35\1\36\1\37\1\41\1\14\1\41", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "\1\uffff", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + }; + static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s); + static final char[] dfa_77 = DFA.unpackEncodedStringToUnsignedChars(dfa_77s); + static final char[] dfa_78 = DFA.unpackEncodedStringToUnsignedChars(dfa_78s); + static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s); + static final short[] dfa_80 = DFA.unpackEncodedString(dfa_80s); + static final short[][] dfa_81 = unpackEncodedStringArray(dfa_81s); + + class DFA154 extends DFA { + + public DFA154(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 154; + this.eot = dfa_38; + this.eof = dfa_76; + this.min = dfa_77; + this.max = dfa_78; + this.accept = dfa_79; + this.special = dfa_80; + this.transition = dfa_81; + } + public String getDescription() { + return "9502:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?"; + } + public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { + TokenStream input = (TokenStream)_input; + int _s = s; + switch ( s ) { + case 0 : + int LA154_1 = input.LA(1); + + + int index154_1 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_1); + if ( s>=0 ) return s; + break; + case 1 : + int LA154_2 = input.LA(1); + + + int index154_2 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_2); + if ( s>=0 ) return s; + break; + case 2 : + int LA154_3 = input.LA(1); + + + int index154_3 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_3); + if ( s>=0 ) return s; + break; + case 3 : + int LA154_4 = input.LA(1); + + + int index154_4 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_4); + if ( s>=0 ) return s; + break; + case 4 : + int LA154_5 = input.LA(1); + + + int index154_5 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_5); + if ( s>=0 ) return s; + break; + case 5 : + int LA154_6 = input.LA(1); + + + int index154_6 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_6); + if ( s>=0 ) return s; + break; + case 6 : + int LA154_7 = input.LA(1); + + + int index154_7 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_7); + if ( s>=0 ) return s; + break; + case 7 : + int LA154_8 = input.LA(1); + + + int index154_8 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_8); + if ( s>=0 ) return s; + break; + case 8 : + int LA154_9 = input.LA(1); + + + int index154_9 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_9); + if ( s>=0 ) return s; + break; + case 9 : + int LA154_10 = input.LA(1); + + + int index154_10 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_10); + if ( s>=0 ) return s; + break; + case 10 : + int LA154_11 = input.LA(1); + + + int index154_11 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_11); + if ( s>=0 ) return s; + break; + case 11 : + int LA154_12 = input.LA(1); + + + int index154_12 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_12); + if ( s>=0 ) return s; + break; + case 12 : + int LA154_13 = input.LA(1); + + + int index154_13 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_13); + if ( s>=0 ) return s; + break; + case 13 : + int LA154_14 = input.LA(1); + + + int index154_14 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_14); + if ( s>=0 ) return s; + break; + case 14 : + int LA154_15 = input.LA(1); + + + int index154_15 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_15); + if ( s>=0 ) return s; + break; + case 15 : + int LA154_16 = input.LA(1); + + + int index154_16 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_16); + if ( s>=0 ) return s; + break; + case 16 : + int LA154_17 = input.LA(1); + + + int index154_17 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_17); + if ( s>=0 ) return s; + break; + case 17 : + int LA154_18 = input.LA(1); + + + int index154_18 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_18); + if ( s>=0 ) return s; + break; + case 18 : + int LA154_19 = input.LA(1); + + + int index154_19 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_19); + if ( s>=0 ) return s; + break; + case 19 : + int LA154_20 = input.LA(1); + + + int index154_20 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_20); + if ( s>=0 ) return s; + break; + case 20 : + int LA154_21 = input.LA(1); + + + int index154_21 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_21); + if ( s>=0 ) return s; + break; + case 21 : + int LA154_22 = input.LA(1); + + + int index154_22 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_22); + if ( s>=0 ) return s; + break; + case 22 : + int LA154_23 = input.LA(1); + + + int index154_23 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_23); + if ( s>=0 ) return s; + break; + case 23 : + int LA154_24 = input.LA(1); + + + int index154_24 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_24); + if ( s>=0 ) return s; + break; + case 24 : + int LA154_25 = input.LA(1); + + + int index154_25 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_25); + if ( s>=0 ) return s; + break; + case 25 : + int LA154_26 = input.LA(1); + + + int index154_26 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_26); + if ( s>=0 ) return s; + break; + case 26 : + int LA154_27 = input.LA(1); + + + int index154_27 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_27); + if ( s>=0 ) return s; + break; + case 27 : + int LA154_28 = input.LA(1); + + + int index154_28 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_28); + if ( s>=0 ) return s; + break; + case 28 : + int LA154_29 = input.LA(1); + + + int index154_29 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} - // $ANTLR start synpred3_InternalScope - public final void synpred3_InternalScope_fragment() throws RecognitionException { - // InternalScope.g:2335:4: ( 'else' ) - // InternalScope.g:2335:5: 'else' - { - match(input,52,FOLLOW_2); if (state.failed) return ; + else if ( (true) ) {s = 33;} - } - } - // $ANTLR end synpred3_InternalScope + + input.seek(index154_29); + if ( s>=0 ) return s; + break; + case 29 : + int LA154_30 = input.LA(1); - // Delegated rules + + int index154_30 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} - public final boolean synpred2_InternalScope() { - state.backtracking++; - int start = input.mark(); - try { - synpred2_InternalScope_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred1_InternalScope() { - state.backtracking++; - int start = input.mark(); - try { - synpred1_InternalScope_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred3_InternalScope() { - state.backtracking++; - int start = input.mark(); - try { - synpred3_InternalScope_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } + else if ( (true) ) {s = 33;} + + input.seek(index154_30); + if ( s>=0 ) return s; + break; + case 30 : + int LA154_31 = input.LA(1); - protected DFA11 dfa11 = new DFA11(this); - protected DFA31 dfa31 = new DFA31(this); - protected DFA36 dfa36 = new DFA36(this); - static final String dfa_1s = "\6\uffff"; - static final String dfa_2s = "\1\7\1\24\1\7\2\uffff\1\24"; - static final String dfa_3s = "\1\7\1\54\1\7\2\uffff\1\54"; - static final String dfa_4s = "\3\uffff\1\1\1\2\1\uffff"; - static final String dfa_5s = "\6\uffff}>"; - static final String[] dfa_6s = { - "\1\1", - "\1\3\6\uffff\1\4\20\uffff\1\2", - "\1\5", - "", - "", - "\1\3\6\uffff\1\4\20\uffff\1\2" - }; + + int index154_31 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} - static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s); - static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s); - static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s); - static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s); - static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s); - static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s); + else if ( (true) ) {s = 33;} - class DFA11 extends DFA { + + input.seek(index154_31); + if ( s>=0 ) return s; + break; + case 31 : + int LA154_32 = input.LA(1); - public DFA11(BaseRecognizer recognizer) { - this.recognizer = recognizer; - this.decisionNumber = 11; - this.eot = dfa_1; - this.eof = dfa_1; - this.min = dfa_2; - this.max = dfa_3; - this.accept = dfa_4; - this.special = dfa_5; - this.transition = dfa_6; - } - public String getDescription() { - return "584:3: ( ( ( ruleQualifiedID ) ) | ( ( ( ruleQualifiedID ) ) otherlv_6= '#' ( ( ruleIdentifier ) ) ) )"; + + int index154_32 = input.index(); + input.rewind(); + s = -1; + if ( (synpred40_InternalScope()) ) {s = 77;} + + else if ( (true) ) {s = 33;} + + + input.seek(index154_32); + if ( s>=0 ) return s; + break; + } + if (state.backtracking>0) {state.failed=true; return -1;} + NoViableAltException nvae = + new NoViableAltException(getDescription(), 154, _s, input); + error(nvae); + throw nvae; } } - static final String dfa_7s = "\40\uffff"; - static final String dfa_8s = "\1\4\1\0\36\uffff"; - static final String dfa_9s = "\1\124\1\0\36\uffff"; - static final String dfa_10s = "\2\uffff\1\2\34\uffff\1\1"; - static final String dfa_11s = "\1\uffff\1\0\36\uffff}>"; - static final String[] dfa_12s = { - "\4\2\14\uffff\1\2\4\uffff\1\1\7\uffff\1\2\11\uffff\1\2\2\uffff\1\2\3\uffff\1\2\2\uffff\1\2\13\uffff\1\2\1\uffff\22\2", + static final String dfa_82s = "\117\uffff"; + static final String dfa_83s = "\1\2\116\uffff"; + static final String dfa_84s = "\1\4\1\0\115\uffff"; + static final String dfa_85s = "\1\170\1\0\115\uffff"; + static final String dfa_86s = "\2\uffff\1\2\113\uffff\1\1"; + static final String dfa_87s = "\1\uffff\1\0\115\uffff}>"; + static final String[] dfa_88s = { + "\2\2\1\uffff\3\2\6\uffff\3\2\1\uffff\1\2\1\uffff\2\2\1\uffff\1\2\1\uffff\3\2\2\uffff\3\2\2\uffff\1\2\10\uffff\2\2\1\uffff\2\2\1\uffff\1\2\1\uffff\5\2\1\uffff\3\2\1\uffff\1\2\1\1\4\2\11\uffff\3\2\1\uffff\1\2\3\uffff\42\2", "\1\uffff", "", "", @@ -13523,212 +35613,319 @@ public String getDescription() { "", "", "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", "" }; - static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s); - static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s); - static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s); - static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s); - static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s); - static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s); + static final short[] dfa_82 = DFA.unpackEncodedString(dfa_82s); + static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s); + static final char[] dfa_84 = DFA.unpackEncodedStringToUnsignedChars(dfa_84s); + static final char[] dfa_85 = DFA.unpackEncodedStringToUnsignedChars(dfa_85s); + static final short[] dfa_86 = DFA.unpackEncodedString(dfa_86s); + static final short[] dfa_87 = DFA.unpackEncodedString(dfa_87s); + static final short[][] dfa_88 = unpackEncodedStringArray(dfa_88s); - class DFA31 extends DFA { + class DFA172 extends DFA { - public DFA31(BaseRecognizer recognizer) { + public DFA172(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 31; - this.eot = dfa_7; - this.eof = dfa_7; - this.min = dfa_8; - this.max = dfa_9; - this.accept = dfa_10; - this.special = dfa_11; - this.transition = dfa_12; + this.decisionNumber = 172; + this.eot = dfa_82; + this.eof = dfa_83; + this.min = dfa_84; + this.max = dfa_85; + this.accept = dfa_86; + this.special = dfa_87; + this.transition = dfa_88; } public String getDescription() { - return "1643:2: ( ( ( '(' )=> (otherlv_0= '(' ( (lv_names_1_0= ruleNamingExpression ) ) (otherlv_2= ',' ( (lv_names_3_0= ruleNamingExpression ) ) )* otherlv_4= ')' ) ) | ( (lv_names_5_0= ruleNamingExpression ) ) )"; + return "10160:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA31_1 = input.LA(1); + int LA172_1 = input.LA(1); - int index31_1 = input.index(); + int index172_1 = input.index(); input.rewind(); s = -1; - if ( (synpred1_InternalScope()) ) {s = 31;} + if ( (synpred47_InternalScope()) ) {s = 78;} else if ( (true) ) {s = 2;} - input.seek(index31_1); + input.seek(index172_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 31, _s, input); + new NoViableAltException(getDescription(), 172, _s, input); error(nvae); throw nvae; } } - static final String dfa_13s = "\36\uffff"; - static final String dfa_14s = "\1\4\1\uffff\1\0\33\uffff"; - static final String dfa_15s = "\1\124\1\uffff\1\0\33\uffff"; - static final String dfa_16s = "\1\uffff\1\1\1\uffff\1\3\31\uffff\1\2"; - static final String dfa_17s = "\2\uffff\1\0\33\uffff}>"; - static final String[] dfa_18s = { - "\4\3\14\uffff\1\3\4\uffff\1\2\24\uffff\1\1\3\uffff\1\3\2\uffff\1\3\13\uffff\1\3\1\uffff\22\3", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - }; - - static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s); - static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s); - static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s); - static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s); - static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s); - static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s); - class DFA36 extends DFA { + class DFA170 extends DFA { - public DFA36(BaseRecognizer recognizer) { + public DFA170(BaseRecognizer recognizer) { this.recognizer = recognizer; - this.decisionNumber = 36; - this.eot = dfa_13; - this.eof = dfa_13; - this.min = dfa_14; - this.max = dfa_15; - this.accept = dfa_16; - this.special = dfa_17; - this.transition = dfa_18; + this.decisionNumber = 170; + this.eot = dfa_82; + this.eof = dfa_83; + this.min = dfa_84; + this.max = dfa_85; + this.accept = dfa_86; + this.special = dfa_87; + this.transition = dfa_88; } public String getDescription() { - return "1900:2: (this_LetExpression_0= ruleLetExpression | ( ( ruleCastedExpression )=>this_CastedExpression_1= ruleCastedExpression ) | this_ChainExpression_2= ruleChainExpression )"; + return "10254:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?"; } public int specialStateTransition(int s, IntStream _input) throws NoViableAltException { TokenStream input = (TokenStream)_input; int _s = s; switch ( s ) { case 0 : - int LA36_2 = input.LA(1); + int LA170_1 = input.LA(1); - int index36_2 = input.index(); + int index170_1 = input.index(); input.rewind(); s = -1; - if ( (synpred2_InternalScope()) ) {s = 29;} + if ( (synpred49_InternalScope()) ) {s = 78;} - else if ( (true) ) {s = 3;} + else if ( (true) ) {s = 2;} - input.seek(index36_2); + input.seek(index170_1); if ( s>=0 ) return s; break; } if (state.backtracking>0) {state.failed=true; return -1;} NoViableAltException nvae = - new NoViableAltException(getDescription(), 36, _s, input); + new NoViableAltException(getDescription(), 170, _s, input); error(nvae); throw nvae; } } + static final String dfa_89s = "\7\uffff"; + static final String dfa_90s = "\2\uffff\1\4\2\uffff\1\4\1\uffff"; + static final String dfa_91s = "\1\7\1\uffff\1\31\1\7\1\uffff\1\31\1\uffff"; + static final String dfa_92s = "\1\157\1\uffff\1\57\1\40\1\uffff\1\57\1\uffff"; + static final String dfa_93s = "\1\uffff\1\1\2\uffff\1\2\1\uffff\1\3"; + static final String dfa_94s = "\7\uffff}>"; + static final String[] dfa_95s = { + "\1\2\147\uffff\1\1", + "", + "\1\4\25\uffff\1\3", + "\1\5\30\uffff\1\6", + "", + "\1\4\25\uffff\1\3", + "" + }; + + static final short[] dfa_89 = DFA.unpackEncodedString(dfa_89s); + static final short[] dfa_90 = DFA.unpackEncodedString(dfa_90s); + static final char[] dfa_91 = DFA.unpackEncodedStringToUnsignedChars(dfa_91s); + static final char[] dfa_92 = DFA.unpackEncodedStringToUnsignedChars(dfa_92s); + static final short[] dfa_93 = DFA.unpackEncodedString(dfa_93s); + static final short[] dfa_94 = DFA.unpackEncodedString(dfa_94s); + static final short[][] dfa_95 = unpackEncodedStringArray(dfa_95s); + + class DFA179 extends DFA { + + public DFA179(BaseRecognizer recognizer) { + this.recognizer = recognizer; + this.decisionNumber = 179; + this.eot = dfa_89; + this.eof = dfa_90; + this.min = dfa_91; + this.max = dfa_92; + this.accept = dfa_93; + this.special = dfa_94; + this.transition = dfa_95; + } + public String getDescription() { + return "10716:3: ( ( ( (lv_static_1_0= 'static' ) ) ( (lv_extension_2_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_4_0= '*' ) ) | ( (lv_memberName_5_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_7_0= ruleQualifiedNameWithWildcard ) ) )"; + } + } public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L}); public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000080L}); - public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x00000000010F6002L}); - public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x00000000010F4002L}); - public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x00000000010F0002L}); - public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x00000000010E0002L}); - public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000001000002L}); + public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x00000000043D8002L}); + public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x00000000043D0002L}); + public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x00000000043C0002L}); + public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000004380002L}); + public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000004000002L}); public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000008002L}); - public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000008000L}); - public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0000000000600000L}); - public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000080000L}); - public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000100000L}); - public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000200080L}); - public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x00244802021000F0L,0x00000000001FFFFAL}); - public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000002000080L}); - public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000004000000L}); - public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000008000000L}); - public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000010200000L}); - public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000040000080L}); - public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x00244816021000F0L,0x00000000001FFFFAL}); - public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000020800000L}); - public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000080000002L}); - public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000100000000L}); - public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000002000000L}); - public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x00244812021000F0L,0x00000000001FFFFAL}); - public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000804000000L}); - public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000048002L}); - public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000002000000000L}); - public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x000000C000000000L}); - public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000008000000000L}); - public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000010000000000L}); - public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000080000080L}); - public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000020000000000L}); - public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000042000080L}); - public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000040000000000L}); - public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000100000000002L}); - public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000200000000002L}); - public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000800000000000L}); - public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000080L,0x00000000001C0000L}); - public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0001000000000002L}); - public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0002000000000002L}); - public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0008000000000000L}); - public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0010000000000002L}); - public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000002100000L}); - public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x00000000021000F0L,0x00000000001FFFFAL}); - public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0040000000040000L}); - public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0080000000000002L}); - public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0100000000000002L}); - public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0200000000000002L}); - public static final BitSet FOLLOW_56 = new BitSet(new long[]{0xFC00000000000002L}); - public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000003L}); - public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000040000002L,0x0000000000000004L}); - public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x00244802061000F0L,0x00000000001FFFFAL}); - public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); - public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001FE0L}); - public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x00244802023000F0L,0x00000000001FFFFAL}); - public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000800200000L}); - public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000080000000L}); + public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000020002L}); + public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000020000L}); + public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000000000L,0x0600000000000000L}); + public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000200000L}); + public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000400000L}); + public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000000800080L}); + public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000001000000L}); + public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x00912008084000F0L,0x00000000007FFFE8L}); + public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000002000000L}); + public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000008000080L}); + public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000010000000L}); + public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000020000000L}); + public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000040000000L}); + public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000040800000L}); + public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000100000080L}); + public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x00912058084000F0L,0x00000000007FFFE8L}); + public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000082000000L}); + public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000200000002L}); + public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000400000000L}); + public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000008000000L}); + public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x00912048084000F0L,0x00000000007FFFE8L}); + public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000002010000000L}); + public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000120002L}); + public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000008000000000L}); + public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000030000000000L}); + public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000020000000000L}); + public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000040000000000L}); + public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000200000080L}); + public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000080000000000L}); + public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000108000080L}); + public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000100000000000L}); + public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000400000000002L}); + public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000800000000002L}); + public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0002000000000000L}); + public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000080L,0x0000000000700000L}); + public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0004000000000002L}); + public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0008000000000002L}); + public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0020000000000000L}); + public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0040000000000002L}); + public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000008400000L}); + public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x00000000084000F0L,0x00000000007FFFE8L}); + public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0100000000100000L}); + public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000800000L}); + public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0200000000000002L}); + public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0400000000000002L}); + public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0800000000000002L}); + public static final BitSet FOLLOW_56 = new BitSet(new long[]{0xF000000000000002L,0x0000000000000003L}); + public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x0000000000000002L,0x000000000000000CL}); + public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000100000002L,0x0000000000000010L}); + public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x00912008184000F0L,0x00000000007FFFE8L}); + public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L}); + public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000007F80L}); + public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x0091200808C000F0L,0x00000000007FFFE8L}); + public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000002000800000L}); + public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000200000000L}); + public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x00900002284503B0L,0x005FCE00000B802EL}); + public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000002L,0x000000000F800003L}); + public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L}); + public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x4000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x4000000000000000L}); + public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x3000000000000002L,0x0000000030000000L}); + public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x4000000000000002L,0x0000000040000003L}); + public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000008000080L,0x0000000200000000L}); + public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0004000000000002L,0x0000000F80000003L}); + public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L}); + public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000002L}); + public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000100000002L,0x0000003000000010L}); + public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000000002L,0x000000C000000000L}); + public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000C00000000002L,0x0000010000000000L}); + public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000000050080L,0x0000C00000000000L}); + public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000050080L,0x0001C00000000002L}); + public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0008000008000080L,0x0000000200000000L}); + public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000002000000000L,0x0000000000000001L}); + public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0000C00208000002L,0x0000010000000000L}); + public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x00901002384503B0L,0x005FCE02000B802EL}); + public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000C00200000002L,0x0000010000000000L}); + public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0090000228C503B0L,0x005FCE00000B802EL}); + public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x00900006284503B0L,0x005FCE00000B802EL}); + public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000002400000000L}); + public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x00901006284503B0L,0x005FFE02000B802EL}); + public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000102000000000L}); + public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x00900006284503B0L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x009000022A4503B2L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x00900002284503B2L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x00900002284503B0L,0x005FCE02000B802EL}); + public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0102002008900080L,0x0000000200000000L}); + public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0002002000100000L}); + public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0002002000000000L}); + public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x009000022A4503B0L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000002002000000L}); + public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x00900002284503B0L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x009000022A4503B0L,0x005FCE00000B802EL}); + public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x00900002384503B0L,0x005FCE00000B802EL}); + public static final BitSet FOLLOW_104 = new BitSet(new long[]{0x0000000000000000L,0x0000040000000000L}); + public static final BitSet FOLLOW_105 = new BitSet(new long[]{0x0090000228C503B0L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_106 = new BitSet(new long[]{0x009000022AC503B0L,0x005FFE00000B802EL}); + public static final BitSet FOLLOW_107 = new BitSet(new long[]{0x0000000001000002L}); + public static final BitSet FOLLOW_108 = new BitSet(new long[]{0x0000000208000002L}); + public static final BitSet FOLLOW_109 = new BitSet(new long[]{0x0000000208000002L,0x0000000000000002L}); + public static final BitSet FOLLOW_110 = new BitSet(new long[]{0x0000000210000000L}); + public static final BitSet FOLLOW_111 = new BitSet(new long[]{0x00900002284503B2L,0x005FCE00000B802EL}); + public static final BitSet FOLLOW_112 = new BitSet(new long[]{0x0000000000000000L,0x00A0000000000000L}); + public static final BitSet FOLLOW_113 = new BitSet(new long[]{0x0000000000000002L,0x00A0000000000000L}); + public static final BitSet FOLLOW_114 = new BitSet(new long[]{0x0000000000000220L}); + public static final BitSet FOLLOW_115 = new BitSet(new long[]{0x0000000018000080L,0x0000000200000000L}); + public static final BitSet FOLLOW_116 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L}); + public static final BitSet FOLLOW_117 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000002L}); + public static final BitSet FOLLOW_118 = new BitSet(new long[]{0x0000800000000002L,0x0000000000000002L}); + public static final BitSet FOLLOW_119 = new BitSet(new long[]{0x0000000000000002L,0x0001400000000000L}); + public static final BitSet FOLLOW_120 = new BitSet(new long[]{0x0000000000000002L,0x0100000000000000L}); + public static final BitSet FOLLOW_121 = new BitSet(new long[]{0x0000800000000000L}); + public static final BitSet FOLLOW_122 = new BitSet(new long[]{0x0000000100000000L}); + public static final BitSet FOLLOW_123 = new BitSet(new long[]{0x0000000000000080L,0x0000800000000000L}); + public static final BitSet FOLLOW_124 = new BitSet(new long[]{0x0000000000040080L}); + public static final BitSet FOLLOW_125 = new BitSet(new long[]{0x0000000002000002L}); + public static final BitSet FOLLOW_126 = new BitSet(new long[]{0x0000000000000082L}); } \ No newline at end of file diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSemanticSequencer.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSemanticSequencer.java index bfe7e80ac6..8adc5734f4 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSemanticSequencer.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSemanticSequencer.java @@ -51,9 +51,54 @@ import org.eclipse.xtext.Action; import org.eclipse.xtext.Parameter; import org.eclipse.xtext.ParserRule; +import org.eclipse.xtext.common.types.JvmFormalParameter; +import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference; +import org.eclipse.xtext.common.types.JvmInnerTypeReference; +import org.eclipse.xtext.common.types.JvmLowerBound; +import org.eclipse.xtext.common.types.JvmParameterizedTypeReference; +import org.eclipse.xtext.common.types.JvmTypeParameter; +import org.eclipse.xtext.common.types.JvmUpperBound; +import org.eclipse.xtext.common.types.JvmWildcardTypeReference; +import org.eclipse.xtext.common.types.TypesPackage; import org.eclipse.xtext.serializer.ISerializationContext; import org.eclipse.xtext.serializer.acceptor.SequenceFeeder; import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient; +import org.eclipse.xtext.xbase.XAssignment; +import org.eclipse.xtext.xbase.XBasicForLoopExpression; +import org.eclipse.xtext.xbase.XBinaryOperation; +import org.eclipse.xtext.xbase.XBlockExpression; +import org.eclipse.xtext.xbase.XBooleanLiteral; +import org.eclipse.xtext.xbase.XCasePart; +import org.eclipse.xtext.xbase.XCastedExpression; +import org.eclipse.xtext.xbase.XCatchClause; +import org.eclipse.xtext.xbase.XClosure; +import org.eclipse.xtext.xbase.XConstructorCall; +import org.eclipse.xtext.xbase.XDoWhileExpression; +import org.eclipse.xtext.xbase.XFeatureCall; +import org.eclipse.xtext.xbase.XForLoopExpression; +import org.eclipse.xtext.xbase.XIfExpression; +import org.eclipse.xtext.xbase.XInstanceOfExpression; +import org.eclipse.xtext.xbase.XListLiteral; +import org.eclipse.xtext.xbase.XMemberFeatureCall; +import org.eclipse.xtext.xbase.XNullLiteral; +import org.eclipse.xtext.xbase.XNumberLiteral; +import org.eclipse.xtext.xbase.XPostfixOperation; +import org.eclipse.xtext.xbase.XReturnExpression; +import org.eclipse.xtext.xbase.XSetLiteral; +import org.eclipse.xtext.xbase.XStringLiteral; +import org.eclipse.xtext.xbase.XSwitchExpression; +import org.eclipse.xtext.xbase.XSynchronizedExpression; +import org.eclipse.xtext.xbase.XThrowExpression; +import org.eclipse.xtext.xbase.XTryCatchFinallyExpression; +import org.eclipse.xtext.xbase.XTypeLiteral; +import org.eclipse.xtext.xbase.XUnaryOperation; +import org.eclipse.xtext.xbase.XVariableDeclaration; +import org.eclipse.xtext.xbase.XWhileExpression; +import org.eclipse.xtext.xbase.XbasePackage; +import org.eclipse.xtext.xtype.XFunctionTypeRef; +import org.eclipse.xtext.xtype.XImportDeclaration; +import org.eclipse.xtext.xtype.XImportSection; +import org.eclipse.xtext.xtype.XtypePackage; @SuppressWarnings("all") public abstract class AbstractScopeSemanticSequencer extends ExpressionSemanticSequencer { @@ -384,6 +429,245 @@ else if (rule == grammarAccess.getSimpleScopeExpressionRule()) { } else break; } + else if (epackage == TypesPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case TypesPackage.JVM_FORMAL_PARAMETER: + if (rule == grammarAccess.getFullJvmFormalParameterRule()) { + sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmFormalParameterRule()) { + sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject); + return; + } + else break; + case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE: + sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); + return; + case TypesPackage.JVM_INNER_TYPE_REFERENCE: + sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); + return; + case TypesPackage.JVM_LOWER_BOUND: + if (rule == grammarAccess.getJvmLowerBoundAndedRule()) { + sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmLowerBoundRule()) { + sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE: + if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) { + sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmTypeReferenceRule() + || action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0() + || rule == grammarAccess.getJvmParameterizedTypeReferenceRule() + || rule == grammarAccess.getJvmArgumentTypeReferenceRule()) { + sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); + return; + } + else break; + case TypesPackage.JVM_TYPE_PARAMETER: + sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); + return; + case TypesPackage.JVM_UPPER_BOUND: + if (rule == grammarAccess.getJvmUpperBoundAndedRule()) { + sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); + return; + } + else if (rule == grammarAccess.getJvmUpperBoundRule()) { + sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); + return; + } + else break; + case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE: + sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); + return; + } + else if (epackage == XbasePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XbasePackage.XASSIGNMENT: + sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject); + return; + case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION: + sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject); + return; + case XbasePackage.XBINARY_OPERATION: + sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject); + return; + case XbasePackage.XBLOCK_EXPRESSION: + if (rule == grammarAccess.getXExpressionRule() + || rule == grammarAccess.getXAssignmentRule() + || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOrExpressionRule() + || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAndExpressionRule() + || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXEqualityExpressionRule() + || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXRelationalExpressionRule() + || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0() + || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOtherOperatorExpressionRule() + || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAdditiveExpressionRule() + || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXMultiplicativeExpressionRule() + || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXUnaryOperationRule() + || rule == grammarAccess.getXCastedExpressionRule() + || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0() + || rule == grammarAccess.getXPostfixOperationRule() + || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0() + || rule == grammarAccess.getXMemberFeatureCallRule() + || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0() + || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0() + || rule == grammarAccess.getXPrimaryExpressionRule() + || rule == grammarAccess.getXParenthesizedExpressionRule() + || rule == grammarAccess.getXBlockExpressionRule() + || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) { + sequence_XBlockExpression(context, (XBlockExpression) semanticObject); + return; + } + else if (rule == grammarAccess.getXExpressionInClosureRule()) { + sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject); + return; + } + else break; + case XbasePackage.XBOOLEAN_LITERAL: + sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject); + return; + case XbasePackage.XCASE_PART: + sequence_XCasePart(context, (XCasePart) semanticObject); + return; + case XbasePackage.XCASTED_EXPRESSION: + sequence_XCastedExpression(context, (XCastedExpression) semanticObject); + return; + case XbasePackage.XCATCH_CLAUSE: + sequence_XCatchClause(context, (XCatchClause) semanticObject); + return; + case XbasePackage.XCLOSURE: + if (rule == grammarAccess.getXExpressionRule() + || rule == grammarAccess.getXAssignmentRule() + || action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOrExpressionRule() + || action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAndExpressionRule() + || action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXEqualityExpressionRule() + || action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXRelationalExpressionRule() + || action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0() + || action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0() + || rule == grammarAccess.getXOtherOperatorExpressionRule() + || action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXAdditiveExpressionRule() + || action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXMultiplicativeExpressionRule() + || action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0() + || rule == grammarAccess.getXUnaryOperationRule() + || rule == grammarAccess.getXCastedExpressionRule() + || action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0() + || rule == grammarAccess.getXPostfixOperationRule() + || action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0() + || rule == grammarAccess.getXMemberFeatureCallRule() + || action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0() + || action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0() + || rule == grammarAccess.getXPrimaryExpressionRule() + || rule == grammarAccess.getXLiteralRule() + || rule == grammarAccess.getXClosureRule() + || rule == grammarAccess.getXParenthesizedExpressionRule() + || rule == grammarAccess.getXExpressionOrVarDeclarationRule()) { + sequence_XClosure(context, (XClosure) semanticObject); + return; + } + else if (rule == grammarAccess.getXShortClosureRule()) { + sequence_XShortClosure(context, (XClosure) semanticObject); + return; + } + else break; + case XbasePackage.XCONSTRUCTOR_CALL: + sequence_XConstructorCall(context, (XConstructorCall) semanticObject); + return; + case XbasePackage.XDO_WHILE_EXPRESSION: + sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject); + return; + case XbasePackage.XFEATURE_CALL: + sequence_XFeatureCall(context, (XFeatureCall) semanticObject); + return; + case XbasePackage.XFOR_LOOP_EXPRESSION: + sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject); + return; + case XbasePackage.XIF_EXPRESSION: + sequence_XIfExpression(context, (XIfExpression) semanticObject); + return; + case XbasePackage.XINSTANCE_OF_EXPRESSION: + sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject); + return; + case XbasePackage.XLIST_LITERAL: + sequence_XListLiteral(context, (XListLiteral) semanticObject); + return; + case XbasePackage.XMEMBER_FEATURE_CALL: + sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject); + return; + case XbasePackage.XNULL_LITERAL: + sequence_XNullLiteral(context, (XNullLiteral) semanticObject); + return; + case XbasePackage.XNUMBER_LITERAL: + sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject); + return; + case XbasePackage.XPOSTFIX_OPERATION: + sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject); + return; + case XbasePackage.XRETURN_EXPRESSION: + sequence_XReturnExpression(context, (XReturnExpression) semanticObject); + return; + case XbasePackage.XSET_LITERAL: + sequence_XSetLiteral(context, (XSetLiteral) semanticObject); + return; + case XbasePackage.XSTRING_LITERAL: + sequence_XStringLiteral(context, (XStringLiteral) semanticObject); + return; + case XbasePackage.XSWITCH_EXPRESSION: + sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject); + return; + case XbasePackage.XSYNCHRONIZED_EXPRESSION: + sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject); + return; + case XbasePackage.XTHROW_EXPRESSION: + sequence_XThrowExpression(context, (XThrowExpression) semanticObject); + return; + case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION: + sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject); + return; + case XbasePackage.XTYPE_LITERAL: + sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject); + return; + case XbasePackage.XUNARY_OPERATION: + sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject); + return; + case XbasePackage.XVARIABLE_DECLARATION: + sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject); + return; + case XbasePackage.XWHILE_EXPRESSION: + sequence_XWhileExpression(context, (XWhileExpression) semanticObject); + return; + } + else if (epackage == XtypePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case XtypePackage.XFUNCTION_TYPE_REF: + sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); + return; + case XtypePackage.XIMPORT_DECLARATION: + sequence_XImportDeclaration(context, (XImportDeclaration) semanticObject); + return; + case XtypePackage.XIMPORT_SECTION: + sequence_XImportSection(context, (XImportSection) semanticObject); + return; + } if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); } diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSyntacticSequencer.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSyntacticSequencer.java index f55d03d8fa..f5cbc0b686 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSyntacticSequencer.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/serializer/AbstractScopeSyntacticSequencer.java @@ -11,6 +11,7 @@ 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.GroupAlias; import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias; import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable; import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition; @@ -22,19 +23,56 @@ public abstract class AbstractScopeSyntacticSequencer extends AbstractSyntacticS protected ScopeGrammarAccess grammarAccess; protected AbstractElementAlias match_ParanthesizedExpression_LeftParenthesisKeyword_0_a; protected AbstractElementAlias match_ParanthesizedExpression_LeftParenthesisKeyword_0_p; + protected AbstractElementAlias match_XBlockExpression_SemicolonKeyword_2_1_q; + protected AbstractElementAlias match_XExpressionInClosure_SemicolonKeyword_1_1_q; + protected AbstractElementAlias match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q; + protected AbstractElementAlias match_XImportDeclaration_SemicolonKeyword_2_q; + protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_a; + protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_p; @Inject protected void init(IGrammarAccess access) { grammarAccess = (ScopeGrammarAccess) access; match_ParanthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); match_ParanthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getParanthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + match_XBlockExpression_SemicolonKeyword_2_1_q = new TokenAlias(false, true, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); + match_XExpressionInClosure_SemicolonKeyword_1_1_q = new TokenAlias(false, true, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); + match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()), new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2())); + match_XImportDeclaration_SemicolonKeyword_2_q = new TokenAlias(false, true, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_2()); + match_XParenthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); + match_XParenthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); } @Override protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (ruleCall.getRule() == grammarAccess.getArrayBracketsRule()) + return getArrayBracketsToken(semanticObject, ruleCall, node); + else if (ruleCall.getRule() == grammarAccess.getOpSingleAssignRule()) + return getOpSingleAssignToken(semanticObject, ruleCall, node); return ""; } + /** + * ArrayBrackets : + * '[' ']' + * ; + */ + protected String getArrayBracketsToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "[ ]"; + } + + /** + * OpSingleAssign: + * '=' + * ; + */ + protected String getOpSingleAssignToken(EObject semanticObject, RuleCall ruleCall, INode node) { + if (node != null) + return getTokenText(node); + return "="; + } @Override protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) { @@ -46,6 +84,18 @@ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition trans emit_ParanthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes); else if (match_ParanthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax)) emit_ParanthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XBlockExpression_SemicolonKeyword_2_1_q.equals(syntax)) + emit_XBlockExpression_SemicolonKeyword_2_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XExpressionInClosure_SemicolonKeyword_1_1_q.equals(syntax)) + emit_XExpressionInClosure_SemicolonKeyword_1_1_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q.equals(syntax)) + emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XImportDeclaration_SemicolonKeyword_2_q.equals(syntax)) + emit_XImportDeclaration_SemicolonKeyword_2_q(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_a.equals(syntax)) + emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes); + else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax)) + emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes); else acceptNodes(getLastNavigableState(), syntaxNodes); } } @@ -150,4 +200,176 @@ protected void emit_ParanthesizedExpression_LeftParenthesisKeyword_0_p(EObject s acceptNodes(transition, nodes); } + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' ')' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 
+	 *
+ */ + protected void emit_XBlockExpression_SemicolonKeyword_2_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 
+	 *
+ */ + protected void emit_XExpressionInClosure_SemicolonKeyword_1_1_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ('(' ')')?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '=>' returnType=JvmTypeReference
+	 
+	 *
+ */ + protected void emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     importedNamespace=QualifiedNameWithWildcard (ambiguity) (rule end)
+	 *     importedType=[JvmDeclaredType|QualifiedName] (ambiguity) (rule end)
+	 *     memberName=ValidID (ambiguity) (rule end)
+	 *     wildcard?='*' (ambiguity) (rule end)
+	 
+	 *
+ */ + protected void emit_XImportDeclaration_SemicolonKeyword_2_q(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     '('*
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' (rule start)
+	 *     (rule start) (ambiguity) 'return' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 
+	 *
+ */ + protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + + /** + * 
+	 * Ambiguous syntax:
+	 *     '('+
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' ')' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 
+	 *
+ */ + protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(EObject semanticObject, ISynNavigable transition, List nodes) { + acceptNodes(transition, nodes); + } + } diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/services/ScopeGrammarAccess.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/services/ScopeGrammarAccess.java index 2b1faf48b4..c3027ef3d6 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/services/ScopeGrammarAccess.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/services/ScopeGrammarAccess.java @@ -20,9 +20,10 @@ import org.eclipse.xtext.ParserRule; import org.eclipse.xtext.RuleCall; import org.eclipse.xtext.TerminalRule; -import org.eclipse.xtext.common.services.TerminalsGrammarAccess; import org.eclipse.xtext.service.AbstractElementFinder; import org.eclipse.xtext.service.GrammarProvider; +import org.eclipse.xtext.xbase.services.XbaseGrammarAccess; +import org.eclipse.xtext.xbase.services.XtypeGrammarAccess; @Singleton public class ScopeGrammarAccess extends AbstractElementFinder.AbstractGrammarElementFinder { @@ -1262,15 +1263,19 @@ public class CasingElements extends AbstractElementFinder.AbstractEnumRuleElemen private final ExpressionGrammarAccess gaExpression; - private final TerminalsGrammarAccess gaTerminals; + private final XbaseGrammarAccess gaXbase; + + private final XtypeGrammarAccess gaXtype; @Inject public ScopeGrammarAccess(GrammarProvider grammarProvider, ExpressionGrammarAccess gaExpression, - TerminalsGrammarAccess gaTerminals) { + XbaseGrammarAccess gaXbase, + XtypeGrammarAccess gaXtype) { this.grammar = internalFindGrammar(grammarProvider); this.gaExpression = gaExpression; - this.gaTerminals = gaTerminals; + this.gaXbase = gaXbase; + this.gaXtype = gaXtype; this.pScopeModel = new ScopeModelElements(); this.pImport = new ImportElements(); this.pExtension = new ExtensionElements(); @@ -1322,8 +1327,12 @@ public ExpressionGrammarAccess getExpressionGrammarAccess() { return gaExpression; } - public TerminalsGrammarAccess getTerminalsGrammarAccess() { - return gaTerminals; + public XbaseGrammarAccess getXbaseGrammarAccess() { + return gaXbase; + } + + public XtypeGrammarAccess getXtypeGrammarAccess() { + return gaXtype; } @@ -2086,41 +2095,976 @@ public ParserRule getIdentifierRule() { return getIdentifierAccess().getRule(); } - //terminal ID: '^'?('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*; - public TerminalRule getIDRule() { - return gaTerminals.getIDRule(); + //XExpression returns XExpression : + // XAssignment; + public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() { + return gaXbase.getXExpressionAccess(); + } + + public ParserRule getXExpressionRule() { + return getXExpressionAccess().getRule(); + } + + //XAssignment returns XExpression : + // {XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | + // XOrExpression ( + // =>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign]) rightOperand=XAssignment + // )?; + public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() { + return gaXbase.getXAssignmentAccess(); + } + + public ParserRule getXAssignmentRule() { + return getXAssignmentAccess().getRule(); + } + + //OpSingleAssign: + // '=' + //; + public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() { + return gaXbase.getOpSingleAssignAccess(); + } + + public ParserRule getOpSingleAssignRule() { + return getOpSingleAssignAccess().getRule(); + } + + //OpMultiAssign: + // '+=' | '-=' | '*=' | '/=' | '%=' | + // '<' '<' '=' | + // '>' '>'? '>='; + public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() { + return gaXbase.getOpMultiAssignAccess(); + } + + public ParserRule getOpMultiAssignRule() { + return getOpMultiAssignAccess().getRule(); + } + + //XOrExpression returns XExpression: + // XAndExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr]) rightOperand=XAndExpression)*; + public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() { + return gaXbase.getXOrExpressionAccess(); + } + + public ParserRule getXOrExpressionRule() { + return getXOrExpressionAccess().getRule(); + } + + //OpOr: + // '||'; + public XbaseGrammarAccess.OpOrElements getOpOrAccess() { + return gaXbase.getOpOrAccess(); + } + + public ParserRule getOpOrRule() { + return getOpOrAccess().getRule(); + } + + //XAndExpression returns XExpression: + // XEqualityExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd]) rightOperand=XEqualityExpression)*; + public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() { + return gaXbase.getXAndExpressionAccess(); + } + + public ParserRule getXAndExpressionRule() { + return getXAndExpressionAccess().getRule(); + } + + //OpAnd: + // '&&'; + public XbaseGrammarAccess.OpAndElements getOpAndAccess() { + return gaXbase.getOpAndAccess(); + } + + public ParserRule getOpAndRule() { + return getOpAndAccess().getRule(); + } + + //XEqualityExpression returns XExpression: + // XRelationalExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality]) + // rightOperand=XRelationalExpression)*; + public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() { + return gaXbase.getXEqualityExpressionAccess(); + } + + public ParserRule getXEqualityExpressionRule() { + return getXEqualityExpressionAccess().getRule(); + } + + //OpEquality: + // '==' | '!=' | '===' | '!=='; + public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() { + return gaXbase.getOpEqualityAccess(); + } + + public ParserRule getOpEqualityRule() { + return getOpEqualityAccess().getRule(); + } + + //XRelationalExpression returns XExpression: + // XOtherOperatorExpression + // (=>({XInstanceOfExpression.expression=current} 'instanceof') type=JvmTypeReference | + // =>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare]) rightOperand=XOtherOperatorExpression)*; + public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() { + return gaXbase.getXRelationalExpressionAccess(); + } + + public ParserRule getXRelationalExpressionRule() { + return getXRelationalExpressionAccess().getRule(); + } + + //OpCompare: + // '>=' | '<' '=' | '>' | '<' ; + public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() { + return gaXbase.getOpCompareAccess(); + } + + public ParserRule getOpCompareRule() { + return getOpCompareAccess().getRule(); + } + + //XOtherOperatorExpression returns XExpression: + // XAdditiveExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther]) + // rightOperand=XAdditiveExpression)*; + public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() { + return gaXbase.getXOtherOperatorExpressionAccess(); + } + + public ParserRule getXOtherOperatorExpressionRule() { + return getXOtherOperatorExpressionAccess().getRule(); + } + + //OpOther: + // '->' + // | '..<' + // | '>' '..' + // | '..' + // | '=>' + // | '>' (=>('>' '>') | '>') + // | '<' (=>('<' '<') | '<' | '=>') + // | '<>' + // | '?:'; + public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() { + return gaXbase.getOpOtherAccess(); + } + + public ParserRule getOpOtherRule() { + return getOpOtherAccess().getRule(); + } + + //XAdditiveExpression returns XExpression: + // XMultiplicativeExpression (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd]) + // rightOperand=XMultiplicativeExpression)*; + public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() { + return gaXbase.getXAdditiveExpressionAccess(); + } + + public ParserRule getXAdditiveExpressionRule() { + return getXAdditiveExpressionAccess().getRule(); + } + + //OpAdd: + // '+' | '-'; + public XbaseGrammarAccess.OpAddElements getOpAddAccess() { + return gaXbase.getOpAddAccess(); + } + + public ParserRule getOpAddRule() { + return getOpAddAccess().getRule(); + } + + //XMultiplicativeExpression returns XExpression: + // XUnaryOperation (=>({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti]) rightOperand=XUnaryOperation)*; + public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() { + return gaXbase.getXMultiplicativeExpressionAccess(); + } + + public ParserRule getXMultiplicativeExpressionRule() { + return getXMultiplicativeExpressionAccess().getRule(); + } + + //OpMulti: + // '*' | '**' | '/' | '%'; + public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() { + return gaXbase.getOpMultiAccess(); + } + + public ParserRule getOpMultiRule() { + return getOpMultiAccess().getRule(); + } + + //XUnaryOperation returns XExpression: + // {XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation + // | XCastedExpression; + public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() { + return gaXbase.getXUnaryOperationAccess(); + } + + public ParserRule getXUnaryOperationRule() { + return getXUnaryOperationAccess().getRule(); + } + + //OpUnary: + // "!" | "-" | "+"; + public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() { + return gaXbase.getOpUnaryAccess(); + } + + public ParserRule getOpUnaryRule() { + return getOpUnaryAccess().getRule(); + } + + //XCastedExpression returns XExpression: + // XPostfixOperation (=>({XCastedExpression.target=current} 'as') type=JvmTypeReference)* + //; + public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() { + return gaXbase.getXCastedExpressionAccess(); + } + + public ParserRule getXCastedExpressionRule() { + return getXCastedExpressionAccess().getRule(); + } + + //XPostfixOperation returns XExpression: + // XMemberFeatureCall =>({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])? + //; + public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() { + return gaXbase.getXPostfixOperationAccess(); + } + + public ParserRule getXPostfixOperationRule() { + return getXPostfixOperationAccess().getRule(); + } + + //OpPostfix: + // "++" | "--" + //; + public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() { + return gaXbase.getOpPostfixAccess(); + } + + public ParserRule getOpPostfixRule() { + return getOpPostfixAccess().getRule(); + } + + //XMemberFeatureCall returns XExpression: + // XPrimaryExpression + // (=>({XAssignment.assignable=current} ('.'|explicitStatic?="::") feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment + // |=>({XMemberFeatureCall.memberCallTarget=current} ("."|nullSafe?="?."|explicitStatic?="::")) + // ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // feature=[types::JvmIdentifiableElement|IdOrSuper] ( + // =>explicitOperationCall?='(' + // ( + // memberCallArguments+=XShortClosure + // | memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)* + // )? + // ')')? + // memberCallArguments+=XClosure? + // )*; + public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() { + return gaXbase.getXMemberFeatureCallAccess(); + } + + public ParserRule getXMemberFeatureCallRule() { + return getXMemberFeatureCallAccess().getRule(); + } + + //XPrimaryExpression returns XExpression: + // XConstructorCall | + // XBlockExpression | + // XSwitchExpression | + // XSynchronizedExpression | + // XFeatureCall | + // XLiteral | + // XIfExpression | + // XForLoopExpression | + // XBasicForLoopExpression | + // XWhileExpression | + // XDoWhileExpression | + // XThrowExpression | + // XReturnExpression | + // XTryCatchFinallyExpression | + // XParenthesizedExpression; + public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() { + return gaXbase.getXPrimaryExpressionAccess(); + } + + public ParserRule getXPrimaryExpressionRule() { + return getXPrimaryExpressionAccess().getRule(); + } + + //XLiteral returns XExpression: + // XCollectionLiteral | + // XClosure | + // XBooleanLiteral | + // XNumberLiteral | + // XNullLiteral | + // XStringLiteral | + // XTypeLiteral + //; + public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() { + return gaXbase.getXLiteralAccess(); + } + + public ParserRule getXLiteralRule() { + return getXLiteralAccess().getRule(); + } + + //XCollectionLiteral: + // XSetLiteral | XListLiteral + //; + public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() { + return gaXbase.getXCollectionLiteralAccess(); + } + + public ParserRule getXCollectionLiteralRule() { + return getXCollectionLiteralAccess().getRule(); + } + + //XSetLiteral: + // {XSetLiteral} '#' '{' (elements+=XExpression (',' elements+=XExpression )*)? '}' + //; + public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() { + return gaXbase.getXSetLiteralAccess(); + } + + public ParserRule getXSetLiteralRule() { + return getXSetLiteralAccess().getRule(); + } + + //XListLiteral: + // {XListLiteral} '#' '[' (elements+=XExpression (',' elements+=XExpression )*)? ']' + //; + public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() { + return gaXbase.getXListLiteralAccess(); + } + + public ParserRule getXListLiteralRule() { + return getXListLiteralAccess().getRule(); + } + + //XClosure returns XExpression: + // =>({XClosure} + // '[') + // =>((declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?='|')? + // expression=XExpressionInClosure + // ']'; + public XbaseGrammarAccess.XClosureElements getXClosureAccess() { + return gaXbase.getXClosureAccess(); + } + + public ParserRule getXClosureRule() { + return getXClosureAccess().getRule(); + } + + //XExpressionInClosure returns XExpression: + // {XBlockExpression} + // (expressions+=XExpressionOrVarDeclaration ';'?)* + //; + public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() { + return gaXbase.getXExpressionInClosureAccess(); + } + + public ParserRule getXExpressionInClosureRule() { + return getXExpressionInClosureAccess().getRule(); + } + + //XShortClosure returns XExpression: + // =>({XClosure} (declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)? explicitSyntax?='|') expression=XExpression; + public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() { + return gaXbase.getXShortClosureAccess(); + } + + public ParserRule getXShortClosureRule() { + return getXShortClosureAccess().getRule(); + } + + //XParenthesizedExpression returns XExpression: + // '(' XExpression ')'; + public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() { + return gaXbase.getXParenthesizedExpressionAccess(); + } + + public ParserRule getXParenthesizedExpressionRule() { + return getXParenthesizedExpressionAccess().getRule(); + } + + //XIfExpression returns XExpression: + // {XIfExpression} + // 'if' '(' if=XExpression ')' + // then=XExpression + // (=>'else' else=XExpression)?; + public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() { + return gaXbase.getXIfExpressionAccess(); + } + + public ParserRule getXIfExpressionRule() { + return getXIfExpressionAccess().getRule(); + } + + //XSwitchExpression returns XExpression: + // {XSwitchExpression} + // 'switch' (=>('(' declaredParam=JvmFormalParameter ':') switch=XExpression ')' + // | =>(declaredParam=JvmFormalParameter ':')? switch=XExpression) '{' + // (cases+=XCasePart)* + // ('default' ':' default=XExpression )? + // '}'; + public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() { + return gaXbase.getXSwitchExpressionAccess(); + } + + public ParserRule getXSwitchExpressionRule() { + return getXSwitchExpressionAccess().getRule(); + } + + //XCasePart: + // {XCasePart} + // typeGuard=JvmTypeReference? ('case' case=XExpression)? + // (':' then=XExpression | fallThrough?=',') ; + public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() { + return gaXbase.getXCasePartAccess(); + } + + public ParserRule getXCasePartRule() { + return getXCasePartAccess().getRule(); + } + + //XForLoopExpression returns XExpression: + // =>({XForLoopExpression} + // 'for' '(' declaredParam=JvmFormalParameter ':') forExpression=XExpression ')' + // eachExpression=XExpression; + public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() { + return gaXbase.getXForLoopExpressionAccess(); + } + + public ParserRule getXForLoopExpressionRule() { + return getXForLoopExpressionAccess().getRule(); + } + + //XBasicForLoopExpression returns XExpression: + // {XBasicForLoopExpression} + // 'for' '('(initExpressions+=XExpressionOrVarDeclaration (',' initExpressions+=XExpressionOrVarDeclaration)*)? ';' + // expression=XExpression? ';' + // (updateExpressions+=XExpression (',' updateExpressions+=XExpression)*)? ')' + // eachExpression=XExpression; + public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() { + return gaXbase.getXBasicForLoopExpressionAccess(); + } + + public ParserRule getXBasicForLoopExpressionRule() { + return getXBasicForLoopExpressionAccess().getRule(); + } + + //XWhileExpression returns XExpression: + // {XWhileExpression} + // 'while' '(' predicate=XExpression ')' + // body=XExpression; + public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() { + return gaXbase.getXWhileExpressionAccess(); + } + + public ParserRule getXWhileExpressionRule() { + return getXWhileExpressionAccess().getRule(); + } + + //XDoWhileExpression returns XExpression: + // {XDoWhileExpression} + // 'do' + // body=XExpression + // 'while' '(' predicate=XExpression ')'; + public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() { + return gaXbase.getXDoWhileExpressionAccess(); + } + + public ParserRule getXDoWhileExpressionRule() { + return getXDoWhileExpressionAccess().getRule(); + } + + //XBlockExpression returns XExpression: + // {XBlockExpression} + // '{' + // (expressions+=XExpressionOrVarDeclaration ';'?)* + // '}'; + public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() { + return gaXbase.getXBlockExpressionAccess(); + } + + public ParserRule getXBlockExpressionRule() { + return getXBlockExpressionAccess().getRule(); } - //terminal INT returns ecore::EInt: ('0'..'9')+; + //XExpressionOrVarDeclaration returns XExpression: + // XVariableDeclaration | XExpression; + public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() { + return gaXbase.getXExpressionOrVarDeclarationAccess(); + } + + public ParserRule getXExpressionOrVarDeclarationRule() { + return getXExpressionOrVarDeclarationAccess().getRule(); + } + + //XVariableDeclaration returns XExpression: + // {XVariableDeclaration} + // (writeable?='var'|'val') (=>(type=JvmTypeReference name=ValidID) | name=ValidID) ('=' right=XExpression)?; + public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() { + return gaXbase.getXVariableDeclarationAccess(); + } + + public ParserRule getXVariableDeclarationRule() { + return getXVariableDeclarationAccess().getRule(); + } + + //JvmFormalParameter returns types::JvmFormalParameter: + // (parameterType=JvmTypeReference)? name=ValidID; + public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() { + return gaXbase.getJvmFormalParameterAccess(); + } + + public ParserRule getJvmFormalParameterRule() { + return getJvmFormalParameterAccess().getRule(); + } + + //FullJvmFormalParameter returns types::JvmFormalParameter: + // parameterType=JvmTypeReference name=ValidID; + public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() { + return gaXbase.getFullJvmFormalParameterAccess(); + } + + public ParserRule getFullJvmFormalParameterRule() { + return getFullJvmFormalParameterAccess().getRule(); + } + + //XFeatureCall returns XExpression: + // {XFeatureCall} + // ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // feature=[types::JvmIdentifiableElement|IdOrSuper] + // (=>explicitOperationCall?='(' + // ( + // featureCallArguments+=XShortClosure + // | featureCallArguments+=XExpression (',' featureCallArguments+=XExpression)* + // )? + // ')')? + // featureCallArguments+=XClosure?; + public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() { + return gaXbase.getXFeatureCallAccess(); + } + + public ParserRule getXFeatureCallRule() { + return getXFeatureCallAccess().getRule(); + } + + //FeatureCallID: + // ValidID | 'extends' | 'static' | 'import' | 'extension' + //; + public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() { + return gaXbase.getFeatureCallIDAccess(); + } + + public ParserRule getFeatureCallIDRule() { + return getFeatureCallIDAccess().getRule(); + } + + //IdOrSuper : + // FeatureCallID | 'super' + //; + public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() { + return gaXbase.getIdOrSuperAccess(); + } + + public ParserRule getIdOrSuperRule() { + return getIdOrSuperAccess().getRule(); + } + + //XConstructorCall returns XExpression: + // {XConstructorCall} + // 'new' constructor=[types::JvmConstructor|QualifiedName] + // (=>'<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')? + // (=>explicitConstructorCall?='(' + // ( + // arguments+=XShortClosure + // | arguments+=XExpression (',' arguments+=XExpression)* + // )? + // ')')? + // arguments+=XClosure?; + public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() { + return gaXbase.getXConstructorCallAccess(); + } + + public ParserRule getXConstructorCallRule() { + return getXConstructorCallAccess().getRule(); + } + + //XBooleanLiteral returns XExpression : + // {XBooleanLiteral} ('false' | isTrue?='true'); + public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() { + return gaXbase.getXBooleanLiteralAccess(); + } + + public ParserRule getXBooleanLiteralRule() { + return getXBooleanLiteralAccess().getRule(); + } + + //XNullLiteral returns XExpression : + // {XNullLiteral} 'null'; + public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() { + return gaXbase.getXNullLiteralAccess(); + } + + public ParserRule getXNullLiteralRule() { + return getXNullLiteralAccess().getRule(); + } + + //XNumberLiteral returns XExpression : + // {XNumberLiteral} value=Number; + public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() { + return gaXbase.getXNumberLiteralAccess(); + } + + public ParserRule getXNumberLiteralRule() { + return getXNumberLiteralAccess().getRule(); + } + + //XStringLiteral returns XExpression: + // {XStringLiteral} value=STRING; + public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() { + return gaXbase.getXStringLiteralAccess(); + } + + public ParserRule getXStringLiteralRule() { + return getXStringLiteralAccess().getRule(); + } + + //XTypeLiteral returns XExpression : + // {XTypeLiteral} 'typeof' '(' type=[types::JvmType|QualifiedName] (arrayDimensions+=ArrayBrackets)* ')' + //; + public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() { + return gaXbase.getXTypeLiteralAccess(); + } + + public ParserRule getXTypeLiteralRule() { + return getXTypeLiteralAccess().getRule(); + } + + //XThrowExpression returns XExpression : + // {XThrowExpression} 'throw' expression=XExpression; + public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() { + return gaXbase.getXThrowExpressionAccess(); + } + + public ParserRule getXThrowExpressionRule() { + return getXThrowExpressionAccess().getRule(); + } + + //XReturnExpression returns XExpression : + // {XReturnExpression} 'return' (->expression=XExpression)?; + public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() { + return gaXbase.getXReturnExpressionAccess(); + } + + public ParserRule getXReturnExpressionRule() { + return getXReturnExpressionAccess().getRule(); + } + + //XTryCatchFinallyExpression returns XExpression: + // {XTryCatchFinallyExpression} + // 'try' + // expression=XExpression + // ( + // catchClauses+=XCatchClause+ + // (=>'finally' finallyExpression=XExpression)? + // | 'finally' finallyExpression=XExpression + // ); + public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() { + return gaXbase.getXTryCatchFinallyExpressionAccess(); + } + + public ParserRule getXTryCatchFinallyExpressionRule() { + return getXTryCatchFinallyExpressionAccess().getRule(); + } + + //XSynchronizedExpression returns XExpression: + // =>({XSynchronizedExpression} + // 'synchronized' '(') param=XExpression ')' expression=XExpression; + public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() { + return gaXbase.getXSynchronizedExpressionAccess(); + } + + public ParserRule getXSynchronizedExpressionRule() { + return getXSynchronizedExpressionAccess().getRule(); + } + + //XCatchClause : + // =>'catch' '(' declaredParam=FullJvmFormalParameter ')' expression=XExpression; + public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() { + return gaXbase.getXCatchClauseAccess(); + } + + public ParserRule getXCatchClauseRule() { + return getXCatchClauseAccess().getRule(); + } + + //@Override + //QualifiedName: + // ValidID (=>'.' ValidID)*; + public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() { + return gaXbase.getQualifiedNameAccess(); + } + + public ParserRule getQualifiedNameRule() { + return getQualifiedNameAccess().getRule(); + } + + //Number hidden(): + // HEX | (INT | DECIMAL) ('.' (INT | DECIMAL))?; + public XbaseGrammarAccess.NumberElements getNumberAccess() { + return gaXbase.getNumberAccess(); + } + + public ParserRule getNumberRule() { + return getNumberAccess().getRule(); + } + + ///** + // * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes, + // * which makes downstream grammars break on classloading, when a rule is removed. + // */ + //StaticQualifier: + // (ValidID '::')+ + //; + public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() { + return gaXbase.getStaticQualifierAccess(); + } + + public ParserRule getStaticQualifierRule() { + return getStaticQualifierAccess().getRule(); + } + + //terminal HEX: + // ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ + // ('#' (('b'|'B')('i'|'I') | ('l'|'L')))?; + public TerminalRule getHEXRule() { + return gaXbase.getHEXRule(); + } + + //terminal INT returns ecore::EInt: + // '0'..'9' ('0'..'9'|'_')*; public TerminalRule getINTRule() { - return gaTerminals.getINTRule(); + return gaXbase.getINTRule(); + } + + //terminal DECIMAL: + // INT + // (('e'|'E') ('+'|'-')? INT)? + // (('b'|'B')('i'|'I'|'d'|'D') | ('l'|'L'|'d'|'D'|'f'|'F'))?; + public TerminalRule getDECIMALRule() { + return gaXbase.getDECIMALRule(); + } + + //JvmTypeReference: + // JvmParameterizedTypeReference =>({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)* + // | XFunctionTypeRef; + public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() { + return gaXtype.getJvmTypeReferenceAccess(); + } + + public ParserRule getJvmTypeReferenceRule() { + return getJvmTypeReferenceAccess().getRule(); + } + + //ArrayBrackets : + // '[' ']' + //; + public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() { + return gaXtype.getArrayBracketsAccess(); + } + + public ParserRule getArrayBracketsRule() { + return getArrayBracketsAccess().getRule(); + } + + //XFunctionTypeRef: + // ('(' (paramTypes+=JvmTypeReference (',' paramTypes+=JvmTypeReference)*)? ')')? '=>' returnType=JvmTypeReference; + public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() { + return gaXtype.getXFunctionTypeRefAccess(); + } + + public ParserRule getXFunctionTypeRefRule() { + return getXFunctionTypeRefAccess().getRule(); + } + + //JvmParameterizedTypeReference: + // type=[JvmType|QualifiedName] ( + // =>'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>' + // (=>({JvmInnerTypeReference.outer=current} '.') type=[JvmType|ValidID] (=>'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>')?)* + // )?; + public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() { + return gaXtype.getJvmParameterizedTypeReferenceAccess(); + } + + public ParserRule getJvmParameterizedTypeReferenceRule() { + return getJvmParameterizedTypeReferenceAccess().getRule(); + } + + //JvmArgumentTypeReference returns JvmTypeReference: + // JvmTypeReference | JvmWildcardTypeReference; + public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() { + return gaXtype.getJvmArgumentTypeReferenceAccess(); + } + + public ParserRule getJvmArgumentTypeReferenceRule() { + return getJvmArgumentTypeReferenceAccess().getRule(); + } + + //JvmWildcardTypeReference: + // {JvmWildcardTypeReference} '?' ( + // constraints+=JvmUpperBound (constraints+=JvmUpperBoundAnded)* + // | constraints+=JvmLowerBound (constraints+=JvmLowerBoundAnded)* + // )?; + public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() { + return gaXtype.getJvmWildcardTypeReferenceAccess(); + } + + public ParserRule getJvmWildcardTypeReferenceRule() { + return getJvmWildcardTypeReferenceAccess().getRule(); + } + + //JvmUpperBound : + // 'extends' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() { + return gaXtype.getJvmUpperBoundAccess(); + } + + public ParserRule getJvmUpperBoundRule() { + return getJvmUpperBoundAccess().getRule(); + } + + //JvmUpperBoundAnded returns JvmUpperBound: + // '&' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() { + return gaXtype.getJvmUpperBoundAndedAccess(); + } + + public ParserRule getJvmUpperBoundAndedRule() { + return getJvmUpperBoundAndedAccess().getRule(); + } + + //JvmLowerBound : + // 'super' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() { + return gaXtype.getJvmLowerBoundAccess(); + } + + public ParserRule getJvmLowerBoundRule() { + return getJvmLowerBoundAccess().getRule(); + } + + //JvmLowerBoundAnded returns JvmLowerBound: + // '&' typeReference=JvmTypeReference; + public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() { + return gaXtype.getJvmLowerBoundAndedAccess(); + } + + public ParserRule getJvmLowerBoundAndedRule() { + return getJvmLowerBoundAndedAccess().getRule(); + } + + //JvmTypeParameter : + // name=ValidID + // (constraints+=JvmUpperBound (constraints+=JvmUpperBoundAnded)*)?; + public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() { + return gaXtype.getJvmTypeParameterAccess(); + } + + public ParserRule getJvmTypeParameterRule() { + return getJvmTypeParameterAccess().getRule(); + } + + //QualifiedNameWithWildcard : + // QualifiedName '.' '*'; + public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() { + return gaXtype.getQualifiedNameWithWildcardAccess(); + } + + public ParserRule getQualifiedNameWithWildcardRule() { + return getQualifiedNameWithWildcardAccess().getRule(); + } + + //ValidID: + // ID; + public XtypeGrammarAccess.ValidIDElements getValidIDAccess() { + return gaXtype.getValidIDAccess(); + } + + public ParserRule getValidIDRule() { + return getValidIDAccess().getRule(); + } + + //XImportSection: + // importDeclarations+=XImportDeclaration+; + public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() { + return gaXtype.getXImportSectionAccess(); + } + + public ParserRule getXImportSectionRule() { + return getXImportSectionAccess().getRule(); + } + + //XImportDeclaration: + // 'import' ( + // (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID)) + // | importedType=[JvmDeclaredType|QualifiedName] + // | importedNamespace=QualifiedNameWithWildcard) ';'? + //; + public XtypeGrammarAccess.XImportDeclarationElements getXImportDeclarationAccess() { + return gaXtype.getXImportDeclarationAccess(); + } + + public ParserRule getXImportDeclarationRule() { + return getXImportDeclarationAccess().getRule(); + } + + //QualifiedNameInStaticImport: + // (ValidID '.')+ + //; + public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() { + return gaXtype.getQualifiedNameInStaticImportAccess(); + } + + public ParserRule getQualifiedNameInStaticImportRule() { + return getQualifiedNameInStaticImportAccess().getRule(); + } + + //terminal ID: + // '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*; + public TerminalRule getIDRule() { + return gaXtype.getIDRule(); } //terminal STRING: - // '"' ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|'"') )* '"' | - // "'" ( '\\' . /* 'b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\' */ | !('\\'|"'") )* "'" - // ; + // '"' ( '\\' . /* ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') */ | !('\\'|'"') )* '"'? | + // "'" ( '\\' . /* ('b'|'t'|'n'|'f'|'r'|'u'|'"'|"'"|'\\') */ | !('\\'|"'") )* "'"?; public TerminalRule getSTRINGRule() { - return gaTerminals.getSTRINGRule(); + return gaXtype.getSTRINGRule(); } - //terminal ML_COMMENT : '/*' -> '*/'; + //terminal ML_COMMENT: '/*' -> '*/'; public TerminalRule getML_COMMENTRule() { - return gaTerminals.getML_COMMENTRule(); + return gaXtype.getML_COMMENTRule(); } - //terminal SL_COMMENT : '//' !('\n'|'\r')* ('\r'? '\n')?; + //terminal SL_COMMENT: '//' !('\n'|'\r')* ('\r'? '\n')?; public TerminalRule getSL_COMMENTRule() { - return gaTerminals.getSL_COMMENTRule(); + return gaXtype.getSL_COMMENTRule(); } - //terminal WS : (' '|'\t'|'\r'|'\n')+; + //terminal WS: (' '|'\t'|'\r'|'\n')+; public TerminalRule getWSRule() { - return gaTerminals.getWSRule(); + return gaXtype.getWSRule(); } //terminal ANY_OTHER: .; public TerminalRule getANY_OTHERRule() { - return gaTerminals.getANY_OTHERRule(); + return gaXtype.getANY_OTHERRule(); } } diff --git a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/validation/AbstractScopeValidator.java b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/validation/AbstractScopeValidator.java index 94b3d9c326..3184415705 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/validation/AbstractScopeValidator.java +++ b/com.avaloq.tools.ddk.xtext.scope/src-gen/com/avaloq/tools/ddk/xtext/scope/validation/AbstractScopeValidator.java @@ -15,6 +15,9 @@ protected List getEPackages() { List result = new ArrayList(super.getEPackages()); result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.avaloq.com/tools/ddk/xtext/Scope")); result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.avaloq.com/tools/ddk/xtext/expression/Expression")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xbase")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/common/JavaVMTypes")); + result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xtype")); return result; } } diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/ScopeRuntimeModule.java b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/ScopeRuntimeModule.java index 09c5499475..103bee2a13 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/ScopeRuntimeModule.java +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/ScopeRuntimeModule.java @@ -53,6 +53,7 @@ public ClassLoader bindClassLoaderToInstance() { * * @return implementation */ + @Override public Class bindIQualifiedNameConverter() { return ScopeQualifiedNameConverter.class; } @@ -67,6 +68,7 @@ public Class bindILocationInFileProvider() { * * @return {@link ScopeResourceDescriptionStrategy} */ + @Override public Class bindIDefaultResourceDescriptionStrategy() { return ScopeResourceDescriptionStrategy.class; } diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeGenerator.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeGenerator.xtend deleted file mode 100644 index 3dce9dd4fa..0000000000 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeGenerator.xtend +++ /dev/null @@ -1,83 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2016 Avaloq Group AG and others. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the Eclipse Public License v1.0 - * which accompanies this distribution, and is available at - * http://www.eclipse.org/legal/epl-v10.html - * - * Contributors: - * Avaloq Group AG - initial API and implementation - *******************************************************************************/ - -package com.avaloq.tools.ddk.xtext.scope.generator - -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorSupport -import com.avaloq.tools.ddk.xtext.expression.generator.Naming -import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel -import com.google.inject.Inject -import org.eclipse.core.resources.IProject -import org.eclipse.core.resources.ResourcesPlugin -import org.eclipse.emf.ecore.resource.Resource -import org.eclipse.xtext.generator.IFileSystemAccess -import org.eclipse.xtext.scoping.IScopeProvider -import org.eclipse.xtext.generator.IGenerator2 -import org.eclipse.xtext.generator.IFileSystemAccess2 -import org.eclipse.xtext.generator.IGeneratorContext - -/** - * Scope generator generating the {@link IScopeProvider} implementation for a given scope file. - */ -class ScopeGenerator implements IGenerator2 { - - @Inject - extension Naming - @Inject - ScopeProviderGenerator scopeProvider - @Inject - ScopeNameProviderGenerator nameProvider - @Inject - GenModelUtilX genModelUtil - @Inject - GeneratorSupport generatorSupport - - CompilationContext compilationContext - - override doGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) { - if (input === null || input.contents.empty || !(input.contents.head instanceof ScopeModel)) { - return - } - val model = input.contents.head as ScopeModel - genModelUtil.resource = model.eResource - var IProject project = null - if (input.URI.isPlatformResource) { - val res = ResourcesPlugin.workspace.root.findMember(input.URI.toPlatformString(true)) - if (res !== null) { - project = res.project - } - } - - generatorSupport.executeWithProjectResourceLoader(project, [ - compilationContext = ScopingGeneratorUtil.getCompilationContext(model, genModelUtil) - - generateScopeNameProvider(model, fsa) - generateScopeProvider(model, fsa) - ]) - } - - def generateScopeProvider(ScopeModel model, IFileSystemAccess fsa) { - val fileName = (model.name.toJavaPackage + ".scoping.").replace('.', '/') + model.name.toSimpleName + "ScopeProvider.java"; - fsa.generateFile(fileName, scopeProvider.generate(model, nameProvider, compilationContext, genModelUtil)) - } - - def generateScopeNameProvider(ScopeModel model, IFileSystemAccess fsa) { - val fileName = (model.name.toJavaPackage + ".scoping.").replace('.', '/') + model.name.toSimpleName + "ScopeNameProvider.java"; - fsa.generateFile(fileName, nameProvider.generate(model, compilationContext, genModelUtil)) - } - - override afterGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) {} - - override beforeGenerate(Resource input, IFileSystemAccess2 fsa, IGeneratorContext context) {} - -} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeModelTypeResolver.java b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeModelTypeResolver.java new file mode 100644 index 0000000000..8dfe9123c9 --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeModelTypeResolver.java @@ -0,0 +1,117 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.scope.generator; + +import java.util.List; + +import org.eclipse.emf.ecore.EClassifier; +import org.eclipse.emf.ecore.EObject; +import org.eclipse.emf.ecore.EPackage; +import org.eclipse.emf.ecore.util.EcoreUtil; + +import com.avaloq.tools.ddk.xtext.scope.scope.Import; +import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel; +import com.avaloq.tools.ddk.xtext.scope.scope.ScopePackage; +import com.avaloq.tools.ddk.xtext.util.EObjectUtil; +import com.google.common.collect.Iterables; +import com.google.common.collect.Lists; + + +/** + * Resolves the model type names that appear in scope expressions (casts, {@code typeSelect} and {@code isInstance}) + * to their EMF {@link EClassifier} using the EPackages imported by the scope model. + *

+ * This reproduces, without the classic Xtend type system, the resolution that the legacy + * {@code EmfRegistryMetaModel} performed: an unqualified name such as {@code Entity} is looked up across all + * imported packages, while an aliased or package qualified name such as {@code alias::Entity} resolves the alias to + * the imported package first. The list of visible EPackages is obtained exactly as the legacy generator did, namely + * through the scope of the {@code IMPORT__PACKAGE} reference. + */ +public final class ScopeModelTypeResolver { + + private final ScopeModel model; + private final List packages; + + /** + * Creates a resolver for the given scope model. + * + * @param model + * the scope model whose imported packages provide the visible model types, must not be {@code null} + */ + public ScopeModelTypeResolver(final ScopeModel model) { + this.model = model; + this.packages = Lists.newArrayList(Iterables.transform( + EObjectUtil.getScopeProviderByEObject(model).getScope(model, ScopePackage.Literals.IMPORT__PACKAGE).getAllElements(), + d -> (EPackage) EcoreUtil.resolve(d.getEObjectOrProxy(), model))); + } + + /** + * Resolves the given DSL type name segments to the matching model classifier. + * + * @param segments + * the {@code ::}-separated name segments of the type, must not be {@code null} or empty + * @return the resolved classifier, or {@code null} if no imported package declares it + */ + public EClassifier resolve(final List segments) { + if (segments == null || segments.isEmpty()) { + return null; + } + if (segments.size() == 1) { + return findClassifier(segments.get(0)); + } + final String alias = segments.get(0); + final String typeName = segments.get(segments.size() - 1); + for (final Import imp : model.getImports()) { + if (alias.equals(imp.getName()) && imp.getPackage() != null) { + return imp.getPackage().getEClassifier(typeName); + } + } + for (final EPackage ePackage : packages) { + if (alias.equals(ePackage.getName())) { + final EClassifier classifier = ePackage.getEClassifier(typeName); + if (classifier != null) { + return classifier; + } + } + } + return findClassifier(typeName); + } + + /** + * Finds the first classifier with the given (unqualified) name across all imported packages. + * + * @param name + * the unqualified classifier name, must not be {@code null} + * @return the matching classifier, or {@code null} if none is found + */ + private EClassifier findClassifier(final String name) { + for (final EPackage ePackage : packages) { + final EClassifier classifier = ePackage.getEClassifier(name); + if (classifier != null) { + return classifier; + } + } + return null; + } + + /** + * Convenience factory that returns {@code null} when the given element is not a scope model. + * + * @param element + * the model element a scope expression originates from, may be {@code null} + * @return a resolver for the containing scope model, or {@code null} if none can be determined + */ + public static ScopeModelTypeResolver forElement(final EObject element) { + final ScopeModel scopeModel = org.eclipse.xtext.EcoreUtil2.getContainerOfType(element, ScopeModel.class); + return scopeModel == null ? null : new ScopeModelTypeResolver(scopeModel); + } + +} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeNameProviderGenerator.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeNameProviderGenerator.xtend index 57ea48a998..c6caca582f 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeNameProviderGenerator.xtend +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeNameProviderGenerator.xtend @@ -5,11 +5,11 @@ import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext -import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensionsX +import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensions import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX +import com.avaloq.tools.ddk.xtext.scope.jvmmodel.ScopeExpressionCompiler +import com.avaloq.tools.ddk.xtext.scope.jvmmodel.ScopeExpressionTranslator import com.avaloq.tools.ddk.xtext.scope.scope.Naming import com.avaloq.tools.ddk.xtext.scope.scope.NamingExpression import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel @@ -18,119 +18,118 @@ import org.eclipse.emf.ecore.EClass class ScopeNameProviderGenerator { - @Inject extension CodeGenerationX - @Inject extension ExpressionExtensionsX - @Inject extension com.avaloq.tools.ddk.xtext.expression.generator.Naming @Inject extension GeneratorUtilX @Inject extension ScopeProviderX + @Inject ScopeExpressionTranslator translator + @Inject ScopeExpressionCompiler compiler + extension GenModelUtilX genModelUtil - CompilationContext compilationContext - def generate(ScopeModel it, CompilationContext compilationContext, GenModelUtilX genModelUtil) { - this.compilationContext = compilationContext + /** + * Configures the collaborators required by the extracted body method. Used by the Xbase based + * {@code ScopeJvmModelInferrer} which attaches the body method directly to an inferred JVM operation rather than + * generating a full compilation unit through {@link #generate}. + * + * @param genModelUtil + * the gen model utility, must not be {@code null} + */ + def void configure(GenModelUtilX genModelUtil) { this.genModelUtil = genModelUtil - ''' - package «getScopeNameProvider().toJavaPackage()»; - - import java.util.Arrays; - - import org.eclipse.emf.ecore.EClass; - - import org.eclipse.xtext.naming.QualifiedName; - - import com.avaloq.tools.ddk.xtext.scoping.AbstractScopeNameProvider; - import com.avaloq.tools.ddk.xtext.scoping.INameFunction; - import com.avaloq.tools.ddk.xtext.scoping.NameFunctions; - - import com.google.common.base.Function; - import com.google.inject.Singleton; - - @SuppressWarnings("all") - @Singleton - public class «getScopeNameProvider().toSimpleName()» extends AbstractScopeNameProvider { - - @Override - public Iterable internalGetNameFunctions(final EClass eClass) { - «IF it.naming !== null» - «FOR p : it.naming.namings.map[type.EPackage].toSet()» - if («p.qualifiedPackageInterfaceName()».eINSTANCE == eClass.getEPackage()) { - switch (eClass.getClassifierID()) { - - «FOR n : it.naming.namings.filter(n|n.type.EPackage == p)» - case «n.type.classifierIdLiteral()»: - «javaContributorComment(n.location())» - return «nameFunctions(n.naming, it)»; - «ENDFOR» - - default: - return !eClass.getESuperTypes().isEmpty() ? getNameFunctions(eClass.getESuperTypes().get(0)) : null; - } - } - «ENDFOR» - «ENDIF» - return !eClass.getESuperTypes().isEmpty() ? getNameFunctions(eClass.getESuperTypes().get(0)) : null; - } - - } - ''' } + /** + * Produces the body of the {@code internalGetNameFunctions(EClass)} method. Extracted so the Xbase based + * {@code ScopeJvmModelInferrer} can attach it directly as a method body. + * + * @param it + * the scope model, must not be {@code null} + * @return the method body, never {@code null} + */ + def internalGetNameFunctionsBody(ScopeModel it) ''' + «IF it.naming !== null» + «FOR p : it.naming.namings.map[type.EPackage].toSet()» + if («p.qualifiedPackageInterfaceName()».eINSTANCE == eClass.getEPackage()) { + switch (eClass.getClassifierID()) { + + «FOR n : it.naming.namings.filter(n|n.type.EPackage == p)» + case «n.type.classifierIdLiteral()»: + «javaContributorComment(n.location())» + return «nameFunctions(n.naming, it)»; + «ENDFOR» + + default: + return !eClass.getESuperTypes().isEmpty() ? getNameFunctions(eClass.getESuperTypes().get(0)) : null; + } + } + «ENDFOR» + «ENDIF» + return !eClass.getESuperTypes().isEmpty() ? getNameFunctions(eClass.getESuperTypes().get(0)) : null; + ''' + def nameFunctions(Naming it, ScopeModel model) { nameFunctions(it, model, null, null) } def nameFunctions(Naming it, ScopeModel model, String contextName, EClass contextType) { - '''Arrays.asList(«FOR n : names SEPARATOR ", "»«nameFunction(n, model, contextName, contextType)»«ENDFOR»)''' + '''java.util.Arrays.asList(«FOR n : names SEPARATOR ", "»«nameFunction(n, model, contextName, contextType)»«ENDFOR»)''' } def dispatch String nameFunction(NamingExpression it, ScopeModel model, String contextName, EClass contextType) { if (factory) { if (contextName === null || contextType === null) { - expression.javaExpression(compilationContext.clone('UNEXPECTED_THIS')) + compiler.javaExpression(expression, translator.newCompilationContext('UNEXPECTED_THIS', null, #[], it)) } else { - expression.javaExpression(compilationContext.clone('UNEXPECTED_THIS', null, contextName, contextType)) + compiler.javaExpression(expression, translator.newCompilationContext('UNEXPECTED_THIS', null, #[contextName -> contextType.instanceClassName], it)) } } else if (export) { - 'NameFunctions.exportNameFunction()' + 'com.avaloq.tools.ddk.xtext.scoping.NameFunctions.exportNameFunction()' } else { nameFunction(expression, model, contextName, contextType) } } def dispatch String nameFunction(Expression it, ScopeModel model, String contextName, EClass contextType) { - 'EXPRESSION_NOT_SUPPORTED("' + serialize() + '")' + 'EXPRESSION_NOT_SUPPORTED("' + ExpressionExtensions.serialize(it) + '")' } def dispatch String nameFunction(StringLiteral it, ScopeModel model, String contextName, EClass contextType) { - 'NameFunctions.fromConstant("' + ^val + '")' + 'com.avaloq.tools.ddk.xtext.scoping.NameFunctions.fromConstant("' + ^val + '")' } def dispatch String nameFunction(IntegerLiteral it, ScopeModel model, String contextName, EClass contextType) { - 'NameFunctions.fromConstant(String.valueOf(' + ^val + '))' + 'com.avaloq.tools.ddk.xtext.scoping.NameFunctions.fromConstant(String.valueOf(' + ^val + '))' } def dispatch String nameFunction(FeatureCall it, ScopeModel model, String contextName, EClass contextType) ''' - «val currentContext = if (contextName === null) compilationContext.clone('obj', scopeType()) else compilationContext.clone('obj', scopeType(), 'ctx', contextType)» - «IF (target === null || target.isThisCall()) && isSimpleFeatureCall(currentContext)»NameFunctions.fromFeature(«literalIdentifier(feature())»)« - ELSEIF isSimpleNavigation(currentContext)» + «val currentContext = if (contextName === null) translator.newCompilationContext('obj', scopeType(), #[], it) else translator.newCompilationContext('obj', scopeType(), #[contextName -> contextType.instanceClassName], it)» + «IF (target === null || target.isThisCall()) && compiler.isSimpleFeatureCall(it, currentContext)»com.avaloq.tools.ddk.xtext.scoping.NameFunctions.fromFeature(«literalIdentifier(feature())»)« + ELSEIF compiler.isSimpleNavigation(it, currentContext)» object -> { final «scopeType().instanceClassName()» obj = («scopeType().instanceClassName()») object; - return toQualifiedName(«javaExpression(currentContext)»); + return toQualifiedName(«compiler.javaExpression(it, currentContext)»); } « - ELSE»EXPRESSION_NOT_SUPPORTED("«serialize()»")«ENDIF + ELSE»EXPRESSION_NOT_SUPPORTED("«ExpressionExtensions.serialize(it)»")«ENDIF »''' def dispatch String nameFunction(OperationCall it, ScopeModel model, String contextName, EClass contextType) ''' - «val currentContext = if (contextName === null) compilationContext.clone('obj', scopeType()) else compilationContext.clone('obj', scopeType(), 'ctx', contextType)» - «IF isCompilable(currentContext)» + «val currentContext = if (contextName === null) translator.newCompilationContext('obj', scopeType(), #[], it) else translator.newCompilationContext('obj', scopeType(), #[contextName -> contextType.instanceClassName], it)» + «IF compiler.isCompilable(it, currentContext)» object -> { final «scopeType().instanceClassName()» obj = («scopeType().instanceClassName()») object; - return toQualifiedName(«javaExpression(currentContext)»); + return toQualifiedName(«compiler.javaExpression(it, currentContext)»); } « - ELSE»EXPRESSION_NOT_SUPPORTED("«serialize()»")«ENDIF + ELSE»EXPRESSION_NOT_SUPPORTED("«ExpressionExtensions.serialize(it)»")«ENDIF »''' + def private dispatch boolean isThisCall(Expression it) { + false + } + + def private dispatch boolean isThisCall(FeatureCall it) { + name === null && type !== null && type.id !== null && type.id.size == 1 && type.id.head == 'this' + } + } diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderGenerator.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderGenerator.xtend index cf57184807..99faadcf7d 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderGenerator.xtend +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderGenerator.xtend @@ -13,13 +13,17 @@ package com.avaloq.tools.ddk.xtext.scope.generator import com.avaloq.tools.ddk.xtext.expression.expression.Expression import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall +import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.NullLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.RealLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral import com.avaloq.tools.ddk.xtext.expression.generator.EClassComparator -import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensionsX +import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensions import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX -import com.avaloq.tools.ddk.xtext.expression.generator.Naming import com.avaloq.tools.ddk.xtext.scope.scope.FactoryExpression import com.avaloq.tools.ddk.xtext.scope.scope.GlobalScopeExpression import com.avaloq.tools.ddk.xtext.scope.scope.LambdaDataExpression @@ -31,208 +35,267 @@ import com.avaloq.tools.ddk.xtext.scope.scope.ScopeExpression import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel import com.avaloq.tools.ddk.xtext.scope.scope.ScopeRule import com.avaloq.tools.ddk.xtext.scope.scope.SimpleScopeExpression +import com.avaloq.tools.ddk.xtext.scope.jvmmodel.ScopeExpressionCompiler +import com.avaloq.tools.ddk.xtext.scope.jvmmodel.ScopeExpressionMethodRequest +import com.avaloq.tools.ddk.xtext.scope.jvmmodel.ScopeExpressionTranslator import com.google.common.collect.Lists import com.google.inject.Inject import java.util.List import org.eclipse.emf.ecore.EClass +import org.eclipse.xtext.util.Strings class ScopeProviderGenerator { - @Inject extension CodeGenerationX - @Inject extension ExpressionExtensionsX @Inject extension GeneratorUtilX - @Inject extension Naming @Inject extension ScopeProviderX + @Inject ScopeExpressionTranslator translator + @Inject ScopeExpressionCompiler compiler + ScopeNameProviderGenerator nameProviderGenerator - CompilationContext compilationContext extension GenModelUtilX genModelUtil - def generate(ScopeModel it, ScopeNameProviderGenerator nameProviderGenerator, CompilationContext compilationContext, GenModelUtilX genModelUtil) { + val List expressionMethods = newArrayList + int expressionMethodCounter + + /** + * Configures the collaborators required by the extracted body methods. Used by the Xbase based + * {@code ScopeJvmModelInferrer} which attaches the body methods directly to inferred JVM operations rather than + * generating a full compilation unit through {@link #generate}. + * + * @param nameProviderGenerator + * the name provider generator, must not be {@code null} + * @param genModelUtil + * the gen model utility, must not be {@code null} + */ + def void configure(ScopeNameProviderGenerator nameProviderGenerator, GenModelUtilX genModelUtil) { this.nameProviderGenerator = nameProviderGenerator - this.compilationContext = compilationContext this.genModelUtil = genModelUtil - ''' - package «getScopeProvider().toJavaPackage()»; - - import java.util.Arrays; - - import org.apache.logging.log4j.Logger; - import org.apache.logging.log4j.LogManager; - import org.eclipse.emf.ecore.EClass; - import org.eclipse.emf.ecore.EObject; - import org.eclipse.emf.ecore.EPackage; - import org.eclipse.emf.ecore.EReference; - import org.eclipse.emf.ecore.resource.Resource; - - import org.eclipse.xtext.naming.QualifiedName; - import org.eclipse.xtext.resource.IEObjectDescription; - import org.eclipse.xtext.scoping.IScope; - - import com.avaloq.tools.ddk.xtext.scoping.AbstractNameFunction; - import com.avaloq.tools.ddk.xtext.scoping.AbstractPolymorphicScopeProvider; - import com.avaloq.tools.ddk.xtext.scoping.IContextSupplier; - import com.avaloq.tools.ddk.xtext.scoping.INameFunction; - import com.avaloq.tools.ddk.xtext.scoping.NameFunctions; - import com.avaloq.tools.ddk.xtext.util.EObjectUtil; - - import com.google.common.base.Predicate; - «IF !allInjections().isEmpty» - import com.google.inject.Inject; - «ENDIF» + expressionMethods.clear + expressionMethodCounter = 0 + } - @SuppressWarnings("all") - public class «getScopeProvider().toSimpleName()» extends AbstractPolymorphicScopeProvider { + /** + * Returns the helper expression methods recorded while the body methods were rendered. The Xbase based + * {@code ScopeJvmModelInferrer} reads this after rendering all bodies and contributes one inferred operation per + * request. + * + * @return the recorded requests, never {@code null} + */ + def List getExpressionMethods() { + expressionMethods + } - /** Class-wide logger. */ - private static final Logger LOGGER = LogManager.getLogger(«getScopeProvider().toSimpleName()».class); - «IF !allInjections().isEmpty» - «FOR i : allInjections()» - @Inject - private «i.type» «i.name»; - «ENDFOR» - «ENDIF» + /** + * Produces the body of the {@code doGetScope(EObject, EReference, String, Resource)} method. Extracted so the + * Xbase based {@code ScopeJvmModelInferrer} can attach it directly as a method body. + * + * @param it + * the scope model, must not be {@code null} + * @return the method body, never {@code null} + */ + def doGetScopeByReferenceBody(ScopeModel it) ''' + «IF !allScopes().filter(s|s.reference !== null).empty» + if (scopeName == null) { + return null; + } - «scopeMethods(it, name.toSimpleName())» + switch (scopeName) { + «FOR name : allScopes().filter(s|s.reference !== null).map(s|s.getScopeName()).toSet() + »case "«name»": + «FOR scope : allScopes().filter(s|s.reference !== null).filter(s|s.getScopeName()==name)» + if (reference == «scope.reference.literalIdentifier()») return «scope.scopeMethodName()»(context, reference, originalResource); + «ENDFOR» + break; + « + ENDFOR» + default: break; + } + «ENDIF» + return null; + ''' - } - ''' - } + /** + * Produces the body of the {@code doGetScope(EObject, EClass, String, Resource)} method. + * + * @param it + * the scope model, must not be {@code null} + * @return the method body, never {@code null} + */ + def doGetScopeByTypeBody(ScopeModel it) ''' + «IF !allScopes().filter(s|s.reference === null).empty» + if (scopeName == null) { + return null; + } - def scopeMethods(ScopeModel it, String baseName) ''' - @Override - protected IScope doGetScope(final EObject context, final EReference reference, final String scopeName, final Resource originalResource) { - «IF !allScopes().filter(s|s.reference !== null).empty» - if (scopeName == null) { - return null; - } + switch (scopeName) { + «FOR name : allScopes().filter(s|s.reference === null).map(s|s.getScopeName()).toSet() + »case "«name»": + «FOR scope : allScopes().filter(s|s.reference === null).filter(s|s.getScopeName()==name)» + if (type == «scope.targetType.literalIdentifier()») return «scope.scopeMethodName()»(context, type, originalResource); + «ENDFOR» + break; + « + ENDFOR» + default: break; + } + «ENDIF» + return null; + ''' + /** + * Produces the body of the {@code doGlobalCache(EObject, EReference, String, Resource)} method. + * + * @param it + * the scope model, must not be {@code null} + * @return the method body, never {@code null} + */ + def doGlobalCacheByReferenceBody(ScopeModel it) ''' + «IF !allScopes().filter(s|s.reference !== null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).empty» + if (scopeName != null && context.eContainer() == null) { switch (scopeName) { - «FOR name : allScopes().filter(s|s.reference !== null).map(s|s.getScopeName()).toSet() + «FOR name : allScopes().filter(s|s.reference !== null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).map(s|s.getScopeName()).toSet() »case "«name»": «FOR scope : allScopes().filter(s|s.reference !== null).filter(s|s.getScopeName()==name)» - if (reference == «scope.reference.literalIdentifier()») return «scope.scopeMethodName()»(context, reference, originalResource); + «val globalRules = scope.allScopeRules().filter(r|r.context.global)» + «IF globalRules.size > 0» + if (reference == «scope.reference.literalIdentifier()») return true; + «ENDIF» «ENDFOR» break; « ENDFOR» default: break; } - «ENDIF» - return null; } + «ENDIF» + return false; + ''' - @Override - protected IScope doGetScope(final EObject context, final EClass type, final String scopeName, final Resource originalResource) { - «IF !allScopes().filter(s|s.reference === null).empty» - if (scopeName == null) { - return null; - } - + /** + * Produces the body of the {@code doGlobalCache(EObject, EClass, String, Resource)} method. + * + * @param it + * the scope model, must not be {@code null} + * @return the method body, never {@code null} + */ + def doGlobalCacheByTypeBody(ScopeModel it) ''' + «IF !allScopes().filter(s|s.reference === null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).empty» + if (context.eContainer() == null) { switch (scopeName) { - «FOR name : allScopes().filter(s|s.reference === null).map(s|s.getScopeName()).toSet() + «FOR name : allScopes().filter(s|s.reference === null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).map(s|s.getScopeName()).toSet() »case "«name»": «FOR scope : allScopes().filter(s|s.reference === null).filter(s|s.getScopeName()==name)» - if (type == «scope.targetType.literalIdentifier()») return «scope.scopeMethodName()»(context, type, originalResource); + «val globalRules = scope.allScopeRules().filter(r|r.context.global)» + «IF globalRules.size > 0» + if (type == «scope.targetType.literalIdentifier()») return true; + «ENDIF» «ENDFOR» break; - « - ENDFOR» + « + ENDFOR» default: break; } - «ENDIF» - return null; } + «ENDIF» + return false; + ''' - @Override - protected boolean doGlobalCache(final EObject context, final EReference reference, final String scopeName, final Resource originalResource) { - «IF !allScopes().filter(s|s.reference !== null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).empty» - if (scopeName != null && context.eContainer() == null) { - switch (scopeName) { - «FOR name : allScopes().filter(s|s.reference !== null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).map(s|s.getScopeName()).toSet() - »case "«name»": - «FOR scope : allScopes().filter(s|s.reference !== null).filter(s|s.getScopeName()==name)» - «val globalRules = scope.allScopeRules().filter(r|r.context.global)» - «IF globalRules.size > 0» - if (reference == «scope.reference.literalIdentifier()») return true; - «ENDIF» - «ENDFOR» - break; - « - ENDFOR» - default: break; - } - } - «ENDIF» - return false; + /** + * Produces the body of a single {@code } scope method. Extracted so the Xbase based + * {@code ScopeJvmModelInferrer} can attach it directly as a method body. + * + * @param scope + * the scope definition the method is generated for, must not be {@code null} + * @param it + * the scope model, must not be {@code null} + * @return the method body, never {@code null} + */ + def scopeMethodBody(ScopeDefinition scope, ScopeModel it) ''' + «val localRules = scope.allScopeRules().filter(r|!r.context.global).toList» + «val globalRules = scope.allScopeRules().filter(r|r.context.global).toList» + «if (globalRules.size > 1) throw new RuntimeException("only one global rule allowed")» + «FOR r : localRules.filterUniqueRules().sortedRules()» + «javaContributorComment(r.location())» + if («IF EClassComparator.isEObjectType(r.context.contextType)»true«ELSE»context instanceof «r.context.contextType.instanceClassName()»«ENDIF») { + final «r.context.contextType.instanceClassName()» ctx = («r.context.contextType.instanceClassName()») context; + «val rulesForTypeAndContext = localRules.filter(r2|r2.hasSameContext(r)).toList» + «scopeRuleBlock(rulesForTypeAndContext, it, if (r.contextRef() !== null) 'ref' else 'type', r.context.contextType, r.context.global)» } + «ENDFOR» + «IF !localRules.isEmpty || !globalRules.isEmpty» - @Override - protected boolean doGlobalCache(final EObject context, final EClass type, final String scopeName, final Resource originalResource) { - «IF !allScopes().filter(s|s.reference === null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).empty» - if (context.eContainer() == null) { - switch (scopeName) { - «FOR name : allScopes().filter(s|s.reference === null).filter(s|s.allScopeRules().filter(r|r.context.global).size > 0).map(s|s.getScopeName()).toSet() - »case "«name»": - «FOR scope : allScopes().filter(s|s.reference === null).filter(s|s.getScopeName()==name)» - «val globalRules = scope.allScopeRules().filter(r|r.context.global)» - «IF globalRules.size > 0» - if (type == «scope.targetType.literalIdentifier()») return true; - «ENDIF» - «ENDFOR» - break; - « - ENDFOR» - default: break; - } - } - «ENDIF» - return false; + final EObject eContainer = context.eContainer(); + if (eContainer != null) { + return internalGetScope(«IF !localRules.isEmpty»eContainer«ELSE»getRootObject(eContainer)«ENDIF», «IF scope.reference !== null»ref«ELSE»type«ENDIF», "«scope.getScopeName()»", originalResource); } - «FOR scope : allScopes()» - protected IScope «scope.scopeMethodName()»(final EObject context, final «IF scope.reference !== null»EReference ref«ELSE»EClass type«ENDIF», final Resource originalResource) { - «val localRules = scope.allScopeRules().filter(r|!r.context.global).toList» - «val globalRules = scope.allScopeRules().filter(r|r.context.global).toList» - «if (globalRules.size > 1) throw new RuntimeException("only one global rule allowed")» - «FOR r : localRules.filterUniqueRules().sortedRules()» - «javaContributorComment(r.location())» - if («IF EClassComparator.isEObjectType(r.context.contextType)»true«ELSE»context instanceof «r.context.contextType.instanceClassName()»«ENDIF») { - final «r.context.contextType.instanceClassName()» ctx = («r.context.contextType.instanceClassName()») context; - «val rulesForTypeAndContext = localRules.filter(r2|r2.hasSameContext(r)).toList» - «scopeRuleBlock(rulesForTypeAndContext, it, if (r.contextRef() !== null) 'ref' else 'type', r.context.contextType, r.context.global)» - } - «ENDFOR» - «IF !localRules.isEmpty || !globalRules.isEmpty» - - final EObject eContainer = context.eContainer(); - if (eContainer != null) { - return internalGetScope(«IF !localRules.isEmpty»eContainer«ELSE»getRootObject(eContainer)«ENDIF», «IF scope.reference !== null»ref«ELSE»type«ENDIF», "«scope.getScopeName()»", originalResource); - } - - «ENDIF» - «IF !globalRules.isEmpty» - «val r = globalRules.head» - «val rulesForTypeAndContext = #[r]» - «javaContributorComment(r.location())» - if (context.eResource() != null) { - final Resource ctx = context.eResource(); - «scopeRuleBlock(rulesForTypeAndContext, it, if (r.contextRef() !== null) 'ref' else 'type', r.context.contextType, r.context.global)» - } - - «ENDIF» - return null; + «ENDIF» + «IF !globalRules.isEmpty» + «val r = globalRules.head» + «val rulesForTypeAndContext = #[r]» + «javaContributorComment(r.location())» + if (context.eResource() != null) { + final Resource ctx = context.eResource(); + «scopeRuleBlock(rulesForTypeAndContext, it, if (r.contextRef() !== null) 'ref' else 'type', r.context.contextType, r.context.global)» } - «ENDFOR» + «ENDIF» + return null; ''' + /** + * Records a helper method for the guard of the given scope rule and returns the Java call that the rule block + * uses in its {@code if} condition. The guard is evaluated against the {@code ctx} variable holding the rule's + * context object. + * + * @param r + * the scope rule whose guard to translate, must not be {@code null} + * @return the Java call to the generated guard method, never {@code null} + */ + def guardCall(ScopeRule r) { + val request = new ScopeExpressionMethodRequest + val methodName = 'guard' + (expressionMethodCounter++) + request.methodName = methodName + request.returnTypeName = 'boolean' + request.variableName = 'ctx' + request.variableTypeName = r.scopeType().instanceClassName() + request.expression = r.context.guard + request.fallbackBody = 'return ' + compiler.javaExpression(r.context.guard, translator.newCompilationContext('ctx', r.scopeType(), #[], r.context.guard)) + ';' + expressionMethods.add(request) + methodName + '(ctx)' + } + + /** + * Records a helper method for an embedded {@link String} valued expression (e.g. a container query data value or a + * prefix) and returns the Java call that the surrounding template uses in place of the inlined expression. The + * expression is evaluated against the {@code ctx} variable holding the rule's context object. + * + * @param expr + * the expression to translate, must not be {@code null} + * @param contextType + * the type of the {@code ctx} context variable, must not be {@code null} + * @return the Java call to the generated helper method, never {@code null} + */ + def stringExpressionCall(Expression expr, EClass contextType) { + val request = new ScopeExpressionMethodRequest + val methodName = 'expr' + (expressionMethodCounter++) + request.methodName = methodName + request.returnTypeName = 'java.lang.String' + request.variableName = 'ctx' + request.variableTypeName = contextType.instanceClassName() + request.expression = expr + request.fallbackBody = 'return ' + compiler.javaExpression(expr, translator.newCompilationContext('ctx', contextType, #[], expr)) + ';' + expressionMethods.add(request) + methodName + '(ctx)' + } + def scopeRuleBlock(List it, ScopeModel model, String typeOrRef, EClass contextType, Boolean isGlobal) ''' IScope scope = IScope.NULLSCOPE; try { «IF it.exists(r|r.context.guard !== null)» «FOR r : it.sortBy(r|if (r.context.guard === null) it.size else it.indexOf(r)) SEPARATOR ' else ' - »«IF r.context.guard !== null»if («r.context.guard.javaExpression(compilationContext.clone('ctx', r.scopeType()))») «ENDIF»{ + »«IF r.context.guard !== null»if («guardCall(r)») «ENDIF»{ «IF it.size > 1»«javaContributorComment(r.location())» «ENDIF »«FOR e : Lists.newArrayList(r.exprs).reverse()»«scopeExpression(e, model, typeOrRef, r.getScope(), isGlobal)»«ENDFOR» @@ -243,10 +306,10 @@ class ScopeProviderGenerator { «ELSEIF it.size == 1» «FOR e : Lists.newArrayList(it.head.exprs).reverse()»«scopeExpression(e, model, typeOrRef, it.head.getScope(), isGlobal)»«ENDFOR» «ELSE» - «error('scope context not unique for definitions: ' + ', '.join(it.map(r|r.location())))» + «error('scope context not unique for definitions: ' + it.map(r|r.location()).join(', '))» «ENDIF» } catch (Exception e) { - LOGGER.error("Error calculating scope for «if (isGlobal) "Resource. Context:" else contextType.name» " + EObjectUtil.getLocationString(context) + " («it.get(0).locatorString()»)", e); + LOGGER.error("Error calculating scope for «if (isGlobal) "Resource. Context:" else contextType.name» " + com.avaloq.tools.ddk.xtext.util.EObjectUtil.getLocationString(context) + " («it.get(0).locatorString()»)", e); } return scope; ''' @@ -257,38 +320,72 @@ class ScopeProviderGenerator { def dispatch scopeExpression(FactoryExpression it, ScopeModel model, String typeOrRef, ScopeDefinition scope, Boolean isGlobal) { val b = new StringBuilder - val ctx = compilationContext.clone('ctx', eContainer(ScopeRule).context.contextType) - b.append('scope = ').append(javaCall(it.expr, ctx)).append('(scope, ctx, ').append(typeOrRef).append(', originalResource'); + val method = translator.resolveFactoryMethod(it.expr, model) + if (method === null) { + error('cannot resolve scope factory ' + it.expr?.toString + '; expected a fully qualified static call Type.method(...)') + return b + } + b.append('scope = ').append(method).append('(scope, ctx, ').append(typeOrRef).append(', originalResource'); if (expr instanceof OperationCall) { for (param : (expr as OperationCall).params) { - b.append(', ').append(javaExpression(param, ctx)) + b.append(', ').append(factoryArgument(param)) } } b.append(');\n') return b } - def dispatch javaCall(Expression it, CompilationContext ctx) { - error('cannot handle scope factory ' + it.toString()) + /** + * Produces the Java source for a single scope factory argument. Only the literal and context-variable argument + * forms that occur in scope sources are supported; anything else is reported as an error. This keeps the factory + * emission independent of the legacy {@code .ext}/{@code CompilationContext} expression compiler. + * + * @param it + * the argument expression, must not be {@code null} + * @return the Java source for the argument, never {@code null} + */ + def dispatch factoryArgument(Expression it) { + error('unsupported scope factory argument ' + it.toString()) } - def dispatch javaCall(OperationCall it, CompilationContext ctx) { - if (isJavaExtensionCall(ctx)) - calledJavaMethod(ctx) - else - '/* Error: cannot handle scope factory ' + it.toString() + ' */' + def dispatch factoryArgument(StringLiteral it) { + '"' + Strings.convertToJavaString(getVal()) + '"' + } + + def dispatch factoryArgument(IntegerLiteral it) { + Integer.toString(getVal()) + } + + def dispatch factoryArgument(RealLiteral it) { + getVal() + } + + def dispatch factoryArgument(BooleanLiteral it) { + getVal() + } + + def dispatch factoryArgument(NullLiteral it) { + 'null' + } + + def dispatch factoryArgument(FeatureCall it) { + if (name === null && type !== null) { + type.id.join('.') + } else { + error('unsupported scope factory argument ' + it.toString()) + } } def dispatch scopeExpression(ScopeDelegation it, ScopeModel model, String typeOrRef, ScopeDefinition scope, Boolean isGlobal) ''' «IF delegate !== null » - «val delegateString = delegate.serialize()» + «val delegateString = ExpressionExtensions.serialize(delegate)» «IF delegateString == "this.eContainer()" || delegateString == "this.eContainer" || delegateString == "eContainer()" || delegateString == "eContainer"» scope = newSameScope("«it.locatorString()»", scope, ctx.eContainer()« ELSEIF delegateString == "this"» scope = newSameScope("«it.locatorString()»", scope, ctx« ELSE» scope = newDelegateScope("«it.locatorString()»", scope, « - IF !isGlobal »() -> IContextSupplier.makeIterable(«scopedElements(delegate, model, eContainer(ScopeRule).context.contextType, 'ctx')»)« + IF !isGlobal »() -> com.avaloq.tools.ddk.xtext.scoping.IContextSupplier.makeIterable(«scopedElements(delegate, model, eContainer(ScopeRule).context.contextType, 'ctx')»)« ELSE»«scopedElements(delegate, model, eContainer(ScopeRule).context.contextType, 'ctx')»« ENDIF»« ENDIF»« @@ -326,28 +423,83 @@ class ScopeProviderGenerator { def query (GlobalScopeExpression it, ScopeModel model, String typeOrRef, ScopeDefinition scope) ''' newQuery(«type.literalIdentifier()»)« val matchData = data.filter(MatchDataExpression)»« - IF name !== null».name(«doExpression (name, model, 'ctx', eContainer(ScopeRule).context.contextType)»)«ENDIF»« - IF !matchData.isEmpty»«FOR d : matchData».data("«javaEncode(d.key)»", «doExpression (d.value, model, 'ctx', eContainer(ScopeRule).context.contextType)»)«ENDFOR»«ENDIF»« - IF !domains.isEmpty && domains.get(0) != "*"».domains(«FOR d : domains SEPARATOR ", "»"«javaEncode(d)»"«ENDFOR»)«ENDIF + IF name !== null».name(«nameValue(name, eContainer(ScopeRule).context.contextType, model)»)«ENDIF»« + IF !matchData.isEmpty»«FOR d : matchData».data("«Strings.convertToJavaString(d.key)»", «stringExpressionCall(d.value, eContainer(ScopeRule).context.contextType)»)«ENDFOR»«ENDIF»« + IF !domains.isEmpty && domains.get(0) != "*"».domains(«FOR d : domains SEPARATOR ", "»"«Strings.convertToJavaString(d)»"«ENDFOR»)«ENDIF »''' + /** + * Produces the Java for a container query name argument. When the name expression can be translated by the Xbase + * based translator to a {@link String} it is extracted into a generated helper method; otherwise the legacy + * fragment is emitted. The {@code String} guard avoids selecting the {@code name(QualifiedName)} overload by + * mistake. + * + * @param name + * the name expression, must not be {@code null} + * @param contextType + * the type of the rule context object, must not be {@code null} + * @param model + * the scope model, must not be {@code null} + * @return the Java name argument source, never {@code null} + */ + def nameValue(Expression name, EClass contextType, ScopeModel model) { + if (translator.canExtractAsString(name, contextType, model)) { + stringExpressionCall(name, contextType) + } else { + doExpression(name, model, 'ctx', contextType) + } + } + def dispatch scopeExpressionPart (GlobalScopeExpression it, ScopeModel model, String typeOrRef, ScopeDefinition scope) ''' «val matchData = data.filter(LambdaDataExpression)» «IF matchData.isEmpty && prefix === null»newContainerScope(«ELSEIF matchData.isEmpty && prefix !== null»newPrefixedContainerScope(«ELSE»newDataMatchScope(«ENDIF»"«it.locatorString()»", scope, ctx, «query (it, model, typeOrRef, scope)», originalResource« IF !matchData.isEmpty», // - Arrays.asList( + java.util.Arrays.asList( «FOR d : matchData SEPARATOR ","» - «val CompilationContext cc = compilationContext.cloneWithVariable('ctx', eContainer(ScopeRule).context.contextType, d.desc, 'org::eclipse::xtext::resource::IEObjectDescription')» - «IF d.value.isCompilable(cc.clone('ctx'))» - «d.desc» -> «d.value.javaExpression(cc.clone('ctx'))» - «ELSE» - «d.desc» -> EXPRESSION_NOT_SUPPORTED("«serialize()»") - «ENDIF»« + «lambdaDataMatch(d, model, eContainer(ScopeRule).context.contextType, it)»« ENDFOR» )« - ELSEIF prefix !== null», «doExpression (prefix, model, 'ctx', eContainer(ScopeRule).context.contextType)», «recursivePrefix»« + ELSEIF prefix !== null», «stringExpressionCall(prefix, eContainer(ScopeRule).context.contextType)», «recursivePrefix»« ENDIF »''' + /** + * Produces the Java lambda for a single data match filter. When the filter value can be translated by the Xbase + * based translator it is extracted into a generated helper method (taking the rule context and the element + * description) and the lambda delegates to it; otherwise the legacy fragment is emitted (or an + * {@code EXPRESSION_NOT_SUPPORTED} marker when the legacy compiler cannot handle it either). + * + * @param d + * the lambda data expression, must not be {@code null} + * @param model + * the scope model, must not be {@code null} + * @param contextType + * the type of the rule context object, must not be {@code null} + * @param owner + * the enclosing global scope expression (used for diagnostics), must not be {@code null} + * @return the Java lambda source, never {@code null} + */ + def lambdaDataMatch(LambdaDataExpression d, ScopeModel model, EClass contextType, GlobalScopeExpression owner) { + val descType = 'org.eclipse.xtext.resource.IEObjectDescription' + val cc = translator.newCompilationContext('ctx', contextType, #[d.desc -> descType], owner) + if (translator.canExtractAsValue(d.value, contextType, #[d.desc -> descType], model)) { + val request = new ScopeExpressionMethodRequest + val methodName = 'expr' + (expressionMethodCounter++) + request.methodName = methodName + request.returnTypeName = 'boolean' + request.variableName = 'ctx' + request.variableTypeName = contextType.instanceClassName + request.expression = d.value + request.extraParameters.add(d.desc -> descType) + request.fallbackBody = 'return ' + compiler.javaExpression(d.value, cc) + ';' + expressionMethods.add(request) + d.desc + ' -> ' + methodName + '(ctx, ' + d.desc + ')' + } else if (compiler.isCompilable(d.value, cc)) { + d.desc + ' -> ' + compiler.javaExpression(d.value, cc) + } else { + d.desc + ' -> EXPRESSION_NOT_SUPPORTED("' + ExpressionExtensions.serialize(owner) + '")' + } + } + def dispatch scopeExpressionNaming (NamedScopeExpression it, ScopeModel model, String typeOrRef, ScopeDefinition scope) { error("Xtend called the wrong definition for scopeExpressionNaming with this=" + it.toString() + javaContributorComment(it.location())) } @@ -365,11 +517,24 @@ class ScopeProviderGenerator { } def scopedElements(Expression it, ScopeModel model, EClass type, String object) { - doExpression(it, model, object, type) + if (object == 'ctx' && translator.canExtractAsValue(it, type, model)) { + val request = new ScopeExpressionMethodRequest + val methodName = 'expr' + (expressionMethodCounter++) + request.methodName = methodName + request.returnTypeName = null + request.variableName = 'ctx' + request.variableTypeName = type.instanceClassName + request.expression = it + request.fallbackBody = 'return ' + compiler.javaExpression(it, translator.newCompilationContext(object, type, #[], it)) + ';' + expressionMethods.add(request) + methodName + '(ctx)' + } else { + doExpression(it, model, object, type) + } } def doExpression(Expression it, ScopeModel model, String object, EClass type) { - javaExpression (compilationContext.clone(object, type)) + compiler.javaExpression(it, translator.newCompilationContext(object, type, #[], it)) } def name(NamedScopeExpression it, ScopeModel model, String typeOrRef, String contextName, EClass contextType) { @@ -383,4 +548,12 @@ class ScopeProviderGenerator { throw new RuntimeException(message) } + def private dispatch boolean isEmptyList(Expression it) { + false + } + + def private dispatch boolean isEmptyList(ListLiteral it) { + elements.isEmpty + } + } diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderX.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderX.xtend index 6ad50bec0e..400bd54e59 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderX.xtend +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopeProviderX.xtend @@ -13,8 +13,7 @@ package com.avaloq.tools.ddk.xtext.scope.generator import com.avaloq.tools.ddk.xtext.expression.expression.Expression import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall -import com.avaloq.tools.ddk.xtext.expression.generator.CodeGenerationX -import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensionsX +import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensions import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorUtilX import com.avaloq.tools.ddk.xtext.expression.generator.Naming import com.avaloq.tools.ddk.xtext.scope.ScopeUtil @@ -33,6 +32,7 @@ import org.eclipse.emf.ecore.ENamedElement import org.eclipse.emf.ecore.EObject import org.eclipse.emf.ecore.EReference import org.eclipse.emf.ecore.EStructuralFeature +import org.eclipse.xtext.util.Strings class ScopeProviderX { @@ -40,10 +40,6 @@ class ScopeProviderX { extension Naming @Inject extension GeneratorUtilX - @Inject - extension CodeGenerationX - @Inject - extension ExpressionExtensionsX /* * CODE GENERATION @@ -62,7 +58,7 @@ class ScopeProviderX { } def String locatorString(EObject it) { - location().split('/').lastOrNull().javaEncode() + Strings.convertToJavaString(location().split('/').lastOrNull()) } def String calledFeature(FeatureCall it) { @@ -107,7 +103,7 @@ class ScopeProviderX { def dispatch boolean isEqual(ScopeRule a, ScopeRule b) { a.hasSameContext(b) // && ((a.name === null) == (b.name === null)) && (a.name === null || a.name.matches (b.name)) - && a.context.guard.serialize() == b.context.guard.serialize() + && ExpressionExtensions.serialize(a.context.guard) == ExpressionExtensions.serialize(b.context.guard) } def boolean hasSameContext(ScopeRule a, ScopeRule b) { diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopingGeneratorUtil.java b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopingGeneratorUtil.java index 62e1f11df8..a83bdefa4c 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopingGeneratorUtil.java +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/generator/ScopingGeneratorUtil.java @@ -12,47 +12,21 @@ import java.util.Collection; import java.util.List; -import java.util.Map; -import java.util.Set; -import org.eclipse.emf.ecore.EPackage; -import org.eclipse.emf.ecore.util.EcoreUtil; -import org.eclipse.internal.xtend.expression.parser.SyntaxConstants; -import org.eclipse.xtend.expression.ExecutionContextImpl; -import org.eclipse.xtend.expression.ResourceManagerDefaultImpl; -import org.eclipse.xtend.expression.TypeSystemImpl; -import org.eclipse.xtend.expression.Variable; -import org.eclipse.xtend.typesystem.Type; -import org.eclipse.xtend.typesystem.emf.EmfRegistryMetaModel; import org.eclipse.xtext.EcoreUtil2; -import com.avaloq.tools.ddk.xtext.expression.generator.CompilationContext; import com.avaloq.tools.ddk.xtext.expression.generator.EClassComparator; -import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX; import com.avaloq.tools.ddk.xtext.scope.scope.Casing; -import com.avaloq.tools.ddk.xtext.scope.scope.Import; -import com.avaloq.tools.ddk.xtext.scope.scope.Injection; import com.avaloq.tools.ddk.xtext.scope.scope.NamedScopeExpression; import com.avaloq.tools.ddk.xtext.scope.scope.NamingSection; import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel; -import com.avaloq.tools.ddk.xtext.scope.scope.ScopePackage; import com.avaloq.tools.ddk.xtext.scope.scope.ScopeRule; -import com.avaloq.tools.ddk.xtext.util.EObjectUtil; -import com.google.common.base.Predicates; -import com.google.common.collect.Collections2; -import com.google.common.collect.ImmutableMap; -import com.google.common.collect.Iterables; -import com.google.common.collect.Lists; -import com.google.common.collect.Maps; -import com.google.common.collect.Sets; /** * Various utility functions for the scoping generator. */ -// CHECKSTYLE:COUPLING-OFF public final class ScopingGeneratorUtil { - // CHECKSTYLE:COUPLING-ON /** * Inhibit public instantiation. @@ -61,143 +35,6 @@ private ScopingGeneratorUtil() { // No public constructor } - /** - * Return a compilation context for Xtend executions during the generator run. - * - * @param model - * the ScopeModel for which we generate - * @param genModelUtil - * GenModel util, must not be {@code null} - * @return the {@link CompilationContext} - */ - public static CompilationContext getCompilationContext(final ScopeModel model, final GenModelUtilX genModelUtil) { - return new CompilationContext(new ScopeExecutionContext(model), genModelUtil); - } - - /** - * Helper class defining the execution context for an Xtend compilation during scope generation. - * Sets up the metamodels as needed. - */ - private static class ScopeExecutionContext extends ExecutionContextImpl { - - private static final String VAR_ORIGINAL_RESOURCE = "originalResource"; //$NON-NLS-1$ - - ScopeExecutionContext(final ScopeModel model) { - super(new ResourceManagerDefaultImpl(), new ScopeResource(model), new TypeSystemImpl(), getVariables(model), null, null, null, null, null, null, null, null, null); - registerMetaModels(model); - } - - /** - * Returns the variables which should be visible to the Xtend expressions. - * - * @param model - * context scope model, must not be {@code null} - * @return map of variables, never {@code null} - */ - private static Map getVariables(final ScopeModel model) { - Map result = Maps.newLinkedHashMap(); - result.put(VAR_ORIGINAL_RESOURCE, new Variable(VAR_ORIGINAL_RESOURCE, null)); - for (ScopeModel scopeModel : getAllScopeModels(model)) { - for (Injection injection : scopeModel.getInjections()) { - result.putIfAbsent(injection.getName(), new Variable(injection.getName(), null)); - } - } - return ImmutableMap.copyOf(result); - } - - /** - * Registers all metamodels accessible to the scope model in the Xtend execution context. - * - * @param model - * scope model to register metamodels for - */ - private void registerMetaModels(final ScopeModel model) { - // First, create one meta model that has all the packages that are visible. Use the scope provider to get that list, - // then convert to a list of EPackages. - final EPackage[] ePackages = Lists.newArrayList(Iterables.transform(EObjectUtil.getScopeProviderByEObject(model).getScope(model, ScopePackage.Literals.IMPORT__PACKAGE).getAllElements(), d -> (EPackage) EcoreUtil.resolve(d.getEObjectOrProxy(), model))).toArray(new EPackage[0]); - registerMetaModel(new EmfRegistryMetaModel() { - @Override - public EPackage[] allPackages() { - return ePackages; - } - - @Override - public Type getTypeForName(final String name) { - final String[] frags = name.split(SyntaxConstants.NS_DELIM); - if (frags.length == 2) { - // convert references which use import alias - for (Import imp : model.getImports()) { - if (frags[0].equals(imp.getName()) && imp.getPackage() != null) { - return super.getTypeForName(imp.getPackage().getName() + SyntaxConstants.NS_DELIM + frags[1]); - } - } - } - return super.getTypeForName(name); - } - }); - // Finally, add the default meta models - // registerMetaModel(new EmfRegistryMetaModel()); - // registerMetaModel(new JavaBeansMetaModel()); - } - } - - /** - * "Fake" resource for Xtend compilation that gives correct extensions and package imports depending on whether - * we're running Xtend inside the export section or the scoping section. - */ - private static class ScopeResource implements org.eclipse.xtend.expression.Resource { - - private final ScopeModel model; - private String qualifiedName; - private Set importedExtensions; - private Set importedNamespaces; - - ScopeResource(final ScopeModel model) { - this.model = model; - } - - @Override - public String getFullyQualifiedName() { - if (qualifiedName == null) { - this.setFullyQualifiedName(model.eResource().getURI().path()); - } - return qualifiedName; - } - - @Override - public String[] getImportedExtensions() { - if (importedExtensions == null) { - importedExtensions = Sets.newLinkedHashSet(); - for (ScopeModel included : getAllScopeModels(model)) { - importedExtensions.addAll(Lists.transform(included.getExtensions(), e -> e.getExtension())); - } - } - return importedExtensions.toArray(new String[importedExtensions.size()]); - } - - @Override - public String[] getImportedNamespaces() { - if (importedNamespaces == null) { - importedNamespaces = Sets.newLinkedHashSet(); - for (ScopeModel included : getAllScopeModels(model)) { - importedNamespaces.addAll(Collections2.filter(Lists.transform(included.getImports(), i -> { - if (i.getPackage() != null) { - return i.getPackage().getName(); - } - return null; - }), Predicates.notNull())); - } - } - return importedNamespaces.toArray(new String[importedNamespaces.size()]); - } - - @Override - public void setFullyQualifiedName(final String fqn) { - qualifiedName = fqn; - } - - } - /** * Determine whether a certain scope expression is case sensitive or not. * @@ -227,33 +64,4 @@ public static List sortedRules(final Collection rules) { return EClassComparator.sortedGroups(rules, r -> r.getContext().getContextType()); } - /** - * Returns a set containing the given model plus all (transitively) {@link ScopeModel#getIncludedScopes() included} models. - * - * @param model - * scope model, must not be {@code null} - * @return set, never {@code null} - */ - private static Set getAllScopeModels(final ScopeModel model) { - Set result = Sets.newLinkedHashSet(); - getAllScopeModelsInternal(model, result); - return result; - } - - /** - * Adds the given model plus all (transitively) {@link ScopeModel#getIncludedScopes() included} models to the given set. - * - * @param model - * scope model, must not be {@code null} - * @param result - * set to add to, must not be {@code null} - */ - private static void getAllScopeModelsInternal(final ScopeModel model, final Set result) { - if (result.add(model)) { - for (ScopeModel included : model.getIncludedScopes()) { - getAllScopeModelsInternal(included, result); - } - } - } - } diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionCompiler.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionCompiler.xtend new file mode 100644 index 0000000000..9528431051 --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionCompiler.xtend @@ -0,0 +1,483 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.scope.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanOperation +import com.avaloq.tools.ddk.xtext.expression.expression.CastedExpression +import com.avaloq.tools.ddk.xtext.expression.expression.CollectionExpression +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.expression.expression.IfExpression +import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.Literal +import com.avaloq.tools.ddk.xtext.expression.expression.NullLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall +import com.avaloq.tools.ddk.xtext.expression.expression.RealLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.TypeSelectExpression +import com.avaloq.tools.ddk.xtext.expression.generator.ExpressionExtensions +import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX +import com.google.inject.Inject +import java.util.List +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.common.types.JvmDeclaredType +import org.eclipse.xtext.common.types.JvmOperation +import org.eclipse.xtext.common.types.JvmType +import org.eclipse.xtext.util.Strings + +/** + * Compiles the custom {@link Expression} AST of the scope/export expression DSL into equivalent Java source text. + *

+ * This is the self-contained, {@code org.eclipse.xtend}-free replacement of the legacy + * {@code CodeGenerationX}/{@code CompilationContext} expression compiler. It produces exactly the same Java + * fragments as the legacy compiler did, but resolves types, variables and the implicit ({@code this}) receiver + * through the shared {@link ScopeTranslationContext} that the + * {@link ScopeExpressionTranslator} already uses, rather than through the classic Xtend type system. + *

+ * The compiler is used as the fallback for expression forms that the Xbase based {@link ScopeExpressionTranslator} + * does not turn into an {@link org.eclipse.xtext.xbase.XExpression} tree (for example string concatenation, the + * unary/binary arithmetic operators and the relational operators). The {@code .ext}/{@code JAVA} extension + * branches of the legacy compiler are intentionally dropped: scope sources no longer reference Xtend extension + * files. + */ +class ScopeExpressionCompiler { + + /** Maps EMF model types to their generated Java instance class names. */ + @Inject GenModelUtilX genModelUtil + + /** Reuses the translator's type/variable/getter resolution so both stay consistent. */ + @Inject ScopeExpressionTranslator translator + + ////////////////////////////////////////////////// + // ENTRY POINTS + ////////////////////////////////////////////////// + /** + * Tests whether the given expression can be compiled to Java by this compiler. + * + * @param expression + * the source expression, may be {@code null} + * @param context + * the compilation context, must not be {@code null} + * @return {@code true} if a non-{@code null} fragment without the {@code NOT COMPILABLE} marker can be produced + */ + def boolean isCompilable(Expression expression, ScopeTranslationContext context) { + val expr = expression.javaExpression(context) + expr !== null && !expr.contains('/* NOT COMPILABLE: ') + } + + /** + * Compiles the given expression into the equivalent Java source text. + * + * @param expression + * the source expression, may be {@code null} + * @param context + * the compilation context, must not be {@code null} + * @return the Java source text, never {@code null} + */ + def dispatch String javaExpression(Void it, ScopeTranslationContext ctx) { + '' + } + + def dispatch String javaExpression(Expression it, ScopeTranslationContext ctx) { + notCompilable + } + + def private String notCompilable(Expression it) { + '/* NOT COMPILABLE: Complex expressions like "' + serialize() + '" cannot be translated to Java. Consider rewriting the expression or using a JAVA extension. */' + } + + ////////////////////////////////////////////////// + // LITERALS + ////////////////////////////////////////////////// + def dispatch String javaExpression(StringLiteral it, ScopeTranslationContext ctx) { + '"' + javaEncode(getVal()) + '"' + } + + def dispatch String javaExpression(BooleanLiteral it, ScopeTranslationContext ctx) { + getVal() + } + + def dispatch String javaExpression(IntegerLiteral it, ScopeTranslationContext ctx) { + getVal().toString() + } + + def dispatch String javaExpression(NullLiteral it, ScopeTranslationContext ctx) { + "null" + } + + def dispatch String javaExpression(RealLiteral it, ScopeTranslationContext ctx) { + getVal().toString() + } + + def dispatch String javaExpression(ListLiteral it, ScopeTranslationContext ctx) { + if (elements.empty) { + "java.util.Collections. emptyList()" + } else if (elements.size == 1) { + "java.util.Collections.singletonList(" + elements.head.javaExpression(ctx) + ")" + } else { + "com.google.common.collect.Lists.newArrayList(" + ', '.join(elements.map[javaExpression(ctx)]) + ")" + } + } + + ////////////////////////////////////////////////// + // TYPES AND VARIABLES + ////////////////////////////////////////////////// + def dispatch String javaExpression(Identifier it, ScopeTranslationContext ctx) { + if (isThis()) ctx.implicitVariableName else '::'.join(id) + } + + def private boolean isTypeRef(FeatureCall it, ScopeTranslationContext ctx) { + name === null && type !== null && (ctx.modelTypeResolver?.resolve(type.id) !== null || ctx.resolveDslType(type) !== null) + } + + def private boolean isVariableRef(Expression it, ScopeTranslationContext ctx) { + false + } + + def private boolean isVariableRef(FeatureCall it, ScopeTranslationContext ctx) { + target === null && name === null && type !== null && type.id.size == 1 && ctx.getVariable(type.id.head) !== null + } + + def private String featureCallTarget(FeatureCall it, ScopeTranslationContext ctx) { + if (target === null || target.isThisCall()) + ctx.implicitVariableName + else + target.javaExpression(ctx) + } + + ////////////////////////////////////////////////// + // BOOLEAN OPERATIONS + ////////////////////////////////////////////////// + def dispatch String javaExpression(BooleanOperation it, ScopeTranslationContext ctx) { + autoBracket(left.javaExpression(ctx) + ' ' + operator + ' ' + right.javaExpression(ctx), ctx) + } + + ////////////////////////////////////////////////// + // COLLECTION OPERATIONS + ////////////////////////////////////////////////// + def dispatch String javaExpression(CollectionExpression it, ScopeTranslationContext ctx) { + if ('select' == name) { + 'com.google.common.collect.Iterables.filter(' + target.javaExpression(ctx) + + ', new com.google.common.base.Predicate() { public boolean apply(Object ' + + (if (getVar() !== null) getVar() else 'e') + ') {return ' + + exp.javaExpression(ctx) + ';} })' + } else { + notCompilable() + } + } + + def dispatch String javaExpression(TypeSelectExpression it, ScopeTranslationContext ctx) { + if (isSimpleNavigation(ctx)) + 'com.google.common.collect.Iterables.filter(' + target.javaExpression(ctx) + ', ' + ctx.javaType(type) + '.class)' + else notCompilable() + } + + ////////////////////////////////////////////////// + // TYPE CAST + ////////////////////////////////////////////////// + def dispatch String javaExpression(CastedExpression it, ScopeTranslationContext ctx) { + '((' + ctx.javaType(type) + ') ' + target.javaExpression(ctx) + ')' + } + + ////////////////////////////////////////////////// + // IF EXPRESSIONS + ////////////////////////////////////////////////// + def dispatch String javaExpression(IfExpression it, ScopeTranslationContext ctx) { + autoBracket(condition.javaExpression(ctx) + ' ? ' + thenPart.javaExpression(ctx) + ' : ' + elsePart.javaExpression(ctx), ctx) + } + + ////////////////////////////////////////////////// + // FEATURE CALLS + ////////////////////////////////////////////////// + def dispatch String javaExpression(FeatureCall it, ScopeTranslationContext ctx) { + if (isThisCall()) { + ctx.implicitVariableName + } else if (isVariableRef(ctx)) { + type.javaExpression(ctx) + } else if (isTypeRef(ctx)) { + ctx.javaType(type) + } else if (isSimpleFeatureCall(ctx)) { + featureCallTarget(ctx) + '.' + (if (calledFeature() == 'eContainer') 'eContainer' else (if (calledFeature() == 'isEmpty') 'isEmpty' else calledFeature().toFirstUpper().featureCallName())) + '()' + } else if (isSimpleNavigation(ctx)) { + notCompilable() + } else { + featureCallTarget(ctx) + '.' + (if (calledFeature() == 'eContainer') 'eContainer' else (if (calledFeature() == 'isEmpty') 'isEmpty' else calledFeature().toFirstUpper().featureCallName())) + '()' + } + } + + def private String featureCallName(String it) { + if (it.startsWith('^')) + it.substring(1, it.length).toFirstUpper().featureCallName() + else + (if (it.startsWith('Is')) 'is' else 'get') + it + } + + /** + * Tests whether the given feature call is a simple feature access on the implicit receiver or an in-scope + * variable, i.e. one that compiles to a single {@code getX()}/{@code isX()} accessor. Replaces the legacy + * {@code CodeGenerationX.isSimpleFeatureCall}. + * + * @param it + * the expression, must not be {@code null} + * @param ctx + * the compilation context, must not be {@code null} + * @return {@code true} if the call is a simple feature access + */ + def dispatch boolean isSimpleFeatureCall(Expression it, ScopeTranslationContext ctx) { + false + } + + def dispatch boolean isSimpleFeatureCall(FeatureCall it, ScopeTranslationContext ctx) { + eClass.name.contains('FeatureCall') && name === null && type.isFeature() && (target === null || target.isVariableRef(ctx) || target.isThisCall()) + } + + def dispatch boolean isSimpleNavigation(Expression it, ScopeTranslationContext ctx) { + false + } + + def dispatch boolean isSimpleNavigation(TypeSelectExpression it, ScopeTranslationContext ctx) { + true + } + + def dispatch boolean isSimpleNavigation(FeatureCall it, ScopeTranslationContext ctx) { + name === null && type.isFeature() && (target === null || target.isVariableRef(ctx) || target.isThisCall() || target.isSimpleNavigation(ctx)) + } + + ////////////////////////////////////////////////// + // OPERATION CALLS + ////////////////////////////////////////////////// + def dispatch String javaExpression(OperationCall it, ScopeTranslationContext ctx) { + if ((target === null || target.isThisCall()) && targetHasOperation(ctx)) { + (if (target !== null) target.javaExpression(ctx) + '.' else '') + name + '(' + ', '.join(params.map[javaExpression(ctx)]) + ')' + } else if (isArithmeticOperatorCall(ctx)) { + autoBracket((' ' + name + ' ').join(params.map(e|e.javaExpression(ctx))), ctx) + } else if (isSimpleConcatCall()) { + (' + ').join(params.map(e|e.javaExpression(ctx))) + } else if (isPrefixExpression()) { + autoBracket(name + params.head.javaExpression(ctx), ctx) + } else if ('first' == name && params.isEmpty && target !== null) { + target.javaExpression(ctx) + '.get(0)' + } else if ('isInstance' == name && params.size == 1 && target instanceof FeatureCall && (target as FeatureCall).isTypeRef(ctx)) { + autoBracket(params.head.javaExpression(ctx) + ' instanceof ' + target.javaExpression(ctx), ctx) + } else if ('eContainer' == name && params.isEmpty) { + target.javaExpression(ctx) + '.eContainer()' + } else { + (if (target !== null) target.javaExpression(ctx) + '.' else '') + name + '(' + (if (params.isEmpty) '' else ', '.join(params.map[javaExpression(ctx)])) + ')' + } + } + + /** + * Heuristically tests whether an unqualified or {@code this} qualified operation call refers to an operation + * declared on the implicit receiver's type. Replaces the legacy {@code CompilationContext.targetHasOperation}. + * + * @param it + * the operation call, must not be {@code null} + * @param ctx + * the compilation context, must not be {@code null} + * @return {@code true} if the implicit receiver type declares a matching operation + */ + def private boolean targetHasOperation(OperationCall it, ScopeTranslationContext ctx) { + val receiverType = translator.resolveType(target, ctx) + if (!(receiverType instanceof JvmDeclaredType)) { + return false + } + val operationName = name + val parameterCount = params.size + val declaredType = receiverType as JvmDeclaredType + declaredType.allFeatures.filter(JvmOperation).exists [ + simpleName == operationName && parameters.size == parameterCount + ] + } + + ////////////////////////////////////////////////// + // EXPRESSION BRACKETING + ////////////////////////////////////////////////// + def private String autoBracket(Expression it, String javaCode, ScopeTranslationContext ctx) { + if (requiresBracketing(ctx)) '(' + javaCode + ')' else javaCode + } + + def private dispatch boolean requiresBracketing(Expression it, ScopeTranslationContext ctx) { + (isPrefixExpression() || isInfixExpression(ctx)) && eContainer() !== null && requiresBracketing(it, eContainer(), ctx) + } + + def private dispatch boolean requiresBracketing(Literal it, ScopeTranslationContext ctx) { + false + } + + def private dispatch boolean requiresBracketing(Expression it, Object parent, ScopeTranslationContext ctx) { + false + } + + def private dispatch boolean requiresBracketing(Expression it, Expression parent, ScopeTranslationContext ctx) { + isPrefixExpression() && parent.isPrefixExpression() || + (isInfixExpression(ctx) && (parent.isPrefixExpression() || parent.isInfixExpression(ctx))) + } + + def private dispatch boolean requiresBracketing(OperationCall it, OperationCall parent, ScopeTranslationContext ctx) { + isPrefixExpression() && parent.isPrefixExpression() || + (isInfixExpression(ctx) && (parent.isPrefixExpression() || (parent.isInfixExpression(ctx) && name != parent.name))) + } + + def private dispatch boolean requiresBracketing(BooleanOperation it, BooleanOperation parent, ScopeTranslationContext ctx) { + operator != parent.operator + } + + ////////////////////////////////////////////////// + // OPERATOR CLASSIFICATION + ////////////////////////////////////////////////// + def private boolean isSimpleConcatCall(OperationCall it) { + name == '+' && type === null && target === null && !params.isEmpty + } + + def private boolean isNumber(Expression it, ScopeTranslationContext ctx) { + val type = translator.resolveType(it, ctx) + type !== null && type.isNumeric + } + + def private boolean isNumeric(JvmType it) { + val name = qualifiedName + switch name { + case 'int', + case 'long', + case 'short', + case 'byte', + case 'double', + case 'float', + case 'java.lang.Integer', + case 'java.lang.Long', + case 'java.lang.Short', + case 'java.lang.Byte', + case 'java.lang.Double', + case 'java.lang.Float', + case 'java.lang.Number', + case 'java.math.BigInteger', + case 'java.math.BigDecimal': + true + default: + false + } + } + + def private dispatch boolean isArithmeticOperatorCall(OperationCall it, ScopeTranslationContext ctx) { + type === null && target === null && params.size > 1 && (name == '+' || name == '-' || name == '*' || name == '/') && params.forall[isNumber(ctx)] + } + + def private dispatch boolean isArithmeticOperatorCall(Expression it, ScopeTranslationContext ctx) { + false + } + + def private dispatch boolean isPrefixExpression(Expression it) { + false + } + + def private dispatch boolean isPrefixExpression(OperationCall it) { + type === null && target === null && params.size == 1 && (name == '-' || name == '!') + } + + def private dispatch boolean isInfixExpression(Void it, ScopeTranslationContext ctx) { + false + } + + def private dispatch boolean isInfixExpression(Expression it, ScopeTranslationContext ctx) { + false + } + + def private dispatch boolean isInfixExpression(OperationCall it, ScopeTranslationContext ctx) { + isArithmeticOperatorCall(ctx) || 'isInstance' == name + } + + def private dispatch boolean isInfixExpression(IfExpression it, ScopeTranslationContext ctx) { + true + } + + def private dispatch boolean isInfixExpression(BooleanOperation it, ScopeTranslationContext ctx) { + true + } + + ////////////////////////////////////////////////// + // TYPE RESOLUTION + ////////////////////////////////////////////////// + /** + * Resolves the Java class name of the given source DSL type identifier. Model types resolve through the imported + * EPackages to their generated instance class name (exactly as the legacy {@code CompilationContext.javaType} + * did through {@code genModelUtil.instanceClassName}); plain Java types resolve against the classpath. Replaces + * the legacy {@code CompilationContext.javaType}. + * + * @param ctx + * the compilation context, must not be {@code null} + * @param type + * the source type identifier, must not be {@code null} + * @return the qualified Java class name (or the joined identifier when the type cannot be resolved) + */ + def private String javaType(ScopeTranslationContext ctx, Identifier type) { + val classifier = ctx.modelTypeResolver?.resolve(type.id) + if (classifier !== null) { + return genModelUtil.instanceClassName(classifier) + } + val resolved = ctx.resolveDslType(type) + if (resolved === null) { + return '::'.join(type.id) + } + val name = resolved.qualifiedName + if (name.startsWith('java.lang.') && !name.substring('java.lang.'.length).contains('.')) { + name.substring('java.lang.'.length) + } else { + name + } + } + + ////////////////////////////////////////////////// + // HELPER FUNCTIONS + ////////////////////////////////////////////////// + def private dispatch boolean isThisCall(Expression it) { + false + } + + def private dispatch boolean isThisCall(FeatureCall it) { + name === null && type.isThis() + } + + def private boolean isFeature(Identifier it) { + id !== null && id.size == 1 + } + + def private dispatch boolean isThis(Expression it) { + false + } + + def private dispatch boolean isThis(Identifier it) { + id !== null && id.size == 1 && id.head == "this" + } + + def private String calledFeature(FeatureCall it) { + type.id.head + } + + def private String serialize(EObject it) { + ExpressionExtensions.serialize(it) + } + + def private dispatch String javaEncode(Expression it) { + javaEncode(serialize()) + } + + def private dispatch String javaEncode(String it) { + Strings.convertToJavaString(it) + } + + def private String join(String it, List strings) { + if (strings.isEmpty) '' else Strings.concat(it, strings) + } + +} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionMethodRequest.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionMethodRequest.xtend new file mode 100644 index 0000000000..d17f9c6f7a --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionMethodRequest.xtend @@ -0,0 +1,173 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.scope.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import java.util.List +import org.eclipse.xtext.xbase.lib.Pair + +/** + * Describes a private helper operation that the {@link ScopeJvmModelInferrer} has to contribute to the inferred + * scope provider for an embedded scope/export expression. + *

+ * The legacy generators emit Java for embedded expressions by splicing fragment strings (produced by the + * {@code expression.generator.CodeGenerationX} compiler) into larger source templates. The Xbase based code + * generation instead attaches a fully linked {@link org.eclipse.xtext.xbase.XExpression} as a whole method body, + * which cannot be spliced into a string. Each embedded expression is therefore turned into a generated helper + * method: the string template emits a call to {@link #getMethodName()} and this request carries everything the + * inferrer needs to build that method. The {@link #getFallbackBody() fallback body} (the legacy string emission) + * is used when the translator cannot (yet) translate the expression, so behaviour is preserved while coverage is + * migrated incrementally. + */ +class ScopeExpressionMethodRequest { + + String methodName + + String returnTypeName + + String variableName + + String variableTypeName + + Expression expression + + String fallbackBody + + List> extraParameters = newArrayList + + /** + * Returns the name of the helper method to generate. + * + * @return the method name, never {@code null} + */ + def String getMethodName() { + methodName + } + + /** + * Sets the name of the helper method to generate. + * + * @param methodName + * the method name, must not be {@code null} + */ + def void setMethodName(String methodName) { + this.methodName = methodName + } + + /** + * Returns the fully qualified name of the helper method's return type (or a Java primitive name such as + * {@code boolean}). + * + * @return the return type name, never {@code null} + */ + def String getReturnTypeName() { + returnTypeName + } + + /** + * Sets the fully qualified name of the helper method's return type. + * + * @param returnTypeName + * the return type name, must not be {@code null} + */ + def void setReturnTypeName(String returnTypeName) { + this.returnTypeName = returnTypeName + } + + /** + * Returns the source name of the single context variable the expression is evaluated against. + * + * @return the variable name, never {@code null} + */ + def String getVariableName() { + variableName + } + + /** + * Sets the source name of the single context variable the expression is evaluated against. + * + * @param variableName + * the variable name, must not be {@code null} + */ + def void setVariableName(String variableName) { + this.variableName = variableName + } + + /** + * Returns the fully qualified name of the context variable's type. + * + * @return the variable type name, never {@code null} + */ + def String getVariableTypeName() { + variableTypeName + } + + /** + * Sets the fully qualified name of the context variable's type. + * + * @param variableTypeName + * the variable type name, must not be {@code null} + */ + def void setVariableTypeName(String variableTypeName) { + this.variableTypeName = variableTypeName + } + + /** + * Returns the source expression to translate into the helper method body. + * + * @return the source expression, never {@code null} + */ + def Expression getExpression() { + expression + } + + /** + * Sets the source expression to translate into the helper method body. + * + * @param expression + * the source expression, must not be {@code null} + */ + def void setExpression(Expression expression) { + this.expression = expression + } + + /** + * Returns the legacy method body (a complete Java statement sequence, including the {@code return}) used when the + * translator cannot translate the expression. + * + * @return the fallback body, never {@code null} + */ + def String getFallbackBody() { + fallbackBody + } + + /** + * Sets the legacy method body used when the translator cannot translate the expression. + * + * @param fallbackBody + * the fallback body, must not be {@code null} + */ + def void setFallbackBody(String fallbackBody) { + this.fallbackBody = fallbackBody + } + + /** + * Returns the additional helper method parameters (beyond the primary context variable), each as a + * source-name to fully-qualified-type-name pair. These cover expressions evaluated against more than one variable, + * such as a data match lambda's element description. + * + * @return the extra parameters, never {@code null} + */ + def List> getExtraParameters() { + extraParameters + } + +} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionTranslator.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionTranslator.xtend new file mode 100644 index 0000000000..0560037bad --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeExpressionTranslator.xtend @@ -0,0 +1,881 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.scope.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.BooleanOperation +import com.avaloq.tools.ddk.xtext.expression.expression.CastedExpression +import com.avaloq.tools.ddk.xtext.expression.expression.Expression +import com.avaloq.tools.ddk.xtext.expression.expression.FeatureCall +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.expression.expression.IfExpression +import com.avaloq.tools.ddk.xtext.expression.expression.IntegerLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.ListLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.NullLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.OperationCall +import com.avaloq.tools.ddk.xtext.expression.expression.RealLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.StringLiteral +import com.avaloq.tools.ddk.xtext.expression.expression.TypeSelectExpression +import com.avaloq.tools.ddk.xtext.scope.generator.ScopeModelTypeResolver +import com.google.common.collect.Iterables +import com.google.inject.Inject +import java.util.List +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.common.types.JvmDeclaredType +import org.eclipse.xtext.common.types.JvmFormalParameter +import org.eclipse.xtext.common.types.JvmOperation +import org.eclipse.xtext.common.types.JvmType +import org.eclipse.xtext.common.types.TypesFactory +import org.eclipse.xtext.common.types.util.TypeReferences +import org.eclipse.xtext.xbase.XExpression +import org.eclipse.xtext.xbase.XbaseFactory +import org.eclipse.xtext.xbase.lib.BooleanExtensions +import org.eclipse.xtext.xbase.lib.ObjectExtensions + +/** + * Translates the custom {@link Expression} AST of the scope/export expression DSL into equivalent Xbase + * {@link XExpression} trees that can be compiled by the {@code XbaseCompiler} through the JVM model inferrer. + *

+ * Translation happens against a {@link ScopeTranslationContext} that provides the variables in scope and the + * implicit ({@code this}) variable. Increments covered so far: + *

    + *
  • I1 - literals, list literals and conditional expressions (no JVM linking required).
    • + *
  • I2 - variable and {@code this} feature calls, linked to the enclosing operation's formal parameters.
    • + *
  • I3 - boolean, equality and relational operations, linked to the matching {@code org.eclipse.xtext.xbase.lib} + * operator methods.
    • + *
  • I3b - getter navigations, linked to the {@code getX()}/{@code isX()} operation on the receiver's JVM type.
    • + *
  • I4 - extension operation calls, linked to the {@code static} method of an extension class declared through + * {@code extension a::b::C}.
    • + *
  • I5 - type casts, {@code typeSelect} filters, {@code isInstance} checks and receiver/implicit method calls, + * linked to the resolved JVM type, method or {@code com.google.common.collect.Iterables} operation.
    • + *
+ * Nodes that require resolving EMF feature getters, operators, operations, extensions, casts, collection + * closures, constructor calls or global variables return {@code null} for now and are added in later increments. + */ +class ScopeExpressionTranslator { + + /** Provides access to the {@code org.eclipse.xtext.xbase.lib} operator methods that back binary operations. */ + @Inject extension TypeReferences + + /** + * Translates the given expression into an equivalent {@link XExpression}. + * + * @param expression + * the source expression, may be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the translated {@link XExpression}, or {@code null} if the expression cannot (yet) be translated + */ + def XExpression translate(Expression expression, ScopeTranslationContext context) { + if (expression === null) { + return null + } + return expression.doTranslate(context) + } + + /** + * Resolves a factory expression of the form {@code Type.method(args)} to the fully qualified static Java method + * {@code .} by linking the type reference against the classpath. This replaces the + * legacy {@code .ext} based resolution: the declaring type is named directly in the scope source rather than + * indirected through an Xtend extension file. + * + * @param expression + * the factory expression, must not be {@code null} + * @param sourceElement + * a model element used to resolve the type against the classpath, must not be {@code null} + * @return the fully qualified static method ({@code type.method}), or {@code null} if the expression is not a + * type-qualified operation call or the type cannot be resolved + */ + def String resolveFactoryMethod(Expression expression, EObject sourceElement) { + if (!(expression instanceof OperationCall)) { + return null + } + val call = expression as OperationCall + if (!(call.target instanceof FeatureCall)) { + return null + } + val typeReference = call.target as FeatureCall + if (typeReference.name !== null || typeReference.type === null) { + return null + } + val jvmType = findDeclaredType(typeReference.type.id.join('.'), sourceElement) + if (jvmType instanceof JvmDeclaredType) { + return jvmType.qualifiedName + '.' + call.name + } + null + } + + /** + * Tests whether the given expression can be extracted into a typed helper method, i.e. whether it can be both + * translated into an {@link XExpression} and have its result type resolved. The check is performed against a + * fresh trial context holding a single {@code ctx} variable of the given context type, so it can be used at code + * generation time before the actual JVM operation (and its formal parameter) exist. + * + * @param expression + * the source expression to test, must not be {@code null} + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return {@code true} if the expression can be extracted into a typed helper method + */ + def boolean canExtractAsValue(Expression expression, EClass contextType, EObject sourceElement) { + val context = newTrialContext(contextType, sourceElement) + translate(expression, context) !== null && resolveType(expression, context) !== null + } + + /** + * Tests whether the given expression can be extracted into a helper method whose result is a {@link String}, i.e. + * whether it can be translated and its result type resolves to {@code java.lang.String}. Used for splice sites that + * are overloaded on the argument type (such as a container query name) where extracting a non-{@code String} value + * would select the wrong overload. + * + * @param expression + * the source expression to test, must not be {@code null} + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return {@code true} if the expression can be extracted as a {@code String} valued helper method + */ + def boolean canExtractAsString(Expression expression, EClass contextType, EObject sourceElement) { + val context = newTrialContext(contextType, sourceElement) + if (translate(expression, context) === null) { + return false + } + val resolved = resolveType(expression, context) + resolved !== null && resolved.qualifiedName == String.name + } + + /** + * Tests whether the given expression can be extracted into a typed helper method that, in addition to the primary + * {@code ctx} variable, has the given extra variables in scope (for example a data match lambda's element + * description). The check uses a fresh trial context so it can be used at code generation time. + * + * @param expression + * the source expression to test, must not be {@code null} + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param extraVariables + * the extra variables as source-name to fully-qualified-type-name pairs, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return {@code true} if the expression can be extracted into a typed helper method + */ + def boolean canExtractAsValue(Expression expression, EClass contextType, List> extraVariables, + EObject sourceElement) { + val context = newTrialContext(contextType, sourceElement) + for (extra : extraVariables) { + context.putVariable(extra.key, newTrialParameter(extra.key, extra.value, sourceElement)) + } + translate(expression, context) !== null && resolveType(expression, context) !== null + } + + /** + * Creates a trial translation context holding a single {@code ctx} variable of the given context type. The + * context's type resolver resolves DSL type identifiers by their fully qualified name against the classpath. + * + * @param contextType + * the EClass of the {@code ctx} context variable, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return the trial context, never {@code null} + */ + def private ScopeTranslationContext newTrialContext(EClass contextType, EObject sourceElement) { + val parameter = newTrialParameter('ctx', contextType.instanceClassName, sourceElement) + val context = new ScopeTranslationContext + context.sourceElement = sourceElement + context.putVariable('ctx', parameter) + context.implicitVariable = parameter + context.typeResolver = [Identifier identifier|findDeclaredType(identifier.id.join('.'), sourceElement)] + context + } + + /** + * Creates a trial formal parameter with the given name and type, used to populate a trial translation context. + * + * @param name + * the parameter name, must not be {@code null} + * @param typeName + * the fully qualified type name of the parameter, must not be {@code null} + * @param sourceElement + * a model element used to resolve the type against the classpath, must not be {@code null} + * @return the trial parameter, never {@code null} + */ + def private JvmFormalParameter newTrialParameter(String name, String typeName, EObject sourceElement) { + val parameter = TypesFactory.eINSTANCE.createJvmFormalParameter + parameter.name = name + val jvmType = findDeclaredType(typeName, sourceElement) + if (jvmType !== null) { + parameter.parameterType = createTypeRef(jvmType) + } + parameter + } + + /** + * Creates a translation context for rendering an expression to Java source text with the + * {@link ScopeExpressionCompiler}. The context binds the implicit ({@code this}) receiver to the given Java + * variable name and EMF type, registers the implicit and any extra variables, and resolves DSL type identifiers + * against the classpath. This replaces the legacy {@code CompilationContext.clone(...)} factories. + * + * @param implicitVariableName + * the Java variable name an unqualified {@code this} reference compiles to, must not be {@code null} + * @param implicitType + * the EMF type of the implicit receiver, may be {@code null} + * @param extraVariables + * extra in-scope variables as source-name to fully-qualified-type-name pairs, must not be {@code null} + * @param sourceElement + * a model element used to resolve types against the classpath, must not be {@code null} + * @return the compilation context, never {@code null} + */ + def ScopeTranslationContext newCompilationContext(String implicitVariableName, EClass implicitType, + List> extraVariables, EObject sourceElement) { + val context = new ScopeTranslationContext + context.sourceElement = sourceElement + context.implicitVariableName = implicitVariableName + context.modelTypeResolver = ScopeModelTypeResolver.forElement(sourceElement) + if (implicitType !== null) { + val parameter = newTrialParameter(implicitVariableName, implicitType.instanceClassName, sourceElement) + context.implicitVariable = parameter + context.putVariable(implicitVariableName, parameter) + } + for (extra : extraVariables) { + context.putVariable(extra.key, newTrialParameter(extra.key, extra.value, sourceElement)) + } + context.typeResolver = [Identifier identifier|findDeclaredType(identifier.id.join('.'), sourceElement)] + context + } + + /** + * Fallback for expression types that are not (yet) supported by the translator. + * + * @param it + * the source expression, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return {@code null}, indicating the expression cannot be translated yet + */ + def dispatch protected XExpression doTranslate(Expression it, ScopeTranslationContext context) { + null + } + + /** + * Translates a string literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XStringLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(StringLiteral it, ScopeTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXStringLiteral + literal.value = getVal() + literal + } + + /** + * Translates a boolean literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XBooleanLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(BooleanLiteral it, ScopeTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXBooleanLiteral + literal.isTrue = 'true' == getVal() + literal + } + + /** + * Translates an integer literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XNumberLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(IntegerLiteral it, ScopeTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXNumberLiteral + literal.value = Integer.toString(getVal()) + literal + } + + /** + * Translates a real (floating point) literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XNumberLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(RealLiteral it, ScopeTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXNumberLiteral + literal.value = getVal() + literal + } + + /** + * Translates a {@code null} literal. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XNullLiteral}, never {@code null} + */ + def dispatch protected XExpression doTranslate(NullLiteral it, ScopeTranslationContext context) { + XbaseFactory.eINSTANCE.createXNullLiteral + } + + /** + * Translates a list literal. Each element is translated recursively; if any element cannot be translated + * the whole list literal is considered untranslatable. + * + * @param it + * the source literal, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XListLiteral}, or {@code null} if an element cannot be translated + */ + def dispatch protected XExpression doTranslate(ListLiteral it, ScopeTranslationContext context) { + val literal = XbaseFactory.eINSTANCE.createXListLiteral + for (element : elements) { + val translated = element.translate(context) + if (translated === null) { + return null + } + literal.elements += translated + } + literal + } + + /** + * Translates a conditional expression (ternary {@code ? :} or {@code if}/{@code then}/{@code else}). When the + * source has no else branch a {@link org.eclipse.xtext.xbase.XNullLiteral} is used as the else value. + * + * @param it + * the source conditional, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XIfExpression}, or {@code null} if a branch cannot be translated + */ + def dispatch protected XExpression doTranslate(IfExpression it, ScopeTranslationContext context) { + val xIf = XbaseFactory.eINSTANCE.createXIfExpression + val xCondition = condition.translate(context) + val xThen = thenPart.translate(context) + if (xCondition === null || xThen === null) { + return null + } + xIf.^if = xCondition + xIf.then = xThen + if (elsePart !== null) { + val xElse = elsePart.translate(context) + if (xElse === null) { + return null + } + xIf.^else = xElse + } else { + xIf.^else = XbaseFactory.eINSTANCE.createXNullLiteral + } + xIf + } + + /** + * Translates a boolean, equality or relational operation into an {@link org.eclipse.xtext.xbase.XBinaryOperation}. + * The operator is linked to the corresponding {@code org.eclipse.xtext.xbase.lib} operator method so that the + * {@code XbaseCompiler} can emit the equivalent Java code. Operators without a backing library method (currently + * {@code implies} and the relational comparisons) are left untranslated for now. + * + * @param it + * the source operation, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the {@link org.eclipse.xtext.xbase.XBinaryOperation}, or {@code null} if it cannot (yet) be translated + */ + def dispatch protected XExpression doTranslate(BooleanOperation it, ScopeTranslationContext context) { + val xLeft = left.translate(context) + val xRight = right.translate(context) + if (xLeft === null || xRight === null) { + return null + } + val sourceElement = context.sourceElement + switch operator { + case '||': toBinaryOperation(xLeft, xRight, BooleanExtensions, 'operator_or', sourceElement) + case '&&': toBinaryOperation(xLeft, xRight, BooleanExtensions, 'operator_and', sourceElement) + case '==': toBinaryOperation(xLeft, xRight, ObjectExtensions, 'operator_equals', sourceElement) + case '!=': toBinaryOperation(xLeft, xRight, ObjectExtensions, 'operator_notEquals', sourceElement) + default: null + } + } + + /** + * Translates an operation call. In order, an {@code isInstance} check is mapped to an + * {@link org.eclipse.xtext.xbase.XInstanceOfExpression}, a receiver or implicit method call (which also covers + * {@code eContainer}/{@code eClass} style operations) to an {@link org.eclipse.xtext.xbase.XMemberFeatureCall} + * linked to the resolved method, and finally an extension call to a {@code static} extension method (see I4). + * Arithmetic, concatenation and prefix operator calls are added in later increments. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the resolved expression, or {@code null} if it cannot (yet) be translated + */ + def dispatch protected XExpression doTranslate(OperationCall it, ScopeTranslationContext context) { + it.translateInstanceOf(context) ?: it.translateMethodCall(context) ?: it.translateExtensionCall(context) + } + + /** + * Translates a type cast ({@code (Type) target}) into an {@link org.eclipse.xtext.xbase.XCastedExpression}. + * + * @param it + * the source cast, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the casted expression, or {@code null} if the type or target cannot be translated + */ + def dispatch protected XExpression doTranslate(CastedExpression it, ScopeTranslationContext context) { + val jvmType = context.resolveDslType(type) + if (jvmType === null) { + return null + } + val xTarget = target.translate(context) + if (xTarget === null) { + return null + } + val cast = XbaseFactory.eINSTANCE.createXCastedExpression + cast.type = createTypeRef(jvmType) + cast.target = xTarget + cast + } + + /** + * Translates a {@code typeSelect(Type)} navigation into a {@code com.google.common.collect.Iterables.filter} + * call that keeps the elements assignable to the given type, mirroring the legacy code generation. + * + * @param it + * the source type select, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the filter feature call, or {@code null} if the type, target or filter method cannot be resolved + */ + def dispatch protected XExpression doTranslate(TypeSelectExpression it, ScopeTranslationContext context) { + val jvmType = context.resolveDslType(type) + if (jvmType === null) { + return null + } + val xTarget = target.translate(context) + if (xTarget === null) { + return null + } + val filter = findIterablesFilterByClass(context.sourceElement) + if (filter === null) { + return null + } + val call = XbaseFactory.eINSTANCE.createXFeatureCall + call.feature = filter + call.featureCallArguments += xTarget + val typeLiteral = XbaseFactory.eINSTANCE.createXTypeLiteral + typeLiteral.type = jvmType + call.featureCallArguments += typeLiteral + call + } + + /** + * Translates a feature call. The supported cases are an unqualified {@code this} reference (mapped to the + * implicit variable), a single-segment identifier that matches a variable in scope, and a getter navigation + * ({@code receiver.feature}) which is resolved to the matching {@code getX()}/{@code isX()} operation on the + * receiver's JVM type. Type references and operation calls are added in later increments. + * + * @param it + * the source feature call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the resolved feature call, or {@code null} if it cannot (yet) be translated + */ + def dispatch protected XExpression doTranslate(FeatureCall it, ScopeTranslationContext context) { + if (it.isThisReference) { + return context.implicitVariable.toFeatureCall + } + if (target === null && name === null && type !== null && type.id.size == 1) { + val parameter = context.getVariable(type.id.head) + if (parameter !== null) { + return parameter.toFeatureCall + } + } + if (name === null && type !== null && type.id.size == 1) { + return it.translateGetter(context) + } + null + } + + /** + * Tests whether the given feature call is an unqualified {@code this} reference. + * + * @param call + * the feature call, must not be {@code null} + * @return {@code true} if the call refers to {@code this} + */ + def private boolean isThisReference(FeatureCall call) { + call.name === null && call.target === null && call.type !== null && call.type.id.size == 1 && + 'this' == call.type.id.head + } + + /** + * Creates an {@link org.eclipse.xtext.xbase.XFeatureCall} that references the given formal parameter. + * + * @param parameter + * the formal parameter to reference, may be {@code null} + * @return the feature call, or {@code null} if the parameter is {@code null} + */ + def private XExpression toFeatureCall(JvmFormalParameter parameter) { + if (parameter === null) { + return null + } + val featureCall = XbaseFactory.eINSTANCE.createXFeatureCall + featureCall.feature = parameter + featureCall + } + + /** + * Translates a getter navigation ({@code receiver.feature}) into an {@link org.eclipse.xtext.xbase.XMemberFeatureCall} + * linked to the resolved {@code getX()}/{@code isX()} operation. The receiver is the translated target, or the + * implicit variable when there is no explicit target. + * + * @param it + * the source feature call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the member feature call, or {@code null} if the receiver type or getter cannot be resolved + */ + def private XExpression translateGetter(FeatureCall it, ScopeTranslationContext context) { + val receiverType = resolveType(target, context) + if (receiverType === null) { + return null + } + val getter = findGetter(receiverType, type.id.head) + if (getter === null) { + return null + } + val receiver = if (target === null) context.implicitVariable.toFeatureCall else target.translate(context) + if (receiver === null) { + return null + } + val memberCall = XbaseFactory.eINSTANCE.createXMemberFeatureCall + memberCall.memberCallTarget = receiver + memberCall.feature = getter + memberCall + } + + /** + * Resolves the static JVM type of the given expression as far as needed to link getter navigations. Supported + * expressions are the implicit variable (when {@code expression} is {@code null} or a {@code this} reference), a + * variable in scope, and a getter navigation chain. + * + * @param expression + * the source expression whose type to resolve, may be {@code null} to denote the implicit variable + * @param context + * the translation context, must not be {@code null} + * @return the resolved JVM type, or {@code null} if it cannot be determined + */ + def JvmType resolveType(Expression expression, ScopeTranslationContext context) { + if (expression === null) { + return context.implicitVariable?.parameterType?.type + } + switch expression { + CastedExpression: + context.resolveDslType(expression.type) + StringLiteral: + findDeclaredType(String, expression) + TypeSelectExpression: + findDeclaredType(Iterable, context.sourceElement) + ListLiteral: + findDeclaredType(List, context.sourceElement) + OperationCall: { + val receiverType = resolveType(expression.target, context) + findMethod(receiverType, expression.name, expression.params.size)?.returnType?.type + } + FeatureCall: { + if (expression.isThisReference) { + context.implicitVariable?.parameterType?.type + } else if (expression.target === null && expression.name === null && expression.type !== null && + expression.type.id.size == 1 && context.getVariable(expression.type.id.head) !== null) { + context.getVariable(expression.type.id.head).parameterType?.type + } else if (expression.name === null && expression.type !== null && expression.type.id.size == 1) { + val receiverType = resolveType(expression.target, context) + if (receiverType !== null) findGetter(receiverType, expression.type.id.head)?.returnType?.type else null + } else { + null + } + } + default: + null + } + } + + /** + * Finds the no-argument getter operation for the given feature name on the given JVM type. The candidate method + * names are the feature name itself (covering operations such as {@code eContainer} or {@code isEmpty}) as well as + * the {@code getX} and {@code isX} accessor variants. + * + * @param type + * the receiver type, must not be {@code null} + * @param feature + * the source feature name, must not be {@code null} + * @return the matching getter operation, or {@code null} if none is found + */ + def private JvmOperation findGetter(JvmType type, String feature) { + if (type instanceof JvmDeclaredType) { + val candidates = feature.getterCandidates + return type.allFeatures.filter(JvmOperation).findFirst [ + parameters.empty && candidates.contains(simpleName) + ] + } + null + } + + /** + * Computes the candidate getter method names for the given source feature name. + * + * @param feature + * the source feature name, must not be {@code null} + * @return the list of candidate method names, never {@code null} + */ + def private getterCandidates(String feature) { + val name = if (feature.startsWith('^')) feature.substring(1) else feature + val upper = name.toFirstUpper + #[name, 'get' + upper, 'is' + upper] + } + + /** + * Translates an {@code isInstance} operation call ({@code Type.isInstance(value)}) into an + * {@link org.eclipse.xtext.xbase.XInstanceOfExpression}. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the instance-of expression, or {@code null} if the call is not an {@code isInstance} type check or the + * type or value cannot be resolved + */ + def private XExpression translateInstanceOf(OperationCall it, ScopeTranslationContext context) { + if (name != 'isInstance' || params.size != 1 || !(target instanceof FeatureCall)) { + return null + } + val typeReference = target as FeatureCall + if (typeReference.name !== null || typeReference.type === null) { + return null + } + val jvmType = context.resolveDslType(typeReference.type) + if (jvmType === null) { + return null + } + val xValue = params.head.translate(context) + if (xValue === null) { + return null + } + val instanceOf = XbaseFactory.eINSTANCE.createXInstanceOfExpression + instanceOf.expression = xValue + instanceOf.type = createTypeRef(jvmType) + instanceOf + } + + /** + * Translates a receiver or implicit method call ({@code receiver.method(args)} or {@code method(args)}) into an + * {@link org.eclipse.xtext.xbase.XMemberFeatureCall} linked to the resolved method. The receiver is the translated + * target, or the implicit variable when there is no explicit target. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the member feature call, or {@code null} if the receiver type, method or an argument cannot be resolved + */ + def private XExpression translateMethodCall(OperationCall it, ScopeTranslationContext context) { + val receiverType = resolveType(target, context) + if (receiverType === null) { + return null + } + val operation = findMethod(receiverType, name, params.size) + if (operation === null) { + return null + } + val receiver = if (target === null) context.implicitVariable.toFeatureCall else target.translate(context) + if (receiver === null) { + return null + } + val memberCall = XbaseFactory.eINSTANCE.createXMemberFeatureCall + memberCall.memberCallTarget = receiver + memberCall.feature = operation + memberCall.explicitOperationCall = true + for (param : params) { + val xParam = param.translate(context) + if (xParam === null) { + return null + } + memberCall.memberCallArguments += xParam + } + memberCall + } + + /** + * Finds the method of the given name and parameter count on the given JVM type. + * + * @param type + * the receiver type, may be {@code null} + * @param methodName + * the source method name, must not be {@code null} + * @param parameterCount + * the number of arguments the call passes + * @return the matching method, or {@code null} if none is found + */ + def private JvmOperation findMethod(JvmType type, String methodName, int parameterCount) { + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + simpleName == methodName && parameters.size == parameterCount + ] + } + null + } + + /** + * Finds the {@code com.google.common.collect.Iterables.filter(Iterable, Class)} operation used to back a + * {@code typeSelect} navigation. + * + * @param context + * the source element used to resolve the type against the classpath, may be {@code null} + * @return the {@code filter} operation, or {@code null} if it cannot be resolved + */ + def private JvmOperation findIterablesFilterByClass(EObject context) { + if (context === null) { + return null + } + val type = findDeclaredType(Iterables, context) + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + isStatic && simpleName == 'filter' && parameters.size == 2 && + parameters.get(1).parameterType?.type?.simpleName == 'Class' + ] + } + null + } + + /** + * Translates an extension operation call into an {@link org.eclipse.xtext.xbase.XFeatureCall} that invokes the + * matching {@code static} extension method. The call's target (when present) is prepended to the declared + * parameters to form the argument list. + * + * @param it + * the source operation call, must not be {@code null} + * @param context + * the translation context, must not be {@code null} + * @return the feature call, or {@code null} if no matching extension method exists or an argument cannot be translated + */ + def private XExpression translateExtensionCall(OperationCall it, ScopeTranslationContext context) { + val argumentCount = (if (target !== null) 1 else 0) + params.size + val operation = context.extensionClassNames.map [ className | + findExtensionOperation(className, name, argumentCount, context.sourceElement) + ].filterNull.head + if (operation === null) { + return null + } + val featureCall = XbaseFactory.eINSTANCE.createXFeatureCall + featureCall.feature = operation + if (target !== null) { + val xTarget = target.translate(context) + if (xTarget === null) { + return null + } + featureCall.featureCallArguments += xTarget + } + for (param : params) { + val xParam = param.translate(context) + if (xParam === null) { + return null + } + featureCall.featureCallArguments += xParam + } + featureCall + } + + /** + * Finds the {@code static} extension method of the given name and argument count on the given extension class. + * + * @param className + * the fully qualified name of the extension class, must not be {@code null} + * @param operationName + * the source operation name, must not be {@code null} + * @param argumentCount + * the number of arguments the call passes + * @param context + * the source element used to resolve the type against the classpath, may be {@code null} + * @return the matching {@code static} operation, or {@code null} if none is found + */ + def private JvmOperation findExtensionOperation(String className, String operationName, int argumentCount, + EObject context) { + if (context === null) { + return null + } + val type = findDeclaredType(className, context) + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + isStatic && simpleName == operationName && parameters.size == argumentCount + ] + } + null + } + + /** + * Builds an {@link org.eclipse.xtext.xbase.XBinaryOperation} linked to the given {@code org.eclipse.xtext.xbase.lib} + * operator method. + * + * @param left + * the already translated left operand, must not be {@code null} + * @param right + * the already translated right operand, must not be {@code null} + * @param operatorClass + * the {@code org.eclipse.xtext.xbase.lib} class declaring the operator method, must not be {@code null} + * @param operatorName + * the simple name of the operator method, must not be {@code null} + * @param context + * the source element used to resolve the operator type, may be {@code null} + * @return the binary operation, or {@code null} if the operator method cannot be resolved + */ + def private XExpression toBinaryOperation(XExpression left, XExpression right, Class operatorClass, + String operatorName, EObject context) { + val operation = findOperator(operatorClass, operatorName, context) + if (operation === null) { + return null + } + val binaryOperation = XbaseFactory.eINSTANCE.createXBinaryOperation + binaryOperation.leftOperand = left + binaryOperation.rightOperand = right + binaryOperation.feature = operation + binaryOperation + } + + /** + * Resolves the two-argument operator method of the given name on the given {@code org.eclipse.xtext.xbase.lib} class. + * + * @param operatorClass + * the class declaring the operator method, must not be {@code null} + * @param operatorName + * the simple name of the operator method, must not be {@code null} + * @param context + * the source element used to resolve the type against the classpath, may be {@code null} + * @return the operator {@link JvmOperation}, or {@code null} if it cannot be resolved + */ + def private JvmOperation findOperator(Class operatorClass, String operatorName, EObject context) { + if (context === null) { + return null + } + val type = findDeclaredType(operatorClass, context) + if (type instanceof JvmDeclaredType) { + return type.allFeatures.filter(JvmOperation).findFirst [ + simpleName == operatorName && parameters.size == 2 + ] + } + null + } + +} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeJvmModelInferrer.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeJvmModelInferrer.xtend new file mode 100644 index 0000000000..1809cb8aaa --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeJvmModelInferrer.xtend @@ -0,0 +1,292 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.scope.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.expression.generator.GenModelUtilX +import com.avaloq.tools.ddk.xtext.expression.generator.GeneratorSupport +import com.avaloq.tools.ddk.xtext.scope.generator.ScopeNameProviderGenerator +import com.avaloq.tools.ddk.xtext.scope.generator.ScopeProviderGenerator +import com.avaloq.tools.ddk.xtext.scope.generator.ScopeProviderX +import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel +import com.avaloq.tools.ddk.xtext.scoping.AbstractPolymorphicScopeProvider +import com.avaloq.tools.ddk.xtext.scoping.AbstractScopeNameProvider +import com.avaloq.tools.ddk.xtext.scoping.INameFunction +import com.google.inject.Inject +import com.google.inject.Singleton +import java.util.Map +import org.apache.logging.log4j.Logger +import org.eclipse.core.resources.IProject +import org.eclipse.core.resources.ResourcesPlugin +import org.eclipse.emf.ecore.EClass +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EReference +import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.xtext.common.types.JvmAnnotationReference +import org.eclipse.xtext.common.types.JvmAnnotationType +import org.eclipse.xtext.common.types.JvmGenericType +import org.eclipse.xtext.common.types.JvmVisibility +import org.eclipse.xtext.common.types.TypesFactory +import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer +import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor +import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder + +/** + * Infers a JVM model from a scope model. + *

+ * Replaces the former {@code IGenerator2} based {@code ScopeGenerator}: the {@code ScopeProvider} and + * {@code ScopeNameProvider} are now contributed as inferred JVM types whose Java source is emitted by the + * Xbase {@code JvmModelGenerator}. The method bodies are produced as strings by the (still expression based) scope + * generators and attached verbatim; framework types referenced by those strings are emitted fully qualified so that + * the generated compilation unit needs no import section of its own. + */ +class ScopeJvmModelInferrer extends AbstractModelInferrer { + + @Inject extension JvmTypesBuilder + @Inject extension ScopeProviderX + + @Inject TypesFactory typesFactory + @Inject ScopeProviderGenerator providerGenerator + @Inject ScopeNameProviderGenerator nameProviderGenerator + @Inject GenModelUtilX genModelUtil + @Inject GeneratorSupport generatorSupport + @Inject ScopeExpressionTranslator translator + + /** + * Infers the scope provider and scope name provider JVM types for the given scope model. + * + * @param element + * the scope model, must not be {@code null} + * @param acceptor + * the type acceptor, must not be {@code null} + * @param isPreIndexingPhase + * whether the method is called in the pre-indexing phase + */ + def dispatch void infer(ScopeModel element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) { + if (isPreIndexingPhase) { + return + } + genModelUtil.resource = element.eResource + providerGenerator.configure(nameProviderGenerator, genModelUtil) + nameProviderGenerator.configure(genModelUtil) + + // The method body strings are produced eagerly here (inside the project resource loader required by the + // expression compiler) rather than from within the deferred body closures, which run later during emission. + val Map bodies = newHashMap + generatorSupport.executeWithProjectResourceLoader(element.projectOf, [ + bodies.put('doGetScopeRef', providerGenerator.doGetScopeByReferenceBody(element).toString) + bodies.put('doGetScopeType', providerGenerator.doGetScopeByTypeBody(element).toString) + bodies.put('doGlobalCacheRef', providerGenerator.doGlobalCacheByReferenceBody(element).toString) + bodies.put('doGlobalCacheType', providerGenerator.doGlobalCacheByTypeBody(element).toString) + for (scope : element.allScopes) { + bodies.put('scope:' + scope.scopeMethodName, providerGenerator.scopeMethodBody(scope, element).toString) + } + bodies.put('nameFunctions', nameProviderGenerator.internalGetNameFunctionsBody(element).toString) + ]) + + val providerName = element.scopeProvider + acceptor.accept(element.toClass(providerName)) [ + superTypes += typeRef(AbstractPolymorphicScopeProvider) + addSuppressWarningsAll + documentation = '''The scope provider for «element.name».''' + members += element.toField('LOGGER', typeRef(Logger)) [ + static = true + final = true + initializer = [append('''org.apache.logging.log4j.LogManager.getLogger(«providerName.simpleName».class)''')] + ] + for (injection : element.allInjections) { + members += element.toField(injection.name, typeRef(injection.type)) [ + visibility = JvmVisibility.PRIVATE + annotations += typeOnlyAnnotation(Inject) + ] + } + members += element.toMethod('doGetScope', typeRef(IScope)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += element.toParameter('context', typeRef(EObject)) + parameters += element.toParameter('reference', typeRef(EReference)) + parameters += element.toParameter('scopeName', typeRef(String)) + parameters += element.toParameter('originalResource', typeRef(Resource)) + val text = bodies.get('doGetScopeRef') + body = [append(text)] + ] + members += element.toMethod('doGetScope', typeRef(IScope)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += element.toParameter('context', typeRef(EObject)) + parameters += element.toParameter('type', typeRef(EClass)) + parameters += element.toParameter('scopeName', typeRef(String)) + parameters += element.toParameter('originalResource', typeRef(Resource)) + val text = bodies.get('doGetScopeType') + body = [append(text)] + ] + members += element.toMethod('doGlobalCache', typeRef(Boolean.TYPE)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += element.toParameter('context', typeRef(EObject)) + parameters += element.toParameter('reference', typeRef(EReference)) + parameters += element.toParameter('scopeName', typeRef(String)) + parameters += element.toParameter('originalResource', typeRef(Resource)) + val text = bodies.get('doGlobalCacheRef') + body = [append(text)] + ] + members += element.toMethod('doGlobalCache', typeRef(Boolean.TYPE)) [ + visibility = JvmVisibility.PROTECTED + annotations += typeOnlyAnnotation(Override) + parameters += element.toParameter('context', typeRef(EObject)) + parameters += element.toParameter('type', typeRef(EClass)) + parameters += element.toParameter('scopeName', typeRef(String)) + parameters += element.toParameter('originalResource', typeRef(Resource)) + val text = bodies.get('doGlobalCacheType') + body = [append(text)] + ] + for (scope : element.allScopes) { + val text = bodies.get('scope:' + scope.scopeMethodName) + val hasReference = scope.reference !== null + members += element.toMethod(scope.scopeMethodName, typeRef(IScope)) [ + visibility = JvmVisibility.PROTECTED + parameters += element.toParameter('context', typeRef(EObject)) + if (hasReference) { + parameters += element.toParameter('ref', typeRef(EReference)) + } else { + parameters += element.toParameter('type', typeRef(EClass)) + } + parameters += element.toParameter('originalResource', typeRef(Resource)) + body = [append(text)] + ] + } + for (request : providerGenerator.expressionMethods) { + addExpressionMethod(it, element, request) + } + ] + + val nameProviderName = element.scopeNameProvider + acceptor.accept(element.toClass(nameProviderName)) [ + superTypes += typeRef(AbstractScopeNameProvider) + annotations += typeOnlyAnnotation(Singleton) + addSuppressWarningsAll + documentation = '''The scope name provider for «element.name».''' + members += element.toMethod('internalGetNameFunctions', typeRef(Iterable, typeRef(INameFunction))) [ + visibility = JvmVisibility.PUBLIC + annotations += typeOnlyAnnotation(Override) + parameters += element.toParameter('eClass', typeRef(EClass)) + val text = bodies.get('nameFunctions') + body = [append(text)] + ] + ] + } + + /** + * Adds a {@code @SuppressWarnings("all")} annotation to the given type. + * + * @param type + * the type to annotate, must not be {@code null} + */ + def private void addSuppressWarningsAll(JvmGenericType type) { + val annotation = typesFactory.createJvmAnnotationReference + annotation.annotation = typeRef(SuppressWarnings).type as JvmAnnotationType + val value = typesFactory.createJvmStringAnnotationValue + value.values += 'all' + annotation.explicitValues += value + type.annotations += annotation + } + + /** + * Creates a marker annotation reference (without values) for the given annotation type. + * + * @param annotationClass + * the annotation type, must not be {@code null} + * @return the annotation reference, never {@code null} + */ + def private JvmAnnotationReference typeOnlyAnnotation(Class annotationClass) { + val annotation = typesFactory.createJvmAnnotationReference + annotation.annotation = typeRef(annotationClass).type as JvmAnnotationType + annotation + } + + /** + * Contributes a private helper operation for an embedded scope expression. The expression is translated into an + * Xbase {@link org.eclipse.xtext.xbase.XExpression} attached as the method body; if the translator cannot (yet) + * translate it, the recorded legacy body string is emitted instead so behaviour is preserved. + * + * @param type + * the inferred provider type to add the method to, must not be {@code null} + * @param element + * the scope model the expression originates from, must not be {@code null} + * @param request + * the recorded helper method request, must not be {@code null} + */ + def private void addExpressionMethod(JvmGenericType type, ScopeModel element, ScopeExpressionMethodRequest request) { + val parameter = element.toParameter(request.variableName, typeRef(request.variableTypeName)) + val translationContext = new ScopeTranslationContext + translationContext.sourceElement = element + translationContext.putVariable(request.variableName, parameter) + translationContext.implicitVariable = parameter + translationContext.typeResolver = [Identifier t|element.newTypeRef(t.id.join('.'))?.type] + val extraParams = newArrayList + for (extra : request.extraParameters) { + val extraParam = element.toParameter(extra.key, typeRef(extra.value)) + extraParams += extraParam + translationContext.putVariable(extra.key, extraParam) + } + val translated = translator.translate(request.expression, translationContext) + val returnType = if (request.returnTypeName == 'boolean') { + typeRef(Boolean.TYPE) + } else if (request.returnTypeName !== null) { + typeRef(request.returnTypeName) + } else { + val resolved = translator.resolveType(request.expression, translationContext) + if (resolved !== null) typeRef(resolved) else typeRef(Object) + } + type.members += element.toMethod(request.methodName, returnType) [ + visibility = JvmVisibility.PRIVATE + parameters += parameter + parameters += extraParams + if (translated !== null) { + body = translated + } else { + val fallback = request.fallbackBody + body = [append(fallback)] + } + ] + } + + /** + * Returns the workspace project containing the given scope model, if any. + * + * @param element + * the scope model, must not be {@code null} + * @return the containing project, or {@code null} if it cannot be determined + */ + def private IProject projectOf(ScopeModel element) { + val uri = element.eResource.URI + if (uri.isPlatformResource) { + val resource = ResourcesPlugin.workspace.root.findMember(uri.toPlatformString(true)) + if (resource !== null) { + return resource.project + } + } + null + } + + /** + * Returns the simple (unqualified) name of a fully qualified Java type name. + * + * @param fqn + * the fully qualified name, must not be {@code null} + * @return the simple name, never {@code null} + */ + def private String simpleName(String fqn) { + fqn.substring(fqn.lastIndexOf('.') + 1) + } + +} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeTranslationContext.xtend b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeTranslationContext.xtend new file mode 100644 index 0000000000..f6e393602b --- /dev/null +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/jvmmodel/ScopeTranslationContext.xtend @@ -0,0 +1,190 @@ +/******************************************************************************* + * Copyright (c) 2016 Avaloq Group AG and others. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * Avaloq Group AG - initial API and implementation + *******************************************************************************/ +package com.avaloq.tools.ddk.xtext.scope.jvmmodel + +import com.avaloq.tools.ddk.xtext.expression.expression.Identifier +import com.avaloq.tools.ddk.xtext.scope.generator.ScopeModelTypeResolver +import java.util.List +import java.util.Map +import org.eclipse.emf.ecore.EObject +import org.eclipse.xtext.common.types.JvmFormalParameter +import org.eclipse.xtext.common.types.JvmType +import org.eclipse.xtext.xbase.lib.Functions.Function1 + +/** + * Carries the information needed while translating a scope/export expression AST into an Xbase + * {@link org.eclipse.xtext.xbase.XExpression} tree. + *

+ * It holds the variables that are in scope (mapping their source names to the {@link JvmFormalParameter}s of the + * enclosing inferred operation) and the implicit variable that an unqualified ({@code this}) feature call refers to. + * The source element the expression originates from is kept for JVM type resolution in later increments. + */ +class ScopeTranslationContext { + + val Map variables = newLinkedHashMap + + val List extensionClassNames = newArrayList + + Function1 typeResolver + + JvmFormalParameter implicitVariable + + String implicitVariableName + + ScopeModelTypeResolver modelTypeResolver + + EObject sourceElement + + /** + * Registers a variable that is in scope for the translated expression. + * + * @param name + * the source name of the variable, must not be {@code null} + * @param parameter + * the inferred formal parameter the variable resolves to, must not be {@code null} + */ + def void putVariable(String name, JvmFormalParameter parameter) { + variables.put(name, parameter) + } + + /** + * Returns the formal parameter a variable name resolves to. + * + * @param name + * the source name of the variable, must not be {@code null} + * @return the matching formal parameter, or {@code null} if no variable with that name is in scope + */ + def JvmFormalParameter getVariable(String name) { + variables.get(name) + } + + /** + * Registers the fully qualified name of a Java class whose {@code static} methods provide extension operations + * (declared in the scope model through {@code extension a::b::C}). + * + * @param className + * the fully qualified Java class name, must not be {@code null} + */ + def void addExtensionClassName(String className) { + extensionClassNames.add(className) + } + + /** + * Returns the fully qualified names of the Java classes whose {@code static} methods provide extension operations. + * + * @return the extension class names, never {@code null} + */ + def List getExtensionClassNames() { + extensionClassNames + } + + /** + * Sets the resolver that maps a source DSL {@link Identifier type} to its corresponding JVM type. This decouples + * the translator from the way types are resolved (a plain classpath lookup for Java types, or a gen-model based + * lookup for EMF model types). + * + * @param resolver + * the type resolver, may be {@code null} + */ + def void setTypeResolver(Function1 resolver) { + this.typeResolver = resolver + } + + /** + * Resolves the JVM type a source DSL type identifier refers to. + * + * @param type + * the source type identifier, may be {@code null} + * @return the resolved JVM type, or {@code null} if it cannot be resolved or no resolver is set + */ + def JvmType resolveDslType(Identifier type) { + if (typeResolver === null || type === null) null else typeResolver.apply(type) + } + + /** + * Returns the implicit variable that an unqualified ({@code this}) feature call refers to. + * + * @return the implicit variable, or {@code null} if none is set + */ + def JvmFormalParameter getImplicitVariable() { + implicitVariable + } + + /** + * Sets the implicit variable that an unqualified ({@code this}) feature call refers to. + * + * @param parameter + * the implicit variable, may be {@code null} + */ + def void setImplicitVariable(JvmFormalParameter parameter) { + this.implicitVariable = parameter + } + + /** + * Returns the name of the Java variable that an unqualified ({@code this}) reference compiles to when the + * expression is rendered as Java source text by the {@link ScopeExpressionCompiler}. + * + * @return the implicit variable name, or {@code null} if none is set + */ + def String getImplicitVariableName() { + implicitVariableName + } + + /** + * Sets the name of the Java variable that an unqualified ({@code this}) reference compiles to when the expression + * is rendered as Java source text by the {@link ScopeExpressionCompiler}. + * + * @param name + * the implicit variable name, may be {@code null} + */ + def void setImplicitVariableName(String name) { + this.implicitVariableName = name + } + + /** + * Returns the resolver used to map model type names in scope expressions to their EMF classifiers. + * + * @return the model type resolver, or {@code null} if none is set + */ + def ScopeModelTypeResolver getModelTypeResolver() { + modelTypeResolver + } + + /** + * Sets the resolver used to map model type names in scope expressions to their EMF classifiers. + * + * @param resolver + * the model type resolver, may be {@code null} + */ + def void setModelTypeResolver(ScopeModelTypeResolver resolver) { + this.modelTypeResolver = resolver + } + + /** + * Returns the source element the translated expression originates from. + * + * @return the source element, or {@code null} if none is set + */ + def EObject getSourceElement() { + sourceElement + } + + /** + * Sets the source element the translated expression originates from. + * + * @param element + * the source element, may be {@code null} + */ + def void setSourceElement(EObject element) { + this.sourceElement = element + } + +} diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/scoping/ScopeScopeProvider.java b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/scoping/ScopeScopeProvider.java index fa441dee29..20ff8d5103 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/scoping/ScopeScopeProvider.java +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/scoping/ScopeScopeProvider.java @@ -19,7 +19,6 @@ import org.eclipse.xtext.naming.QualifiedName; import org.eclipse.xtext.resource.IEObjectDescription; import org.eclipse.xtext.scoping.IScope; -import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider; import org.eclipse.xtext.scoping.impl.SimpleScope; import com.avaloq.tools.ddk.xtext.scope.ScopeUtil; @@ -28,6 +27,7 @@ import com.avaloq.tools.ddk.xtext.scope.scope.ScopeDefinition; import com.avaloq.tools.ddk.xtext.scope.scope.ScopeDelegation; import com.avaloq.tools.ddk.xtext.scope.scope.ScopeModel; +import com.avaloq.tools.ddk.xtext.scope.scope.ScopePackage; import com.avaloq.tools.ddk.xtext.scoping.AbstractNameFunction; import com.avaloq.tools.ddk.xtext.scoping.EObjectDescriptions; import com.avaloq.tools.ddk.xtext.scoping.EPackageScopeProvider; @@ -40,11 +40,41 @@ /** * Scoping for the scoping language. */ -public class ScopeScopeProvider extends AbstractDeclarativeScopeProvider { +public class ScopeScopeProvider extends AbstractScopeScopeProvider { @Inject private EPackageScopeProvider ePackageScopeProvider; + /** + * {@inheritDoc} + *

+ * Dispatches the scope-language specific cross-references to the corresponding declarative + * {@code scope_*} methods. All other references (in particular Xbase feature and type references) + * are delegated to the {@link org.eclipse.xtext.xbase.scoping.batch.XbaseBatchScopeProvider Xbase batch scope provider}. + */ + @Override + public IScope getScope(final EObject context, final EReference reference) { + if (reference == ScopePackage.Literals.IMPORT__PACKAGE) { + return scope_Import_package(context, reference); + } else if (reference == ScopePackage.Literals.SCOPE_DEFINITION__REFERENCE) { + final ScopeDefinition scopeDefinition = EcoreUtil2.getContainerOfType(context, ScopeDefinition.class); + if (scopeDefinition != null) { + return scope_ScopeDefinition_reference(scopeDefinition, reference); + } + } else if (reference == ScopePackage.Literals.SCOPE_DELEGATION__SCOPE) { + final ScopeDelegation scopeDelegation = EcoreUtil2.getContainerOfType(context, ScopeDelegation.class); + if (scopeDelegation != null) { + return scope_ScopeDelegation_scope(scopeDelegation, reference); + } + } else if (EcorePackage.Literals.ECLASS.isSuperTypeOf(reference.getEReferenceType())) { + final ScopeModel scopeModel = EcoreUtil2.getContainerOfType(context, ScopeModel.class); + if (scopeModel != null) { + return scope_EClass(scopeModel, reference); + } + } + return super.getScope(context, reference); + } + /** * Scope for {@link org.eclipse.emf.ecore.EPackage}. These are read from the * registry as well as from the {@link org.eclipse.xtext.Grammar Xtext diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/Messages.java b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/Messages.java index 9845003f5a..0269b44746 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/Messages.java +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/Messages.java @@ -21,7 +21,6 @@ public class Messages extends NLS { public static String duplicatedScopeDefinition; public static String wrongScopeDefinitionSignature; public static String duplicatedScopeRule; - public static String extensionNotFound; public static String overriddenInheritedScopeRule; public static String uriPatternFound; public static String typeMismatch; diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/ScopeValidator.java b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/ScopeValidator.java index e442d6f63b..ca9275bc26 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/ScopeValidator.java +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/ScopeValidator.java @@ -13,15 +13,10 @@ import java.util.Map; import java.util.Set; -import org.eclipse.core.runtime.Platform; import org.eclipse.emf.ecore.EClass; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EStructuralFeature; -import org.eclipse.internal.xtend.xtend.XtendFile; import org.eclipse.osgi.util.NLS; -import org.eclipse.xtend.expression.Resource; -import org.eclipse.xtend.expression.ResourceManager; -import org.eclipse.xtend.expression.ResourceManagerDefaultImpl; import org.eclipse.xtext.EcoreUtil2; import org.eclipse.xtext.nodemodel.ICompositeNode; import org.eclipse.xtext.nodemodel.util.NodeModelUtils; @@ -30,7 +25,6 @@ import com.avaloq.tools.ddk.xtext.expression.expression.Expression; import com.avaloq.tools.ddk.xtext.scope.ScopeUtil; -import com.avaloq.tools.ddk.xtext.scope.scope.Extension; import com.avaloq.tools.ddk.xtext.scope.scope.GlobalScopeExpression; import com.avaloq.tools.ddk.xtext.scope.scope.NamingDefinition; import com.avaloq.tools.ddk.xtext.scope.scope.NamingSection; @@ -57,30 +51,6 @@ public class ScopeValidator extends AbstractScopeValidator { @Inject private ISerializer serializer; - /** - * Verifies that all referenced extensions can be found. - * - * @param model - * scope model to check - */ - @Check - public void checkExtensions(final ScopeModel model) { - ResourceManager resourceManager = null; - if (!Platform.isRunning()) { - resourceManager = new ResourceManagerDefaultImpl(); - } - - if (resourceManager == null) { - return; - } - for (Extension ext : model.getExtensions()) { - final Resource res = resourceManager.loadResource(ext.getExtension(), XtendFile.FILE_EXTENSION); - if (res == null) { - error(NLS.bind(Messages.extensionNotFound, ext.getExtension()), ext, ScopePackage.Literals.EXTENSION__EXTENSION, null); - } - } - } - /** * Verify that the context reference is a cross reference (i.e. no containment or container reference). *

diff --git a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/messages.properties b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/messages.properties index da133a0a22..24ca6e2771 100644 --- a/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/messages.properties +++ b/com.avaloq.tools.ddk.xtext.scope/src/com/avaloq/tools/ddk/xtext/scope/validation/messages.properties @@ -3,7 +3,6 @@ referenceNotOwnedByType=Reference ''{0}'' not owned by type ''{1}'' duplicatedScopeDefinition=Duplicates scope definition {0} wrongScopeDefinitionSignature=Signature of scope does not match {0} duplicatedScopeRule=Duplicates scope rule {0} -extensionNotFound=Extension ''{0}'' not found overriddenInheritedScopeRule=Overrides inherited scope rule {0} uriPatternFound=Consider replacing URI pattern with a key pattern typeMismatch=Type mismatch: Cannot convert from {0} to {1} diff --git a/ddk-target/ddk.target b/ddk-target/ddk.target index 4c8dddee6e..2d0a557612 100644 --- a/ddk-target/ddk.target +++ b/ddk-target/ddk.target @@ -22,12 +22,6 @@ - - - - - -